hibernate Samouczek
Rozpoczęcie pracy z hibernacją

Uwagi

Wersje

Używanie konfiguracji XML do skonfigurowania hibernacji

Gdzieś na ścieżce klasy tworzę plik o nazwie database-servlet.xml .

Początkowo twój plik konfiguracyjny będzie wyglądał następująco:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
    http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">

</beans>

Zauważysz, że importowane z tx i jdbc Wiosenne nazw. Wynika to z faktu, że będziemy je dość intensywnie wykorzystywać w tym pliku konfiguracyjnym.

Pierwszą rzeczą, którą chcesz zrobić, to włączyć zarządzanie transakcjami oparte na adnotacjach ( @Transactional ). Głównym powodem, dla którego ludzie używają Hibernacji na wiosnę, jest to, że Spring zajmie się wszystkimi twoimi transakcjami. Dodaj następujący wiersz do pliku konfiguracyjnego:

<tx:annotation-driven />

Musimy stworzyć źródło danych. Źródłem danych jest w zasadzie baza danych, której Hibernacja zamierza użyć do utrwalenia obiektów. Zasadniczo jeden menedżer transakcji będzie miał jedno źródło danych. Jeśli chcesz, aby Hibernacja rozmawiała z wieloma źródłami danych, masz wielu menedżerów transakcji.

<bean id="dataSource" 
    class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="" />
    <property name="url" value="" />
    <property name="username" value="" />
    <property name="password" value="" />
</bean>

Klasą tego komponentu może być wszystko, co implementuje javax.sql.DataSource , abyś mógł napisać własny. Ta przykładowa klasa jest dostarczana przez Spring, ale nie ma własnej puli wątków. Popularną alternatywą jest Apache Commons org.apache.commons.dbcp.BasicDataSource , ale istnieje wiele innych. Wyjaśnię każdą z poniższych właściwości:

• driverClassName : ścieżka do sterownika JDBC. Jest to plik JAR specyficzny dla bazy danych, który powinien być dostępny na ścieżce klasy. Upewnij się, że masz najnowszą wersję. Jeśli korzystasz z bazy danych Oracle, potrzebujesz OracleDriver. Jeśli masz bazę danych MySQL, potrzebujesz MySQLDriver. Sprawdź, czy możesz znaleźć sterownik trzeba tu jednak szybkie google powinien dać odpowiedni sterownik.

• URL : adres URL Twojej bazy danych. Zwykle będzie to coś w rodzaju jdbc\:oracle\:thin\:\path\to\your\database lub jdbc:mysql://path/to/your/database . Jeśli szukasz w Google domyślnej lokalizacji używanej bazy danych, powinieneś być w stanie dowiedzieć się, jaka to powinna być. Jeśli otrzymujesz org.hibernate.HibernateException: Connection cannot be null when 'hibernate.dialect' not set HibernateException z komunikatem org.hibernate.HibernateException: Connection cannot be null when 'hibernate.dialect' not set i postępujesz zgodnie z tym przewodnikiem, istnieje 90% szans na nieprawidłowy adres URL, 5% szans twoja baza danych nie została uruchomiona i 5% szans na to, że twoja nazwa użytkownika / hasło jest nieprawidłowe.

• nazwa użytkownika : nazwa użytkownika używana podczas uwierzytelniania w bazie danych.

• hasło : hasło używane podczas uwierzytelniania w bazie danych.

Następną rzeczą jest skonfigurowanie SessionFactory . Jest to rzecz, której Hibernacja używa do tworzenia transakcji i zarządzania nimi, a także do komunikacji z bazą danych. Ma sporo opcji konfiguracji, które spróbuję wyjaśnić poniżej.

<bean id="sessionFactory"
    class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="packagesToScan" value="au.com.project />
    <property name="hibernateProperties">
        <props>
            <prop key="hibernate.use_sql_comments">true</prop>
            <prop key="hibernate.hbm2ddl.auto">validate</prop>
        </props>
    </property>
</bean>

• dataSource : Twoja fasola źródła danych. Jeśli zmieniłeś identyfikator źródła danych, ustaw go tutaj.

