3.1 హైబర్నేట్ మరియు డేటాబేస్‌లను లింక్ చేయడం

మావెన్‌ని ఉపయోగించి మా అప్లికేషన్‌కి హైబర్నేట్‌ని ఎలా కనెక్ట్ చేయాలో మరియు ఉల్లేఖనాలను ఉపయోగించి తరగతులకు పట్టికలను ఎలా మ్యాప్ చేయాలో మేము నేర్చుకున్నాము. మరియు ఇప్పుడు తదుపరి ప్రశ్న తలెత్తుతుంది - మేము డేటాబేస్ నుండి వస్తువులను ఎలా చదవాలి లేదా వాటిని అక్కడ ఎలా సేవ్ చేయాలి?

అంత వేగంగా కాదు. అన్నింటిలో మొదటిది, మీరు మరో మూడు విషయాలతో వ్యవహరించాలి:

  • డేటాబేస్ కనెక్షన్‌ని కాన్ఫిగర్ చేస్తోంది
  • హైబర్నేట్‌ని సెటప్ చేస్తోంది
  • EntityManagerతో పని చేస్తోంది

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

హైబర్నేట్‌ను కాన్ఫిగర్ చేయవచ్చు మరియు డేటాబేస్ సమాచారాన్ని మూడు విధాలుగా ఇవ్వవచ్చు

  • ప్రాపర్టీస్ ఫైల్ ఉపయోగించండి
  • hibernate.cfg.xml ఫైల్‌ని ఉపయోగించండి
  • కాన్ఫిగరేషన్ బీన్ పద్ధతులను ఉపయోగించండి

మరియు నాకు చివరిది చాలా ఇష్టం అయినప్పటికీ, మీరు ఖచ్చితంగా ఈ మూడింటిని ఎదుర్కొంటారు, కాబట్టి మేము ఇక్కడ మూడింటిని విశ్లేషిస్తాము.

3.2 డేటాబేస్లో ఆథరైజేషన్

అత్యంత ముఖ్యమైన - డేటాబేస్ కనెక్షన్లతో ప్రారంభిద్దాం. దీన్ని చేయడానికి, మీరు హైబర్నేట్ కావలసిన డేటాబేస్కు లాగిన్ చేయడానికి డేటాను అందించాలి.

గుణాలు ఫైల్ కాన్ఫిగరేషన్
hibernate.గుణాలు 
hibernate.dialect= org.hibernate.dialect.Oracle9Dialect
hibernate.connection.driver_class= oracle.jdbc.driver.OracleDriver
hibernate.connection.url= jdbc:oracle:thin:@localhost:1521:supershop
hibernate.connection.username=root
hibernate.connection.password=secret
hibernate.show_sql=true
hibernate.hbm2ddl=update
Java university

అదే సెట్టింగ్‌లను xml ఫైల్ రూపంలో సెట్ చేయవచ్చు:

XML ఆధారిత కాన్ఫిగరేషన్
hibernate.cfg.xml 
<hibernate-configuration>
	<session-factory>

    	<property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
    	<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
    	<property name="connection.url">jdbc:oracle:thin:@localhost:1521:supershop</property>
    	<property name="connection.username">root</property>
    	<property name="connection.password">secret</property>
    	<property name="hibernate.show_sql ">true</property>
    	<property name="hbm2ddl.auto">update</property>

	</session-factory>
</hibernate-configuration>

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

ఈ సెట్టింగులు మూడు సమూహాలుగా విభజించబడ్డాయి:

  1. DBMS రకాన్ని పేర్కొనండి
    • మాండలికం (DBMS రకం) పేర్కొనండి, ఉదాహరణకు, ఒరాకిల్ 9.0
    • ఈ DBMSతో పని చేయడానికి JDBC డ్రైవర్ పేరును పేర్కొనండి
  2. డేటాబేస్లో అధికారం కోసం డేటాను పేర్కొనండి
    • డేటాబేస్ url
    • వినియోగదారు పేరు
    • పాస్వర్డ్
  3. హైబర్నేట్ ఇంజిన్‌ను కాన్ఫిగర్ చేస్తోంది
    • hibernate.show_sql- హైబర్నేట్ అది అమలు చేసే అన్ని అభ్యర్థనలను కన్సోల్‌లో నకిలీ చేస్తుంది
    • hbm2ddl.auto- అవసరమైతే హైబర్నేట్ డేటాబేస్ నిర్మాణాన్ని మారుస్తుంది

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

3.3 సెషన్ ఫ్యాక్టరీని పొందండి

తదుపరి దశ SessionFactory వస్తువును పొందడం. దీన్ని చేయడానికి అనేక మార్గాలు ఉన్నాయి:

hibernate.properties ఫైల్‌ని ఉపయోగించడం మొదటి మార్గం .

దీన్ని చేయడానికి, మీరు ఈ క్రింది కోడ్‌ను వ్రాయాలి:

SessionFactory sessionFactory = new Configuration().buildSessionFactory();

