Utiliser Hibernate avec Spring: Partie 1

Spring HibernateDans un précédant article, je vous ai présenté comment faire communiquer Spring avec JSF / Facelets. Une application étant rarement composée uniquement d’un front (ou IHM), je vais vous présenter aujourd’hui comment utiliser Hibernate avec Spring.

Dans la première partie de l’article, je présente la configuration de Spring et Hibernate. La deuxième partie est consacrée à la présentation d’un DAO créé grâce à cette configuration.

Pour rappel, Hibernate est un framework open source gérant la persistance des objets en base de données relationnelle (définition wikipédia).

Autrement dit, c’est grâce à Hibernate que vous allez gérer vos données venues de la base dans votre application Java.

Les codes sources de l’exemple sont disponibles à la fin de l’article.

 

Sommaire

Dépendances Maven

Configuration Spring

Création d’un DAO

 

Dépendances Maven


Avant de commencer, voici les dépendances Maven nécessaire pour utiliser Hibernate:

  • hibernate-core version 3.3.1.GA
  • hibernate-annotations version 3.4.0.GA
  • hibernate-commons-annotations version 3.3.0.ga
  • hibernate-entitymanager version 3.4.0.GA
  • hibernate-validator version 3.1.0.GA

L’ensemble de ces artifacts ont pour groupId org.hibernate ce qui nous donne dans le pom.xml des dépendances de la forme suviante:

<dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-core</artifactId>
  <version>3.3.1.GA</version>
</dependency>

Le SGDB utilisé pour cet exemple est mysql, voici la dépendance à ajouter pour utiliser celui-ci:

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.15</version>
</dependency>

Enfin, pour les dépendances Spring, je vous invite à lire la section « Dépendances Maven » de l’article sur Spring et JSF

Toutefois, il vous faudra ajouter les dépendances suivantes:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>3.0.5.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>3.0.5.RELEASE</version>
</dependency>

 

Configuration Spring


Pour faire communiquer Hibernate avec Spring, il va falloir configurer plusieurs beans différents. Comme souvent avec Spring, la configuration Hibernate va se faire dans le fichier applicationContext.xml.

 

DataSource:

La DataSource correspond à la configuration des coordonnées de votre base de données. C’est ici que vous allez configurer les accès à votre serveur de bases. Le bean ainsi créé fournira les connections à votre base.

Voici le code de la DataSource:

<bean id="personneDataSource"
     class="org.springframework.jdbc.datasource.DriverManagerDataSource" >
  <property name="driverClassName" value="com.mysql.jdbc.Driver" />
  <property name="url" value="jdbc:mysql://localhost:3306/test-blog" />
  <property name="username" value="root" />
  <property name="password" value="" />
</bean>

Les différentes propriétés du bean sont:

  • driverClassName: Classe Java qui gère votre SGDB. Pour mysql, cette classe est com.mysql.jdbc.Driver. Pour Oracle cette classe serait oracle.jdbc.driver.OracleDriver
  • username et password: Nom d’utilisateur est mot de passe de connection à votre base de données.
  • url: Url de connection à votre base de données. L’url est du format
jdbc://nom-du-SGDB://adresse-du-serveur:numero-du-port/nom-de-la-base

 

SessionFactory:

Une fois votre DataSource configurée, nous allons configurer la SessionFactory. C’est ici que nous allons configurer les données Hibernate à proprement dit.

La SessionFactory s’occupe de fournir les sessions à votre application quand des ordres Hibernate s’éxécutent.

Voici le code de la SessionFactory, remarquez l’utilisation d’une classe faisant le lien entre Hibernate et Spring:

<bean id="personneSessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean" >
  <property name="dataSource" ref="personneDataSource" />
  <property name="annotatedClasses">
    <list>
      <value>net.blog.dev.persistence.hibernate.Personne</value>
      <value>net.blog.dev.persistence.hibernate.Adresse</value>
    </list>
  </property>
  <property name="hibernateProperties">
    <props>
      <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
      <prop key="hibernate.show_sql">true</prop>
      <prop key="hibernate.hbm2ddl.auto">update</prop>
    </props>
  </property>
</bean>

Les différentes propriétés du bean sont:

  • dataSource: Référence vers la DataSource configurée plus haut. Nous utilisons donc une référence vers personneDataSource
  • annotatedClasses: Listes des classes annotées avec JPA représentant les objets de bases de données.
  • hibernateProperties: Configuration de Hibernate. Il existe beaucoup de propriétés disponible pour configurer Hibernate comme bon vous semble. Ici, nous définissons les éléments suivants:
    • hibernate.dialect: Chaque SGDB utilise sa propre implémentation de SQL. Il faut donc lui indiquer celui de notre SGDB, soit org.hibernate.dialect.MySQLDialect pour mysql.
    • hibernate.show_sql: Force Hibernate à afficher toutes les requêtes qu’il exécute. Ce paramètre est très utile pour le débuggage.
    • hibernate.hdm2ddl.auto: En fixant ce paramètre à « update », nous indiquons à Hibernate qu’il doit mettre à jour le schéma de base de données à chaque démarrage de l’application. Il existe d’autres valeurs pour ce paramètre comme « create » qui force Hibernate à recréer la base de données à chaque démarrage.

 

Si vous préférez utiliser des fichiers de configuration .hbm à la place des classes annotées, utilisez la propriété mappingResources et fournissez le chemin de chacun de vos fichiers .hbm. Il est tout à fait possible d’utiliser à la fois des fichiers .hbm et des classes annotées.

 

TransactionManager:

Le TransactionManager est le bean qui va s’occuper de gérer les transactions vers votre base de données de manière transparente.

La configuration de celui-ci est très simple, seul une référence vers la SessionFactory est demandée:

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

Une fois encore, remarquez la classe du bean qui est une classe de lien entre Hibernate est Spring.

 

Pour permettre à Spring de détecter les classes annotées demandant d’utiliser des transactions, ajoutez la ligne suivante:

<tx:annotation-driven transaction-manager="transactionManager" />

Le namespace pour « tx » est:

xmlns:tx="http://www.springframework.org/schema/tx"

Voila pour la fin de la première partie partie de cette présentation de Spring et Hibernate. Dans la deuxième partie, j’aborderais comment créer un DAO grâce à cette configuration. Et pour le découvrir, c’est par là ;) => Utiliser Hibernate avec Spring: partie 2.