ప్రశ్న కాష్‌ని అనుకూలీకరించడం

మీకు ప్రశ్న కాష్ ఎందుకు అవసరం

HQLలో ఉద్యోగులను పొందడానికి మా ఉదాహరణను తిరిగి వ్రాస్దాం:

Employee director1 = session.createQuery("from Employee where id = 4").uniqueResult();
Employee director2 = session.createQuery("from Employee where id = 4").uniqueResult();

assertTrue(director1 != director2);

అటువంటి ప్రశ్నల ఫలితాలు మొదటి లేదా రెండవ స్థాయి కాష్ ద్వారా నిల్వ చేయబడవు .

క్వెరీ కాష్‌ని సరిగ్గా ఇక్కడే ఉపయోగించవచ్చు . ఇది డిఫాల్ట్‌గా కూడా నిలిపివేయబడింది. దీన్ని ప్రారంభించడానికి, కాన్ఫిగరేషన్ ఫైల్‌కు క్రింది పంక్తిని జోడించండి:

<property name="hibernate.cache.use_query_cache" value="true"/>

కానీ ఇది సగం పరిష్కారం మాత్రమే. మేము ప్రశ్న కాష్‌ను ప్రారంభించాము, కానీ మేము ఏ ప్రశ్న ఫలితాలను కాష్ చేయాలనుకుంటున్నామో కూడా పేర్కొనాలి. ఇది తప్పనిసరిగా ప్రశ్నలో వ్రాయబడాలి:

Query query = session.createQuery("from Employee where id = 4");
query.setCacheable(true);
Employee director1 = query.uniqueResult();

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

కాష్‌ను క్లియర్ చేస్తోంది

కాష్‌తో పని చేస్తున్నప్పుడు ముఖ్యమైన పనులలో ఒకటి కాష్ చేయబడిన వస్తువులు మారుతున్నాయని నిర్ధారించుకోవడం మరియు వాటిని కాష్ నుండి తీసివేయడం (లేదా వాటిని నవీకరించడం). హైబర్నేట్ దీన్ని బాగా చేస్తుంది. కొన్నిసార్లు అతను "ఏదైనా అపారమయిన పరిస్థితిలో కాష్‌ను క్లియర్ చేయండి" అనే నియమం ద్వారా మార్గనిర్దేశం చేయబడినట్లు కూడా అనిపిస్తుంది.

మీరు HQL ద్వారా యూజర్ డేటాను అప్‌డేట్ చేయాలనుకుంటున్నారని అనుకుందాం:

Query query = session.createQuery("update Employee set name=’Alex’ where id = 4")
query. executeUpdate();

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

కానీ NativeQuery మరింత ఆసక్తికరంగా పనిచేస్తుంది:

Query nativeQuery = session.createNativeQuery("update employee set name=’Alex’ where id = 4")
nativeQuery.executeUpdate();

డేటాబేస్కు స్థానిక SQL ప్రశ్న అమలు చేయబడింది. డేటాబేస్‌లో ఏదో మార్పు వచ్చిందని దీని అర్థం - అభ్యర్థనను executeUpdate() పద్ధతిలో పిలుస్తారు . కాబట్టి, ఈ సందర్భంలో, హైబర్నేట్ దీన్ని సురక్షితంగా ప్లే చేస్తుంది మరియు దాని కాష్ నుండి అన్ని రకాల వస్తువులను తీసివేస్తుంది .

మీరు దానిని ఎలా ఇష్టపడతారు? మీరు హానిచేయని అభ్యర్థనకు కాల్ చేస్తారు మరియు ప్రతిస్పందనగా హైబర్నేట్ కాష్ నుండి మొత్తం డేటాను తొలగిస్తుంది! అతను బేస్ నుండి భిన్నమైన వస్తువులను ఉంచినట్లయితే ఇది ఖచ్చితంగా మంచిది, కానీ అంతే!

అందువల్ల, హైబర్నేట్ సృష్టికర్తలు ఈ సందర్భంలో హైబర్నేట్‌కు ఎలా సహాయం చేయాలో త్వరగా కనుగొన్నారు. కాష్ నుండి ఏ ఎంటిటీ రకాన్ని తీసివేయాలో మీరు చెప్పవచ్చు:

Query nativeQuery = session.createNativeQuery("update employee set name=’Alex’ where id = 4");
nativeQuery.unwrap(org.hibernate.SQLQuery.class).addSynchronizedEntityClass(Employee.class);
nativeQuery.executeUpdate();

వ్యాఖ్య . స్థానిక ఎంపిక ప్రశ్నలు కాష్‌ను ఫ్లష్ చేయవు , ఇన్సర్ట్, అప్‌డేట్, డిలీట్, ప్రొసీజర్ కాల్‌లు మొదలైనవి మాత్రమే.

మాన్యువల్ కాష్ క్లియరింగ్

కొన్ని కారణాల వల్ల, మీరు కాష్ నుండి ఒక వస్తువును మీరే తొలగించాలనుకోవచ్చు. ఇది వివిధ మార్గాల్లో చేయవచ్చు.

గమనించండి . కాష్‌లోని వస్తువులు ప్రాంతాలు అని పిలువబడే సమూహాలలో నిల్వ చేయబడతాయి . డిఫాల్ట్‌గా, ప్రాంతం పేరు తరగతి పేరు వలె ఉంటుంది. కాబట్టి, మీ వద్ద com.codegym.Employee రకం వస్తువులు ఉంటే , అవన్నీ “ com.codegym.employee ” పేరుతో ఒక సమూహం (ప్రాంతం)లో నిల్వ చేయబడతాయి.

మీరు కాష్‌ని యాక్సెస్ చేసి, దానితో ఏదైనా చేయాలనుకుంటే, మీరు దీన్ని SessionFactory ఆబ్జెక్ట్ మరియు getCache () పద్ధతితో చేయవచ్చు :

session.getSessionFactory().getCache().evictQueryRegion("com.codegym.employee”);

మీరు అన్ని సమూహాల (ప్రాంతాలు) నుండి డేటాను తొలగించాలనుకుంటే, మీరు క్రింది ప్రశ్నను అమలు చేయాలి:

session.getSessionFactory().getCache().evictAllRegions();

కాష్ నుండి ఒక వస్తువును తీసివేయడానికి, మీరు దాని పేరు (రకం) మరియు ఐడిని పాస్ చేయాలి. మీరు దీన్ని రెండు విధాలుగా చేయవచ్చు:

session.getSessionFactory().getCache().evictEntityData("Employee”, 4);

session.getSessionFactory().getCache().evictEntityData(com.codegym.Employee.class, 4);

నిర్దిష్ట వస్తువు కాష్‌లో ఉందో లేదో కూడా మీరు తనిఖీ చేయవచ్చు:

session.getSessionFactory().getCache().containsEntity("Employee”, 4);
session.getSessionFactory().getCache().containsEntity(com.codegym.Employee.class, 4);