Documentation de rfrence d'HibernateVersion: 2.1.8

Table des matiresPrface ............................................................................................................................................ vi 1. Exemple simple utilisant Tomcat ................................................................................................ 1 1.1. Vos dbuts avec Hibernate .................................................................................................. 1 1.2. La premire classe persistante ............................................................................................. 4 1.3. Mapper le Chat .................................................................................................................. 5 1.4. Jouer avec les chats ............................................................................................................ 6 1.5. Conclusion ........................................................................................................................ 8 2. Architecture ................................................................................................................................ 9 2.1. Gnralits ........................................................................................................................ 9 2.2. Integration JMX ............................................................................................................... 11 2.3. Support JCA .................................................................................................................... 11 3. Configuration de la SessionFactory ........................................................................................... 12 3.1. Configuration par programmation ..................................................................................... 12 3.2. Obtenir une SessionFactory .............................................................................................. 12 3.3. Connexion JDBC fournie par l'utilisateur ........................................................................... 13 3.4. Connexions JDBC fournie par Hibernate ........................................................................... 13 3.5. Proprits de configuration optionnelles ............................................................................ 15 3.5.1. Dialectes SQL ....................................................................................................... 18 3.5.2. Chargement par Jointure Ouverte ........................................................................... 19 3.5.3. Flux binaires ......................................................................................................... 19 3.5.4. CacheProvider spcifique ....................................................................................... 19 3.5.5. Configuration de la stratgie transactionnelle .......................................................... 19 3.5.6. SessionFactory associe au JNDI ............................................................................ 20 3.5.7. Substitution dans le langage de requtage ................................................................ 20 3.6. Logguer ........................................................................................................................... 21 3.7. Implmenter une NamingStrategy ..................................................................................... 21 3.8. Fichier de configuration XML ........................................................................................... 21 4. Classes persistantes ................................................................................................................... 23 4.1. Un exemple simple de POJO ............................................................................................. 23 4.1.1. Dclarer les accesseurs et modifieurs des attributs persistants ................................... 24 4.1.2. Implmenter un constructeur par dfaut .................................................................. 24 4.1.3. Fournir une proprit d'indentifiant (optionnel) ........................................................ 24 4.1.4. Favoriser les classes non finales (optionnel) ............................................................ 25 4.2. Implmenter l'hritage ...................................................................................................... 25 4.3. Implmenter equals() et hashCode() .................................................................................. 25 4.4. Callbacks de cycle de vie .................................................................................................. 26 4.5. Callback de validation ...................................................................................................... 27 4.6. Utiliser le marquage XDoclet ............................................................................................ 27 5. Mapping O/R basique ............................................................................................................... 29 5.1. Dclaration de Mapping .................................................................................................... 29 5.1.1. Doctype ................................................................................................................ 29 5.1.2. hibernate-mapping ................................................................................................. 29 5.1.3. class ..................................................................................................................... 30 5.1.4. id .......................................................................................................................... 32 5.1.4.1. generator .................................................................................................... 32 5.1.4.2. Algorithme Hi/Lo ....................................................................................... 33 5.1.4.3. UUID Algorithm ........................................................................................ 34 5.1.4.4. Colonne Identity et Sequences ..................................................................... 34 Hibernate 2.1.8 ii

HIBERNATE - Persistence Relationnelle dans un Java 5.1.4.5. Identifiants assigns .................................................................................... 34 5.1.5. composite-id ......................................................................................................... 35 5.1.6. discriminator ......................................................................................................... 35 5.1.7. version (optionnel) ................................................................................................ 36 5.1.8. timestamp (optionnel) ............................................................................................ 36 5.1.9. property ................................................................................................................ 37 5.1.10. many-to-one ........................................................................................................ 38 5.1.11. one-to-one ........................................................................................................... 39 5.1.12. component, dynamic-component .......................................................................... 40 5.1.13. subclass .............................................................................................................. 41 5.1.14. joined-subclass .................................................................................................... 41 5.1.15. map, set, list, bag ................................................................................................. 42 5.1.16. import ................................................................................................................. 42 5.2. Types Hibernate ............................................................................................................... 42 5.2.1. Entits et valeurs ................................................................................................... 43 5.2.2. Les types de valeurs basiques ................................................................................. 43 5.2.3. Type persistant d'enumration ................................................................................ 44 5.2.4. Types de valeurs personnaliss ............................................................................... 45 5.2.5. Type de mappings "Any" ....................................................................................... 45 5.3. identificateur SQL mis entre guillemets ............................................................................. 46 5.4. Fichiers de mapping modulaires ........................................................................................ 46 6. Mapping des Collections ........................................................................................................... 47 6.1. Collections persistantes .................................................................................................... 47 6.2. Mapper une Collection ..................................................................................................... 48 6.3. Collections de valeurs et associations Plusieurs-vers-Plusieurs ............................................ 49 6.4. Associations Un-vers-Plusieurs ......................................................................................... 51 6.5. Initialisation tardive .......................................................................................................... 51 6.6. Collections tries .............................................................................................................. 53 6.7. Utiliser un .......................................................................................................... 53 6.8. Associations Bidirectionnelles .......................................................................................... 54 6.9. Associations ternaires ....................................................................................................... 55 6.10. Associations htrognes ................................................................................................ 56 6.11. Exemples de collection ................................................................................................... 56 7. Mappings des composants ......................................................................................................... 58 7.1. Objets dpendants ............................................................................................................ 58 7.2. Collections d'objets dependants ......................................................................................... 59 7.3. Composants pour les indexes de Map ................................................................................ 60 7.4. composants en tant qu'identifiants composs ...................................................................... 60 7.5. Composants dynamiques .................................................................................................. 62 8. Mapping de l'hritage de classe ................................................................................................. 63 8.1. Les trois stratgies ............................................................................................................ 63 8.2. Limitations ...................................................................................................................... 65 9. Manipuler les donnes persistantes ........................................................................................... 67 9.1. Cration d'un objet persistant ............................................................................................ 67 9.2. Chargement d'un objet ...................................................................................................... 67 9.3. Requtage ........................................................................................................................ 68 9.3.1. Requtes scalaires ................................................................................................. 70 9.3.2. L'interface de requtage Query ............................................................................... 70 9.3.3. Iteration scrollable ................................................................................................. 71 9.3.4. Filtrer les collections ............................................................................................. 71 9.3.5. Les requtes par critres ......................................................................................... 72 9.3.6. Requtes en SQL natif ........................................................................................... 72

Hibernate 2.1.8

iii

HIBERNATE - Persistence Relationnelle dans un Java 9.4. Mise jour des objets ....................................................................................................... 72 9.4.1. Mise jour dans la mme session ........................................................................... 72 9.4.2. Mise jour d'objets dtachs .................................................................................. 73 9.4.3. Rassocier des objets dtachs ................................................................................ 74 9.5. Suppression d'objets persistants ......................................................................................... 74 9.6. Flush ............................................................................................................................... 75 9.7. Terminer une Session ....................................................................................................... 75 9.7.1. Flusher la Session .................................................................................................. 76 9.7.2. Commit de la transaction de la base de donnes ....................................................... 76 9.7.3. Fermeture de la Session ......................................................................................... 76 9.8. Traitement des exceptions ................................................................................................. 76 9.9. Cycles de vie et graphes d'objets ....................................................................................... 78 9.10. Intercepteurs .................................................................................................................. 79 9.11. API d'accs aux mtadonnes .......................................................................................... 80 10. Transactions et accs concurrents ........................................................................................... 82 10.1. Configurations, Sessions et Fabriques (Factories) ............................................................. 82 10.2. Threads et connections .................................................................................................... 82 10.3. Comprendre l'identit d'un objet ...................................................................................... 83 10.4. Gestion de la concurrence par contrle optimiste .............................................................. 83 10.4.1. Session longue avec versionnage automatique ....................................................... 83 10.4.2. Plusieurs sessions avec versionnage automatique ................................................... 84 10.4.3. Contrle de version de manire applicative ............................................................ 84 10.5. Dconnexion de Session ................................................................................................. 84 10.6. Vrouillage pessimiste .................................................................................................... 86 11. HQL: Langage de requtage d'Hibernate ................................................................................ 87 11.1. Sensibilit la casse ....................................................................................................... 87 11.2. La clause from ............................................................................................................... 87 11.3. Associations et jointures ................................................................................................. 87 11.4. La clause select .............................................................................................................. 88 11.5. Fonctions d'aggrgation .................................................................................................. 89 11.6. Requtes polymorphiques ............................................................................................... 89 11.7. La clause where .............................................................................................................. 90 11.8. Expressions .................................................................................................................... 91 11.9. La clause order by .......................................................................................................... 94 11.10. La clause group by ....................................................................................................... 94 11.11. Sous requtes ............................................................................................................... 94 11.12. Exemples HQL ............................................................................................................. 95 11.13. Trucs & Astuces ........................................................................................................... 96 12. Requtes par critres ............................................................................................................... 98 12.1. Crer une instance de Criteria .......................................................................................... 98 12.2. Restriction du rsultat ..................................................................................................... 98 12.3. Trier les rsultats ............................................................................................................ 99 12.4. Associations ................................................................................................................... 99 12.5. Peuplement d'associations de manire dynamique ............................................................. 99 12.6. Requte par l'exemple ................................................................................................... 100 13. Requtes en sql natif .............................................................................................................. 101 13.1. Crer une requte base sur SQL ................................................................................... 101 13.2. Alias et rfrences de proprits .................................................................................... 101 13.3. Requtes SQL nommes ............................................................................................... 101 14. Amliorer les performances ................................................................................................... 103 14.1. Comprendre les performances des Collections ................................................................ 103 14.1.1. Classification .................................................................................................... 103

