HIBERNATE - Persistance
relationnelle en Java standard
Documentation de référence d'Hibernate
3.3.0.GA
HIBERNATE - Persistance relationnelle en Java standard
Copyright © 2004 Red Hat Middleware, LLC.
Legal Notice
1801 Varsity Drive Raleigh, NC27606-2072USA Phone: +1 919 754 3700 Phone: 888 733 4281 Fax: +1 919 754 3701 PO Box 13588Research Triangle Park, NC27709USA
Copyright © 2007 by Red Hat, Inc. This copyrighted material is made available to anyone wishing to use,
modify, copy, or redistribute it subject to the terms and conditions of the GNU Lesser General Public License
[http://www.gnu.org/licenses/lgpl-2.1.html], as published by the Free Software Foundation.
Red Hat and the Red Hat "Shadow Man" logo are registered trademarks of Red Hat, Inc. in the United States and other
countries.
All other trademarks referenced herein are the property of their respective owners.
The GPG fingerprint of the security@redhat.com key is:
CA 20 86 86 2B D6 9D FC 65 F6 EC C4 21 91 80 CD DB 42 A6 0E
Hibernate 3.3.0.GA iii
Préface ....................................................................................................... xiii
1. Introduction à Hibernate ........................................................................ 1
1.1. Préface .......................................................................................... 1
1.2. Partie 1 - Première application Hibernate ...................................... 1
1.2.1. La première classe ............................................................. 2
1.2.2. Le fichier de mapping ......................................................... 4
1.2.3. Configuration d'Hibernate ................................................... 7
1.2.4. Construction avec Ant ......................................................... 9
1.2.5. Démarrage et aides .......................................................... 10
1.2.6. Charger et stocker des objets ........................................... 12
1.3. Partie 2 - Mapper des associations ............................................. 15
1.3.1. Mapper la classe Person .................................................. 15
1.3.2. Une association unidirectionnelle basée sur Set ............... 16
1.3.3. Travailler avec l'association .............................................. 18
1.3.4. Collection de valeurs ........................................................ 20
1.3.5. Associations bidirectionnelles ........................................... 22
1.3.6. Travailler avec des liens bidirectionnels ............................ 23
1.4. Part 3 - L'application web EventManager .................................... 24
1.4.1. Ecrire la servlet de base ................................................... 24
1.4.2. Procéder et rendre ............................................................ 25
1.4.3. Déployer et tester ............................................................. 27
1.5. Résumé ....................................................................................... 29
2. Architecture .......................................................................................... 31
2.1. Généralités .................................................................................. 31
2.2. Etats des instances ..................................................................... 34
2.3. Intégration JMX ........................................................................... 34
2.4. Support JCA ................................................................................ 35
2.5. Sessions Contextuelles ............................................................... 35
3. Configuration ........................................................................................ 39
3.1. Configuration par programmation ................................................ 39
3.2. Obtenir une SessionFactory ........................................................ 40
3.3. Connexions JDBC ....................................................................... 40
3.4. Propriétés de configuration optionnelles ...................................... 42
3.4.1. Dialectes SQL ................................................................... 49
3.4.2. Chargement par Jointure Ouverte ..................................... 49
3.4.3. Flux binaires ..................................................................... 50
3.4.4. Cache de second niveau et cache de requêtes ................ 50
3.4.5. Substitution dans le langage de requêtage ....................... 50
3.4.6. Statistiques Hibernate ....................................................... 50
3.5. Tracer .......................................................................................... 51
3.6. Implémenter une NamingStrategy ................................................. 52
3.7. Fichier de configuration XML ....................................................... 53
3.8. Intégration à un serveur d'application J2EE ................................ 54
iv Hibernate 3.3.0.GA
3.8.1. Configuration de la stratégie transactionnelle ................... 55
3.8.2. SessionFactory associée au JNDI ..................................... 56
3.8.3. Association automatique de la Session à JTA .................. 57
3.8.4. Déploiement JMX .............................................................. 57
4. Classes persistantes ............................................................................ 61
4.1. Un exemple simple de POJO ...................................................... 61
4.1.1. Implémenter un constructeur sans argument .................... 63
4.1.2. Fournir une propriété d'indentifiant (optionnel) .................. 63
4.1.3. Favoriser les classes non finales (optionnel) .................... 63
4.1.4. Déclarer les accesseurs et mutateurs des attributs
persistants (optionnel) ................................................................. 64
4.2. Implémenter l'héritage ................................................................. 64
4.3. Implémenter equals() et hashCode() ............................................ 64
4.4. Modèles dynamiques ................................................................... 66
4.5. Tuplizers ...................................................................................... 68
4.6. Extentsions .................................................................................. 70
5. Mapping O/R basique .......................................................................... 71
5.1. Déclaration de Mapping ............................................................... 71
5.1.1. Doctype ............................................................................. 72
5.1.1.1. EntityResolver ........................................................ 73
5.1.2. hibernate-mapping ............................................................ 73
5.1.3. class .................................................................................. 74
5.1.4. id ....................................................................................... 78
5.1.4.1. Generator ............................................................... 79
5.1.4.2. algorithme Hi/lo ...................................................... 81
5.1.4.3. UUID algorithm ....................................................... 82
5.1.4.4. Colonnes identifiantes et séquences ...................... 82
5.1.4.5. Identifiants assignés ............................................... 82
5.1.4.6. Clefs primaires assignées par trigger ..................... 83
5.1.5. Enhanced identifier generators ......................................... 83
5.1.6. Identifier generator optimization ........................................ 85
5.1.7. composite-id ...................................................................... 85
5.1.8. discriminator ...................................................................... 87
5.1.9. version (optionnel) ............................................................ 88
5.1.10. timestamp (optionnel) ...................................................... 89
5.1.11. property ........................................................................... 90
5.1.12. many-to-one .................................................................... 92
5.1.13. Une association one-to-one vers une autre classe
persistante est déclarée avec l'élément one-to-one. ................... 95
5.1.14. Bien que nous recommandions l'utilisation de clé
primaire générée, vous devriez toujours essayer d'identifier
des clé métier (naturelles) pour toutes vos entités. Une clé
naturelle est une propriété ou une combinaison de propriétés
Hibernate 3.3.0.GA v
uniques et non nulles. Si elle est aussi immuable, c'est
encore mieux. Mappez les propriétés de la clé naturelle
dans l'élément <natural-id>. Hibernate générera la clé unique
nécessaire et les contraintes de non-nullité, et votre mapping
s'auto-documentera. .................................................................... 98
5.1.15. L'élément <component> mappe les propriétés d'un objet
fils aux colonnes d'une classe parente. Les composants
peuvent en retour déclarer leurs propres propriétés,
composants ou collections. Voir "Components" plus bas. ........... 98
5.1.16. L'élément <properties> permet la définition d'un
groupement logique nommé des propriétés d'une classe.
L'utilisation la plus importante de cette construction est la
possibilité pour une combinaison de propriétés d'être la cible
d'un property-ref. C'est aussi un moyen pratique de définir
une contrainte d'unicité multi-colonnes. .................................... 100
5.1.17. Pour finir, la persistance polymorphique nécessite
la déclaration de chaque sous-classe de la classe
persistante de base. pour la stratégie de mapping de type
table-per-class-hierarchy, on utilise la déclaration <subclass>.
.................................................................................................... 101
5.1.18. joined-subclass ............................................................. 102
5.1.19. union-subclass .............................................................. 103
5.1.20. join ................................................................................ 104
5.1.21. key ................................................................................ 105
5.1.22. éléments column et formula .......................................... 106
5.1.23. import ............................................................................ 107
5.1.24. any ................................................................................ 107
5.2. Hibernate Types ........................................................................ 109
5.2.1. Entités et valeurs ............................................................ 109
5.2.2. Basic value types ............................................................ 110
5.2.3. Types de valeur définis par l'utilisateur ........................... 111
5.3. Mapper une classe plus d'une fois ............................................ 113
5.4. SQL quoted identifiers ............................................................... 114
5.5. alternatives Metadata ................................................................ 114
5.5.1. utilisation de XDoclet ...................................................... 114
5.5.2. Utilisation des annotations JDK 5.0 ................................ 116
5.6. Propriétés générées .................................................................. 117
5.7. Objets auxiliaires de la base de données .................................. 118
6. Mapping des collections .................................................................... 121
6.1. Collections persistantes ............................................................. 121
6.2. Mapper une collection ............................................................... 122
6.2.1. Les clefs étrangères d'une collection .............................. 124
6.2.2. Les éléments d'une collection ......................................... 124
