రెండవ స్థాయి కాష్‌ని కాన్ఫిగర్ చేస్తోంది

కరెన్సీ వ్యూహాలు

మీరు హైబర్నేట్‌లో రెండవ-స్థాయి కాషింగ్‌ని ప్రారంభించిన తర్వాత, మేము ఏ ఎంటిటీ ఆబ్జెక్ట్‌లను కాష్ చేయాలనుకుంటున్నాము మరియు ఎలా చేయాలో మీరు హైబర్నేట్‌కి వివరించాలి.

దీన్ని చేయడానికి, హైబర్నేట్ ఎంటిటీ తరగతులకు ప్రత్యేక ఉల్లేఖనాన్ని కలిగి ఉంది - @Cache . ఉదాహరణ:

@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)

మేము రెండవ స్థాయి కాష్‌ని ఉపయోగించాలనుకుంటున్న ప్రతి ఎంటిటీ ఎంటిటీ కోసం ఈ ఉల్లేఖనాన్ని వ్రాయాలి. ఉదాహరణ:

@Entity
@Table(name = "employee")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Employee {
    @Id
    private Integer id;
    private Set<Task> tasks;
}

వివిధ థ్రెడ్‌ల నుండి యాక్సెస్ చేయబడినట్లయితే, హైబర్నేట్ కాష్ చేయబడిన ఎంటిటీకి 4 సాధ్యమైన యాక్సెస్ వ్యూహాలను కలిగి ఉంటుంది:

• చదవడానికి మాత్రమే
• చదువు రాయి
• నాన్‌స్ట్రిక్ట్-రీడ్-రైట్
• లావాదేవీల

చదవడానికి మాత్రమే. ఎప్పటికీ మారని డేటా-తగిన కాన్కరెన్సీ వ్యూహం. హైబర్నేట్ ఈ వస్తువులను దాని మెమరీలో నిల్వ చేస్తుంది. సూచన డేటా కోసం మాత్రమే దీన్ని ఉపయోగించండి.

డేటాబేస్‌లు ఎప్పటికీ మారని చాలా సమాచారాన్ని నిల్వ చేస్తాయి. ఉదాహరణకు, ఒక పట్టిక కేవలం జోడించబడిన ఈవెంట్‌ల జాబితాను ఉంచుతుంది కానీ ఎప్పుడూ మార్చబడదు లేదా తీసివేయబడదు. మీరు హైబర్నేట్ ద్వారా ఈ పట్టికతో పని చేయవలసి వస్తే, చదవడానికి మాత్రమే కాషింగ్ వ్యూహం మీకు సరిపోతుంది.

చదవండి-వ్రాయండి (చదవండి-రాయండి). ప్రాథమికంగా చదవగలిగే డేటా కోసం ఈ వ్యూహాన్ని ఉపయోగించండి. అయినప్పటికీ, హైబర్నేట్ ఈ డేటాను మార్చే ప్రయత్నాలను ట్రాక్ చేస్తుంది, అయినప్పటికీ అవి చాలా అరుదుగా ఉంటాయని భావిస్తుంది.

మీరు ప్రధానంగా అరుదుగా మారే మరియు తరచుగా చదివే / అభ్యర్థించే వస్తువులను కాష్ చేయాలి. మీకు అలాంటి వస్తువులు ఉంటే, మీరు వాటి కోసం రీడ్-రైట్ వ్యూహాన్ని ఉపయోగించాలి.

నాన్‌స్ట్రిక్ట్-రీడ్-రైట్ . ఈ వ్యూహం కాష్ మరియు డేటాబేస్ మధ్య స్థిరత్వానికి హామీ ఇవ్వదు. డేటా దాదాపు ఎప్పటికీ మారకుండా మరియు పాత డేటా యొక్క చిన్న అవకాశం క్లిష్టమైన సమస్య కానట్లయితే ఈ వ్యూహాన్ని ఉపయోగించండి.

రీడ్-రైట్ స్ట్రాటజీ వలె కాకుండా, మార్చగల డేటా చదవడానికి లాక్ చేయబడలేదని ఈ వ్యూహం ఊహిస్తుంది. దీని వలన వస్తువు ఒక చోట మార్చబడవచ్చు, మరొక చోట, ఎవరైనా పాత సంస్కరణను చదువుతున్నారు.

