Ruhezustand 3 mit Frühling

1. Übersicht

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

Update: Dieser Artikel konzentriert sich auf den Ruhezustand 3. Wenn Sie nach der aktuellen Version von Hibernate suchen, ist dies der Artikel, der sich darauf konzentriert.

2. Java Spring-Konfiguration für den Ruhezustand 3

Das Einrichten von Hibernate 3 mit Spring- und Java-Konfiguration ist unkompliziert:

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({ "com.baeldung.spring.persistence" }) public class PersistenceConfig { @Autowired private Environment env; @Bean public AnnotationSessionFactoryBean sessionFactory() { AnnotationSessionFactoryBean sessionFactory = new AnnotationSessionFactoryBean(); sessionFactory.setDataSource(restDataSource()); sessionFactory.setPackagesToScan(new String[] { "com.baeldung.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 in der Art und Weise, wie eine Bean in der Konfiguration auf eine andere zugreift. In XML gibt es keinen Unterschied zwischen dem Verweisen auf eine Bean oder dem Verweisen auf eine Bean-Factory, die diese Bean erstellen kann . Da die Java-Konfiguration typsicher ist und es nicht mehr möglich ist, direkt auf die Bean Factory zu verweisen, 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 Hibernate 3 auch mit XML-Konfiguration 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 JDBC- und Hibernate-spezifischen Eigenschaften 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. Spring, Hibernate und MySQL

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

4.1. Der Fahrer

Der Name der Treiberklasse wird über die Eigenschaft jdbc.driverClassName konfiguriert, die der DataSource zur Verfügung gestellt wird.

Im obigen Beispiel wird es auf com.mysql.jdbc.Driver aus der MySQL-Connector-Java- Abhängigkeit festgelegt, die wir im POM am Anfang des Artikels definiert haben.

4.2. Der Dialekt

Der Dialekt wird über konfiguriert die hibernate.dialect Eigenschaft auf den Ruhezustand vorgesehen Session .

Im obigen Beispiel ist dies auf org.hibernate.dialect.MySQL5Dialect festgelegt, da wir MySQL 5 als zugrunde liegende Datenbank verwenden. Es gibt mehrere andere Dialekte, die MySQL unterstützen :

  • 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

Der Ruhezustand unterstützt SQL-Dialekte für jede unterstützte Datenbank.

5. Verwendung

Zu diesem Zeitpunkt ist Hibernate 3 vollständig mit Spring konfiguriert, und wir können die unformatierte Hibernate SessionFactory direkt einfügen, wann immer dies erforderlich ist:

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 im Beispiel Spring with Maven. Wir müssen sowohl den Spring-Kontext als auch den Spring-Orm definieren .

Im 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 auch javassist :

 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 - die DriverManagerDataSource ; Stattdessen verwenden wir eine produktionsbereite Verbindungspoollösung - Tomcat JDBC Connection Pool:

 org.apache.tomcat tomcat-dbcp 7.0.55 

7. Fazit

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