அடுக்கு மாற்றங்கள்

6.1 ஆழமான சார்பு மேலாண்மை

மேலும் @OneToMany சிறுகுறிப்புகள் மற்றும் இது போன்ற சில பயனுள்ள மற்றும் சுவாரஸ்யமான விஷயங்கள். அவை அனைத்தும் பொதுவாகப் பயன்படுத்தப்படும் 4 விருப்பங்களைக் கொண்டுள்ளன:

• அடுக்கை = CascadeType.ALL
• அனாதை அகற்றுதல் = உண்மை
• பெற = FetchType.LAZY

இப்போது நாம் அவற்றை இன்னும் விரிவாக பகுப்பாய்வு செய்வோம். நாங்கள் மிகவும் சுவாரசியமான - CascadeType உடன் தொடங்குவோம் . முக்கிய உட்பொருளை நாம் மாற்றினால், சார்பு நிறுவனங்களுக்கு என்ன நடக்கும் என்பதை இந்த அளவுரு தீர்மானிக்கிறது.

JPA விவரக்குறிப்பு இந்த அளவுருவிற்கு பின்வரும் மதிப்புகளைக் கொண்டுள்ளது:

• அனைத்து
• நிலைத்து
• ஒன்றிணைக்கவும்
• அகற்று
• புதுப்பிப்பு
• பிரிக்கவும்

இருப்பினும், ஹைபர்னேட் இந்த விவரக்குறிப்பை மேலும் மூன்று விருப்பங்களாக விரிவுபடுத்துகிறது:

• பிரதிபலிக்கும்
• SAVE_UPDATE
• பூட்டு

நிச்சயமாக, தரவுத்தளத்திற்கும் அவற்றின் கன்ஸ்ட்ரானிஸுக்கும் வலுவான இணையாக உள்ளது. இருப்பினும், வேறுபாடுகளும் உள்ளன. ஹைபர்னேட் உண்மையான வேலையை தரவுத்தளத்துடன் முடிந்தவரை மறைக்க முயற்சிக்கிறது, எனவே இந்த ஹைபர்னேட் அடுக்குகள் சரியாக நிறுவனப் பொருட்களைப் பற்றியது.

6.2 அடுக்கு வகை

கேஸ்கேட் அளவுரு, சார்ந்திருக்கும் பொருள்களின் பெற்றோரை (மாஸ்டர் ஆப்ஜெக்ட்) மாற்றினால் என்ன நடக்கும் என்பதை விவரிக்கிறது. பெரும்பாலும், இந்த அளவுரு பொருள் சார்புகளை விவரிக்கும் சிறுகுறிப்புகளுடன் ஒன்றாகப் பயன்படுத்தப்படுகிறது:

உதாரணமாக:

OneToOne(cascade = CascadeType.ALL)

அல்லது இப்படி:

@ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})

இதை ஒரு தனி சிறுகுறிப்பாகவும் எழுதலாம்:

@Cascade({ org.hibernate.annotations.CascadeType.ALL })

இப்போது இந்த சிறுகுறிப்புகள் எதைக் குறிக்கின்றன என்பதைப் பற்றி மேலும் பேசலாம்.

6.3 அனைத்தும், நிலைத்து, ஒன்றிணைத்தல்

CascadeType.ALLமூலப்பொருளுடன் நாம் செய்யும் அனைத்து செயல்களும் அதன் சார்புள்ள பொருட்களுக்காக மீண்டும் மீண்டும் செய்யப்பட வேண்டும் என்பதாகும் .

CascadeType.PERSISTதரவுத்தளத்தில் நாம் பெற்றோர் பொருளைச் சேமித்தால், அதைச் சார்ந்திருக்கும் பொருள்களிலும் இதைச் செய்ய வேண்டும். உதாரணமாக:

@Entity
@Table(name="employee")
class Employee {
   @Column(name="id")
   public Integer id;
 
   @OneToOne(cascade = CascadeType.PERSIST, mappedBy="task")
   private EmployeeTask task;
}

இந்த வகுப்பில் வேலை செய்வதற்கான எடுத்துக்காட்டு:

Employee director = new Employee();
EmployeeTask task = new EmployeeTask();
director.task = task;
 
session.persist(director);
session.flush();

பணியாளர் வகையின் ஒரு பொருளை மட்டுமே நாங்கள் சேமிக்கிறோம், அதன் சார்பு பொருள் EmployeeTask தானாகவே தரவுத்தளத்தில் சேமிக்கப்படும்.

CascadeType.MERGEதரவுத்தளத்தில் உள்ள மூலப்பொருளைப் புதுப்பித்தால், அதைச் சார்ந்திருக்கும் பொருள்களிலும் இதைச் செய்ய வேண்டும்.

