హైబర్నేట్‌లో డేటా కాషింగ్

మీ కాషింగ్ పరిష్కారాన్ని ఎప్పుడూ వ్రాయవద్దు

డేటాబేస్తో పనిని వేగవంతం చేయడానికి మరొక మార్గం మేము ఇంతకు ముందు అభ్యర్థించిన వస్తువులను కాష్ చేయడం.

ముఖ్యమైనది! మీ స్వంత కాషింగ్ పరిష్కారాన్ని ఎప్పుడూ వ్రాయవద్దు. ఈ పనిలో మీరు కలలో కూడా ఊహించని అనేక ఆపదలు ఉన్నాయి.

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

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

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

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

సమస్య 4 - యొక్క సమర్థవంతమైన నిల్వ . మీరు కాష్‌లో వస్తువులను నిల్వ చేయలేరు. వస్తువులు చాలా తరచుగా ఇతర వస్తువులకు సూచనలను కలిగి ఉంటాయి మరియు మొదలైనవి. ఈ రేటుతో, మీకు చెత్త సేకరించే యంత్రం అవసరం లేదు: ఇది తీసివేయడానికి ఏమీ ఉండదు.

అందువల్ల, వస్తువులను స్వయంగా నిల్వ చేయడానికి బదులుగా, వాటి ఆదిమ క్షేత్రాల విలువలను నిల్వ చేయడం కొన్నిసార్లు చాలా సమర్థవంతంగా ఉంటుంది. మరియు వాటి ఆధారంగా వస్తువులను త్వరగా నిర్మించే వ్యవస్థలు.

ఫలితంగా, మీరు మెమరీలో మొత్తం వర్చువల్ DBMS పొందుతారు, ఇది త్వరగా పని చేస్తుంది మరియు తక్కువ మెమరీని వినియోగించుకుంటుంది.

డేటాబేస్ కాషింగ్

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

నాలుగు పెద్ద విధానాలు ఉన్నాయి:

డేటాబేస్‌ను డీనార్మలైజ్ చేయడం మొదటి విధానం . SQL సర్వర్ మెమరీలో డేటాను పట్టికలలో ఎలా నిల్వ చేయబడుతుందో దానికి భిన్నంగా నిల్వ చేస్తుంది.

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

రెండవ విధానం ప్రశ్న కాషింగ్ . మరియు ప్రశ్న ఫలితాలు.

DBMS చాలా తరచుగా అదే లేదా సారూప్య అభ్యర్థనలు వస్తుందని చూస్తుంది. అప్పుడు అది కేవలం ఈ అభ్యర్థనలను మరియు వాటి ప్రతిస్పందనలను కాష్ చేయడం ప్రారంభిస్తుంది. కానీ అదే సమయంలో, డేటాబేస్లో మారిన అడ్డు వరుసలు సకాలంలో కాష్ నుండి తీసివేయబడతాయని మీరు నిర్ధారించుకోవాలి.

ప్రశ్నలను విశ్లేషించి, వాటిని ఎలా ఉత్తమంగా కాష్ చేయాలో గుర్తించడంలో DBMSకి సహాయపడే మానవుడితో ఈ విధానం చాలా ప్రభావవంతంగా ఉంటుంది.

మూడవ విధానం ఇన్-మెమరీ డేటాబేస్ .

మరొక సాధారణంగా ఉపయోగించే విధానం. మరొక డేటాబేస్ సర్వర్ మరియు DBMS మధ్య ఉంచబడుతుంది, ఇది మొత్తం డేటాను మెమరీలో మాత్రమే నిల్వ చేస్తుంది. దీనిని ఇన్-మెమరీ-DB అని కూడా అంటారు. మీరు ఒకే డేటాబేస్‌ని యాక్సెస్ చేసే అనేక విభిన్న సర్వర్‌లను కలిగి ఉంటే, ఇన్-మెమరీ-DBని ఉపయోగించి మీరు నిర్దిష్ట సర్వర్ రకం ఆధారంగా కాషింగ్‌ను నిర్వహించవచ్చు.

ఉదాహరణ:

