Work placement bachelor's degree computer science_2009
Presentation hibernate nfe103
1. Session : Juillet 2009
Intervenant : Hubert KADIMA
Auditeur: Manuel RAMOS
2. SOMMAIRESOMMAIRE
1- Qu’est-ce la persistance ?
2 – Histoire d’Hibernate
3 - Pourquoi utiliser
Hibernate ?
4 – Architecture Hibernate
(Interfaces, bibliothèques)
5 – Configuration (de base et
avancée)
6 - Avantages/Inconvénients
7 - Hibernate face à ses
concurrents
8 - L’avenird’Hibernate
9 - Démonstration
10 - Bibliographie
11 – Questions et réponses ?
3. Qu’est-ce que la persistance ?Qu’est-ce que la persistance ?
La persistance est le concept fondamental du
développement d’applications
C’est la couche plus basse d’une architecture
applicative
6. Qu’est-ce que la persistance ?Qu’est-ce que la persistance ?
Il faut absolument distinguer deux types de
persistance:
Persistance d’objet
Le modèle relationnel
7. Histoire d’HibernateHistoire d’Hibernate
Les premières versions datent de novembre
2001, se généralisant dans l’industrie Java
19/01/2002: Annonce de sa création par Gavin
King sur le site theserverside.com
Sortie de l’ouvrage ‘Hibernate in Action’ en
2003, écrit par Christian Bauer
Hibernate joint l’équipe JBoss.org en 2003
8. Pourquoi utiliserHibernate ?Pourquoi utiliserHibernate ?
La programmation de la couche d’accès aux données avec
SQL/JDBC s’est révélée fastidieuse et trop longue
L'intérêt est de pouvoir changer de base de données en
n'ayant besoin de ne modifier que la couche d'accès aux
données
Développer des classes persistantes en accord avec les
caractéristiques du langage objet : association, héritage,
polymorphisme, composition et les collections Java
Joindre l’univers de l’objet et du relationnel à travers le
mapping objet/relationnel (ORM)
9. Pourquoi utiliserHibernate ?Pourquoi utiliserHibernate ?
Les classes de l’API JDBC:
CLASSE ROLE
DriverManager Charge et configure le driver de la BD.
Connection Réalise la connexion et l'authentification à la
BD.
PreparedStatement Contient la requête SQL et la transmet à la
BD.
ResultSet Permet de parcourir les informations
retournées par la BD dans le cas d'une
sélection de données
10. Pourquoi utiliserHibernate ?Pourquoi utiliserHibernate ?
Tous les SGBD connus sont supportés
S’intègre parfaitement dans les plus populaires
serveurs d’applications J2EE, ou les
conteneurs Web tel que Tomcat
Open source et simple à utiliser en définissant
les objets persistés dans un fichier de mapping
XML modifiable
Remplace les accès à la base de données par
des appels à des méthodes objet de haut
niveau.
16. Configuration de baseConfiguration de base
Les étapes pour démarrer Hibernate:
1. Télécharger et décompresser le pilote JDBC
2. Import des librairies nécessaires à l'utilisation
d'hibernate
3. Choisir le pool de connexions JDBC
4. Faire connaître ces propriétés à Configuration
5. Créer une instance de configuration et charger les
fichiers de mapping XML en utilisant addRessource()
6. Générez une SessionFactory à partir de la
Configuration en appelant buildSessionFactory().
21. Déclaration de la classe persistanteDéclaration de la classe persistante
Doit obéir à une
condition : elle doit être
un POJO (Plain
Ordinary Java Object)
Implémenter un
constructeur sans
argument
Fournir une propriété
d’identifiant unique
Elle est mappée dans le
fichier comme extension
Message. Hbm.xml
22. Le fichierde mappingLe fichierde mapping
Décrit comment se fera
la persistance des
objets d’une classe
Se place dans le même
répertoire que la classe
et se nomme
classe.hbm.xml
Stratégie de
génération
D’identifiant
23. Le fichierde configurationLe fichierde configuration
Le placer dans le
répertoire source de
l’application, à la racine
de la classe PATH
Hibernate recherche
automatiquement le
fichier hibernate.cfg.xml
au démarrage.
25. Les associationsLes associations
Dans le modèle objet:
Références d’objets
Directionnelles
Dans le modèle
relationnel:
Colonne de clé
étrangère
Pas directionnelles
26. Les associations 1 to 1Les associations 1 to 1
Bidirectionnelles
simples:
31. Manipulation des données
Les données sont manipulées à partir d'une
session créée à partir de la sessionFactory:
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()
36. Avantages Inconvénients
Gain de 30 à 40% du nombre de
lignes de certains projets
Un plus grand nombre
d’optimisations plus faciles à
mener avec cet ORM automatisé.
Améliore la portabilité du code
pour des changements de SGBD.
Mise en valeur de la logique
métier.
Le plus populaire des frameworks
ORM
Une couche de persistance,
quelle qu'elle soit, a un coût.
C’est une question de choix
d'architecture et de besoin
Les procédures stockées sont
peu portable et peu flexible.
37. Hibernate face à ses concurrentsHibernate face à ses concurrents
Toplink (WebGain puis Oracle)
OJB (Apache Object/relational bridge)
Castor (EXOLAB)
Cocobase (Thought inc)
JDO (Datanucleus)
JPOX 1.2
45. Démonstration 5/23
Le développement sera effectué sur la
configuration suivante:
La plateforme Java 5
Le serveurde BDMySQL 5.0
L’EDI Eclipse 3.2
48. Démonstration 8/23
Implémentation:
Un nouveau projet Eclipse, nommé «
PetStore Hibernate », est créé.
Un nouveau schéma MySQL, nommé «
hibernate », est créé.
l'implémentation de la couche de
persistance contient un nombre réduit de
classes.
50. Démonstration 10/23
Le fichierde configuration
«hibernate.cfg.xml »
contient:
Les paramètres de
connexion à la source de
données
La liste des fichiers de
mapping des classes
persistantes
Le paramètre d’activation
des traces SQL
La configuration du cache
d’objets
64. BibliographieBibliographie
Documentation et bibliothèques: http://www.hibernate.org/
Communauté d’utilisateurs Java à Paris:
http://www.parisjug.org/
Université Marne la Vallée:
http://www-igm.univ-mlv.fr/~dr/XPOSE2004/msamson/
«Hibernate », Christian Bauer, Gavin King, CampusPress
(Open Source Reference), 07/2005
Application démo de Hibernate:
http://caveatemptor.hibernate.org
65. Les meilleures pratiquesLes meilleures pratiques
Déclarez des propriétés d'identifiants dans les
classes persistantes
Ne gérez pas vous même les connexions
JDBC
Préférez les associations bidirectionnelles
Placez chaque mapping de classe dans son
propre fichier
66. Question/Réponse ?Question/Réponse ?
Quelles sont les plug-
ins indispensables pour
concevoir un projet
Java?
A quoi sert la classe
configuration?
Quel est l’utilité de
l’interface Query?
Le package Hibernate
Core associé au plug-in
Hibernate synchronizer.
Regroupe les infos de
mapping et d’accès aux
Base de données.
Pour récupérerles
enregistrements d’une
base répondant à une
requête HQL
67. Question/Réponse ?Question/Réponse ?
Où installer les classes
du package Hibernate
Core?
L’affichage des
requêtes réalisées par
Hibernate peuvent être
activés dans le fichier
de configuration?
Dans le sous répertoire
WEB-INF/lib de
l’application web.
Modifier simplement la
valeur de l’attribut de
l’élément <property>
dont l’attribut name vaut
hibernate.show_sql.
Hinweis der Redaktion
Je me réfère aux spécifications de la persistance.
Hibernate Annotations et EntityManager >> EJB3 . Hibernate Tools >>Génère les classes de mapping à partir de la base de données. Offre un outil appelé « console Hibernate ». Hibernate extensions >>Livre CodeGenerator pour créer le fichier de mapping. Conclusion:
Chaque session factory contient les infos pour obtenir une connexion à la base (le driver JDBC, adresse URL), le dialecte SQL(Oracle, DB2,……)et d’autres informations. Hibernate affiche sur la console les requêtes SQL lancées>>>>la valeur de show_sql est porté à true.
Table par hiérarchie: 1 seule table. Table par classe fille: 3 tables. Table par classe concrète: 2 tables.
La SessionFactory est créée à partir d'une configuration de l'objet, et comme son nom l'indique il s'agit d'une usine pour la session objets.
Pour créer et persister un objet ‘BallPlayer’ dans la table ‘Player’ utilisant un API Hibernate, voir le code ci-dessus.
Code pour lire, ou pour créer un objet BallPlayer à partir de l’état persistant stocké dans une base de données est similaire.
Le type est une caractéristique puissante et fondamentale d’Hibernate. Il y’a des types primitifs, les types de mapping de date et heure (java.util), les types de mapping grands objets (binary, text, serializable, clob et blob). Il est possible de personnaliser les types par l’utilisateur . Les interfaces UserType et CompositeUserType sont proposées afin de vous permettre d’ajouter vos propres types .
1) Imaginez que vous recherchez la référence d’un contrat dans votre système commercial. Vous vous souvenez juste qu’il s’agit d’une étude de portails. Vous tapez "étude portail" dans la barre de recherche sur la page d’accueil de votre application et vous avez comme premier résultat la mission que vous cherchiez : "Étude comparative de portails". Les usages ont changé et les besoins techniques sont apparus : Pouvoir indexer les contenus métiers dans des moteurs de recherche plein texte et pouvoir les requêter simplement. 3) Depuis Hibernate 3 2, Hibernate est compatible avec la spécification JPA. Hibernate est proposée comme implémentation JPA pour les serveurs d'applications JBoss et JOnAS. Le serveur d'application GlassFish, implémentation de référence JAVA EE 5, donc d'EJB 3, propose Toplink par défaut comme implémentation de JPA(4), maîs on aurait pu imaginer un choix alternatif : Hibernate ou encore OpenJPA (Apache).
Imaginez que vous recherchez la référence d’un contrat dans votre système commercial. Vous vous souvenez juste qu’il s’agit d’une étude de portails. Vous tapez "étude portail" dans la barre de recherche sur la page d’accueil de votre application et vous avez comme premier résultat la mission que vous cherchiez : "Étude comparative de portails".
La couche de persistance de cette application fait appel à deux couches: La couche de service implémentée par la classe « CatalogueEJB ». Ce composant « EJB Session stateless » contient les règles métiers. - La couche d’accès aux données met en œuvre un modèle de conception (design pattern) « DAO ». Conclusion: Cette architecture permet de séparer le modèle de données du mécanisme de persistance.
Nous allons nous intéresser à la couche d’accès aux données. Le modèle représente le diagramme de classe d'un sous-ensemble de la couche de persistance de PetStore
L'étude va présenter le développement de 3 nouvelles stratégies d'accès aux données mettant en oeuvre le framework Hibernate . Le développement d'une nouvelle stratégie va consister à concevoir et implémenter une classe d'accès aux données , implémentant l'interface « CatalogDAO », une liste de classes persistantes et un ensemble de fichiers de mapping ou d'annotations. Les trois nouvelles classes , implémentant l'interface « CatalogDAO » posséderont les méthodes d'accès suivantes.
La classe « HibernateCatalogDAO », implémentant l'interface « CatalogueDAO », aura la charge d'accéder aux services de persistance d'Hibernate et de retourner les données sauvegardées en base de données, dans des objets du modèle de « PetStore ».
La méthode « getCategory ».
1. La méthode « currentSession( ) » de la classe « HibernateUtil » retourne la session Hibernate du thread courant. 2. Un objet « Transaction » est créé. 3. L'objet persistant « HibCategory », dont l'identifiant correspond au paramètre « categoryID », est retrouvé en appelant simplement la méthode « load » de l'objet « session ». Cet appel lance l'exécution d'une série de requêtes SQL pour retrouver l'état de l'objet « category », créée et initialise une nouvelle instance de la classe « HibCategory », puis, place l'objet reconstruit dans le système de cache. 4. L'objet « HibCategory » est converti en objet du modèle de données « Category ». 5. La transaction est « commitée » bien qu'aucune donnée n'ait été mise à jour. Les 3 méthodes de recherche de liste d'objets sont également construites sur le même modèle. L'implémentation de la méthode « getItems » est la suivante :
1. La requête doit retourner des objets de type « HibItem » : « from HibItem as i where ... » 2. Les objets « HibItem », dont la description contient l'un des mots passés en paramètre, doivent être retournés : « lower(i.details[' » + localeStr + « '].description) like '% » + token + « %' » 3. Les objets « HibItem », dont le nom du produit contient l'un des mots passés en paramètre, doivent être retournés : « lower(i.product.details[' » + localeStr + « '].name) like '% » + token + « %' » -------------------------------------------------------------------------------------------------------------------------------------------------------------------- Cette requête complexe met en oeuvre les caractérises de HQL suivantes : · navigation au travers d'une hiérarchie d'objets persistants, · accès aux données d'une table de hachage, · opérations sur les chaînes de caractères (lower, like). Une fois la requête générée, son exécution s'effectue comme nous l'avons vu dans le paragraphe précédent. ------------------------------------------------------------------------------------------------------------------------------------------------------------------- Remarque : Dans un souci de lisibilité, l'extrait de code précédent construit la requête HQL en concaténant un grand nombre de chaînes de caractères à la variable « queryStr ». Dans une implémentation réelle, un objet de type « StringBuffer » aurait été utilisée.
Les classes « HibCategory », « HibProduct » et « HibItem » sont construites sur le même modèle. Nous allons examiner l'implémentation de la classe HibItem dans ce paragraphe. La classe « HibItem » est un simple composant JavaBean possédant un constructeur par défaut et des accesseurs pour chacun de ses attributs.
Le fichier de description Hibernate.
Les classes « HibCategoryDetail », « HibProductDetail » et « HibItemDetail » sont construites sur le même modèle. Nous allons examiner l'implémentation de la classe « HibItemDetail » dans ce paragraphe. Elle contient les informations localisées de la classe « HibItem ». Comme « HibItem », la classe « HibItemDetail » est un simple composant JavaBean possédant un constructeur par défaut et des accesseurs pour chacun de ses attributs. Son fichier de description Hibernate est le suivant ci dessous :
La classe « HibernateUtil » permet de : · charger le fichier de configuration d'Hibernate et d'initialiser le singleton sessionFactory, · retourner l'objet de type « Session » associé au thread courant, · libérer l'objet de type « Session ».
Le rôle de la classe « Converter » est de créer des objets du modèle à partir des objets persistants Hibernate. L'objectif est de découpler ces deux ensembles d'objets afin de limiter les modifications à apporter au projet en cas d'évolution de l'une de ces deux parties. Le code source de la méthode de conversion d'un objet de type « HibItem », par exemple, est le suivant :
Le fichier de configuration d'Hibernate value la propriété « hibernate.hbm2ddl.auto » à « update ». Cela indique à Hibernate de mettre à jour le schéma de la base de données à chaque exécution . Lors de la première utilisation de la couche de persistance Hibernate, le schéma suivant est créé : L'absence de table associée à la classe « HibCategoryDetail » et la diversité des noms sont dues aux différents types de mapping utilisés. Nous allons les voir plus en détail :
1) Liste des bibliothèques à télécharger: Core , Annotations pour les EJB3 , Tools pour générer les classes de mapping à partir de la base de données et Entity Manager .
Hibernate rend les propriétés d'identifiants optionnelles. Il existe beaucoup de raisons pour lesquelles vous devriez les utiliser. Nous recommandons que vous utilisiez des identifiants techniques (générés, et sans connotation métier). Hibernate laisse l'application gérer les connexions JDBC. Vous ne devriez gérer vos connexions qu'en dernier recours. Si vous ne pouvez pas utiliser les systèmes de connexions livrés, réfléchissez à l'idée de fournir votre propre implémentation de org.hibernate.connection.ConnectionProvider . Les associations unidirectionnelles sont plus difficiles à questionner. Dans une grande application, la plupart des associations devraient être navigables dans les deux directions dans les requêtes. Cela prend tout son sens lors d'un travail en équipe.