Hibernate 2.1.8

iv

standard 14.1.2. Les lists, les maps et les sets sont les collections les plus efficaces pour la mise jour ..................................................................................................................................... 104 14.1.3. Les Bags et les lists sont les plus efficaces pour les collections inverse .................. 104 14.1.4. Suppression en un coup ...................................................................................... 104 14.2. Proxy pour une Initialisation Tardive ............................................................................. 105 14.3. Utiliser le batch fetching (chargement par batch) ............................................................ 107 14.4. Le cache de second niveau ............................................................................................ 107 14.4.1. Mapping de Cache ............................................................................................. 108 14.4.2. Strategie : lecture seule ...................................................................................... 108 14.4.3. Stratgie : lecture/criture ................................................................................... 108 14.4.4. Stratgie : lecture/criture non stricte .................................................................. 109 14.4.5. Stratgie : transactionelle ................................................................................... 109 14.5. Grer le cache de la Session .......................................................................................... 110 14.6. Le cache de requtes ..................................................................................................... 110 15. Guide des outils ..................................................................................................................... 112 15.1. Gnration de Schma .................................................................................................. 112 15.1.1. Personnaliser le schma ..................................................................................... 112 15.1.2. Excuter l'outil .................................................................................................. 114 15.1.3. Proprits .......................................................................................................... 114 15.1.4. Utiliser Ant ....................................................................................................... 115 15.1.5. Mises jour incrmentales du schma ................................................................. 115 15.1.6. Utiliser Ant pour des mises jour de schma par incrment .................................. 116 15.2. Gnration de code ....................................................................................................... 116 15.2.1. Le fichier de configuration (optionnel) ................................................................ 116 15.2.2. L'attribut meta ................................................................................................... 117 15.2.3. Gnrateur de Requteur Basique (Basic Finder) ................................................. 119 15.2.4. Renderer/Gnrateur bass sur Velocity .............................................................. 120 15.3. Gnration des fichier de mapping ................................................................................. 120 15.3.1. Excuter l'outil .................................................................................................. 121 16. Exemple : Pre/Fils ................................................................................................................ 123 16.1. Une note propos des collections .................................................................................. 123 16.2. un-vers-plusieurs bidirectionnel ..................................................................................... 123 16.3. Cycle de vie en cascade ................................................................................................ 124 16.4. Utiliser update() en cascade ........................................................................................... 125 16.5. Conclusion ................................................................................................................... 127 17. Exemple : Application de Weblog .......................................................................................... 128 17.1. Classes persistantes ...................................................................................................... 128 17.2. Mappings Hibernate ..................................................................................................... 129 17.3. Code Hibernate ............................................................................................................ 130 18. Exemple : Quelques mappings ............................................................................................... 134 18.1. Employeur/Employ (Employer/Employee) ................................................................... 134 18.2. Auteur/Travail (Author/Work) ...................................................................................... 135 18.3. Client/Commande/Produit (Customer/Order/Product) ..................................................... 137 19. Meilleures pratiques .............................................................................................................. 140

Hibernate 2.1.8

v

PrfaceWARNING! This is a translated version of the English Hibernate reference documentation. The translated version might not be up to date! However, the differences should only be very minor. Consult the English reference documentation if you are missing information or encounter a translation error. If you like to contribute to a particular translation, contact us on the Hibernate developer mailing list. Traducteur(s): Anthony Patricio , Emmanuel Bernard , Rmy Laroche, Bassem Khadige, Stphane Vanpoperynghe Travailler dans les deux univers que sont l'orient objet et la base de donnes relationnelle peut tre lourd et consommateur en temps dans le monde de l'entreprise d'aujourd'hui. Hibernate est un outil de mapping objet/relationnel pour le monde Java. Le terme mapping objet/relationnel (ORM) dcrit la technique consistant faire le lien entre la reprsentation objet des donnes et sa reprsentation relationnelle bas sur un schma SQL. Non seulement, Hibernate s'occupe du transfert des classes Java dans les tables de la base de donnes (et des types de donnes Java dans les types de donnes SQL), mais il permet de requter les donnes et propose des moyens de les rcuprer. Il peut donc rduire de manire significative le temps de dveloppement qui aurait t dpens autrement dans une manipulation manuelle des donnes via SQL et JDBC. Le but d'Hibernate est de librer le dveloppeur de 95 pourcent des tches de programmation lies la persistence des donnes communes. Hibernate n'est probablement pas la meilleure solution pour les applications centres sur les donnes qui n'utilisent que les procdures stockes pour implmenter la logique mtier dans la base de donnes, il est le plus utile dans les modles mtier orients objets dont la logique mtier est implmente dans la couche Java dite intermdiaire. Cependant, Hibernate vous aidera supprimer ou encapsuler le code SQL spcifique votre base de donnes et vous aidera sur la tche commune qu'est la transformation des donnes d'une reprsentation tabulaire une reprsentation sous forme de graphe d'objets. Si vous tes nouveau dans Hibernate et le mapping Objet/Relationnel voire mme en Java, suivez ces quelques tapes : 1. 2. Lisez Chapitre 1, Exemple simple utilisant Tomcat, c'est un tutoriel de 30 minutes utilisant Tomcat. Lisez Chapitre 2, Architecture pour comprendre les environnements dans lesquels Hibernate peut tre utilis. Regardez le rpertoire eg de la distribution Hibernate, il contient une application simple et autonome. Copiez votre pilote JDBC dans le rpertoire lib/ et ditez src/hibernate.properties, en positionnant correctement les valeurs pour votre base de donnes. A partir d'une invite de commande dans le rpertoire de la distribution, tapez ant eg (cela utilise Ant), ou sous Windows tapez build eg. Fates de cette documentation de rfrence votre principale source d'information. Pensez lire Hibernate in Action (http://www.manning.com/bauer) si vous avez besoin de plus d'aide avec le design d'applications ou si vous prfrez un tutoriel pas pas. Visitez aussi http://caveatemptor.hibernate.org et tlchargez l'application exemple pour Hibernate in Action. Les questions les plus frquemment poses (FAQs) trouvent leur rponse sur le site web Hibernate. Des dmos, exemples et tutoriaux de tierces personnes sont rfrencs sur le site web Hibernate. La zone communautaire (Community Area) du site web Hibernate est une bonne source d'information sur les design patterns et sur diffrentes solutions d'intgration d'Hibernate (Tomcat, JBoss, Spring vi

3.

4.

5. 6. 7.

Hibernate 2.1.8

Prface

Framework, Struts, EJB, etc...). Si vous avez des questions, utilisez le forum utilisateurs du site web Hibernate. Nous utilisons galement l'outil de gestion des incidents JIRA pour tout ce qui est rapports de bogue et demandes d'volution. Si vous tes intress par le dveloppement d'Hibernate, joignez-vous la liste de diffusion de dveloppement. Le dveloppement commercial, le support de production et les formations Hibernate sont proposs par JBoss Inc (voir http://www.hibernate.org/SupportTraining/). Hibernate est un projet de la suite de produits Open Source Professionels JBoss.

Hibernate 2.1.8

vii

Chapitre 1. Exemple simple utilisant Tomcat1.1. Vos dbuts avec HibernateCe tutoriel dtaille la mise en place d'Hibernate 2.1 avec le conteneur de servlet Apache Tomcat sur une application web. Hibernate est prvu pour fonctionner la fois dans un environnement manag tel que propos par tous les plus grands serveurs d'applications J2EE, mais aussi dans les applications Java autonomes. Bien que le systme de base de donnes utilis dans ce toturiel soit PostgreSQL 7.3, le support d'autres bases de donnes n'est qu'une question de configuration du dialecte SQL d'Hibernate. Premirement, nous devons copier toutes les bibliothques ncessaires l'installation dans Tomcat. Utilisant un contexte web spar (webapps/quickstart) pour ce tutoriel, nous devons faire attention la fois au chemin vers des bibliothques globales (TOMCAT/common/lib) et au chemin du classloader contextuel de la webapp dans webapps/quickstart/WEB-INF/lib (pour les fichiers JAR) et webapps/quickstart/WEB-INF/classes. On se rfrera aux deux niveaux de classloader que sont le classloader de classpath global et de classpath contextuel de la webapp. Maintenant, copions les bibliothques dans les deux classpaths : 1. Copiez le pilote JDBC de la base de donnes dans le classpath global. C'est ncessaire l'utilisation du pool de connexions DBCP qui vient avec Tomcat. Hibernate utilise les connexions JDBC pour excuter les ordres SQL sur la base de donnes, donc vous devez soit fournir les connexions JDBC pooles, soit configurer Hibernate pour utiliser l'un des pools nativement supports (C3P0, Proxool). Pour ce tutoriel, copiez la blbliothque pg73jdbc3.jar (pour PostgreSQL 7.3 et le JDK 1.4) dans le classpath global. Si vous voulez utiliser une base de donnes diffrente, copiez simplement le pilote JDBC appropri. Ne copiez jamais autre chose dans le classpath global de Tomcat ou vous auriez des problmes avec divers outils tels que log4j, commons-logging, et d'autres. Utilisez toujours le classpath contextuel de la webapp propre chaque application, et donc copiez les bibliothques dans WEB-INF/lib, puis copiez vos propres classes ainsi que les fichiers de configuration/de proprit dans WEB-INF/classes. Ces deux rpertoires sont, par dfinition de la spcification J2EE, dans le classpath contextuel de la webapp. Hibernate se prsente sous la forme d'une blbliothque JAR. Le fichier hibernate2.jar doit tre copi dans le classpath contextuel de la webapp avec les autres classes de l'application. Hibernate a besoin de quelques bibliothques tierces l'excution, elles sont embarques dans la distribution Hibernate et se trouvent dans le rpertoire lib/ ; voir Tableau 1.1, Bibliothques tierces ncessaires Hibernate . Copiez les bibliothques tierces requises dans le classpath de contexte.

