3.1 Pag-uugnay ng Hibernate at Mga Database

Natutunan namin kung paano ikonekta ang Hibernate sa aming application gamit ang Maven, at kung paano i-map ang mga talahanayan sa mga klase gamit ang mga anotasyon. At ngayon ang susunod na tanong ay lumitaw - paano natin binabasa ang mga bagay mula sa database o i-save ang mga ito doon?

Teka muna. Una sa lahat, kailangan mong harapin ang tatlo pang bagay:

  • Pag-configure ng koneksyon sa database
  • Pagse-set up ng Hibernate
  • Nagtatrabaho sa EntityManager

Ang hibernate ay ganap na nagtatago ng trabaho kasama ang database mula sa iyong aplikasyon, ngunit upang maiwasan ang anumang mga labis, dapat itong i-configure nang tama. Hindi mo maaaring laktawan ang yugtong ito - kung hindi, paano malalaman ng Hibernate kung saang database ise-save ang mga bagay?

Maaaring i-configure at mabigyan ng impormasyon sa database ang hibernate sa tatlong paraan

  • Gamitin ang Properties file
  • Gamitin ang hibernate.cfg.xml file
  • Gumamit ng mga paraan ng Configuration bean

At bagama't pinakagusto ko ang huli, tiyak na makakaharap mo ang lahat ng tatlo, kaya lahat ng tatlo ay susuriin natin dito.

3.2 Awtorisasyon sa database

Magsimula tayo sa pinakamahalaga - mga koneksyon sa database. Para magawa ito, kakailanganin mong magbigay ng data para makapag-log in ang Hibernate sa gustong database.

Configuration ng File ng Properties
hibernate.properties 
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

Ang parehong mga setting ay maaaring itakda sa anyo ng isang xml file:

Java university
XML Based Configuration
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>

Sa parehong mga halimbawa, nakikita namin ang parehong mga setting na may parehong mga halaga. Ang unang halimbawa ay kumakatawan sa mga ito bilang isang properties file , at ang pangalawa bilang isang xml file .

Ang mga setting na ito ay nahahati sa tatlong pangkat:

  1. Tukuyin ang uri ng DBMS
    • Tukuyin ang diyalekto (uri ng DBMS), halimbawa, Oracle 9.0
    • Tukuyin ang pangalan ng driver ng JDBC para sa pagtatrabaho sa DBMS na ito
  2. Tukuyin ang data para sa awtorisasyon sa database
    • url ng database
    • username
    • password
  3. Pag-configure ng Hibernate Engine
    • hibernate.show_sql- Ido-duplicate ng hibernate sa console ang lahat ng mga kahilingang ipapatupad nito
    • hbm2ddl.auto- Babaguhin ng hibernate ang istraktura ng database kung kinakailangan

Mayroong ikatlong paraan ng pagtatakda ng pagsasaayos - sa pamamagitan ng mga bin. Karaniwan itong ginagamit kasabay ng Spring, kaya titingnan natin ito kapag natutunan natin ang SpringFramework.

3.3 Kunin ang SessionFactory

Ang susunod na hakbang ay upang makuha ang SessionFactory object. Mayroong ilang mga paraan upang gawin ito:

Ang unang paraan ay ang paggamit ng hibernate.properties file .

Upang gawin ito, kailangan mo lamang isulat ang sumusunod na code:

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

Kung ang hibernate.properties file ay hindi matagpuan sa kasalukuyang direktoryo ng proyekto, isang pagbubukod ang itatapon.

Ang pangalawang paraan ay pagsasaayos gamit ang hibernate.cfg.xml .

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

Kung isusulat mo ang naturang code, ang hibernate.cfg.xml. Kung walang nakitang ganoong file, ang pamamaraan buildSessionFactory()ay magtapon ng isang pagbubukod.

Ang ikatlong paraan ay ang manu-manong itakda ang configuration file .

Minsan sa panahon ng proseso ng pag-unlad, kinakailangan na lumipat sa isang base ng pagsubok o baguhin ang ilang iba pang mga setting para sa pagtatrabaho sa base, para dito maaari mong manu-manong itakda ang configuration file:

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

Ikaapat na paraan - gumagamit kami ng custom na hibernate.properties file:

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

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

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

At sa wakas, maaari mo lamang tahiin ang lahat ng kinakailangang mga parameter nang direkta sa code:

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 Tukuyin kung saan hahanapin ang mga klase ng Entity

Ngunit hindi lang iyon. Kapag nag-configure kami ng object ng SessionFactory sa Hibernate, sinusuri ng SessionFactory na ito na ang lahat ng kinakailangang talahanayan na may mga kinakailangang uri ng column ay umiiral sa database.

At para magawa ito ng SessionFactory , kailangang maipasa ang isang listahan ng mga klase ng entity na kailangan nitong imapa sa database.

May tatlong paraan upang makapasa sa isang listahan ng mga klase ng entity:

Pamamaraan isa. Sa hibernate.cfg.xmlmagdagdag ng isang linya tulad ng:

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

Halimbawa:

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

Ikalawang pamamaraan. Tawagan ang paraan sa ConfigurationaddAnnotatedClass() object . Halimbawa:

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

Kung mayroong maraming mga klase, maaari mong idagdag ang mga ito sa buong mga pakete:

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

3.5 Pangwakas na halimbawa

Ngayong natutunan na natin kung paano i-configure ang SessionFactory object, isulat natin ang code na gagamit nito.

Ito ay binubuo ng tatlong pamamaraan:

  1. Pag-configure ng Hibernate
  2. Paraan na nakakakuha ng lahat ng empleyado mula sa database
  3. Paraan na nagse-save ng isang bagong empleyado sa database

Ang template ng code na ito ay magmumukhang ganito:

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();
     	}
   }
}

Bago magsagawa ng query sa database, kailangan mong lumikha ng isang hiwalay na session. Kung ang mga kahilingan ay nauugnay, maaari silang isagawa sa parehong session. Kung ang mga kahilingan ay hindi nauugnay (at ilang minuto ang maaaring dumaan sa pagitan nila), kailangan nilang gumawa ng sarili nilang mga session.

Kung gusto mong magbasa ng data mula sa database o magsagawa ng kumplikadong query, kailangan mo munang lumikha ng Query object at gamitin ito upang maisagawa ang iyong query.

Gayundin, ang bawat query sa database ay isinasagawa sa sarili nitong transaksyon. Kailangan mong buksan ito, isagawa ang mga kinakailangang operasyon, at pagkatapos ay isara (commit).

Sa mga sumusunod na lektura, susuriin namin nang mas detalyado kung paano gumagana ang lahat.