అప్రోచ్ 4 - డేటాబేస్ క్లస్టర్ . అనేక రీడ్-ఓన్లీ బేస్‌లు.

క్లస్టర్‌ను ఉపయోగించడం మరొక పరిష్కారం: ఒకే రకమైన అనేక DBMSలు ఒకే విధమైన డేటాను కలిగి ఉంటాయి. అదే సమయంలో, మీరు అన్ని డేటాబేస్‌ల నుండి డేటాను చదవవచ్చు మరియు ఒకదానికి మాత్రమే వ్రాయవచ్చు. ఇది మిగిలిన డేటాబేస్‌లతో సమకాలీకరించబడుతుంది.

ఇది చాలా మంచి పరిష్కారం ఎందుకంటే ఇది కాన్ఫిగర్ చేయడం సులభం మరియు ఆచరణలో పని చేస్తుంది. సాధారణంగా, డేటాను మార్చడానికి డేటాబేస్కు ఒక అభ్యర్థన కోసం, డేటాను చదవడానికి 10-100 అభ్యర్థనలు వస్తాయి.

హైబర్నేట్‌లో కాషింగ్ రకాలు

హైబర్నేట్ మూడు స్థాయిల కాషింగ్‌కు మద్దతు ఇస్తుంది:

• సెషన్ స్థాయిలో కాషింగ్ (సెషన్)
• SessionFactory స్థాయిలో కాషింగ్
• కాషింగ్ అభ్యర్థనలు (మరియు వాటి ఫలితాలు)

మీరు ఈ వ్యవస్థను అటువంటి బొమ్మ రూపంలో సూచించడానికి ప్రయత్నించవచ్చు:

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

కింది ఉదాహరణను వెంటనే పరిశీలిద్దాం:

Employee director1 = session.get(Employee.class, 4);
Employee director2 = session.get(Employee.class, 4);

assertTrue(director1 == director2);

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

అదే వస్తువు అంటే ఆబ్జెక్ట్ సూచనలు కూడా ఒకేలా ఉంటాయి. ఇది నిజంగా అదే వస్తువు.

save() , update() , saveOrUpdate() , load() , get() , list() , iterate() , మరియు scroll() పద్ధతులు ఎల్లప్పుడూ మొదటి స్థాయి కాష్‌ని ఉపయోగిస్తాయి. వాస్తవానికి, జోడించడానికి ఇంకేమీ లేదు.

రెండవ స్థాయి కాషింగ్

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

ఉదాహరణ:

Session session = factory.openSession();
Employee director1 = session.get(Employee.class, 4);
session.close();

Session session = factory.openSession();
Employee director2 = session.get(Employee.class, 4);
session.close();

assertTrue(director1 != director2);
assertTrue(director1.equals(director2));

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

రెండవ స్థాయి కాషింగ్ డిఫాల్ట్‌గా నిలిపివేయబడింది . కాబట్టి, మనకు డేటాబేస్‌లో ఒకటికి బదులుగా రెండు ప్రశ్నలు ఉన్నాయి.

దీన్ని ప్రారంభించడానికి, మీరు hibernate.cfg.xml ఫైల్‌లో క్రింది పంక్తులను వ్రాయాలి:

<property name="hibernate.cache.provider_class" value="net.sf.ehcache.hibernate.SingletEhCacheProvider"/>
<property name="hibernate.cache.use_second_level_cache" value="true"/>

రెండవ-స్థాయి కాషింగ్‌ను ప్రారంభించిన తర్వాత, హైబర్నేట్ ప్రవర్తన కొద్దిగా మారుతుంది:

Session session = factory.openSession();
Employee director1 = session.get(Employee.class, 4);
session.close();

Session session = factory.openSession();
Employee director2 = session.get(Employee.class, 4);
session.close();

assertTrue(director1 == director2);

ఈ అన్ని అవకతవకల తర్వాత మాత్రమే రెండవ-స్థాయి కాష్ ప్రారంభించబడుతుంది మరియు ఎగువ ఉదాహరణలో, డేటాబేస్కు ఒక ప్రశ్న మాత్రమే అమలు చేయబడుతుంది.