HIBERNATE
http://www.gherabi.com/
HIBERNATE
Mapping Objet / base de données relationnelle
Introduction
Les applications d'entreprises
s'orientent de plus en plus vers des
architectures orientée service. La
technologie J2EE et les frameworks qui
se sont créés autour offrent beaucoup
d'outils pour répondre aux
besoins modernes.
Introduction
Travailler dans les deux univers que sont l'orienté objet et la base de
données relationnelle peut être lourd et consommateur en temps dans le
monde de l'entreprise d'aujourd'hui.
Orienté objet Hibernate Base de données relationnelle
Hibernate est un outil de mapping objet/relationnel pour le monde Java.
Le terme mapping objet/relationnel (ORM) décrit la technique qui
consiste à faire le lien entre la représentation objet des données et sa
représentation relationnelle basée sur un schéma SQL.
Introduction
Sans Hibernate Avec Hibernate
Mapping objet-relationnel
SGBD
SGBD
Logique SQL
métier
Logique
métier
Transparence de la persistance
Introduction
Hibernate:
§ S'occupe du Transfert des classes Java dans les tables de la base de
données.
§ Il permet d’interroger les données.
§ Propose des moyens de les récupérer.
Il peut donc réduire de manière significative le temps de
développement qui aurait été autrement perdu dans une
manipulation manuelle des données via SQL et JDBC.
Objectif
q Le but d'Hibernate est de libérer le développeur de 95% des tâches de
programmation liées à la persistance des données communes.
q Hibernate vous aidera à supprimer ou à encapsuler le code SQL
spécifique à votre base de données et vous aidera sur la tâche
commune qu'est la transformation des données d'une représentation
tabulaire à une représentation sous forme de graphe d'objets.
Architecture
Une vue (très) haut niveau de l'architecture d'Hibernate
Hibernate utilise une base de données et
des données de configuration pour fournir
un service de persistance (et des objets
persistants) à l'application.
Architecture
Hibernate est flexible et supporte différentes approches. L'architecture
légère laisse l'application fournir ses propres connexions JDBC et gérer ses
propres transactions.
§ Cette approche utilise le minimum des APIs Hibernate
Architecture
§ Séparation des couches
Définitions
q SessionFactory (org.hibernate.SessionFactory)
Un cache threads des mappings vers une (et une seule) base de données. Une
factory (fabrique) de Session et un client de ConnectionProvider. Peut contenir un
cache optionnel de données (de second niveau) qui est réutilisable entre les
différentes transactions
q Session (org.hibernate.Session)
Un objet mono-threadé, à durée de vie courte, qui représente une conversation entre
l'application et l'entrepôt de persistance. Encapsule une connexion JDBC. Factory
(fabrique) des objets Transaction. Contient un cache des objets persistants, ce cache
est obligatoire. Il est utilisé lors de la navigation dans le graphe d'objets ou lors de la
récupération d'objets par leur identifiant.
q Objets et Collections persistants
Objets mono-threadés à vie courte contenant l'état de persistance et la fonction
métier. Ceux-ci sont en général les objets de type JavaBean; la seule particularité est
qu'ils sont associés avec une (et une seule) Session.
Définitions
q Transaction (org.hibernate.Transaction)
(Optionnel) Un objet mono-threadé à vie courte utilisé par l'application pour définir
une unité de travail. Abstrait l'application des transactions sous-jacentes qu'elles
soient JDBC, JTA ou CORBA. Une Session peut fournir plusieurs Transactions dans
certains cas.
q ConnectionProvider (org.hibernate.connection.ConnectionProvider)
(Optionnel) Le fabriquant des connexions JDBC. Abstrait l'application de la
Datasource ou du DriverManager sous-jacent.
Configuration Hibernate
Principales classes et interfaces
² Classe org.hibernate.cfg.Configuration → hibernate.cfg.xml
² Classe org.hibernate.HibernateException → Gestion d’exceptions
² Interface org.hibernate.SessionFactory → Fabrique d’objets → Permet
de lire les fichiers hbm.
² Interface org.hibernate.Session → Creation des sessions
² Interface org.hibernate.Query → Ecrire du HQL en utilisant les objets
JAVA de persistence.
² Interface org.hibernate.SQLQuery → Ecrire du SQL
² Interface org.hibernate.Transaction : Objet transaction → commit(),
rollback().
Configuration Hibernate
Configuration Hibernate.cfg.xml Chemin : /META-INF
<?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/mabase</property>
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property>
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="show_sql">true</property>
<property name="hbm2ddl.auto">create</property>
<mapping resource="library/Book.hbm.xml" />
</session-factory>
</hibernate-configuration>
Configuration Hibernate
Fichier de mapping
§ Chargement et stockage des données persistantes
§ Indication des tables et la base de données à utiliser
§ Définition de la structure des tables
§ Définition des clés primaires
§ Correspondance entre les noms et les types des objets et les noms des
colonnes
v Format XML : Se place dans le même répertoire que la classe et se
nomme Classe.hbm.xml si la classe s’appelle Classe
v Fichier de propriétés : se nomme log4.properties Se place dans le même
répertoire META-INF
Configuration Hibernate
Classe de persistance : Book Chemin : /SRC
public class Book implements Serializable {
private java.lang.Integer id;
private java.lang.String title;
public Book() {}
public java.lang.Integer getId() {
return id; }
public void setId(java.lang.Integer id) {
this.id = id;}
public java.lang.String getTitle() {
return this.title;}
public void setTitle(java.lang.String title) {
this.title = title; }
}
Configuration Hibernate
Fichier de mapping Chemin : /SRC
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net//hibernate-mapping 3.0.dtd">
<hibernate-mapping>
<class name="Book" table=" Table_Book">
<id name="id" column="BOOK_ID">
<generator class=" Increment " />
</id>
<property name="title"
type ="String" column="Book_TITLE"/>
</class>
</hibernate-mapping>
Configuration Hibernate
Attributs du tag property
v column : indique le nom de la colonne dans la table
relationnelle. Par défaut, elle a le même nom que la
propriété (attribut name)
v type : indique le type « Hibernate » de la propriété;
Hibernate en déduit le type SQL et le type Java.
v id : est obligatoire pour chaque classe qui est représentée
par une table. Il indique quelle sera la clé primaire de la
table
Configuration Hibernate
Générateur de clés
v Le tag generator, sous tag de id, indique comment seront
générées les clés des objets
v Pratique conseillée : clé artificielle
<id name="id" column="PERSON_ID">
<generator class="native"/>
</id>
Configuration Hibernate
Générateur disponibles
v Quelques Générateurs :
§ Increment : génère des identifiants de type long, short ou int qui
ne sont uniques que si aucun autre processus n'insère de données
dans la même table
§ native: choisit le générateur en fonction de la base de données
(sequence pour Oracle ou PostgreSQL, identity pour MYSQL par
ex.)
§ assigned: laisse l'application affecter un identifiant à l'objet avant
que la métode save() ou persist() ne soit appelée.
Requêtes HQL
v Hibernate Query Langage est un langage d'interrogation des classes
persistantes avec une syntaxe proche du SQL. Cependant les objets
manipulés sont les classes et membres du mapping contrairement
au SQL qui réalise les requêtes directement sur la base de données.
Aussi, le HQL contient des fonctionnalités spécifiques au modèle
objet.
v Les requêtes HQL peuvent être formées des éléments principaux
suivants :
§ les clauses (from, select, where, order by, ...)
§ les fonctions d'agrégation (count, sum, avg, max, ...)
Requêtes HQL
Exemple :
v Select
From Personne where nom = ’Saloumi’
v Update
update Personne set age = ’35’ where nom = ’Saloumi’
v Delete
delete Personne where nom = :nom
Persistance des données
Sauvegarde des données
v Pour créer une nouvelle occurrence dans la source de données, il
suffit de :
- créer une nouvelle instance de la classe encapsulant les données, de
valoriser ces propriétés, et d’appeler la méthode save() de la session
en lui passant en paramètre l’objet encapsulant les données.
- Pour enregistrer les données dans la base, il faut réaliser un commit
sur la connexion ou la transaction ou faire appel à la méthode flush()
de la classe Session.
tx = session.beginTransaction();
Personnes personne = new Personnes("nom3", "prenom3", new Date());
session.save(personne);
session.flush() ;
tx.commit();
Persistance des données
Récupération des données
v La méthode load() de la classe Session permet d’effectuer une
recherche d’occurrences grâce à la requête fournie en paramètre.
v La méthode load() possède plusieurs surcharges pour permettre de
fournir un seul ou plusieurs paramètres
Personnes personne = (Personnes) session.load(Personnes.class, new Integer(1));
Id
Gestion de session
Parcourir les données
v Il est également possible de définir des requêtes utilisant des paramètres
nommés grâce à un objet implémentant l’interface Query.
v Un objet de type Query est obtenu en invoquant la méthode createQuery()
de la classe Session avec comme paramètre la requête HQL.
v Pour parcourir la collection des occurrences trouvées, l’interface Query
propose la méthode list() qui renvoie une collection de type List ou la
méthode iterate() qui renvoie un itérateur sur la collection.
Query query = session.createQuery( "from Personnes p where p.nomPersonne
=:nom");
Iterator personnes = query.iterate();
while (personnes.hasNext())
{ Personnes personne = (Personnes) personnes.next();
System.out.println("nom = " + personne.getNomPersonne());
}
Gestion de session
Exemple : Enregistrer des données
public class TestHibernate {
public static void main(String args[]) throws Exception {
Configuration config = new Configuration();
SessionFactory sessionFactory = config.buildSessionFactory();
Session session = sessionFactory.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
Personnes personne = new Personnes("nom", "prenom", new Date());
session.save(personne);
tx.commit();
} catch (Exception e) { if (tx != null) {
tx.rollback(); }
} finally {
session.close(); }
sessionFactory.close(); }
}