ఉదాహరణకు, ఒక వినియోగదారు తన వ్యాఖ్యను మార్చుకున్నారు, కానీ ఇతర వినియోగదారులు కొంత సమయం వరకు అతని పాత సంస్కరణను ఇప్పటికీ చూస్తారు. ఇది మీకు సమస్య కాకపోతే, నాన్‌స్ట్రిక్ట్-రీడ్-రైట్ స్ట్రాటజీని ఉపయోగించండి.

లావాదేవీ . అప్‌డేట్ యొక్క అరుదైన సందర్భంలో ఉమ్మడి లావాదేవీలలో పాత డేటాను నిరోధించడం ముఖ్యం అయిన ప్రాథమికంగా చదవడానికి మాత్రమే డేటా కోసం ఈ వ్యూహాన్ని ఉపయోగించండి.

కాష్‌లో డేటాను నిల్వ చేస్తోంది

మీరు గుర్తుంచుకోవలసిన రెండవ స్థాయి కాష్ గురించిన మరొక ముఖ్యమైన వివరాలు ఏమిటంటే, హైబర్నేట్ మీ తరగతుల వస్తువులను నిల్వ చేయదు. ఇది తీగలు, సంఖ్యలు మొదలైన వాటి శ్రేణుల వలె సమాచారాన్ని నిల్వ చేస్తుంది.

మరియు ఆబ్జెక్ట్ ఐడెంటిఫైయర్ ఈ సమాచారానికి పాయింటర్‌గా పనిచేస్తుంది. సంభావితంగా, ఇది మ్యాప్ లాంటిది, దీనిలో ఆబ్జెక్ట్ యొక్క ఐడి కీలకం మరియు డేటా శ్రేణులు విలువ. మీరు దీన్ని ఇలా ఊహించవచ్చు:

1 -> { "Ivanov", 1, null , {1,2,5} }
2 -> { "Petrov", 2, null , {1,2,5} }
3 -> { "Sidorov", 3, null , {1,2,5} }

ప్రతి వస్తువు ఎంత అదనపు మెమరీని తీసుకుంటుందో పరిగణనలోకి తీసుకోవడం చాలా సహేతుకమైనది.

పైన పేర్కొన్న వాటికి అదనంగా, మీ ఎంటిటీ క్లాస్ డిపెండెన్సీలు కూడా డిఫాల్ట్‌గా కాష్ చేయబడవని మీరు గుర్తుంచుకోవాలి. ఉదాహరణకు, మేము ఎగువ తరగతిని పరిగణనలోకి తీసుకుంటే, ఉద్యోగి , అప్పుడు పొందేటప్పుడు, టాస్క్‌ల సేకరణ డేటాబేస్ నుండి తిరిగి పొందబడుతుంది మరియు రెండవ-స్థాయి కాష్ నుండి కాదు .

మీరు డిపెండెన్సీలను కూడా కాష్ చేయాలనుకుంటే, తరగతి ఇలా ఉండాలి:

@Entity
@Table(name = "employee")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Employee {
    @Id
    private Integer id;

   @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
   private Set<Task> tasks;
}

మరియు చివరి వివరాలు - మొదటి-స్థాయి కాష్‌లో కావలసిన వస్తువు కనుగొనబడకపోతే మాత్రమే రెండవ-స్థాయి కాష్ నుండి చదవడం జరుగుతుంది.

CacheMode

హైబర్నేట్ చాలా సౌకర్యవంతమైన కాషింగ్ నిర్వహణను అనుమతిస్తుంది. మీరు ప్రతి సెషన్ కోసం లేదా ప్రతి డేటాబేస్ అభ్యర్థన కోసం కూడా కాష్ మోడ్‌ను సెట్ చేయవచ్చు.

అలాంటి ఐదు మోడ్‌లు ఉన్నాయి:

• పొందండి
• పట్టించుకోకుండా
• సాధారణ
• పెట్టండి
• రిఫ్రెష్ చేయండి

దిగువ పట్టిక వారి పనిని వివరిస్తుంది:

సెషన్ కోసం కాష్ మోడ్‌ను సెట్ చేయడానికి ఉదాహరణ:

session.setCacheMode(CacheMode.GET);
Employee director = session.createQuery("from Employee where id = 4").uniqueResult();

మరియు సెషన్ మరియు అభ్యర్థన కోసం మోడ్‌ను సెట్ చేయడానికి ఒక ఉదాహరణ:

session.setCacheMode(CacheMode.GET);
Query query = session.createQuery("from Employee where id = 4");
query.setCacheMode(CacheMode.IGNORE); // Ignore cache work for this request
Employee director = query.uniqueResult();