Hibernate

Employé :
<one-to-one name="person" class="Person"/>

Personne :
<one-to-one name="employee" class="Employee" constrained="true"/>

2. Relation d'héritage

Exemple : une personne peut être associée à son statut d'employé ou d'externe par une relation d'héritage. Cette technique peut se décompose en trois cas :
-table par hiérachie : création d'une seule table. (personne avec 2 colonnes en plus société et codeInterne)
-table par classe fille : création de 3 tables (personne - employé - externe)
-table par classe concrète : création de deux tables (employé - externe)
Dans le premier cas, le fichier de mapping s'écrit :

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<!-- Strategie table-per-class hierarchy mapping -->
<hibernate-mapping package="utilisateur4">
	 <class name="Personne" table="PERSONNES" discriminator-value="P">
	 	<id name="idPers" column="idPers" type="long">
	 		<generator class="sequence"/>
        </id>
        <discriminator column="sousclasse" type="character"/>
		<property name="nom" column="nom" type="string"/>
		<property name="prenom" column="prenom" type="string"/>
        <set name="identifications" inverse="true" cascade="all-delete-orphan" >
		 	<key column="pers"/>
            <one-to-many class="utilisateur4.Identification" />
		</set>
		<subclass name="Employe" discriminator-value="E">
			<property name="codeInterne" column="codeInterne" type="string"/>
		</subclass>
		<subclass name="Externe" discriminator-value="X">
			<property name="societe" column="societe" type="string"/>
		</subclass>
	</class>
</hibernate-mapping>

3. Relation <many to one>

Exemple : une personne peut être associée à plusieurs identifications dans le cadre d'un logiciel gérant des profils. La classe Personne a un nouvel attribut , correspondant à une collection d'objet Identification, et la classe Identification à un nouveau champ correspondant à une personne. Le fichier de mapping de la classe Personne s'écrit :

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<!-- Strategie table-per-class hierarchy mapping -->
<hibernate-mapping package="utilisateur3">
	 <class name="Personne" table="PERSONNES" discriminator-value="P">
	 	<id name="idPers" column="idPers" type="long">
	 		<generator class="sequence"/>
        </id>
        <discriminator column="sousclasse" type="character"/>
		<property name="nom" column="nom" type="string"/>
		<property name="prenom" column="prenom" type="string"/>
        <set name="identifications" inverse="true" cascade="all-delete-orphan">
		 <key column="pers"/>
            <one-to-many class="utilisateur3.Identification" />
	   </set>
	</class>
</hibernate-mapping>

La balise <set> permet d'identifier la collection qui contiendra les identifications. La clause cascade="all-delete-orphan" permet d'effacer les identifications correspondant à une personne lors de la suppression de la personne. Le fichier de mapping de la classe Identification s'écrit :

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping package="utilisateur3">
	<class name="Identification" table="UTILISATEUR2" >
		<id name="idUser" column="idUser" type="long">
			<generator class="sequence" />
		</id>
		<property name="login" column="login" type="string"/>
		<property name="password" column="password" type="string"/>
		<many-to-one name="pers" class="utilisateur3.Personne" not-null="true"/>
	</class>
</hibernate-mapping>

4. Relation <many to many>

Exemple : une personne peut être associée à plusieurs rôles dans une entreprise et un rôle peut être affecté à plusieurs personnes.
La classe Personne a un nouvel attribut, correspondant à une collection d'objets rôle, et la classe rôle a une collection d'attributs correspondant à une collection d'objets Personne. Il faut trois tables pour pouvoir mapper cette relation. Le fichier de mapping de la classe Personne s'écrit :

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<!-- Strategie table-per-class hierarchy mapping -->
<hibernate-mapping package="utilisateur5">
	 <class name="Personne" table="PERSONNES" discriminator-value="P">
	 	<id name="idPers" column="idPers" type="long">
	 		<generator class="sequence"/>
        </id>
        <discriminator column="sousclasse" type="character"/>
		<property name="nom" column="nom" type="string"/>
		<property name="prenom" column="prenom" type="string"/>
        <set  name="roles" table="PERSONNES_ROLES">
			<key column="idPers" />
			<many-to-many  class="utilisateur5.Role" column="idRole" />
	  </set>	
</hibernate-mapping>

La table PERSONNES_ROLES permet de faire la jointure entre la table PERSONNES et la tables ROLES. Le fichier de mapping de la classe Role s'écrit :

