HIBERNATE Framework de mapping objet-relationnel

Présentation au sujet: "HIBERNATE Framework de mapping objet-relationnel"— Transcription de la présentation:

1 HIBERNATE Framework de mapping objet-relationnel
Riadh Ouersighni Année

2 Architecture d'une application Java en couches
Une application java est souvent découpée en couches. Considérons une architecture courante, celle à trois couches : La couche [1], (User Interface) : dialogue avec l'utilisateur, via une interface graphique Swing, une interface console ou une interface web. Elle a pour rôle de fournir des données provenant de l'utilisateur à la couche [2] ou bien de présenter à l'utilisateur des données fournies par la couche [2]. • La couche [2], appelée ici [metier] est la couche qui applique les règles dites métier, c.a.d. la logique spécifique de l'application, sans se préoccuper de savoir d'où viennent les données qu'on lui donne, ni où vont les résultats qu'elle produit. • La couche [3], appelée ici [dao] (Data Access Object) est la couche qui fournit à la couche [2] des données pré-enregistrées et qui enregistre certains des résultats fournis par la couche [2]. Couche Interface utilisateur Couche Métier Couche d’accès aux données (DAO) Données 1 2 3 Hibernate java

3 Couche accès aux données
Il existe différentes possibilités pour implémenter la couche Accès aux Données Couche Interface Couche Métier Couche d’accès aux données (DAO) 1 2 3 Couche JDBC utilisateur Base de données La couche [JDBC] est la couche standard utilisée en Java pour accéder à des bases de données. Elle isole la couche [dao] du SGBD qui gère la base de données. Hibernate java

4 Couche d’accès aux données (DAO)
Couche HIBERNATE De multiples efforts ont été faits pour isoler la couche [dao] des aspects propriétaires des SGBD. Une solution qui a eu un vrai succès dans ce domaine ces dernières années, est celle d'Hibernate BD Couche Hibernate Objets image de la BD Couche d’accès aux données (DAO) Couche JDBC La couche [Hibernate] vient se placer entre la couche [dao] écrite par le développeur et la couche [Jdbc] Hibernate est un ORM (Object Relational Mapping), un outil qui fait le pont entre le modèle relationnel des bases de données et celui des objets manipulés par Java Le développeur ne voit plus la couche [Jdbc] ni les tables de la BD. Il ne voit que l'image objet de BD, fournie par la couche [Hibernate]. Le pont entre les tables de la BD et les objets manipulés par la couche [dao] est fait par des fichiers de configuration de type XML Hibernate java

5 Hibernate Hibernate est un projet open source visant à proposer un outil de mapping entre les objets et des données stockées dans une base de données relationnelle. Ce projet ne repose sur aucun standard mais il est très populaire notamment à cause de ses bonnes performances et de son ouverture avec de nombreuses bases de données. Les bases de données supportées sont les principales du marché : Oracle, MySQL, PostgreSQL, Sybase, SQLServer, Sap DB, DB2,Interbase, ... Le site officiel contient beaucoup d'informations sur l'outil et propose de le télécharger ainsi que sa documentation. Hibernate java

6 Architecture Hibernate
Hibernate java

7 Principe de fonctionnement à l’aide d’un Exemple
Nous allons utiliser Hibernate avec une base de données de type MySQL possédant une table nommée "personnes". Créez la table personnes dans la BD bdperso Hibernate a besoin de plusieurs éléments pour fonctionner : Une classe « javabean » qui encapsule les données d'une occurrence d'une table Un fichier de correspondance qui configure la correspondance entre la classe et la table des propriétés de configuration notamment des informations concernant la connexion à la base de données Une fois ces éléments correctement définis, il est possible d'utiliser Hibernate dans le code des traitements à réaliser. Hibernate java

8 Configuration Hibernate sous NetBeans 6.1
Sous Netbeans, ajoutez le framework Hibernate : Allez dans « tools “ + “plugins “+ “Available plugins” , sélectionnez Hibernate puis installez. Créez un nouveau projet web sous NetBeans Dans la définition du nouveau projet, cochez Framework Hibernate Ajoutez Mysql jdbc Driver (click droit sur Librairie puis Add) Configuration hibernate.cfg.xml : Pour exécuter Hibernate, il faut lui fournir un certain nombre de propriétés concernant sa configuration pour qu'il puisse se connecter à la base de données. Ces propriétés peuvent être fournies sous plusieurs formes : un fichier de configuration nommé hibernate.properties et stocké dans un répertoire inclus dans le classpath un fichier de configuration au format XML nommé hibernate.cfg.xml Hibernate java