• PackageToScan : pakiety do skanowania w celu znalezienia obiektów z komentarzami JPA. Są to obiekty, którymi musi zarządzać fabryka sesji, zwykle będą to obiekty POJO i będą opatrzone adnotacjami @Entity . Aby uzyskać więcej informacji na temat konfigurowania relacji między obiektami w trybie hibernacji, zobacz tutaj .

• annotatedClasses (niepokazane): Możesz również podać listę klas do skanowania Hibernacji, jeśli nie wszystkie znajdują się w tym samym pakiecie. Powinieneś użyć albo packagesToScan lub annotatedClasses ale nie obu. Deklaracja wygląda następująco:

<property name="annotatedClasses">
    <list>
        <value>foo.bar.package.model.Person</value>
        <value>foo.bar.package.model.Thing</value>
    </list>
</property>

• hibernateProperties : Istnieje niezliczona ich liczba, pięknie tu udokumentowana . Główne, których będziesz używać, to:
• hibernacja.hbm2ddl.auto : Jedno z najgorętszych pytań o hibernację opisuje tę właściwość. Zobacz więcej informacji . Zasadniczo używam sprawdzania poprawności i konfiguruję bazę danych za pomocą skryptów SQL (dla pamięci w pamięci) lub wcześniej tworzę bazę danych (istniejącą bazę danych).
• hibernacja.show_sql : Flaga boolowska, jeśli true Hibernacja wypisze wszystkie wygenerowane przez siebie SQL na standardowe stdout . Możesz także skonfigurować swój rejestrator, aby pokazywał wartości związane z zapytaniami, ustawiając log4j.logger.org.hibernate.type=TRACE log4j.logger.org.hibernate.SQL=DEBUG w menedżerze logów (używam log4j ).
• hibernacja.format_sql : Flaga boolowska spowoduje, że Hibernacja ładnie wydrukuje twój SQL na standardowe wyjście.
• hibernacja.dialekt (Nie pokazano, nie bez powodu): Wiele starych samouczków pokazuje, jak ustawić dialekt hibernacji, który będzie używany do komunikacji z bazą danych. Hibernacja może automatycznie wykryć używany dialekt na podstawie używanego sterownika JDBC. Ponieważ istnieją około 3 różne dialekty Oracle i 5 różnych dialektów MySQL, pozostawiłbym tę decyzję Hibernacji. Pełna lista dialektów obsługiwanych przez Hibernację znajduje się tutaj .

Ostatnie 2 ziarna, które musisz zadeklarować to:

<bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"
    id="PersistenceExceptionTranslator" />

<bean id="transactionManager" 
    class="org.springframework.orm.hibernate4.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory" />
</bean>

PersistenceExceptionTranslator tłumaczy specyficzne dla bazy danych wyjątki HibernateException lub SQLExceptions na wyjątki Spring, które można zrozumieć w kontekście aplikacji.

Fasola TransactionManager kontroluje transakcje, a także wycofania.

Uwaga: powinieneś automatycznie wypożyczyć fasolę SessionFactory do swoich DAO.

Konfiguracja Hibernacji bez XML

Ten przykład został zaczerpnięty stąd