2.

3.

Tableau 1.1. Bibliothques tierces ncessaires Hibernate Bibliothque dom4j (requise) CGLIB (requise) Description Hibernate utilise dom4j pour lire la configuration XML et les fichiers XML de mtadonnes du mapping. Hibernate utilise cette bibliothque de gnration de code pour tendre les classes l'excution (en conjonction avec la rflexion Java).

Commons Collections, Commons Hibernate utilise diverses bibliothques du projet Apache Jakarta Logging (requises) Commons. ODMG4 (requise) Hibernate 2.1.8 Hibernate est compatible avec l'interface de gestion de la persistance 1

Exemple simple utilisant Tomcat Bibliothque Description telle que dfinie par l'ODMG. Elle est ncessaire si vous voulez mapper des collections mme si vous n'avez pas l'intention d'utiliser l'API de l'ODMG. Nous ne mappons pas de collections dans ce tutoriel, mais, quoi qu'il arrive c'est une bonne ide de copier ce JAR. EHCache (requise) Hibernate peut utiliser diverses implmentations de cache de second niveau. EHCache est l'implmentation par dfaut (tant qu'elle n'est pas change dans le fichier de configuration). Hibernate utilise l'API Commons Logging, qui peut utiliser log4j comme mcanisme de log sous-jacent. Si la bibliothque Log4j est disponible dans le classpath, Commons Logging l'utilisera ainsi que son fichier de configuration log4j.properties rcupr depuis le classpath. Un exemple de fichier de proprits pour log4j est embarqu dans la distribution d'Hibernate. Donc, copiez log4j.jar et le fichier de configuration (qui se trouve dans src/) dans le classpath contextuel de la webapp si vous voulez voir ce que fait Hibernate pour vous. Jetez un coup d'oeil lib/README.txt de la distribution d'Hibernate. C'est une liste jour des bibliothques tierces distribues avec Hibernate. Vous y trouverez toutes les bibliothques listes et si elles sont requises ou optionnelles.

Log4j (optionnelle)

Ncessaire ou pas ?