9 Hibernate java

10 Nom de la BD Hibernate java

11 Les propriétés de configuration Les principales propriétés pour configurer la connexion JDBC sont :
Nom Propriété Rôle hibernate.connection.driver_class nom pleinement qualifié de classe du pilote JDBC hibernate.connection.url URL JDBC désignant la base de données hibernate.connection.username nom de l'utilisateur pour la connexion hibernate.connection.password mot de passe de l'utilisateur hibernate.connection.pool_size nombre maximum de connexions dans le pool Autres propriétés Nom Propriété Rôle hibernate.dialect nom de la classe pleinement qualifiée qui assure le dialogue avec la base de données hibernate.show_sql booléen qui précise si les requêtes SQL générées par Hibernate sont affichées dans la console (utile lors du débogage) Hibernate java

12 Le Fichier Hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>  <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration  DTD 3.0//EN" " <hibernate-configuration>  <session-factory name="hiSession">  <!-- dialect -->  <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>  <!-- driver -->  <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>  <!-- host -->  <property name="hibernate.connection.url"> jdbc:mysql://localhost:3306/bdperso </property>  <!-- username -->  <property name="hibernate.connection.username">root</property>  <!-- password to my db -->  <property name="hibernate.connection.password"/></property>  </session-factory>  </hibernate-configuration>  Hibernate java