6.4 நீக்கவும், நீக்கவும், பிரிக்கவும்

CascadeType.REMOVEதரவுத்தளத்தில் உள்ள ஒரு மூலப்பொருளை நாம் நீக்கினால், அதைச் சார்ந்திருக்கும் பொருள்களிலும் இதைச் செய்ய வேண்டும்.

CascadeType.DELETEஅதே பொருள். இவை ஒத்த சொற்கள். வெவ்வேறு விவரக்குறிப்புகளிலிருந்து.

CascadeType.DETACHஅமர்விலிருந்து மூலப்பொருளை அகற்றினால், அதைச் சார்ந்திருக்கும் பொருள்களிலும் இதைச் செய்ய வேண்டும். உதாரணமாக:

@Entity
@Table(name="employee")
class Employee {
   @Column(name="id")
   public Integer id;
 
   @OneToOne(cascade = CascadeType.DETACH, mappedBy="task")
   private EmployeeTask task;
}

இந்த வகுப்பில் வேலை செய்வதற்கான எடுத்துக்காட்டு:

Employee director = new Employee();
EmployeeTask task = new EmployeeTask();
director.task = task;
director.task = task;
session.flush();
 
assertThat(session.contains(director)).isTrue();
assertThat(session.contains(task)).isTrue();
 
session.detach(director);
 
assertThat(session.contains(director)).isFalse();
assertThat(session.contains(task)).isFalse();

CascadeType.REFRESHமற்றும் CascadeType.SAVE_UPDATEநாம் எதிர்பார்ப்பது போலவே செயல்படும் - அவை மூலப் பொருளுடன் செய்யப்படும் செயல்களை அதன் சார்ந்த பொருளுக்கு நகலெடுக்கின்றன.

6.5 அனாதை அகற்றும் விருப்பம்

மேலும் சில நேரங்களில் நீங்கள் அளவுருவைக் காணலாம் orphan. இது அனாதை நீக்கம் என்பதன் சுருக்கம். பெற்றோர் நிறுவனங்கள் இல்லாமல் குழந்தை நிறுவனங்கள் இல்லை என்பதை உறுதிப்படுத்த இது பயன்படுத்தப்படுகிறது.

OneToOne(orphan = true)

இந்த அளவுரு சரி என அமைக்கப்பட்டால், குழந்தைப் பொருள் மறைந்திருந்தால் அது நீக்கப்படும்அனைத்து இணைப்புகள். இது சரியாக ஒரே மாதிரியாக இல்லை Cascade.REMOVE.

பல பெற்றோர் நிறுவனங்கள் ஒரு குழந்தையைக் குறிப்பிடும் சூழ்நிலை உங்களுக்கு இருக்கலாம். பின்னர் அது பெற்றோர் நிறுவனத்தை நீக்குவதுடன் நீக்கப்படாமல் இருப்பது நன்மை பயக்கும், ஆனால் அது பற்றிய அனைத்து குறிப்புகளும் ரத்து செய்யப்பட்டால் மட்டுமே.

உங்களிடம் ஒரு வகுப்பு உள்ளது என்று வைத்துக்கொள்வோம்:

@Entity
@Table(name="user")
class Employee {
   @Column(name="id")
   public Integer id;
 
   @OneToMany(cascade = CascadeType.ALL, orphan = true)
   @JoinColumn(name = "employee_id")
   private Set<EmployeeTask> tasks = new HashSet<EmployeeTask>();
}

Employee director = session.find(Employee.class, 4);
EmployeeTask task = director.tasks.get(0);
director.tasks.remove(task)
session.persist(director);
session.flush();

EmployeeTask பொருள் நீக்கப்படும், ஏனெனில் அதில் குறிப்புகள் எதுவும் இல்லை. அதே நேரத்தில், பெற்றோர் பொருளை யாரும் நீக்கவில்லை.

6.6 பெற விருப்பம்

சார்பு பொருள்கள் எவ்வாறு ஏற்றப்படுகின்றன என்பதைக் கட்டுப்படுத்த பெறுதல் விருப்பம் உங்களை அனுமதிக்கிறது. இது பொதுவாக இரண்டு மதிப்புகளில் ஒன்றை எடுக்கும்:

• FetchType.LAZY
• FetchType.EAGER

இது பல்வேறு இடர்பாடுகளைக் கொண்ட மிகவும் சுவாரஸ்யமான தலைப்பு, எனவே இதைப் பற்றி ஒரு தனி விரிவுரையில் பேசுவது நல்லது.