Nous allons maintenant configurer le pool de connexions la base de donnes la fois dans Tomcat mais aussi dans Hibernate. Cela signifie que Tomcat proposera des connexions JDBC pooles (en s'appuyant sur son pool DBCP), et qu'Hibernate demandera ces connexions travers le JNDI. Tomcat proposant l'accs au pool de connexions via JNDI, nous ajoutons la dclaration de ressource dans le fichier de configuration principal de Tomcat (TOMCAT/conf/server.xml) : factory org.apache.commons.dbcp.BasicDataSourceFactory url jdbc:postgresql://localhost/quickstart driverClassNameorg.postgresql.Driver username quickstart password secret maxWait 3000

Hibernate 2.1.8

2

Exemple simple utilisant Tomcat

maxIdle 100 maxActive 10

Le contexte web que l'on a configur dans cet exemple se nomme quickstart, son rpertoire de base tant TOMCAT/webapp/quickstart. Pour accder aux servlets, appeler l'URL http://localhost:8080/quickstart partir de votre navigateur (aprs avoir bien entendu ajout le nom de votre servlet et l'avoir li dans votre fichier web.xml). Vous pouvez galement commencer crer une servlet simple qui possde une mthode process() vide. Tomcat utilise le pool de connexions DBCP avec sa configuration et fournit les Connections JDBC pooles travers l'interface JNDI l'adresse java:comp/env/jdbc/quickstart. Si vous prouvez des problmes pour faire fonctionner le pool de connexions, rfrez-vous la documentation Tomcat. Si vous avez des messages de type exception du pilote JDBC, commencez par configurer le pool de connexions JDBC sans Hibernate. Des tutoriels sur Tomcat et JDBC sont disponibles sur le Web. La prochaine tape consiste configurer Hibernate pour utiliser les connexions du pool attach au JNDI. Nous allons utiliser le fichier de configuration XML d'Hibernate. L'approche basique utilisant le fichier .properties est quivalente fonctionnellement, mais n'offre pas d'avantage. Nous utiliserons le fichier de configuration XML parce que c'est souvent plus pratique. Le fichier de configuration XML est plac dans le classpath contextuel de la webapp (WEB-INF/classes), sous le nom hibernate.cfg.xml : java:comp/env/jdbc/quickstart false net.sf.hibernate.dialect.PostgreSQLDialect

Le fichier de configuration montre que nous avons stopp la log des commandes SQL, positionn le dialecte SQL de la base de donnes utilise, et fournit le lien o rcuprer les connexions JDBC (en dclarant l'adresse JNDI laquelle est attache le pool de source de donnes). Le dialecte est un paramtrage ncessaire du fait que les bases de donnes diffrent dans leur interprtation du SQL "standard". Hibernate s'occupe de ces diffrences et vient avec des dialectes pour toutes les bases de donnes les plus connues commerciales ou open sources. Une SessionFactory est un concept Hibernate qui reprsente un et un seul entrept de donnes ; plusieurs bases de donnes peuvent tre utilises en crant plusieurs fichiers de configuration XML, plusieurs objets Configuration et SessionFactory dans votre application. Le dernier lment de hibernate.cfg.xml dclare Cat.hbm.xml comme fichier de mapping Hibernate pour la Hibernate 2.1.8 3

Exemple simple utilisant Tomcat classe Cat. Ce fichier contient les mtadonnes du lien entre la classe Java (aussi appel POJO pour Plain Old Java Object) et une table de la base de donnes (voire plusieurs tables). Nous reviendrons bientt sur ce fichier. Commenons par crire la classe java (ou POJO) et dclarons les mtadonnes de mapping pour celle-ci.

1.2. La premire classe persistanteHibernate fonctionne au mieux dans un modle de programmation consistant utiliser de Bon Vieux Objets Java (Plain Old Java Objects - POJO) pour les classes persistantes (NdT: on parle de POJO en comparaison d'objets de type EJB ou d'objets ncessitants d'hriter d'une quelconque classe de base). Un POJO est souvent un JavaBean dont les proprits de la classe sont accessibles via des getters et des setters qui encapsulent la reprsentation interne dans une interface publique :package net.sf.hibernate.examples.quickstart; public class Cat { private private private private String id; String name; char sex; float weight;

public Cat() { } public String getId() { return id; } private void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public char getSex() { return sex; } public void setSex(char sex) { this.sex = sex; } public float getWeight() { return weight; } public void setWeight(float weight) { this.weight = weight; } }

Hibernate ne restreint pas l'usage des types de proprits ; tous les types du JDK et les types primitifs (comme String, char et Date) peuvent tre mapps, ceci inclus les classes du framework de collection de Java. Vous pouvez les mapper en tant que valeurs, collections de valeurs ou comme associations avec les autres entits. id est une proprit spciale qui reprsente l'identifiant dans la base de donnes pour cette classe (appel aussi cl primaire). Cet identifiant est chaudement recommand pour les entits comme Cat : Hibernate peut utiliser les

Hibernate 2.1.8

4

Exemple simple utilisant Tomcat identifiants pour son seul fonctionnement interne (non visible de l'application) mais vous perdriez en flexibilit dans l'architecture de votre application. Les classes persistantes n'ont besoin d'implmenter aucune interface particulire et n'ont pas besoin d'hriter d'une quelconque classe de base. Hibernate n'utilise galement aucun mcanisme de manipulation des classes la construction, tel que la manipulation du byte-code ; il s'appuie uniquement sur le mcanisme de rflexion de Java et sur l'extension des classes l'excution (via CGLIB). On peut donc, sans la moindre dpendance entre les classes POJO et Hibernate, les mapper une table de la base de donnes.

1.3. Mapper le ChatLe fichier de mapping Cat.hbm.xml contient les mtadonnes requises pour le mapping objet/relationnel. Les mtadonnes contiennent la dclaration des classes persistantes et le mapping entre les proprits (les colonnes, les relations de type cl trangre vers les autres entits) et les tables de la base de donnes.

Toute classe persistante doit avoir un identifiant (en fait, uniquement les classes reprsentant des entits, pas les valeurs dpendant d'objets, qui sont mappes en tant que composant d'une entit). Cette proprit est utilise pour distinguer les objets persistants : deux chats sont gaux si l'expression catA.getId().equals(catB.getId()) est vraie, ce concept est appel identit de base de donnes. Hibernate fournit en standard un certain nombre de gnrateurs d'identifiants qui couvrent la plupart des scnarii (notamment les gnrateurs natifs pour les squences de base de donnes, les tables d'identifiants hi/lo, et les identifiants assigns par l'application). Nous utilisons le gnrateur UUID (recommand uniquement pour les tests dans la mesure o les cls techniques gnres par la base de donnes doivent tre privilgies). et dclarons que la colonne CAT_ID de la table CAT contient la valeur de l'identifiant gnr par Hibernate (en tant que cl primaire de la table). Toutes les proprits de Cat sont mappes la mme table. La proprit name est mappe utilisant une dclaration explicite de la colonne de base de donnes. C'est particulirement utile dans le cas o le schma de la base de donnes est gnr automatiquement (en tant qu'ordre SQL - DDL) par l'outil d'Hibernate Hibernate 2.1.8 5

Exemple simple utilisant Tomcat SchemaExport partir des dclarations du mapping. Toutes les autres proprits prennent la valeur par dfaut donne par Hibernate ; ce qui, dans la majorit des cas, est ce que l'on souhaite. La table CAT dans la base de donnes sera :Colonne | Type | Modificateurs ---------+-----------------------+--------------cat_id | character(32) | not null name | character varying(16) | not null sex | character(1) | weight | real | Indexes : cat_pkey primary key btree (cat_id)

Vous devez maintenant crer manuellement cette table dans votre base de donnes, plus tard, vous pourrez vous rfrer Chapitre 15, Guide des outils si vous dsirez automatiser cette tape avec l'outil SchemaExport. Cet outil cre un fichier de type DDL SQL qui contient la dfinition de la table, les contraintes de type des colonnes, les contraintes d'unicit et les index.

1.4. Jouer avec les chatsNous sommes maintenant prts utiliser la Session Hibernate. C'est l'interface du gestionnaire de persistance, on l'utilise pour sauver et rcuprer les Cats respectivement dans et partir de la base de donnes. Mais d'abord, nous devons rcuprer une Session (l'unit de travail Hibernate) partir de la SessionFactory :SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

Une SessionFactory est responsable d'une base de donnes et n'accepte qu'un seul fichier de configuration XML (hibernate.cfg.xml). Vous pouver positionner les autres proprits (voire mme changer le mta-modle du mapping) en utilisant Configuration avant de construire la SessionFactory (elle est immuable). Comment crer la SessionFactory et comment y accder dans notre application ? En gnral, une SessionFactory n'est construite qu'une seule fois, c'est--dire au dmarrage (avec une servlet de type load-on-startup). Cela veut donc dire que l'on ne doit pas la garder dans une variable d'instance des servlets, mais plutt ailleurs. Il faut un support de type Singleton pour pouvoir y accder facilement. L'approche montre ci-dessous rsout les deux problmes : celui de configuration et celui de la facilit d'accs SessionFactory. Nous implmentons HibernateUtil, une classe utilitaireimport net.sf.hibernate.*; import net.sf.hibernate.cfg.*; public class HibernateUtil { private static final SessionFactory sessionFactory; static { try { // Cre la SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory(); } catch (HibernateException ex) { throw new RuntimeException("Problme de configuration : " + ex.getMessage(), ex); } } public static final ThreadLocal session = new ThreadLocal(); public static Session currentSession() throws HibernateException { Session s = (Session) session.get(); // Ouvre une nouvelle Session, si ce Thread n'en a aucune

Hibernate 2.1.8

6

Exemple simple utilisant Tomcat

if (s == null) { s = sessionFactory.openSession(); session.set(s); } return s; } public static void closeSession() throws HibernateException { Session s = (Session) session.get(); session.set(null); if (s != null) s.close(); } }

Non seulement cette classe s'occupe de garder SessionFactory dans un de ses attributs statiques, mais en plus elle garde la Session du thread courant dans une variable de type ThreadLocal. Vous devez bien comprendre le concept Java de variable de type tread-local (locale un thread) avant d'utiliser cette classe utilitaire. Une SessionFactory est threadsafe : beaucoup de threads peuvent y accder de manire concurrente et demander une Session. Une Session est un objet non threadsafe qui reprsente une unit de travail avec la base de donnes. Les Sessions sont ouvertes par la SessionFactory et sont fermes quand le travail est termin :Session session = HibernateUtil.currentSession(); Transaction tx= session.beginTransaction(); Cat princess = new Cat(); princess.setName("Princess"); princess.setSex('F'); princess.setWeight(7.4f); session.save(princess); tx.commit(); HibernateUtil.closeSession();

Dans une Session, chaque opration sur la base de donnes se fait dans une transaction qui isole les oprations de la base de donnes (c'est galement le cas pour les lectures seules). Nous utilisons l'API Transaction pour s'abstraire de la stratgie transactionnelle utilise (dans notre cas, les transactions JDBC). Cela permet d'avoir un code portable et dployable sans le moindre changement dans un environnement transactionnel gr par le conteneur - CMT - (JTA est utilis dans ce cas). Il est noter que l'exemple ci-dessus ne gre pas les exceptions. Notez galement que vous pouvez appeler HibernateUtil.currentSession(); autant de fois que vous voulez, cette mthode vous ramnera toujours la Session courante pour ce thread. Vous devez vous assurer que la Session est ferme aprs la fin de votre unit de travail et avant que la rponse HTTP soit envoye. Cela peut tre par exemple dans le code de votre servlet ou dans un filtre de servlet. L'effet de bord intressant de la seconde solution est l'initialisation tardive : la Session est encore ouverte lorsque la vue est construite. Hibernate peut donc charger, lors de votre navigation dans le graphe, les objets qui n'taient pas initialiss. Hibernate possde diffrentes mthodes de rcupration des objets partir de la base de donnes. La plus flexible est d'utiliser le langage de requtage d'Hibernate (HQL comme Hibernate Query Language). Ce langage puissant et facile comprendre est une extension oriente objet du SQL:Transaction tx = session.beginTransaction(); Query query = session.createQuery("select c from Cat as c where c.sex = :sex"); query.setCharacter("sex", 'F'); for (Iterator it = query.iterate(); it.hasNext();) {

Hibernate 2.1.8

7

Exemple simple utilisant Tomcat

Cat cat = (Cat) it.next(); out.println("Chat femelle : " + cat.getName() ); } tx.commit();

Hibernate offre galement une API oriente objet de requtage par critres qui peut tre utilise pour formuler des requtes types. Bien sr, Hibernate utilise des PreparedStatements et les paramtres associs pour toutes ses communications SQL avec la base de donnes. Vous pouvez galement utiliser la fonctionalit de requtage SQL natif d'Hibernate ou, dans de rares occasions, rcuprer un connexion JDBC partir de la Session.

1.5. ConclusionNous n'avons fait que gratter la surface d'Hibernate dans ce petit tutoriel. Notez que nous n'avons pas inclus de code spcifique aux servlets dans notre exemple. Vous devez crer vous-mme une servlet et y insrer le code Hibernate qui convient. Garder l'esprit qu'Hibernate, en tant que couche d'accs aux donnes, est fortement intgr votre application. En gnral, toutes les autres couches dpendent du mcanisme de persistance quel qu'il soit. Soyez sr de comprendre les implications de ce design.

Hibernate 2.1.8

8

Chapitre 2. Architecture2.1. GnralitsVoici une vue (trs) haut niveau de l'architecture d'Hibernate :

Ce diagramme montre Hibernate utilisant une base de donnes et des donnes de configuration pour fournir un service de persistance (et des objets persistants) l'application. Nous aimerions dcrire une vue plus dtaille de l'architecture. Malheureusement, Hibernate est flexible et supporte diffrentes approches. Nous allons en montrer les deux extrmes. L'architecture lgre laisse l'application fournir ses propres connexions JDBC et grer ses propres transactions. Cette approche utilise le minimum des APIs Hibernate.:

L'architecture la plus complte abstrait l'application des APIs JDBC/JTA sous-jacentes et laisse Hibernate

Hibernate 2.1.8

9

Architecture

s'occuper des dtails.

Voici quelques dfinitions des objets des diagrammes : SessionFactory (net.sf.hibernate.SessionFactory) Un cache threadsafe (immuable) des mappings vers une (et une seule) base de donnes. Une factory (fabrique) de Session et un client de ConnectionProvider. Peut contenir un cache optionnel de donnes (de second niveau) qui est rutilisable entre les diffrentes transactions que cela soit au niveau processus ou au niveau cluster. Session (net.sf.hibernate.Session) Un objet mono-thread, dure de vie courte, qui reprsente une conversation entre l'application et l'entrept de persistance. Encapsule une connexion JDBC. Factory (fabrique) des objets Transaction. Contient un cache (de premier niveau) des objets persistants, ce cache est obligatoire. Il est utilis lors de la navigation dans le graphe d'objets ou lors de la rcupration d'objets par leur identifiant. Objets et Collections persistants Objets mono-threads vie courte contenant l'tat de persistance et la fonction mtier. Ceux-ci sont en gnral les objets de type JavaBean (ou POJOs) ; la seule particularit est qu'ils sont associs avec une (et une seule) Session. Ds que la Session est ferme, ils seront dtachs et libre d'tre utiliss par n'importe laquelle des couches de l'application (ie. de et vers la prsentation en tant que Data Transfer Objects - DTO : objet de transfert de donnes). Objets et collections transients Instances de classes persistantes qui ne sont actuellement pas associes une Session. Elles ont pu tre instancies par l'application et ne pas avoir (encore) t persistes ou elle ont pu tre instancies par une Session ferme. Transaction (net.sf.hibernate.Transaction) Hibernate 2.1.8 10

Architecture (Optionnel) Un objet mono-thread vie courte utilis par l'application pour dfinir une unit de travail atomique. Abstrait l'application des transactions sous-jacentes qu'elles soient JDBC, JTA ou CORBA. Une Session peut fournir plusieurs Transactions dans certain cas. ConnectionProvider (net.sf.hibernate.connection.ConnectionProvider) (Optionnel) Une fabrique de (pool de) connexions JDBC. Abstrait l'application de la Datasource ou du DriverManager sous-jacent. Non expos l'application, mais peut tre tendu/implment par le dveloppeur. TransactionFactory (net.sf.hibernate.TransactionFactory) (Optionnel) Une fabrique d'instances de Transaction. Non expos l'application, mais peut tre tendu/implment par le dveloppeur. Dans une architecture lgre, l'application n'utilisera pas les APIs Transaction/TransactionFactory et/ou n'utilisera pas les APIs ConnectionProvider pour utiliser JTA ou JDBC.

2.2. Integration JMXJMX est le standard J2EE du configuration des composants Java. Hibernate peut tre configur via une MBean standard. Mais dans la mesure o la plupart des serveurs d'application ne supportent pas encore JMX, Hibernate fournit quelques mcanismes de configuration "non-standard". Merci de vous rfrer au site web d'Hibernate pour de plus amples dtails sur la faon de configurer Hibernate et le faire tourner en tant que composant JMX dans JBoss.

2.3. Support JCAHibernate peut aussi tre configur en tant que connecteur JCA. Rfrez-vous au site web pour de plus amples dtails.

Hibernate 2.1.8

11

Chapitre 3. Configuration de la SessionFactoryParce qu'Hibernate est conu pour fonctionner dans diffrents environnements, il existe beaucoup de paramtres de configuration. Heureusement, la plupart ont des valeurs par dfaut appropries et la distribution d'Hibernate contient un exemple de fichier hibernate.properties qui montre les diffrentes options. Gnralement, vous n'avez qu' placer ce fichier dans votre classpath et l'adapter.

3.1. Configuration par programmationUne instance de net.sf.hibernate.cfg.Configuration reprsente un ensemble de mappings des classes Java d'une application vers la base de donnes SQL. La Configuration est utilise pour construire un objet (immuable) SessionFactory. Les mappings sont constitus d'un ensemble de fichiers de mapping XML. Vous pouvez obtenir une instance de Configuration en l'instanciant directement. Voici un exemple de configuration d'une source de donnes et d'un mapping compos de deux fichiers de configuration XML (qui se trouvent dans le classpath) :Configuration cfg = new Configuration() .addFile("Item.hbm.xml") .addFile("Bid.hbm.xml");

Une alternative (parfois meilleure) est de laisser Hibernate charger le fichier de mapping en utilisant getResourceAsStream() :Configuration cfg = new Configuration() .addClass(org.hibernate.auction.Item.class) .addClass(org.hibernate.auction.Bid.class);

Hibernate

fichiers de mappings /org/hibernate/auction/Item.hbm.xml et /org/hibernate/auction/Bid.hbm.xml dans le classpath. Cette approche limine les noms de fichiers en dur. Une Configuration permet galement plusieurs valeurs optionnelles :Properties props = new Properties(); ... Configuration cfg = new Configuration() .addClass(org.hibernate.auction.Item.class) .addClass(org.hibernate.auction.Bid.class) .setProperties(props);

va

rechercher

les

Une Configuration est sense tre un objet ncessaire pendant la phase de configuration et tre libre une fois la SessionFactory construite.

3.2. Obtenir une SessionFactoryQuand tous les mappings ont t parss par la Configuration, l'application doit obtenir une fabrique d'instances de Session. Cette fabrique est suppose tre partage par tous les threads de l'application :SessionFactory sessions = cfg.buildSessionFactory();

Cependant, Hibernate permet votre application d'instancier plus d'une SessionFactory. C'est utile si vous utilisez plus d'une base de donnes.

Hibernate 2.1.8

12

Configuration de la SessionFactory

3.3. Connexion JDBC fournie par l'utilisateurUne SessionFactory peut ouvrir une Session en utilisant une connexion JDBC fournie par l'utilisateur. Ce choix de design permet l'application d'obtenir les connexions JDBC de la faon qu'il lui plait :java.sql.Connection conn = datasource.getConnection(); Session session = sessions.openSession(conn); // do some data access work

L'application doit faire attention ne pas ouvrir deux Sessions concurrentes en utilisant la mme connexion !

3.4. Connexions JDBC fournie par HibernateAlternativement, vous pouvez laisser la SessionFactory ouvrir les connexions pour vous. La SessionFactory doit recevoir les proprits de connexions JDBC de l'une des manires suivantes : 1. 2. 3. 4. Passer une instance de java.util.Properties Configuration.setProperties(). Placer hibernate.properties dans un rpertoire racine du classpath Positionner les proprits System en utilisant java -Dproperty=value. Inclure des lments dans le fichier hibernate.cfg.xml (voir plus loin).

Si vous suivez cette approche, ouvrir une Session est aussi simple que :Session session = sessions.openSession(); // ouvre une nouvelle session // faire quelques accs aux donnes, une connexion JDBC sera utilise la demande

Tous les noms et smantiques des proprits d'Hibernate sont dfinies dans la javadoc de la classe net.sf.hibernate.cfg.Environment. Nous allons dcrire les paramtres les plus importants pour une connexion JDBC. Hibernate obtiendra des connexions (et les mettra dans un pool) en utilisant java.sql.DriverManager si vous positionner les paramtres de la manire suivante : Tableau 3.1. Proprits JDBC d'Hibernate Nom de la proprithibernate.connection.driver_class hibernate.connection.url hibernate.connection.username hibernate.connection.password hibernate.connection.pool_size

Fonction Classe du driver jdbc URL jdbc utilisateur de la base de donnes mot de passe de la base de donnes nombre maximum de connexions dans le pool

L'algorithme natif de pool de connexions d'Hibernate est plutt rudimentaire. Il a t fait dans le but de vous aider dmarrer et n'est pas prvu pour un systme en production ou mme pour un test de peformance. Utiliser un pool tiers pour de meilleures performances et une meilleure stabilit : remplacer la proprit hibernate.connection.pool_size avec les proprits spcifique au pool de connexions que vous avez choisi.

Hibernate 2.1.8

13

Configuration de la SessionFactory

C3P0 est un pool de connexions JDBC open source distribu avec Hibernate dans le rpertoire lib. Hibernate utilisera le provider intgr C3P0ConnectionProvider pour le pool de connexions si vous positionnez les proprits hibernate.c3p0.*. Il y a galement un support intgr pour Apache DBCP et Proxool. Vous devez positionner les proprits hibernate.dbcp.* (proprits du pool de connexions DBCP) pour activer le DBCPConnectionProvider. Le cache des Prepared Statement est activ (fortement recommand) si hibernate.dbcp.ps.* (proprits du cache de statement de DBCP) sont positionnes. Merci de vous rfrer la documentation de apache commons-pool pour l'utilisation et la comprhension de ces proprits. Vous devez positionner les proprits hibernate.proxool.* si vous voulez utiliser Proxool. Voici un exemple utilisant C3P0:hibernate.connection.driver_class = org.postgresql.Driver hibernate.connection.url = jdbc:postgresql://localhost/mydatabase hibernate.connection.username = myuser hibernate.connection.password = secret hibernate.c3p0.min_size=5 hibernate.c3p0.max_size=20 hibernate.c3p0.timeout=1800 hibernate.c3p0.max_statement=50 hibernate.dialect = net.sf.hibernate.dialect.PostgreSQLDialect

Dans le cadre de l'utilisation au sein d'un serveur d'applications, Hibernate peut obtenir les connexions partir d'une javax.sql.Datasource enregistre dans le JNDI. Positionner les proprits suivantes : Tableau 3.2. Proprit d'une Datasource Hibernate Nom d'une proprithibernate.connection.datasource hibernate.jndi.url hibernate.jndi.class

fonction Nom JNDI de la datasource URL du fournisseur JNDI (optionnelle) Classe de l'InitialContextFactory (optionnelle) du JNDI

hibernate.connection.username hibernate.connection.password

utilisateur de la base de donnes (optionnelle) mot de passe de la base de donnes (optionnelle)

voici un exemple utilisant les datasources JNDI fournies par un serveur d'applications :hibernate.connection.datasource = java:/comp/env/jdbc/MyDB hibernate.transaction.factory_class = \ net.sf.hibernate.transaction.JTATransactionFactory hibernate.transaction.manager_lookup_class = \ net.sf.hibernate.transaction.JBossTransactionManagerLookup hibernate.dialect = \ net.sf.hibernate.dialect.PostgreSQLDialect

Les connexions JDBC obtenues partir d'une datasource JNDI participeront automatiquement aux transactions gres par le conteneur du serveur d'applications. Des proprits supplmentaires de connexion peuvent tre passes en prfixant le nom de la proprit par "hibernate.connnection". Par exemple, vous pouvez spcifier un jeu de caractres en utilisant hibernate.connnection.charSet. Vous pouvez fournir votre propre stratgie d'obtention des connexions JDBC en implmentant l'interface net.sf.hibernate.connection.ConnectionProvider. Vous pouvez slectionner une implmentation Hibernate 2.1.8 14

Configuration de la SessionFactory spcifique en positionnant hibernate.connection.provider_class.

3.5. Proprits de configuration optionnellesIl y a un certain nombre d'autres proprits qui contrlent le fonctionnement d'Hibernate l'excution. Toutes sont optionnelles et ont comme valeurs par dfaut des valeurs "raisonnables" pour un fonctionnement nominal. Les proprits de niveau System ne peuvent tre positionnes que via la ligne de commande (java -Dproperty=value) ou tre dfinies dans hibernate.properties. Elle ne peuvent l'tre dans une instance de Properties passe la Configuration. Tableau 3.3. Proprits de configuration d'Hibernate Nom de la proprithibernate.dialect

Fonction Le nom de la classe du Dialect Hibernate - active l'utilisation de certaines fonctionalits spcifiques la plateforme. ex. nom.complet.de.ma.classe.de.Dialect

hibernate.default_schema

Positionne dans le SQL gnr un schma/tablespace par dfaut pour les noms de table ne l'ayant pas surcharg. ex. MON_SCHEMA

hibernate.session_factory_name

La SessionFactory sera automatiquement lie ce nom dans le JNDI aprs sa cration. ex. jndi/nom/hierarchique

hibernate.use_outer_join

Active le chargement via les jointures ouvertes. Dprcie, utiliser max_fetch_depth. ex. true | false

hibernate.max_fetch_depth

Dfinit la profondeur maximale d'un arbre de chargement par jointures ouvertes pour les associations cardinalit unitaire (un--un, plusieurs--un). Un 0 dsactive le chargement par jointure ouverte. ex. valeurs recommandes entre 0 et 3

hibernate.jdbc.fetch_size

Une valeur non nulle dtermine la taille de chargement des statements JDBC (appelle Statement.setFetchSize()). Une valeur non nulle active l'utilisation par Hibernate des mises jour par batch de JDBC2. ex. les valeurs recommandes entre 5 et 30

hibernate.jdbc.batch_size

hibernate.jdbc.batch_versioned_data

Paramtrez cette proprit true si votre pilote JDBC retourne des row counts corrects depuis

Hibernate 2.1.8

15

Configuration de la SessionFactory Nom de la proprit Fonction (il est souvent appropri d'activer cette option). Hibernate utilisera alors le "batched DML" pour versionner automatiquement les donnes. Par dfaut = false.executeBatch()

eg. true | falsehibernate.jdbc.use_scrollable_resultset

Active l'utilisation par Hibernate des resultsets scrollables de JDBC2. Cette proprit est seulement ncessaire lorsque l'on utilise une connexion JDBC fournie par l'utilisateur. Autrement, Hibernate utilise les mtadonnes de la connexion. ex. true | false

hibernate.jdbc.use_streams_for_binary

Utilise des flux lorsque l'on crit/lit des types binary ou serializable vers et partir de JDBC (proprit de niveau systme). ex. true | false

hibernate.jdbc.use_get_generated_keys

Active

de PreparedStatement.getGeneratedKeys() de JDBC3 pour rcuprer nativement les cls gnres aprs insertion. Ncessite un pilote JDBC3+, le mettre false si votre pilote a des problmes avec les gnrateurs d'identifiant Hibernate. Par dfaut, essaie de dterminer les possibilits du pilote en utilisant les meta donnes de connexion. eg. true|false

l'utilisation

hibernate.cglib.use_reflection_optimizer

Active l'utilisation de CGLIB la place de la rflexion l'excution (Proprit de niveau systme, la valeur par dfaut tant d'utiliser CGLIB lorsque c'est possible). La rflexion est parfois utile en cas de problme. ex. true | false

hibernate.jndi.

Passe

la

proprit

propertyName

au

JNDI

InitialContextFactory. hibernate.connection.isolation

Positionne le niveau de transaction JDBC. Merci de vous rfrer java.sql.Connection pour le dtail des valeurs mais sachez que toutes les bases de donnes ne supportent pas tous les niveaux d'isolation. ex. 1, 2, 4, 8

hibernate.connection.

Passe

la

proprit classe

JDBC d'un

propertyName

au

DriverManager.getConnection(). hibernate.connection.provider_class

Le nom de spcifique.

ConnectionProvider

Hibernate 2.1.8

16

Configuration de la SessionFactory Nom de la proprit Fonction ex. nom.de.classe.du.ConnectionProviderhibernate.cache.provider_class

Le nom de classe d'un CacheProvider spcifique. ex. nom.de.classe.du.CacheProvider

hibernate.cache.use_minimal_puts

Optimise le cache de second niveau en minimisant les critures, au prix de plus de lectures (utile pour les caches en cluster). ex. true|false

hibernate.cache.use_query_cache

Activer le cache de requte, les requtes individuelles doivent tout de mme tre dclares comme mettable en cache. ex. true|false

hibernate.cache.query_cache_factory

Le nom de classe d'une interface QueryCache , par dfaut = built-in StandardQueryCache. eg. nom.de.la.classe.de.QueryCache

hibernate.cache.region_prefix

Un prfixe utiliser pour le nom des rgions du cache de second niveau. ex. prefix

hibernate.transaction.factory_class

Le nom de classe d'une TransactionFactory qui sera utilise par l'API Transaction d'Hibernate (la valeur par dfaut est JDBCTransactionFactory). ex. nom.de.classe.d.une.TransactionFactory

jta.UserTransaction

Le nom JNDI utilis par la JTATransactionFactory pour obtenir la UserTransaction JTA du serveur d'applications. eg. jndi/nom/compose

hibernate.transaction.manager_lookup_class

Le nom de la classe du TransactionManagerLookup requis lorsque le cache de niveau JVM est activ dans un environnement JTA. ex. nom.de.classe.du.TransactionManagerLookup

hibernate.query.substitutions

Lien entre les tokens de requtes Hibernate et les tokens SQL (les tokens peuvent tre des fonctions ou des noms littraux par exemple). ex.hqlFunction=SQLFUNC hqlLiteral=SQL_LITERAL,

hibernate.show_sql

Ecrit les ordres SQL dans la console. ex. true | false

Hibernate 2.1.8

17

Configuration de la SessionFactory Nom de la proprithibernate.hbm2ddl.auto

Fonction Exporte le schma DDL vers la base de donnes automatiquement lorsque la SessionFactory est cre. La valeur create-drop permet de supprimer le schma de base de donnes lorsque la SessionFactory est ferme explicitement. ex. update | create | create-drop

3.5.1. Dialectes SQLVous devriez toujours positionner la proprit hibernate.dialect la sous-classe approprie votre base de donnes. Ce n'est pas strictement obligatoire moins de vouloir utiliser la gnration de cl primaire native ou par sequence ou de vouloir utiliser le mcanisme de lock pessimiste (ex. via Session.lock() ou Query.setLockMode()). Cependant, si vous spcifiez un dialecte, Hibernate utilisera des valeurs adaptes pour certaines autres proprits listes ci-dessus, vous vitant l'effort de le faire la main. Tableau 3.4. Dialectes SQL d'Hibernate (hibernate.dialect) SGBD DB2 DB2 AS/400 DB2 OS390 PostgreSQL MySQL SAP DB Oracle (toutes versions) Oracle 9/10g Sybase Sybase Anywhere Microsoft SQL Server SAP DB Informix HypersonicSQL Ingres Progress Mckoi SQL Interbase Pointbase Dialectenet.sf.hibernate.dialect.DB2Dialect net.sf.hibernate.dialect.DB2400Dialect net.sf.hibernate.dialect.DB2390Dialect net.sf.hibernate.dialect.PostgreSQLDialect net.sf.hibernate.dialect.MySQLDialect net.sf.hibernate.dialect.SAPDBDialect net.sf.hibernate.dialect.OracleDialect net.sf.hibernate.dialect.Oracle9Dialect net.sf.hibernate.dialect.SybaseDialect net.sf.hibernate.dialect.SybaseAnywhereDialect net.sf.hibernate.dialect.SQLServerDialect net.sf.hibernate.dialect.SAPDBDialect net.sf.hibernate.dialect.InformixDialect net.sf.hibernate.dialect.HSQLDialect net.sf.hibernate.dialect.IngresDialect net.sf.hibernate.dialect.ProgressDialect net.sf.hibernate.dialect.MckoiDialect net.sf.hibernate.dialect.InterbaseDialect net.sf.hibernate.dialect.PointbaseDialect

Hibernate 2.1.8

18

Configuration de la SessionFactory SGBD FrontBase Firebird Dialectenet.sf.hibernate.dialect.FrontbaseDialect net.sf.hibernate.dialect.FirebirdDialect

3.5.2. Chargement par Jointure OuverteSi votre base de donnes supporte les outer joins de type ANSI ou Oracle, le chargement par jointure ouverte devrait amliorer les performances en limitant le nombre d'aller-retour avec la base de donnes (la base de donnes effectuant donc potentiellement plus de travail). Le chargement par jointure ouverte permet un graphe connect d'objets par une relation plusieurs--un, un--plusieurs ou un--un d'tre charg en un seul SELECT SQL. Par dfaut, le graphe charg lorsqu'un objet est demand, finit aux objets feuilles, aux collections, aux objets avec proxy ou lorsqu'une circularit apparat. Le chargement peut tre activ ou dsactiv (valeur par dfaut) pour une association particulire, en positionant l'attribut outer-join dans le mapping XML. Le chargement par jointure ouverte peut tre dsactiv de manire globale en positionant la proprit hibernate.max_fetch_depth 0. Une valeur de 1 ou plus permet les jointures ouvertes pour toutes les associations un--un et plusieurs--un qui sont, par dfaut, positionnes la valeur de jointure outerte auto. Cependant, les associations un--plusieurs et les collections ne sont jamais charges en utilisant une jonture ouverte, moins de le dclarer de faon explicite pour chaque association. Cette fonctionalit peut tre surcharge l'excution dans les requtes Hibernate.

3.5.3. Flux binairesOracle limite la taille d'un tableau de byte qui peuvent tre passes et vers son pilote JDBC. Si vous souhaitez utiliser des instances larges de type binary ou serializable, vous devez activer la proprit hibernate.jdbc.use_streams_for_binary. C'est une fonctionalit de niveau JVM uniquement.

3.5.4. CacheProvider spcifiqueVous pouvez intgrer un cache de second niveau de type JVM (ou cluster) en implmentant l'interface net.sf.hibernate.cache.CacheProvider. Vous pouvez slectionner l'implmentation spcifique en positionnant hibernate.cache.provider_class.

3.5.5. Configuration de la stratgie transactionnelleSi vous souhaitez utiliser l'API d'Hibernate Transaction, vous devez spcifier une classe factory d'instances de Transaction en positionnant la proprit hibernate.transaction.factory_class. L'API Transaction masque le mcanisme de transaction sous-jacent et permet au code utilisant Hibernate de tourner dans des environnements manags et non-manags sans le moindre changement. Il existe deux choix standards (fournis) :net.sf.hibernate.transaction.JDBCTransactionFactory

dlgue aux transactions de la base de donnes (JDBC). Valeur par dfaut.

Hibernate 2.1.8

19

Configuration de la SessionFactory

net.sf.hibernate.transaction.JTATransactionFactory

dlgue JTA (si une transaction existant est en cours, la Session excute son travail dans ce contexte ; sinon, une nouvelle transaction est dmarre). Vous pouvez galement dfinir votre propre stratgie transactionnelle (pour un service de transaction CORBA par exemple). Si vous voulez utiliser un cache de niveau JVM pour des donnes muables dans un environnement JTA, vous devez spcifier une stratgie d'obtention du TransactionManager JTA. En effet, cet accs n'est pas standardis par la norme J2EE : Tableau 3.5. TransactionManagers JTA Factory de Transactionnet.sf.hibernate.transaction.JBossTransactionManagerLookup net.sf.hibernate.transaction.WeblogicTransactionManagerLookup net.sf.hibernate.transaction.WebSphereTransactionManagerLookup net.sf.hibernate.transaction.OrionTransactionManagerLookup net.sf.hibernate.transaction.ResinTransactionManagerLookup net.sf.hibernate.transaction.JOTMTransactionManagerLookup net.sf.hibernate.transaction.JOnASTransactionManagerLookup net.sf.hibernate.transaction.JRun4TransactionManagerLookup net.sf.hibernate.transaction.BESTransactionManagerLookup

Serveur d'application JBoss Weblogic WebSphere Orion Resin JOTM JOnAS JRun4 Borland ES

3.5.6. SessionFactory associe au JNDIUne SessionFactory Hibernate associe au JNDI peut simplifier l'accs la fabrique et donc la cration de nouvelles Sessions. Si un nom JNDI, spcifiez un nom (ex. java:comp/env/hibernate/SessionFactory) en utilisant la proprit hibernate.session_factory_name. Si cette proprit est omise, la SessionFactory ne sera pas associe au JNDI (c'est particulirement pratique dans les environnements ayant une implmentation de JNDI en lecture seule, comme c'est le cas pour Tomcat).SessionFactory

vous

dsirez

associer

la

Lorsqu'il associe la SessionFactory au JNDI, Hibernate utilisera les valeurs de hibernate.jndi.url, hibernate.jndi.class pour instancier un contexte d'initialisation. S'ils ne sont pas spcifis, l'InitialContext par dfaut sera utilis. Si vous dcidez d'utiliser JNDI, un EJB ou toute autre classe utilitaire pourra obtenir la SessionFactory en faisant un accs au JNDI.

3.5.7. Substitution dans le langage de requtageVous pouvez dfinir de nouveaux tokens dans les requtes Hibernate en utilisant la proprit hibernate.query.substitutions. Par exemple :

Hibernate 2.1.8

20

Configuration de la SessionFactory

hibernate.query.substitutions vrai=1, faux=0

remplacerait les tokens vrai et faux par des entiers dans le SQL gnr.hibernate.query.substitutions toLowercase=LOWER

permettrait de renommer la fonction SQL LOWER en toLowercase

3.6. LogguerHibernate loggue divers vnements en utilisant Apache commons-logging. Le service commons-logging dlguera directement Apache Log4j (si vous incluez log4j.jar dans votre classpath) ou le systme de log du JDK 1.4 (si vous tournez sous le JDK 1.4 et suprieur). Vous pouvez tlcharger Log4j partir de http://jakarta.apache.org. Pour utiliser Log4j, vous devrez placer dans votre classpath un fichier log4j.properties. Un exemple de fichier est distribu avec Hibernate dans le rpertoire src/. Nous vous recommandons fortement de vous familiariser avec les messages de logs d'Hibernate. Beaucoup de soins a t apport pour donner le plus de dtails possibles sans les rendre illisibles. C'est un outil essentiel en cas de soucis. De mme, n'oubliez pas d'activer les logs SQL comme dcrit prcdemment hibernate.show_sql, c'est la premire tape pour regarder les problmes de performance.

3.7. Implmenter une NamingStrategyL'interface net.sf.hibernate.cfg.NamingStrategy vous permet de spcifier une "stratgie de nommage" des objets et lments de la base de donnes. Vous pouvez fournir des rgles pour automatiquement gnrer les identifiants de base de donnes partir des identifiants Java, ou transformer une colonne ou table "logique" donne dans le fichier de mapping en une colonne ou table "physique". Cette fonctionnalit aide rduire la verbosit de documents de mapping, en liminant le bruit rptitif (les prfixes TBL_ par exemple). La stratgie par dfaut utilise par Hibernate est minimale. Vous pouvez dfinir une stratgie diffrente en appelant Configuration.setNamingStrategy() avant d'ajouter des mappings :SessionFactory sf = new Configuration() .setNamingStrategy(ImprovedNamingStrategy.INSTANCE) .addFile("Item.hbm.xml") .addFile("Bid.hbm.xml") .buildSessionFactory();

net.sf.hibernate.cfg.ImprovedNamingStrategy

est une stratgie fournie qui peut tre utile comme point de

dpart de quelques applications.

3.8. Fichier de configuration XMLUne approche alternative est de spcifier toute la configuration dans un fichier nomm hibernate.cfg.xml. Ce fichier peut tre utilis la place du fichier hibernate.properties, voire mme peut servir surcharger les proprits si les deux fichiers sont prsents. Hibernate 2.1.8 21

Configuration de la SessionFactory

Le fichier de configuration XML doit par dfaut se placer la racine du CLASSPATH. En voici un exemple : ma/premiere/datasource net.sf.hibernate.dialect.MySQLDialect false true net.sf.hibernate.transaction.JTATransactionFactory java:comp/UserTransaction

Configurer Hibernate devient donc aussi simple que ceci :SessionFactory sf = new Configuration().configure().buildSessionFactory();

Vous pouvez utiliser une fichier de configuration XML de nom diffrent en utilisantSessionFactory sf = new Configuration() .configure("/my/package/catdb.cfg.xml") .buildSessionFactory();

Hibernate 2.1.8

22

Chapitre 4. Classes persistantesLes classes persistantes sont les classes d'une application qui implmentent les entits d'un problme mtier (ex. Client et Commande dans une application de commerce lectronique). Les classes persistantes ont, comme leur nom l'indique, des instances transiantes mais aussi persistantes c'est--dire stockes en base de donnes. Hibernate fonctionne de manire optimale lorsque ces classes suivent quelques rgles simples, aussi connues comme le modle de programmation Plain Old Java Object (POJO).

4.1. Un exemple simple de POJOToute bonne application Java ncessite une classe persistante reprsentant les flins.package eg; import java.util.Set; import java.util.Date; public class Cat { private Long id; // identifiant private String name; private Date birthdate; private Cat mate; private Set kittens private Color color; private char sex; private float weight; private void setId(Long id) { this.id=id; } public Long getId() { return id; } void setName(String name) { this.name = name; } public String getName() { return name; } void setMate(Cat mate) { this.mate = mate; } public Cat getMate() { return mate; } void setBirthdate(Date date) { birthdate = date; } public Date getBirthdate() { return birthdate; } void setWeight(float weight) { this.weight = weight; } public float getWeight() { return weight; } public Color getColor() { return color; }

Hibernate 2.1.8

23

Classes persistantes

void setColor(Color color) { this.color = color; } void setKittens(Set kittens) { this.kittens = kittens; } public Set getKittens() { return kittens; } // addKitten n'est pas ncessaire pour Hibernate public void addKitten(Cat kitten) { kittens.add(kitten); } void setSex(char sex) { this.sex=sex; } public char getSex() { return sex; } }

Il y a quatre rgles suivre ici :

4.1.1. Dclarer les accesseurs et modifieurs des attributs persistantsdclare des mthodes d'accs pour tous ses attributs persistants. Beaucoup d'autres solutions de mapping Objet/relationnel persistent directement les instances des attributs. Nous pensons qu'il est bien mieux de dcoupler ce dtail d'implmentation du mcanisme de persistence. Hibernate persiste les proprits suivant le style JavaBeans et reconnait les noms de mthodes de la forme getFoo, isFoo et setFoo.Cat

Les proprits n'ont pas tre dclares publiques - Hibernate peut persister une proprit avec un paire de getter/setter de visibilit par dfault, protected ou private

4.1.2. Implmenter un constructeur par dfautpossde un constructeur par dfaut (sans argument) implicite. Toute classe persistante doit avoir un constructeur par dfaut (qui peut tre non-publique) pour permettre Hibernate de l'instancier en utilisant Constructor.newInstance().Cat

4.1.3. Fournir une proprit d'indentifiant (optionnel)possde une proprit appele id. Cette proprit conserve la valeur de la colonne de cl primaire de la table d'une base de donnes. La proprit aurait pu s'appeler compltement autrement, et son type aurait pu tre n'importe quel type primitif, n'importe quel "encapsuleur" de type primitif, java.lang.String ou java.util.Date. (Si votre base de donnes hrite possde des cls composites, elles peuvent tre mappes en utilisant une classe dfinie par l'utilisateur et possdant les proprits associes aux types de la cl composite voir la section concernant les identifiants composites plus bas).Cat

La proprit d'identifiant est optionnelle. Vous pouver l'oublier et laisser Hibernate s'occuper des identifiants de l'objet en interne. Cependant, pour beaucoup d'applications, avoir un identifiant reste un design bon (et trs populaire). De plus, quelques fonctionnalits ne sont disponibles que pour les classes dclarant un identifiant de proprit : Mises jour en cascade (Voir "Cycle de vie des objets")Session.saveOrUpdate()

Hibernate 2.1.8

24

Classes persistantes

Nous recommandons que vous dclariez les proprits d'identifiant de manire uniforme. Nous recommandons galement que vous utilisiez un type nullable (ie. non primitif).

4.1.4. Favoriser les classes non finales (optionnel)Une fonctionalit cle d'Hibernate, les proxies, ncessitent que la classe persistente soit non finale ou qu'elle soit l'implmentation d'une interface qui dclare toutes les mthodes publiques. Vous pouvez persister, grce Hibernate, les classes final qui n'implmentent pas d'interface, mais vous ne pourrez pas utiliser les proxies - ce qui limitera vos possibilits d'ajustement des performances.

4.2. Implmenter l'hritageUne sous-classe doit galement suivre la premire et la seconde rgle. Elle hrite sa proprit d'identifiant de Cat.package eg; public class DomesticCat extends Cat { private String name; public String getName() { return name; } protected void setName(String name) { this.name=name; } }

4.3. Implmenter equals() et hashCode()Vous devez surcharger les mthodes equals() et hashCode() si vous avez l'intention de "mlanger" des objets de classes persistantes (ex dans un Set). Cette rgle ne s'applique que si ces objets sont chargs partir de deux Sessions diffrentes, dans la mesure o Hibernate ne garantit l'identit de niveau JVM ( a == b , l'implmentation par dfaut d'equals() en Java) qu'au sein d'une seule Session ! Mme si deux objets a et b reprsentent la mme ligne dans la base de donnes (ils ont la mme valeur de cl primaire comme identifiant), nous ne pouvons garantir qu'ils seront la mme instance Java hors du contexte d'une Session donne. La manire la plus vidente est d'implmenter equals()/hashCode() en comparant la valeur de l'identifiant des deux objets. Si cette valeur est identique, les deux doivent reprsenter la mme ligne de base de donnes, ils sont donc gaux (si les deux sont ajouts un Set, nous n'auront qu'un seul lment dans le Set). Malheureusement, nous ne pouvons pas utiliser cette approche. Hibernate n'assignera de valeur d'identifiant qu'aux objets qui sont persistant, une instance nouvellement cre n'aura donc pas de valeur d'identifiant ! Nous recommandons donc d'implmenter equals() et hashCode() en utilisant l'galit par cl mtier. L'galit par cl mtier signifie que la mthode equals() compare uniquement les proprits qui forment une cl mtier, une cl qui identifierait notre instance dans le monde rel (une cl candidate naturelle) :public class Cat {

Hibernate 2.1.8

25

Classes persistantes

... public boolean equals(Object other) { if (this == other) return true; if (!(other instanceof Cat)) return false; final Cat cat = (Cat) other; if (!getName().equals(cat.getName())) return false; if (!getBirthday().equals(cat.getBirthday())) return false; return true; } public int hashCode() { int result; result = getName().hashCode(); result = 29 * result + getBirthday().hashCode(); return result; } }

Garder l'esprit que notre cl candidate (dans ce cas, une cl compose du nom et de la date de naissance) n'a tre valide et pertinente que pour une opration de comparaison particulire (peut-tre mme pour un seul cas d'utilisation). Nous n'avons pas besoin du mme critre de stabilit que celui ncessaire la cl primaire relle !

4.4. Callbacks de cycle de vieUne classe persistence peut, de manire facultative, implmenter l'interface Lifecycle qui fournit des callbacks permettant aux objets persistants d'effectuer des oprations d'initialisation ou de nettoyage aprs une sauvegarde ou un chargement et avant une suppression ou une mise jour. L'Interceptor d'Hibernate offre cependant une alternative moins intrusive.public interface Lifecycle { public boolean onSave(Session s) throws CallbackException; public boolean onUpdate(Session s) throws CallbackException; public boolean onDelete(Session s) throws CallbackException; public void onLoad(Session s, Serializable id); }

(1) (2) (3) (4)

(1) (2) (3) (4)

- appel juste avant que l'objet soit sauv ou insr onUpdate - appel juste avant qu'un objet soit mis jour (quand l'objet est pass Session.update()) onDelete - appel juste avant que l'objet soit supprim onLoad - appel juste aprs que l'objet soit chargonSave

onSave(), onDelete()

et onUpdate() peuvent tre utiliss pour sauver ou supprimer en cascade de objets dpendants. onLoad() peut tre utilis pour initialiser des proprits transiantes de l'objet partir de son tat persistant. Il ne doit pas tre utilis pour charger des objets dpendants parce que l'interface Session ne doit pas tre appele au sein de cette mthode. Un autre usage possible de onLoad(), onSave() et onUpdate() est de garder une rfrence la Session courante pour un usage ultrieur. Notez que onUpdate() n'est pas appel chaque fois que l'tat persistant d'un objet est mis jour. Elle n'est appele que lorsqu'un objet transiant est pass Session.update(). Si onSave(), onUpdate() ou onDelete() retourne true, l'opration n'est pas effectue et ceci de manire silencieuse. Si une CallbackException est leve, l'opration n'est pas effectue et l'exception est retourne l'application.

Hibernate 2.1.8

26

Classes persistantes

Notez que onSave() est appel aprs que l'identifiant ait t assign l'objet sauf si la gnration native de cls est utilise.

4.5. Callback de validationSi la classe persistante a besoin de vrifier des invariants avant que son tat soit persist, elle peut implmenter l'interface suivante :public interface Validatable { public void validate() throws ValidationFailure; }

L'objet doit lever une ValidationFailure si un invariant a t viol. Une instance de Validatable ne doit pas changer son tat au sein de la mthode validate(). Contrairement aux mthodes de callback de l'interface Lifecycle, validate() peut tre appel n'importe quel moment. L'application ne doit pas s'appuyer sur les appels validate() pour des fonctionalits mtier.

4.6. Utiliser le marquage XDocletDans le chapitre suivant, nous allons voir comment les mappings Hibernate sont exprims dans un format XML simple et lisible. Beaucoup d'utilisateurs d'Hibernate prfrent embarquer les informations de mapping directement dans le code source en utilisant les tags XDoclet @hibernate.tags. Nous ne couvrirons pas cette approche dans ce document parce que considre comme une part de XDoclet. Cepdendant, nous avons inclus l'exemple suivant utilisant la classe Cat et le mapping XDoclet.package eg; import java.util.Set; import java.util.Date; /** * @hibernate.class * table="CATS" */ public class Cat { private Long id; // identifiant private Date birthdate; private Cat mate; private Set kittens private Color color; private char sex; private float weight; /** * @hibernate.id * generator-class="native" * column="CAT_ID" */ public Long getId() { return id; } private void setId(Long id) { this.id=id; } /** * @hibernate.many-to-one * column="MATE_ID" */ public Cat getMate() {

Hibernate 2.1.8

27

Classes persistantes

return mate; } void setMate(Cat mate) { this.mate = mate; } /** * @hibernate.property * column="BIRTH_DATE" */ public Date getBirthdate() { return birthdate; } void setBirthdate(Date date) { birthdate = date; } /** * @hibernate.property * column="WEIGHT" */ public float getWeight() { return weight; } void setWeight(float weight) { this.weight = weight; } /** * @hibernate.property * column="COLOR" * not-null="true" */ public Color getColor() { return color; } void setColor(Color color) { this.color = color; } /** * @hibernate.set * lazy="true" * order-by="BIRTH_DATE" * @hibernate.collection-key * column="PARENT_ID" * @hibernate.collection-one-to-many */ public Set getKittens() { return kittens; } void setKittens(Set kittens) { this.kittens = kittens; } // addKitten n'est pas ncesaire Hibernate public void addKitten(Cat kitten) { kittens.add(kitten); } /** * @hibernate.property * column="SEX" * not-null="true" * update="false" */ public char getSex() { return sex; } void setSex(char sex) { this.sex=sex; } }

Hibernate 2.1.8

28

Chapitre 5. Mapping O/R basique5.1. Dclaration de MappingLes mappings objet/relationnel sont dfinis dans un document XML. Le document de mapping est conu pour tre lisible et ditable la main. Le vocabulaire de mapping est orient Java, ce qui signifie que les mappings sont construits autour des classes java et non autour des dclarations de tables. Mme si beaucoup d'utilisateurs d'Hibernate choisissent d'crire les fichiers de mapping la main, il existe des outils pour les gnrer, comme XDoclet, Middlegen et AndroMDA. Enchanons sur un exemple de mapping:

Nous allons parler du document de mapping. Nous aborderons uniquement les lments du document utiliss l'excution par Hibernate. Ce document contient d'autres attributs et lments optionnels qui agissent sur le schma de base de donnes export par l'outil d'export de schma.(par exemple l'attribut not-null.)

5.1.1. DoctypeTous les mappings XML doivent dclarer le doctype de l'exemple prcdent. L'actuelle DTD peut tre trouve l'URL du dessus, dans le rpertoire hibernate-x.x.x/src/net/sf/hibernate ou dans hibernate2.jar. Hibernate cherchera toujours en priorit la DTD dans le classpath.

5.1.2. hibernate-mapping

Hibernate 2.1.8

29

Mapping O/R bas