Site de référence : www.hibernate.org
Hibernate est un produit Open source sous licence GNU LGPL, développé par une équipe issue de la communauté JBOSS, aujourd'hui filiale de la société Red Hat.

Principale fonctionnalité :
Le rôle principal d'Hibernate est de remplacer l'accès aux bases de données par l'appel de méthodes objet de haut niveau.
Hibernate 3, version avec laquelle nous allons travailler, est capable de gérer la persistance avec des bases de données relationnelles, mais aussi avec des bases de données objet et des fichiers XML.

Il existe également une version d'Hibernate pour .net : NHibernate.

• Base de données
• Fichiers jar
• Fichier xml de configuration d'Hibernate

• Documentation Hibernate
• Annotations JPA
• Langage de requêtes HQL

Vous disposez de :

• Eclipse Juno J2EE
• Hibernate 3
• Mysql Server
• Driver JDBC pour Mysql

bklablaz

Nous allons travailler à partir d'un cas simple, et assez couramment utilisé :

• Un SI composé de produits, classés en catégories (1 CIF).
• Des commandes de produits effectuées, dont le détail est stocké dans des lignes (1 CIM).

Mise en place la configuration logicielle.

• Créer un nouveau Dynamic Web Project dans Eclipse
• Intégrer les jars d'Hibernate 3 et le driver JDBC pour mysql dans le dossier WebContent/WEB-INF/lib
• Copier le fichier xml de configuration d'Hibernate dans le dossier src du projet.

• Créer la base de données ormH sur votre serveur Mysql en exécutant le script de création (la base est créée dans le script).

Afficher le concepteur pour visualiser les tables, et les relations : Pour chaque table, notez les contraintes d'intégrité :

1. d'entité (clé primaire)
2. référentielle (relations)

Exemple :

Produit :

• id (primary key)
• idCategorie (foreign key references categorie.id)

Ouvir le fichier de configuration d'Hibernate dans le dossier src :

Vérifiez les paramètres de connexion à Mysql.

Les lignes suivantes vont permettre d'assurer la persistance des classes que nous allons créer : Categorie et Produit.

    <mapping class="metier.Categorie" />
    <mapping class="metier.Produit" />

hibernate.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="connection.url">jdbc:mysql://localhost/orm</property>
		<property name="connection.username">root</property>
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="connection.password"></property>
		<property name="connection.pool_size">10</property>
		<property name="current_session_context_class">thread</property>
		<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
 
		<property name="hbm2ddl.auto">validate</property>
		<property name="show_sql">true</property>
		<property name="format_sql">true</property>
 
	<mapping class="metier.Categorie" />
	<mapping class="metier.Produit" />
 
	</session-factory>
</hibernate-configuration>

Il est maintenant nécessaire de créer une classe Java permettant de piloter une session Hibernate. Cette classe n'ayant besoin d'être instanciée qu'une seule fois pour ensuite nous permettre d'effectuer le mapping entre classes et base de données, nous utiliserons une classe statique, ou un singleton. (c'est une pratique recommandée par la communauté JBoss).

Créer la classe HibernateUtil dans le package hibernate

|h HibernateUtil.java

package hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
 
public class HibernateUtil {
 
	private static final SessionFactory sessionFactory = buildSessionFactory();
 
	private static SessionFactory buildSessionFactory() {
		try {
			// Create the SessionFactory from hibernate.cfg.xml
			return new AnnotationConfiguration().configure().buildSessionFactory();
 
		}
		catch (Throwable ex) {
			// Make sure you log the exception, as it might be swallowed
			System.err.println("Initial SessionFactory creation failed." + ex);
			throw new ExceptionInInitializerError(ex);
		}
	}
 
	public static SessionFactory getSessionFactory() {
		return sessionFactory;
	}
 
	public static void shutdown() {
		// Close caches and connection pools
		getSessionFactory().close();
	}
	public Session getSession(){
		return getSessionFactory().openSession();
	}
}

Modèle relationnel :

Modèle Objet (diagramme de classes) correspondant :

Nous allons modifier le modèle Objet pour le rendre compatible avec Hibernate et permettre le mapping, en ajoutant des membres qui serviront d'identifiants (habituellement inutiles dans le monde Objet) :

La Java persistence API (JPA) sera utilisée pour définir le mapping relationnel/objet. Elle va permettre de mettre des annotations sur les classes métier de façon à définir leur persistance.

Ci-dessous le début de l'implémentation des classes :

Les principes de construction des classes métiers à mapper avec hibernate sont les suivants :

• A chaque champ de la base correspond un membre de données de la classe
• les types de données java et sql doivent être compatibles (consulter la documentation hibernate pour voir la correspondance entre les types)
• La classe doit être un java Bean pour permettre à Hibernate de travailler :
  • elle doit disposer d'un constructeur sans paramètre
  • Chacun de ses membres doit disposer d'accesseurs
  • Le mapping avec la base de données est défini au travers des annotations JPA posées sur les membres de la classe.

Observation du chargement d'un objet, par l'intermédiaire de sa clé primaire.

Interrogation de données avec Hibernate :

Modifiez la méthode toString de la classe Categorie :

	@Override
	public String toString() {
		return "Categorie [id=" + id + ", libelle=" + libelle + ", produits="
				+ produits + "]";
	}

Modifiez le programme pour qu'il utilise cette méthode :

		for(Categorie categorie:categories)
			System.out.println(categorie);

Manipulations et contexte en partie inspirés d'un TD Hibernate de JP PUJOL