LazyCollectionOption.EXTRA

LazyCollectionOption.EXTRA பற்றி அறிந்து கொள்வது

ஆனால் மிகவும் ஆர்வமாக உள்ளது LazyCollectionOption.EXTRA மதிப்பு. @LazyCollection சிறுகுறிப்பின் மதிப்பாக நீங்கள் அதைக் குறிப்பிட்டால் , Hibernate சேகரிப்பின் கூறுகளை ஏற்றுவதை முடிந்தவரை தாமதப்படுத்தும்.

தொகுப்பில் உள்ள உறுப்புகளின் எண்ணிக்கையைப் பெற முயற்சித்தால்:

User user = session.load(User.class, 1);
List<Comment> comments = user.getComments();
int count = commetns.size();

இந்தக் குறியீடு அனைத்திற்கும், Hibernate ஒரே ஒரு வினவலைச் செயல்படுத்தும்:

SELECT COUNT(id) FROM comment WHERE user_id = 1;

இருப்பினும், தொகுப்பிலிருந்து ஒரு கருத்தைப் பெற விரும்பினால், எடுத்துக்காட்டாக எண் 3:

User user = session.load(User.class, 1);
List<Comment> comments = user.getComments();
Comment comment = commetns.get(3);

பின்னர் கேள்வி எழுகிறது: அனைத்து உறுப்புகளையும் நினைவகத்தில் ஏற்றாமல் உறுப்பு மூன்றாவது என்பதை Hibernate எவ்வாறு அறிந்து கொள்ள வேண்டும்?

இந்த சிக்கலை தீர்க்க, கருத்து அட்டவணையில் கூடுதல் நெடுவரிசையை உருவாக்க முன்மொழியப்பட்டது, இது கருத்துகளின் தொகுப்பில் உள்ள கருத்தின் வரிசை எண்ணை சேமிக்கும். மேலும் இதற்கு உங்களுக்கு ஒரு சிறப்பு சிறுகுறிப்பு தேவை - @OrderColumn .

அந்த தீர்வு எப்படி இருக்கும் என்பது இங்கே:

@Entity
@Table(name=”user”)
class User {
   @Column(name=”id”)
   public Integer id;

   @OneToMany(cascade = CascadeType.ALL)
   @LazyCollection(LazyCollectionOption.EXTRA)
   @OrderColumn(name = "order_id")
   public List<Comment> comments;
}

LazyCollectionOption.EXTRA இன் முக்கிய நன்மை

@ManyToMany சிறுகுறிப்பு மூலம் LazyCollectionOption.EXTRA ஐக் குறிப்பிடும்போது, ​​அதன் வலுவான நன்மையைப் பார்க்கிறோம் . எங்களிடம் ஒரு பணியாளர், ஒரு பணி, மற்றும் ஒரு பயனருக்கு பல பணிகளை ஒதுக்கக்கூடிய நமது பழைய வழக்கை எடுத்துக்கொள்வோம்.

எங்கள் ஜாவா வகுப்புகள் இப்படி இருக்கும்:

பணியாளர் வகுப்பு :

@Entity
@Table(name=”employee”)
class Employee {
   @Column(name=”id”)
   public Integer id;

   @ManyToMany(cascade = CascadeType.ALL)
   @JoinTable(name="employee_task",
       	joinColumns=  @JoinColumn(name="employee_id", referencedColumnName="id"),
       	inverseJoinColumns= @JoinColumn(name="task_id", referencedColumnName="id") )
   @LazyCollection(LazyCollectionOption.EXTRA)
   private Set<EmployeeTask> tasks = new HashSet<EmployeeTask>();

}

மற்றும் EmployeeTask வகுப்பு :

@Entity
@Table(name=”task”)
class EmployeeTask {
   @Column(name=”id”)
   public Integer id;

   @ManyToMany(cascade = CascadeType.ALL)
   @JoinTable(name="employee_task",
       	joinColumns=  @JoinColumn(name="task_id", referencedColumnName="id"),
       	inverseJoinColumns= @JoinColumn(name=" employee_id", referencedColumnName="id") )
   @LazyCollection(LazyCollectionOption.EXTRA)
   private Set<Employee> employees = new HashSet<Employee>();

}

இயக்குனருக்கு ஒரு பணியைச் சேர்க்க, நீங்கள் இந்த குறியீட்டைப் போன்ற ஒன்றை எழுத வேண்டும்:

Employee director = session.find(Employee.class, 4);
EmployeeTask task = session.find(EmployeeTask.class, 101);
task.employees.add(director);

session.update(task);
session.flush();

எனவே, பணி வகுப்பில் உள்ள பணியாளர்கள் புலத்தில் LazyCollectionOption.EXTRA சிறுகுறிப்பு இருந்தால், பணியாளர்களின் சேகரிப்பு (பணி வகுப்பின்) மற்றும் பணி சேகரிப்பு (பணியாளர் வகுப்பின்) ஆகியவை தரவுத்தளத்திலிருந்து ஒருபோதும் ஏற்றப்படாது .

இந்தக் குறியீடு செயல்படுத்தப்படும்போது, ​​Employee_task சேவை அட்டவணையில் ஒரே ஒரு பதிவு மட்டுமே செருகப்படும், இது உங்களுக்கு நினைவிருக்கிறபடி, இது போல் தெரிகிறது:

சேர்க்கப்பட்ட வரி பச்சை நிறத்தில் சிறப்பிக்கப்பட்டுள்ளது. இந்த வரியைச் சேர்க்க, தரவுத்தளத்திலிருந்து சேகரிப்புகளை ஏற்ற வேண்டிய அவசியமில்லை - ஹைபர்னேட் அது இல்லாமல் செய்யும். LazyCollectionOption.EXTRA தரவுத்தளத்துடன் பணியை பெரிதும் துரிதப்படுத்தும் போது இதுவே சரியாகும்.

N+1 பிரச்சனை

ஆனால், நிச்சயமாக, இந்த பயன்முறையில் ஒரு குறைபாடு உள்ளது. எடுத்துக்காட்டாக, LazyCollectionOption.EXTRA சிறுகுறிப்பு N+1 சிக்கலை உருவாக்குகிறது .

உங்கள் பயனரின் அனைத்து கருத்துகளையும் பார்க்க முடிவு செய்தால்:

User user = session.load(User.class, 1);
List<Comment> comments = user.getComments();
for (Comment comment : comments) {
    System.out.println(comment);
}

ஒவ்வொரு கருத்துப் பொருளுக்கும் தனித்தனி கோரிக்கையை ஹைபர்னேட் செயல்படுத்தும். மேலும் அனைத்து கருத்துகளின் எண்ணிக்கையைப் பெற மேலும் ஒரு கூடுதல் வினவல். இது குறியீட்டை கணிசமாகக் குறைக்கலாம்.

உங்கள் பயனருக்கு 1000 கருத்துகள் இருந்தால், இந்தக் குறியீட்டை இயக்க, ஹைபர்னேட் 1001 வினவல்களை தரவுத்தளத்தில் செய்யும். இந்த வகுப்பின் அனைத்து பொருட்களும் உங்களுக்குத் தேவைப்படும் என்பதை நீங்கள் முன்கூட்டியே அறிந்திருந்தால்.