1.1 పట్టికలకు తరగతులను మ్యాపింగ్ చేయడం

JDBC నేర్చుకున్న తర్వాత, జావా అప్లికేషన్ నుండి డేటాబేస్‌తో పని చేయడం ఇంకా ఆనందంగా ఉందనే అభిప్రాయం మీకు ఎక్కువగా ఉంటుంది. ఈ పనులన్నీ 10 రెట్లు సులభంగా చేయవచ్చని నేను మీకు చెబితే?

SQL భాష యొక్క ప్రధాన ప్రయోజనం ఏమిటి? ఇది డిక్లరేటివ్ లాంగ్వేజ్ - ఇది మనం ఏమి పొందాలనుకుంటున్నామో వివరిస్తుంది మరియు దీన్ని ఎలా చేయాలో ఏమీ చెప్పదు. ఎలా - ఇది SQL సర్వర్ యొక్క ఆందోళన.

డేటాబేస్‌లతో పనిచేసేటప్పుడు అదే విధానాన్ని ఉపయోగించవచ్చు.

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

నేను ఏమి చెప్పగలను, 2000లో చాలా మంది అబ్బాయిలు ఇలా ఆలోచించారు మరియు వారి స్వంత ORM ఫ్రేమ్‌వర్క్‌ను వ్రాయాలని నిర్ణయించుకున్నారు.

ORM అంటే ఆబ్జెక్ట్-రిలేషనల్ మ్యాపింగ్ మరియు తప్పనిసరిగా SQL ప్రశ్నలకు జావా ఆబ్జెక్ట్‌ల మ్యాపింగ్.

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

ఈ సమస్యను పరిష్కరించడానికి మూడు విధానాలు ఉన్నాయి మరియు అవి ఇలా ఉన్నాయి:

  1. ఆబ్జెక్ట్ తనను తాను డేటాబేస్కు సేవ్ చేస్తుంది మరియు డేటాబేస్ నుండి సమాచారం ఆధారంగా దాని ఫీల్డ్లను నవీకరిస్తుంది.
  2. ఆబ్జెక్ట్ తనంతట తానుగా డేటాబేస్‌లో సేవ్ చేసుకోగలుగుతుంది, కానీ ఈ కేసును ఎప్పటికీ ప్రారంభించదు.
  3. ఆబ్జెక్ట్ డేటాను మాత్రమే కలిగి ఉంటుంది మరియు ఎవరైనా దానిని డేటాబేస్‌లో సేవ్ చేసి డేటాబేస్ నుండి లోడ్ చేస్తారు.

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

కానీ ఒకరోజు అంతా మారిపోయింది...

1.2 హైబర్నేట్ యొక్క ఆవిర్భావం

2001లో, హైబర్నేట్ ఫ్రేమ్‌వర్క్ యొక్క మొదటి వెర్షన్ విడుదలైంది. ఇది చాలా సరళమైన ఫ్రేమ్‌వర్క్, కానీ డేటాబేస్‌లో వాటిని ఎలా నిల్వ చేయాలి లేదా అక్కడ నుండి లోడ్ చేయాలి అనే దాని గురించి ఏమీ తెలియని సాధారణ "స్టుపిడ్ ఆబ్జెక్ట్‌ల" వినియోగాన్ని ఇది అనుమతించింది.

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

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

మరియు ORM విధానం నిజంగా ఆ భావనను విచ్ఛిన్నం చేస్తుంది. డేటా తరగతి దాని అంతర్గత నిర్మాణాన్ని బహిర్గతం చేస్తుంది, అయితే వివిధ రకాల వస్తువుల సమూహాలతో పనిచేయడం చాలా సులభం.

జావా 5 విడుదలైన తర్వాత , JDKలో రెండు విషయాలు కనిపించినప్పుడు ఒక పెద్ద పురోగతి వచ్చింది:

  • ఉల్లేఖనాలు
  • ప్రాక్సీ

ఉల్లేఖనాలుXML త్వరగా భర్తీ చేయబడింది మరియు ఇప్పుడు జావా క్లాస్‌లోని డేటాబేస్‌లోని పట్టికకు జావా క్లాస్‌ను మ్యాపింగ్ చేయడానికి అవసరమైన అన్ని సెట్టింగ్‌లను పేర్కొనడం సులభం.

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

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

1.3 JPA ఆవిర్భావం