package com.reborne.SmartHibernateConnector.utils;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class LiveHibernateConnector implements IHibernateConnector {

    private String DB_DRIVER_NAME = "";
    private String DB_URL = "jdbc:h2:~/liveDB;MV_STORE=FALSE;MVCC=FALSE";
    private String DB_USERNAME = "sa";
    private String DB_PASSWORD = "";
    private String DIALECT = "org.hibernate.dialect.H2Dialect";
    private String HBM2DLL = "create";
    private String SHOW_SQL = "true";
    
    private static Configuration config;
    private static SessionFactory sessionFactory;
    private Session session;
    
    private boolean CLOSE_AFTER_TRANSACTION = false;

    public LiveHibernateConnector() {
        
        config = new Configuration();

        config.setProperty("hibernate.connector.driver_class",         DB_DRIVER_NAME);
        config.setProperty("hibernate.connection.url",                 DB_URL);
        config.setProperty("hibernate.connection.username",         DB_USERNAME);
        config.setProperty("hibernate.connection.password",         DB_PASSWORD);
        config.setProperty("hibernate.dialect",                     DIALECT);
        config.setProperty("hibernate.hbm2dll.auto",                 HBM2DLL);
        config.setProperty("hibernate.show_sql",                    SHOW_SQL);
    
        /*
         * Config connection pools
         */

        config.setProperty("connection.provider_class", "org.hibernate.connection.C3P0ConnectionProvider");
        config.setProperty("hibernate.c3p0.min_size", "5");
        config.setProperty("hibernate.c3p0.max_size", "20");
        config.setProperty("hibernate.c3p0.timeout", "300");
        config.setProperty("hibernate.c3p0.max_statements", "50");
        config.setProperty("hibernate.c3p0.idle_test_period", "3000");
        
        
        /**
         * Resource mapping
         */
        
//        config.addAnnotatedClass(User.class);
//        config.addAnnotatedClass(User.class);
//        config.addAnnotatedClass(User.class);
    
        sessionFactory = config.buildSessionFactory();
    }


    public HibWrapper openSession() throws HibernateException {
        return new HibWrapper(getOrCreateSession(), CLOSE_AFTER_TRANSACTION);
    }


    public Session getOrCreateSession() throws HibernateException {
        if (session == null) {
            session = sessionFactory.openSession();
        }
        return session;
    }

    public void reconnect() throws HibernateException {
        this.sessionFactory = config.buildSessionFactory();
    }

    
}

Należy pamiętać, że w najnowszym Hibernacji to podejście nie działa dobrze (wersja Hibernacja 5.2 nadal pozwala na tę konfigurację)

Prosty przykład hibernacji przy użyciu XML

Aby skonfigurować prosty projekt hibernacji przy użyciu XML dla konfiguracji, potrzebujesz 3 plików, hibernate.cfg.xml, POJO dla każdej encji i EntityName.hbm.xml dla każdej encji. Oto przykład każdego używającego MySQL:

hibernacja.cfg.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC 
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
   <session-factory>
   <property name="hibernate.dialect">
      org.hibernate.dialect.MySQLDialect
   </property>
   <property name="hibernate.connection.driver_class">
      com.mysql.jdbc.Driver
   </property>

   <property name="hibernate.connection.url">
      jdbc:mysql://localhost/DBSchemaName
   </property>
   <property name="hibernate.connection.username">
      testUserName
   </property>
   <property name="hibernate.connection.password">
      testPassword
   </property>

   <!-- List of XML mapping files -->
   <mapping resource="HibernatePractice/Employee.hbm.xml"/>

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

DBSchemaName, testUserName i testPassword zostaną zastąpione. Pamiętaj, aby użyć pełnej nazwy zasobu, jeśli jest ona w pakiecie.

Employee.java

package HibernatePractice;

public class Employee {
    private int id;
    private String firstName;
    private String middleName;
    private String lastName;
    
    public Employee(){
        
    }
    public int getId(){
        return id;
    }
    public void setId(int id){
        this.id = id;
    }
    public String getFirstName(){
        return firstName;
    }
    public void setFirstName(String firstName){
        this.firstName = firstName;
    }
    public String getMiddleName(){
        return middleName;
    }
    public void setMiddleName(String middleName){
        this.middleName = middleName;
    }
    public String getLastName(){
        return lastName;
    }
    public void setLastName(String lastName){
        this.lastName = lastName;
    }
}

Employee.hbm.xml

<hibernate-mapping>
   <class name="HibernatePractice.Employee" table="employee">
      <meta attribute="class-description">
         This class contains employee information. 
      </meta>
      <id name="id" type="int" column="empolyee_id">
         <generator class="native"/>
      </id>
      <property name="firstName" column="first_name" type="string"/>
      <property name="middleName" column="middle_name" type="string"/>
      <property name="lastName" column="last_name" type="string"/>
   </class>
</hibernate-mapping>

Ponownie, jeśli klasa znajduje się w pakiecie, użyj pełnej nazwy klasy nazwa_pakietu. Nazwa_klasy.

Po uzyskaniu tych trzech plików możesz rozpocząć hibernację w swoim projekcie.