</class><?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
	

<hibernate-mapping package="utilisateur5">
	<class name="Role" table="ROLES" >
		<id name="idRole" column="idRole" type="long">
			<generator class="sequence" />
		</id>
		<property name="nom" column="nom" type="string"/>
		
		<set  name="personnes" table="PERSONNES_ROLES" inverse="true" >
			<key column="idRole" />
			<many-to-many  class="utilisateur5.Personne" column="idPers" >
		</set>	
	</class>
</hibernate-mapping>

5. Component mapping

Exemple : Une personne possède un nom et un prénom.
On peut créer une classe Personne dont l'attribut nom est de type Name. Le fichier de mapping de la classe Personne s'écrit :

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<!-- Strategie table-per-class hierarchy mapping -->
<hibernate-mapping package="utilisateur5">
	 <class name="Personne" table="PERSONNES" discriminator-value="P">
	 	<id name="idPers" column="idPers" type="long">
	 		<generator class="sequence"/>
        </id>
        <discriminator column="sousclasse" type="character"/>
	  <property name="nom" column="nom" type="string"/>
	  <property name="prenom" column="prenom" type="string"/>
	   
	<component name="Name" class="utilisateur5.Name"> 
        <property name="nom"/>
        <property name="prenom"/>
      </component>
</hibernate-mapping>

6. Mapping de collections

Hibernate permet d'assurer la persistance des collections de type java.util.Map, java.util.Set, java.util.SortedMap, java.util.SortedSet, java.util.List, et tous les tableaux d'entités et valeurs persistantes. Les propriétés de java.util.Collection ou java.util.List peuvent aussi être mappées avec la sémantique de Sac (Bag).

Manipulation des données

1. Chargement, Sauvegarde, Modification et Supression

Les données sont manipulées à partir d'une session créée à partir de la sessionFactory. Différentes actions sont possibles :
=> chargement des données : session.load()
=> Sauvegarde des données : session.save()
=> Chargement des données non sûres : session.get()
=> Suppression des données : session.delete()
=> Mise à jour des données : session.update()
Exemple de code de manipulation de données :

SessionFactory sessionFactory = cfg.buildSessionFactory();
	// ouverture de la session
	session = sessionFactory.openSession();
	tx = session.beginTransaction();
			
	// Récupérons l utilsateur de iduser = 25
	util1 = (Personne) session.get(Personne.class, new Long(25),LockMode.UPGRADE);
	// Modifions son password
	util1.setPassword("maow");
	// Sauvons l'enregistremment
	session.update(util1);
			
	// Suppression de l'utilisateur id = 26
	util1 = (Personne) session.load(Personne.class, new Long(26));
	session.delete(util1);
   tx.commit();

2. Les différentes Requêtes

Query q2 = session.createQuery("from Personne where idPers = 1");
pers = (Personne) q2.list().get(0);
user.setPers(pers);

Transaction et concurrence

1. Optimistic Control Concurrency

Le mode de contrôle optimiste de la concurrence laisse le soin à hibernate de gérer lui -même l'accès à la base de données. Pour une application distribuée, toutes les sessions doivent être créées à partir de la même instance de la session Factory.

2. Pessimistic Locking

Le mode de contrôle pessimiste laisse à l'utilisateur le soin de gérer les accès concurrents à la base de données. Il existe plusieurs mode de chargement des objets permettant de la manipuler en toute sécurité :

LockMode.WRITE est obtenu automatiquement lorsqu'Hibernate insère ou modifie un enregistrement.

LockMode.UPGRADE peut être obtenu à la demande explicite de l'utilsateur en utilisant la syntaxe SELECT ... FOR UPDATE sur les bases de données qui la supportent.

LockMode.READ est obtenu automatiquement lorsqu'Hibernate consulte des données avec des niveaux d'isolation de type lectures reproductibles (repeatable read) ou de type sérialisable (serializable). Peut être réobtenu à la demande explicite de l'utilsateur

LockMode.NONE représente l'absence de verrou. Tous les objets basculent à ce verrou à la fin d'une Transaction. Les objets associés à la session via l'appel de update() ou saveOrUpdate() démarrent aussi sur ce mode de verrou.

Exemple :

// Récupérons l utilsateur de iduser = 25
util1 = (Personne) session.get(Personne.class, new Long(25), LockMode.UPGRADE);

Liens

Contact