డి ఫాక్టో తర్వాత డి జ్యూర్ గుర్తింపు. JDK డెవలపర్‌లు డేటాబేస్‌లోని టేబుల్‌లకు ఆబ్జెక్ట్‌లను ఎలా సరిగ్గా మ్యాప్ చేయాలో స్పెసిఫికేషన్‌ను రూపొందించాలని నిర్ణయించుకున్నారు. ఈ స్పెసిఫికేషన్ అంటారుJPA- జావా పెర్సిస్టెన్స్ API.

ఇది ఖచ్చితంగా స్పెసిఫికేషన్. ఇది ప్రతిదీ ఎలా పని చేయాలి మరియు దాని వస్తువులు డేటాబేస్‌లో సేవ్ చేయబడాలంటే తరగతిలోని వివిధ భాగాలను గుర్తించాల్సిన ఉల్లేఖనాలను వివరిస్తుంది.

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

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

  • JPA ప్రమాణం
  • హైబర్నేట్ స్థానిక API (అదనపు కార్యాచరణ)

అధికారిక హైబర్నేట్ డాక్యుమెంటేషన్ దీన్ని ఇలా వివరిస్తుంది:

కానీ నా అనుభవం ఆధారంగా మరియు హైబర్నేట్ డాక్యుమెంటేషన్‌ను మళ్లీ చదివిన తర్వాత, JPA మరియు Hibernate API 95% ఒకేలా ఉన్నాయని నేను చెప్పగలను. అవి ఒకే విధమైన భావనలు మాత్రమే.

1.4 హైబర్నేట్ కోసం మావెన్

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

ముందుగా, ఒక అధికారిక సైట్ ఉంది, ఇక్కడ ఆంగ్ల భాషా డాక్యుమెంటేషన్ కొంత ఉంది. ఆమె, వాస్తవానికి, సూచన సమాచారంలో పక్షపాతాన్ని కలిగి ఉంది మరియు శిక్షణలో కాదు. కానీ మూలాలను డీబగ్ చేయడం కంటే ఇది ఇప్పటికీ ఉత్తమం, సరియైనదా? :)

సూచన:

  1. మీరు లింక్ తెరవండి .
  2. మీరు ఆమెను చాలా సేపు చూస్తున్నారు.
  3. CodeGymకి తిరిగి వస్తున్నాను.
  4. మీరు నా తదుపరి ఉపన్యాసాలు చదవండి.

నా పని సంక్లిష్టమైన విషయాలను సరళీకృతం చేయడం మరియు వాటిని సరళంగా వివరించడం. మరియు మీరు ఈ స్థాయికి చేరుకున్నట్లయితే, నేను చేయగలను.

బాగా, హైబర్నేట్‌తో ప్రారంభించడానికి, మీరు దీన్ని మీ pom.xmlకి జోడించాలి. ఈ రోజు వరకు, హైబర్నేట్ యొక్క 6వ వెర్షన్ ఇప్పటికే అందుబాటులో ఉంది, లేదా 6.1.1, కాబట్టి మేము తాజా వెర్షన్‌తో ఎలా పని చేయాలో నేర్చుకుంటాము.

మీ pom.xmlకి ఈ పంక్తులను జోడించండి:


<dependency>
	<groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
	<version>6.1.1.Final</version>
</dependency>

మీరు ఈ ఉపన్యాసాన్ని 2023+ విండో వెలుపల చదువుతున్నట్లయితే, కొత్త సంస్కరణను ఇక్కడ డౌన్‌లోడ్ చేసుకోవచ్చు .

ముఖ్యమైనది! హైబర్నేట్ ఉపయోగించే కొన్ని లైబ్రరీలు JDK 11 మరియు JDK 17లో నిలిపివేయబడ్డాయి, కాబట్టి మీరు మీ ప్రాజెక్ట్‌ను ప్రారంభించడంలో మరియు అమలు చేయడంలో సమస్య ఉన్నట్లయితే, దానికి ఈ డిపెండెన్సీలను జోడించండి:


  	<dependency>
        <groupId>jakarta.xml.bind</groupId>
        <artifactId>jakarta.xml.bind-api</artifactId>
      	<version>4.0.0</version>
  	</dependency>
 
  	<dependency>
        <groupId>org.glassfish.jaxb</groupId>
        <artifactId>jaxb-runtime</artifactId>
      	<version>4.0.0</version>
  	</dependency>
 
  	<dependency>
        <groupId>org.javassist</groupId>
        <artifactId>javassist</artifactId>
        <version>3.29.0-GA</version>
  	</dependency>