సేకరణలను మ్యాపింగ్ చేసేటప్పుడు సోమరితనం లోడ్ అవుతోంది

2.1 పొందే ఎంపిక

హైబర్నేట్ డెవలపర్‌లకు చాలా కాలంగా చైల్డ్ ఎంటిటీలను లోడ్ చేయడంలో సమస్య గురించి తెలుసు. కాబట్టి వారు చేసిన మొదటి పని ఉల్లేఖనాలకు ప్రత్యేక పొందు@OneToMany పరామితిని జోడించడం , @ManyToMany.

ఈ పరామితి రెండు విలువలను తీసుకోవచ్చు:

• ఉత్సాహంగా
• సోమరితనం

ఉదాహరణ:

@OneToMany(fetch = FetchType.LAZY, mappedBy = "user")

పొందడం పరామితి EAGERకి సమానంగా ఉంటే , మాతృ సంస్థ లోడ్ అయినప్పుడు, దాని చైల్డ్ ఎంటిటీలన్నీ కూడా లోడ్ చేయబడతాయి. అలాగే, హైబర్నేట్ ఒక SQL ప్రశ్నలో దీన్ని చేయడానికి ప్రయత్నిస్తుంది, భారీ ప్రశ్నను ఉత్పత్తి చేస్తుంది మరియు మొత్తం డేటాను ఒకేసారి పొందుతుంది.

పొందడం పరామితి LAZY విలువను తీసుకుంటే , పేరెంట్ ఎంటిటీ లోడ్ అయినప్పుడు, చైల్డ్ ఎంటిటీ లోడ్ చేయబడదు. బదులుగా, ప్రాక్సీ ఆబ్జెక్ట్ సృష్టించబడుతుంది.

ఈ ప్రాక్సీ ఆబ్జెక్ట్ సహాయంతో, హైబర్నేట్ ఈ చైల్డ్ ఎంటిటీకి యాక్సెస్‌ని ట్రాక్ చేస్తుంది మరియు మొదటిసారి యాక్సెస్ చేసినప్పుడు మెమరీలోకి లోడ్ చేస్తుంది.

మేము వ్యాఖ్యలతో మా పరిస్థితిని గుర్తుచేసుకుంటే:

@Entity
@Table(name="user")
class User {
   @Column(name="id")
   public Integer id;
 
   @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
   @JoinColumn(name = "user_id")
   public List<Comment> comments;
}

అప్పుడు మీకు "చిక్ ఎంపిక" ఉంది:

ఒకవేళ fetch = FetchType.EAGER, హైబర్నేట్ కోడ్ యొక్క 1వ లైన్‌లో అన్ని వ్యాఖ్యలను లోడ్ చేస్తుంది:

User user = session.get(User.class, 1);		//load all comments here
List<Comment> comments = user.getComments();

ఒకవేళ fetch = FetchType.LAZY, హైబర్నేట్ కోడ్ యొక్క 2వ లైన్‌లోని అన్ని వ్యాఖ్యలను లోడ్ చేస్తుంది:

User user = session.get(User.class, 1);
List<Comment> comments = user.getComments(); //load all comments here

మీరు ఇప్పటికే ఊహించినట్లుగా, ఇది అన్ని వ్యాఖ్యలను లోడ్ చేయనప్పుడు మీకు ఎంపిక లేదు :)

2.2 డిఫాల్ట్ విలువ

మీరు ... ఉల్లేఖన కోసం పొందే ఎంపికను పేర్కొనకుంటే @ManyTo, హైబర్నేట్ డిఫాల్ట్ విలువలను ఉపయోగిస్తుంది.

విభిన్న ఉల్లేఖన రకాలకు అవి కొద్దిగా భిన్నంగా ఉంటాయి. ఉల్లేఖనాల కోసం @OneToOneమరియు @ManyToOneఈజీర్, ఉల్లేఖనాల కోసం @OneToManyమరియు @ManyToManyసోమరితనం. గుర్తుంచుకోవడం సులభం - మనం ఒక వస్తువును సూచిస్తే, అది పూర్తిగా లోడ్ అవుతుంది. మేము సేకరణను సూచిస్తే, అది మొదటిసారి యాక్సెస్ చేయబడినప్పుడు లోడ్ చేయబడుతుంది.

2.3 @LazyCollection ఉల్లేఖన

మీరు ఇప్పటికే చూసినట్లుగా, సేకరణలతో పని చేస్తున్నప్పుడు పొందడం పరామితి పెద్దగా సహాయం చేయదు. హైబర్నేట్ సృష్టికర్తలు ప్రత్యేక ఉల్లేఖనాన్ని జోడించడం ద్వారా దీన్ని పరిష్కరించడానికి ప్రయత్నించారు @LazyCollection. ఇది సాధారణంగా ఇలా వ్రాయబడుతుంది:

@LazyCollection(LazyCollectionOption.TRUE)

సేకరణ ఫీల్డ్‌లను మ్యాప్ చేస్తున్నప్పుడు మీరు దీన్ని పేర్కొనాలి:

@Entity
@Table(name="user")
class User {
   @Column(name="id")
   public Integer id;
 
   @OneToMany(cascade = CascadeType.ALL)
   @LazyCollection(LazyCollectionOption.TRUE)
   public List<Comment> comments;
}

ఈ ఉల్లేఖన విలువ పరామితిని కలిగి ఉంది, అది మూడు విలువలలో ఒకదాన్ని తీసుకోవచ్చు:

• LazyCollectionOption. నిజం
• LazyCollectionOption. తప్పు
• LazyCollectionOption. అదనపు

మొదటి రెండు ఎంపికలు పొందే ఎంపికకు చాలా పోలి ఉంటాయి.

పరామితిని సెట్ చేసినట్లయితే , పేరెంట్ యూజర్ ఆబ్జెక్ట్ లోడ్ అయినప్పుడు LazyCollectionOption.TRUEకామెంట్స్ ఫీల్డ్ విలువలు డేటాబేస్ నుండి లోడ్ చేయబడవని అర్థం. కామెంట్‌ల ఫీల్డ్‌ని మొదటిసారి యాక్సెస్ చేసినప్పుడు వ్యాఖ్య రకం వస్తువులు లోడ్ చేయబడతాయి. నిజానికి, ఇది పరామితికి సమానంFetchType.LAZY

పరామితిని సెట్ చేస్తే , పేరెంట్ యూజర్ ఆబ్జెక్ట్‌ను లోడ్ చేసే సమయంలో LazyCollectionOption.FALSEకామెంట్స్ ఫీల్డ్ విలువలు డేటాబేస్ నుండి లోడ్ అవుతాయని అర్థం. కామెంట్‌ల ఫీల్డ్‌ని మొదటిసారి యాక్సెస్ చేసినప్పుడు వ్యాఖ్య రకం వస్తువులు లోడ్ చేయబడతాయి. నిజానికి, ఇది సమానం FetchType.EAGER.