13 Etape suivante : La création d'une classe qui va encapsuler les données
Cette classe doit respecter le standard des javabeans notamment encapsuler les propriétés dans ces champs private avec des getters et setters et avoir un constructeur vide. import java.util.Date; public class Personnes { private Integer idPersonne; private String nomPersonne; private String prenomPersonne; private Date datenaissPersonne; public Personnes(String nomPersonne, String prenomPersonne, Date datenaissPersonne) { this.nomPersonne = nomPersonne; this.prenomPersonne = prenomPersonne; this.datenaissPersonne = datenaissPersonne; } public Personnes() { } Pour ajouter les Getters et les Setters : click droit puis choisir « Insert code » Netbeans génère automatiquement les méthodes get et set Hibernate java

14 Clic droit ici Hibernate java

15 Etape suivante : Mapping : La création d'un fichier de correspondance
Pour assurer le mapping, Hibernate a besoin d'un fichier de correspondance (mapping file) au format XML qui va contenir des informations sur la correspondance entre la classe définie et la table de la base de données. Le plus simple est de définir un fichier de mapping par classe, nommé du nom de la classe suivi par ".hbm.xml". Ce fichier doit être situé dans le même répertoire que la classe correspondante ou dans la même archive pour les applications packagées. Dans notre projet Netbeans : Click droit / new / other / hibernate / hibernate mapping file / OK Différents éléments sont précisés dans ce document XML : la classe qui va encapsuler les données l'identifiant dans la base de données et son mode de génération le mapping entre les propriétés de classe et les champs de la base de données les relations Hibernate java

16 Hibernate java

17 Hibernate java

18 Hibernate java

19 Hibernate java

20 <. xml version="1. 0". ><
<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN" " <hibernate-mapping> <class name="Personnes" table="personnes"> <id name="idPersonne" type="int" column="idpersonne"> <generator class="native"/> </id> <property name="nomPersonne" type="string" not-null="true" /> <property name="prenomPersonne" type="string" not-null="true" /> <property name="datenaissPersonne" type="date"> <meta attribute="field-description">date de naissance</meta> </property> </class> </hibernate-mapping> Hibernate java

21 Ce tag possède plusieurs attributs dont les principaux sont:
Le tag <class> permet de préciser des informations sur la classe qui va encapsuler les données. Ce tag possède plusieurs attributs dont les principaux sont: Nom Obligatoire rôle name oui Nom de la classe table Nom de la table dans la Base de donnée dynamic-update non booléen qui indique de ne mettre à jour que les champs dont la valeur a été modifiée (false par défaut) dynamic-insert booléen qui indique de générer un ordre insert que pour les champs dont la valeur est non nulle (false par défaut) Le tag <generator>, fils obligatoire du tag <id>, permet de préciser quel est le mode de génération d'un nouvel identifiant. Ce tag possède un attribut : class (obligatoire) qui précise la classe qui va assurer la génération de la valeur d'un nouvel identifiant. Il existe plusieurs classes fournies en standard par Hibernate qui possèdent un nom utilisable comme valeur de cet attribut. Hibernate java

22 Les classes de génération fournies en standard par Hibernate possèdent chacun un nom :
Rôle increment incrémentation d'une valeur dans la JVM identify utilisation d'un identifiant auto-incrémenté pour les bases de données qui le supportent (DB2, MySQL,SQL Server, ...) sequence utilisation d'une séquence pour les bases de données qui le supportent (Oracle, DB2, PostgreSQL, ...) hilo utilisation d'un algorithme qui utilise une valeur réservée pour une table d'une base de données (par exemple une table qui stocke la valeur du prochain identifiant pour chaque table) seqhilo idem mais avec un mécanisme proche d'une séquence uuid.hex utilisation d'un algorithme générant un identifiant sur 32 caractères prenant en compte entre autre l'adresse IP de la machine et l'heure du système uuid.string idem générant un identifiant sur 16 caractères native utilise la meilleure solution proposée par la base de données assigned la valeur est fournie par l'application foreign la valeur est fournie par un autre objet avec lequel la classe est associée Hibernate java

23 Hibernate doit savoir qu’est ce qu’il “mappe”
Ajouter ce code au fichier xml “hibernate.cfg.xml” <mapping class=“Personnes"  resource=“Personnes.hbm.xml"/>  Hibernate java

24 Utilisation d'Hibernate
Pour utiliser Hibernate dans le code, il est nécessaire de réaliser plusieurs opérations : création d'une instance de la classe création d'une instance de la classe SessionFactory création d'une instance de la classe Session qui va permettre d'utiliser les services d'Hibernate Hibernate java

25 addFile() qui attend en paramètre le nom du fichier de mapping
Si les propriétés sont définies dans le fichier hibernate.properties, il faut tout d'abord créer une instance de la classe Configuration. Pour lui associer la ou les classes encapsulant les données, la classe propose deux méthodes : addFile() qui attend en paramètre le nom du fichier de mapping addClass() qui attend en paramètre un objet de type Class encapsulant la classe. Dans ce cas, la méthode va rechercher un fichier nommé nom_de_la_classe.hbm.xml dans le classpath (ce fichier doit se situé dans le même répertoire que le fichier .class de la classe correspondante) Hibernate java

26 fournies par les propriétés de configuration.
Une instance de la classe Session est obtenu à partir d'une fabrique de type SessionFactory. Cet objet est obtenu à partir de l'instance du type Configuration en utilisant la méthode buildSessionFactory(). La méthode openSession() de la classe SessionFactory permet d'obtenir une instance de la classe Session. Par défaut, la méthode openSession() qui va ouvrir une connexion vers la base de données en utilisant les informations fournies par les propriétés de configuration. Hibernate java

27 import net.sf.hibernate.*; import net.sf.hibernate.cfg.Configuration;
Exemple : import net.sf.hibernate.*; import net.sf.hibernate.cfg.Configuration; import java.util.Date; public class TestHibernate1 { public static void main(String args[]) throws Exception { Configuration config = new Configuration(); config.addClass(Personnes.class); SessionFactory sessionFactory = config.buildSessionFactory(); Session session = sessionFactory.openSession(); …. Hibernate java

28 Le fichier “HibernateUtil. java” permet de créer le “session factory “
Le fichier “HibernateUtil.java” permet de créer le “session factory “ . Il faut créer une nouvelle classe import org.hibernate.SessionFactory;  import org.hibernate.cfg.Configuration;  public class HibernateUtil {    private static final SessionFactory sessionFactory;  static {  try {    //Create the SessionFactory  sessionFactory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();  } catch (Throwable ex) {  // Log the Exception  System.err.println("SessionFactory creation failed!!!" + ex);  throw new ExceptionInInitializerError(ex);  }  public static SessionFactory getSessionFactory() {  return sessionFactory;  Hibernate java

29 La persistance d'une nouvelle occurrence
Pour créer une nouvelle occurrence dans la source de données, il suffit de : créer une nouvelle instance de 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. La méthode save() n'a aucune action directe sur la base de 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. Voir exemple de code suivant : Hibernate java

30 import net.sf.hibernate.*; import net.sf.hibernate.cfg.Configuration;
import java.util.Date; public class TestHibernate1 { public static void main(String args[]) throws Exception { Configuration config = new Configuration(); config.addClass(Personnes.class); SessionFactory sessionFactory = config.buildSessionFactory(); Session session = sessionFactory.openSession(); Transaction tx = null; try { tx = session.beginTransaction(); Personnes personne = new Personnes("nom3", "prenom3", new Date()); session.save(personne); session.flush() ; tx.commit(); } catch (Exception e) { if (tx != null) { tx.rollback(); } throw e; } finally { session.close(); sessionFactory.close(); Hibernate java

31 Le langage de requête HQL
Pour offrir un langage d'interrogation commun à toutes les base de données, Hibernate propose son propre langage nommé HQL (Hibernate Query Language) HQL est proche de SQL avec une utilisation sous forme d'objets des noms de certaines entités : il n'y a aucune référence aux tables ou aux champs car ceux ci sont référencés respectivement par leur classe et leurs propriétés. C'est Hibernate qui se charge de générer la requête SQL à partir de la requête HQL en tenant compte du contexte (type de base de données utilisée défini dans le fichier de configuration et la configuration du mapping). Hibernate java

32 Exemple : rechercher toutes les occurrences d'une table
La méthode find() de la classe Session permet d'effectuer une recherche d'occurrences grâce à la requête fournie en paramètre. Exemple : rechercher toutes les occurrences d'une table import net.sf.hibernate.*; import net.sf.hibernate.cfg.Configuration; import java.util.*; public class TestHibernate3 { public static void main(String args[]) throws Exception { Configuration config = new Configuration(); config.addClass(Personnes.class); SessionFactory sessionFactory = config.buildSessionFactory(); Session session = sessionFactory.openSession(); try { List personnes = session.find("from Personnes"); for (int i = 0; i < personnes.size(); i++) { Personnes personne = (Personnes) personnes.get(i); System.out.println("nom = " + personne.getNomPersonne()); } } finally { session.close(); }sessionFactory.close(); }} Hibernate java

33 import net.sf.hibernate.*; import net.sf.hibernate.cfg.Configuration;
import java.util.*; public class TestHibernate4 { public static void main(String args[]) throws Exception { Configuration config = new Configuration(); config.addClass(Personnes.class); SessionFactory sessionFactory = config.buildSessionFactory(); Session session = sessionFactory.openSession(); try { List personnes = session.find("from Personnes p where p.nomPersonne=?","nom1", Hibernate.STRING); for (int i = 0; i < personnes.size(); i++) { Personnes personne = (Personnes) personnes.get(i); System.out.println("nom = " + personne.getNomPersonne()); } } finally { session.close(); sessionFactory.close(); Hibernate java

34 import net.sf.hibernate.*; import net.sf.hibernate.cfg.Configuration;
import java.util.*; public class TestHibernate5 { public static void main(String args[]) throws Exception { Configuration config = new Configuration(); config.addClass(Personnes.class); SessionFactory sessionFactory = config.buildSessionFactory(); Session session = sessionFactory.openSession(); try { int compteur = ( (Integer) session.iterate("select count(*) from Personnes").next()).intValue(); System.out.println("compteur = " + compteur); } finally { session.close(); sessionFactory.close(); } Hibernate java

35 La mise à jour d'une occurrence
Pour mettre à jour une occurrence dans la source de données, il suffit d'appeler la méthode update() de la session en lui passant en paramètre l'objet encapsulant les données. Le mode de fonctionnement de cette méthode est similaire à celui de la méthode save(). La méthode saveOrUpdate() laisse Hibernate choisir entre l'utilisation de la méthode save() ou update() en fonction de la valeur de l'identifiant dans la classe encapsulant les données. Hibernate java

36 session.delete("from Personnes");
La suppression d'une ou plusieurs occurrences La méthode delete() de la classe Session permet de supprimer une ou plusieurs occurrences en fonction de la version surchargée de la méthode utilisée. Pour supprimer une occurrence encapsulée dans une classe, il suffit d'invoquer la classe en lui passant en paramètre l'instance de la classe. Pour supprimer plusieurs occurrences, voire toutes, il faut passer en paramètre de la méthode delete(), une chaîne de caractères contenant la requête HQL pour préciser les éléments concernés par la suppression. Exemple session.delete("from Personnes"); Hibernate java

37 relation de type 1 - 1 (one-to-one)
Les relations Un des fondements du modèle de données relationnelles repose sur les relations qui peuvent intervenir entre une table et une ou plusieurs autres tables ou la table elle même. Hibernate propose de transcrire ces relations du modèle relationnel dans le modèle objet. Il supporte plusieurs types de relations : relation de type (one-to-one) relation de type 1 - n (many-to-one) relation de type n - n (many-to-many) Dans le fichier de mapping, il est nécessaire de définir les relations entre la table concernée et les tables avec lesquelles elle possède des relations. Hibernate java