ప్రస్తుత ప్రాజెక్ట్ డైరెక్టరీలో hibernate.properties ఫైల్ కనుగొనబడకపోతే, మినహాయింపు విసిరివేయబడుతుంది.

రెండవ మార్గం hibernate.cfg.xml ఉపయోగించి కాన్ఫిగరేషన్ .

SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

మీరు అలాంటి కోడ్ వ్రాస్తే, అప్పుడు hibernate.cfg.xml. అటువంటి ఫైల్ ఏదీ కనుగొనబడకపోతే, పద్ధతి buildSessionFactory()మినహాయింపును విసిరివేస్తుంది.

మూడవ మార్గం కాన్ఫిగరేషన్ ఫైల్‌ను మాన్యువల్‌గా సెట్ చేయడం .

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

SessionFactory sessionFactory = new Configuration().configure("hibernate-dev.cfg.xml").buildSessionFactory();

విధానం నాలుగు - మేము అనుకూల hibernate.properties ఫైల్‌ని ఉపయోగిస్తాము:

ClassLoader classLoader = Thread.currentThread().getClassLoader();

Properties properties = new Properties();
properties.load(classLoader.getResourceAsStream("hibernate-dev.properties"));

SessionFactory sessionFactory = new Configuration()
            .addProperties(properties)
            .buildSessionFactory();

చివరకు, మీరు అవసరమైన అన్ని పారామితులను నేరుగా కోడ్‌లోకి కుట్టవచ్చు:

Properties properties = new Properties();
properties.put(Environment.DRIVER, "com.mysql.jdbc.Driver");
properties.put(Environment.URL, "jdbc:mysql://localhost:3306/supershop");
properties.put(Environment.USER, "root");
properties.put(Environment.PASS, "password");

SessionFactory sessionFactory = new Configuration()
            .setProperties(properties)
            .buildSessionFactory();

3.4 ఎంటిటీ తరగతుల కోసం ఎక్కడ వెతకాలో పేర్కొనండి

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

మరియు SessionFactory దీన్ని చేయగలిగేలా చేయడానికి, అది డేటాబేస్‌కు మ్యాప్ చేయడానికి అవసరమైన ఎంటిటీ తరగతుల జాబితాను పాస్ చేయాలి .

ఎంటిటీ తరగతుల జాబితాలో ఉత్తీర్ణత సాధించడానికి మూడు మార్గాలు ఉన్నాయి:

విధానం ఒకటి. hibernate.cfg.xmlవంటి పంక్తిని జోడించండి :

<mapping class="class-qualified-name" />

ఉదాహరణ:

<mapping class="com.codegym.data.User" />
<mapping class="com.codegym.data.Employee" />
<mapping class="com.codegym.data.Task" />

విధానం రెండు. కాన్ఫిగరేషన్ ఆబ్జెక్ట్‌పై పద్ధతిని కాల్ చేయండి addAnnotatedClass(). ఉదాహరణ:

SessionFactory sessionFactory = new Configuration()
   	.configure()
   	.addAnnotatedClass(com.codegym.data.User.class)
   	.buildSessionFactory();

అనేక తరగతులు ఉంటే, మీరు వాటిని మొత్తం ప్యాకేజీలలో జోడించవచ్చు:

SessionFactory sessionFactory = new Configuration()
   	.configure()
   	.addPackage("com.codegym.data")
   	.buildSessionFactory();

3.5 చివరి ఉదాహరణ

ఇప్పుడు మనం SessionFactory ఆబ్జెక్ట్‌ను ఎలా కాన్ఫిగర్ చేయాలో నేర్చుకున్నాము, దానిని ఉపయోగించే కోడ్‌ను వ్రాస్దాం.

ఇది మూడు పద్ధతులను కలిగి ఉంటుంది:

  1. హైబర్నేట్ కాన్ఫిగర్ చేస్తోంది
  2. డేటాబేస్ నుండి ఉద్యోగులందరినీ పొందే పద్ధతి
  3. కొత్త ఉద్యోగిని డేటాబేస్‌లో సేవ్ చేసే పద్ధతి

ఈ కోడ్ టెంప్లేట్ ఇలా కనిపిస్తుంది:

class EmployeeManager {
    private SessionFactory sessionFactory;

    public void class init() {
    	this.sessionFactory = new Configuration()
        	.configure()
        	.buildSessionFactory();
   }

   public List<Employee> getAllEmployes() {
         try (Session session = sessionFactory.openSession()) {
  	          Query<Employee> query = session.createQuery("from Employee", Employee.class);
    	        return query.list();
         }
   }

   public void addEmployee(Employee employee ) {
     	try (Session session = sessionFactory.openSession()) {
            Transaction transaction = session.beginTransaction();
       	    session.save(employee);
            transaction.commit();
     	}
   }
}

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

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

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

కింది ఉపన్యాసాలలో, ఇవన్నీ ఎలా పనిచేస్తాయో మేము మరింత వివరంగా విశ్లేషిస్తాము.