Überwintern Sie 3 mit Spring

Hibernate 3 mit Frühling

1. Überblick

Dieser Artikel konzentriert sich auf das Einrichten vonHibernate 3 with Spring. Wir werden untersuchen, wie Sie mit XML- und Java-Konfiguration Spring mit Hibernate 3 und MySQL einrichten.

Update: Dieser Artikel befasst sich mit Ruhezustand 3. Wenn Sie nach der aktuellen Version von Hibernate suchen -this is the article focused on it.

2. Java Federkonfiguration für den Ruhezustand 3

Das Einrichten von Hibernate 3 mit Spring und Java Config ist einfach:

import java.util.Properties;
import javax.sql.DataSource;
import org.apache.tomcat.dbcp.dbcp.BasicDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
import org.springframework.orm.hibernate3.HibernateTransactionManager;
import org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import com.google.common.base.Preconditions;

@Configuration
@EnableTransactionManagement
@PropertySource({ "classpath:persistence-mysql.properties" })
@ComponentScan({ "org.example.spring.persistence" })
public class PersistenceConfig {

   @Autowired
   private Environment env;

   @Bean
   public AnnotationSessionFactoryBean sessionFactory() {
      AnnotationSessionFactoryBean sessionFactory = new AnnotationSessionFactoryBean();
      sessionFactory.setDataSource(restDataSource());
      sessionFactory.setPackagesToScan(new String[] { "org.example.spring.persistence.model" });
      sessionFactory.setHibernateProperties(hibernateProperties());

      return sessionFactory;
   }

   @Bean
   public DataSource restDataSource() {
      BasicDataSource dataSource = new BasicDataSource();
      dataSource.setDriverClassName(env.getProperty("jdbc.driverClassName"));
      dataSource.setUrl(env.getProperty("jdbc.url"));
      dataSource.setUsername(env.getProperty("jdbc.user"));
      dataSource.setPassword(env.getProperty("jdbc.pass"));

      return dataSource;
   }

   @Bean
   @Autowired
   public HibernateTransactionManager transactionManager(SessionFactory sessionFactory) {
      HibernateTransactionManager txManager = new HibernateTransactionManager();
      txManager.setSessionFactory(sessionFactory);

      return txManager;
   }

   @Bean
   public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
      return new PersistenceExceptionTranslationPostProcessor();
   }

   Properties hibernateProperties() {
      return new Properties() {
         {
            setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
            setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
         }
      };
   }
}

Im Vergleich zur nachfolgend beschriebenen XML-Konfiguration gibt es einen kleinen Unterschied, wie eine Bean in der Konfiguration auf eine andere zugreift. In XML gibt es keinen Unterschied zwischenpointing to a bean or pointing to a bean factory capable of creating that bean. Da die Java-Konfiguration typsicher ist - ein direkter Verweis auf die Bean-Factory ist nicht mehr möglich - müssen wir die Bean manuell aus der Bean-Factory abrufen:

txManager.setSessionFactory(sessionFactory().getObject());

3. XML Spring-Konfiguration für den Ruhezustand 3

In ähnlicher Weise können wir auchHibernate 3 with XML config einrichten:




    
    
    
        
            ${hibernate.hbm2ddl.auto}
            ${hibernate.dialect}

Anschließend wird diese XML-Datei mithilfe einer@Configuration-Klasse in den Spring-Kontext gebootet:

@Configuration
@EnableTransactionManagement
@ImportResource({ "classpath:persistenceConfig.xml" })
public class PersistenceXmlConfig {
   //
}

Für beide Konfigurationstypen werden die spezifischen Eigenschaften von JDBC und Ruhezustand in einer Eigenschaftendatei gespeichert:

# jdbc.X
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_hibernate_dev?createDatabaseIfNotExist=true
jdbc.user=tutorialuser
jdbc.pass=tutorialmy5ql
# hibernate.X
hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
hibernate.show_sql=false
hibernate.hbm2ddl.auto=create-drop

4. Frühling, Ruhezustand und MySQL

Im obigen Beispiel wird MySQL 5 als zugrunde liegende Datenbank verwendet, die mit Hibernate konfiguriert wurde. Hibernate unterstützt jedoch mehrere zugrunde liegendeSQL Databases.

4.1. Der Fahrer

Der Name der Treiberklasse wird überthe jdbc.driverClassName propertykonfiguriert, die der DataSource zur Verfügung gestellt werden.

Im obigen Beispiel wird es aus der Abhängigkeit vonmysql-connector-java, die wir am Anfang des Artikels im pom definiert haben, aufcom.mysql.jdbc.Driver gesetzt.

4.2. Der Dialekt

Der Dialekt wird überthe hibernate.dialect property konfiguriert, die dem RuhezustandSessionFactory zur Verfügung gestellt werden.

Im obigen Beispiel ist dies auforg.hibernate.dialect.MySQL5Dialect festgelegt, da MySQL 5 als zugrunde liegende Datenbank verwendet wird. Es gibt mehrereother dialects supporting MySQL:

org.hibernate.dialect.MySQL5InnoDBDialect - für MySQL 5.x mit der InnoDB-Speicher-Engine
org.hibernate.dialect.MySQLDialect - für MySQL vor 5.x.
org.hibernate.dialect.MySQLInnoDBDialect - für MySQL vor 5.x mit der InnoDB-Speicher-Engine
org.hibernate.dialect.MySQLMyISAMDialect - für alle MySQL-Versionen mit der ISAM-Speicher-Engine

Ruhezustandsupports SQL Dialects für jede unterstützte Datenbank.

5. Verwendungszweck

Zu diesem Zeitpunkt ist Hibernate 3 vollständig mit Spring konfiguriert und wir könneninject the raw HibernateSessionFactory direkt, wann immer wir müssen:

public abstract class FooHibernateDAO{

   @Autowired
   SessionFactory sessionFactory;

   ...

   protected Session getCurrentSession(){
      return sessionFactory.getCurrentSession();
   }
}

6. Maven

Informationen zum Hinzufügen der Spring Persistence-Abhängigkeiten zum POM finden Sie unterSpring with Maven example. Wir müssen sowohlspring-context als auchspring-orm definieren.

In Ruhezustand 3 sind die Maven-Abhängigkeiten einfach:


   org.hibernate
   hibernate-core
   3.6.10.Final

Damit Hibernate sein Proxy-Modell verwenden kann, benötigen wir außerdemjavassist:


   org.javassist
   javassist
   3.18.2-GA

Wir werden MySQL als Datenbank für dieses Tutorial verwenden, daher benötigen wir auch:


   mysql
   mysql-connector-java
   5.1.32
   runtime

Und schließlich werden wir die Spring-Datenquellenimplementierung nicht verwenden -DriverManagerDataSource; Stattdessen verwenden wir eine produktionsbereite Verbindungspoollösung - Tomcat JDBC Connection Pool:


    org.apache.tomcat
    tomcat-dbcp
    7.0.55

7. Fazit

In diesem Beispielwe configured Hibernate 3 with Spring - sowohl mit Java- als auch mit XML-Konfiguration. Die Implementierung dieses einfachen Projekts finden Sie inthe GitHub project - dies ist ein Maven-basiertes Projekt, daher sollte es einfach zu importieren und auszuführen sein, wie es ist.

TOC