Hibernate 3 avec Spring

1. Vue d'ensemble

Cet article se concentrera sur la configuration deHibernate 3 with Spring - nous verrons comment utiliser la configuration XML et Java pour configurer Spring avec Hibernate 3 et MySQL.

Mise à jour: cet article se concentre sur Hibernate 3. Si vous recherchez la version actuelle d'Hibernate -this is the article focused on it.

2. Java Configuration de Spring pour Hibernate 3

La configuration d’Hibernate 3 avec Spring et Java config est simple:

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

Par rapport à la configuration XML (décrite ci-après), il existe une petite différence dans la manière dont un bean de la configuration en accède à un autre. En XML, il n'y a pas de différence entrepointing to a bean or pointing to a bean factory capable of creating that bean. Étant donné que la configuration Java est sécurisée par le type - le pointage direct vers la fabrique de beans n'est plus une option - nous devons récupérer le bean manuellement de la fabrique de beans:

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

3. Configuration XML Spring pour Hibernate 3

De même, nous pouvons également configurerHibernate 3 with XML config:




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

Ensuite, ce fichier XML est amorcé dans le contexte Spring à l'aide d'une classe@Configuration:

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

Pour les deux types de configuration, les propriétés spécifiques à JDBC et Hibernate sont stockées dans un fichier de propriétés:

# 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 et MySQL

L'exemple ci-dessus utilise MySQL 5 comme base de données sous-jacente configurée avec Hibernate - cependant, Hibernate prend en charge plusieursSQL Databasesous-jacents.

4.1. Le conducteur

Le nom de la classe du pilote est configuré viathe jdbc.driverClassName property fourni à DataSource.

Dans l'exemple ci-dessus, il est mis àcom.mysql.jdbc.Driver à partir de la dépendancemysql-connector-java que nous avons définie dans le pom, au début de l'article.

4.2. Le dialecte

Le dialecte est configuré viathe hibernate.dialect property fourni auxSessionFactory Hibernate.

Dans l'exemple ci-dessus, il est défini surorg.hibernate.dialect.MySQL5Dialect car nous utilisons MySQL 5 comme base de données sous-jacente. Il existe plusieursother dialects supporting MySQL:

org.hibernate.dialect.MySQL5InnoDBDialect - pour MySQL 5.x avec le moteur de stockage InnoDB
org.hibernate.dialect.MySQLDialect - pour MySQL antérieur à 5.x
org.hibernate.dialect.MySQLInnoDBDialect - pour MySQL antérieur à 5.x avec le moteur de stockage InnoDB
org.hibernate.dialect.MySQLMyISAMDialect - pour toutes les versions de MySQL avec le moteur de stockage ISAM

Hibernatesupports SQL Dialects pour chaque base de données prise en charge.

5. Usage

À ce stade, Hibernate 3 est entièrement configuré avec Spring et nous pouvonsinject the raw HibernateSessionFactory directement chaque fois que nous avons besoin de:

public abstract class FooHibernateDAO{

   @Autowired
   SessionFactory sessionFactory;

   ...

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

6. Maven

Pour ajouter les dépendances Spring Persistence au pom, veuillez consulter lesSpring with Maven example - nous devrons définir à la foisspring-context etspring-orm.

En poursuivant vers Hibernate 3, les dépendances Maven sont simples:


   org.hibernate
   hibernate-core
   3.6.10.Final

Ensuite, pour permettre à Hibernate d'utiliser son modèle proxy, nous avons également besoin dejavassist:


   org.javassist
   javassist
   3.18.2-GA

Nous allons utiliser MySQL comme base de données pour ce didacticiel, nous aurons donc également besoin de:


   mysql
   mysql-connector-java
   5.1.32
   runtime

Et enfin, nous n'utiliserons pas l'implémentation de la source de données Spring - lesDriverManagerDataSource; à la place, nous utiliserons une solution de pool de connexions prête pour la production - Tomcat JDBC Connection Pool:


    org.apache.tomcat
    tomcat-dbcp
    7.0.55

7. Conclusion

Dans cet exemple,we configured Hibernate 3 with Spring - à la fois avec une configuration Java et XML. L'implémentation de ce projet simple se trouve dansthe GitHub project - il s'agit d'un projet basé sur Maven, il devrait donc être facile à importer et à exécuter tel quel.

TOC

Hibernate 3 avec Spring