Documentation de référence d'Hibernate
Version: 3.2final
Table des matières
Préface ..........................................................................................................................................viii
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 ...................................................................................................1
1.2.2. Le fichier de mapping ..............................................................................................3
1.2.3. Configuration d'Hibernate ........................................................................................ 5
1.2.4. Construction avec Ant .............................................................................................6
1.2.5. Démarrage et aides ..................................................................................................7
1.2.6. Charger et stocker des objets .................................................................................... 8
1.3. Partie 2 - Mapper des associations ..................................................................................... 11
1.3.1. Mapper la classe Person ......................................................................................... 11
1.3.2. Une association unidirectionnelle basée sur Set ....................................................... 11
1.3.3. Travailler avec l'association ................................................................................... 12
1.3.4. Collection de valeurs ............................................................................................. 14
1.3.5. Associations bidirectionnelles ................................................................................ 15
1.3.6. Travailler avec des liens bidirectionnels .................................................................. 16
1.4. Part 3 - L'application web EventManager ........................................................................... 17
1.4.1. Ecrire la servlet de base ......................................................................................... 17
1.4.2. Procéder et rendre .................................................................................................. 18
1.4.3. Déployer et tester .................................................................................................. 19
1.5. Résumé ........................................................................................................................... 20
2. Architecture .............................................................................................................................. 21
2.1. Généralités ...................................................................................................................... 21
2.2. Etats des instances ............................................................................................................ 23
2.3. Intégration JMX ............................................................................................................... 23
2.4. Support JCA .................................................................................................................... 24
2.5. Sessions Contextuelles ..................................................................................................... 24
3. Configuration ............................................................................................................................ 26
3.1. Configuration par programmation ..................................................................................... 26
3.2. Obtenir une SessionFactory .............................................................................................. 26
3.3. Connexions JDBC ............................................................................................................ 27
3.4. Propriétés de configuration optionnelles ............................................................................ 28
3.4.1. Dialectes SQL ....................................................................................................... 34
3.4.2. Chargement par Jointure Ouverte ........................................................................... 35
3.4.3. Flux binaires ......................................................................................................... 35
3.4.4. Cache de second niveau et cache de requêtes ........................................................... 35
3.4.5. Substitution dans le langage de requêtage ................................................................ 35
3.4.6. Statistiques Hibernate ............................................................................................ 36
3.5. Tracer .............................................................................................................................. 36
3.6. Implémenter une NamingStrategy ..................................................................................... 37
3.7. Fichier de configuration XML ........................................................................................... 37
3.8. Intégration à un serveur d'application J2EE ........................................................................ 38
3.8.1. Configuration de la stratégie transactionnelle .......................................................... 39
3.8.2. SessionFactory associée au JNDI ............................................................................ 40
3.8.3. Association automatique de la Session à JTA .......................................................... 40
3.8.4. Déploiement JMX ................................................................................................. 40
4. Classes persistantes ................................................................................................................... 42
Hibernate 3.2final ii
4.1. Un exemple simple de POJO ............................................................................................. 42
4.1.1. Implémenter un constructeur sans argument ............................................................ 43
4.1.2. Fournir une propriété d'indentifiant (optionnel) ........................................................ 43
4.1.3. Favoriser les classes non finales (optionnel) ............................................................ 44
4.1.4. Déclarer les accesseurs et mutateurs des attributs persistants (optionnel) ................... 44
4.2. Implémenter l'héritage ...................................................................................................... 44
4.3. Implémenter equals() et hashCode() .................................................................................. 44
4.4. Modèles dynamiques ........................................................................................................ 45
4.5. Tuplizers ......................................................................................................................... 47
5. Mapping O/R basique ............................................................................................................... 49
5.1. Déclaration de Mapping .................................................................................................... 49
5.1.1. Doctype ................................................................................................................ 50
5.1.1.1. EntityResolver ............................................................................................ 50
5.1.2. hibernate-mapping ................................................................................................. 51
5.1.3. class ..................................................................................................................... 51
5.1.4. id .......................................................................................................................... 54
5.1.4.1. Generator ................................................................................................... 55
5.1.4.2. algorithme Hi/lo ......................................................................................... 56
5.1.4.3. UUID algorithm ......................................................................................... 56
5.1.4.4. Colonnes identifiantes et séquences ............................................................. 56
5.1.4.5. Identifiants assignés .................................................................................... 57
5.1.4.6. Clefs primaires assignées par trigger ............................................................ 57
5.1.5. composite-id ......................................................................................................... 57
5.1.6. discriminator ......................................................................................................... 58
5.1.7. version (optionnel) ................................................................................................ 59
5.1.8. timestamp (optionnel) ............................................................................................ 60
5.1.9. property ................................................................................................................ 60
5.1.10. many-to-one ........................................................................................................ 62
5.1.11. one-to-one ........................................................................................................... 63
5.1.12. natural-id ............................................................................................................ 65
5.1.13. component, dynamic-component .......................................................................... 65
5.1.14. properties ............................................................................................................ 66
5.1.15. subclass .............................................................................................................. 67
5.1.16. joined-subclass .................................................................................................... 68
5.1.17. union-subclass ..................................................................................................... 69
5.1.18. join ..................................................................................................................... 69
5.1.19. key ..................................................................................................................... 70
5.1.20. éléments column et formula .................................................................................. 71
5.1.21. import ................................................................................................................. 71
5.1.22. any ..................................................................................................................... 72
5.2. Hibernate Types ............................................................................................................... 73
5.2.1. Entités et valeurs ................................................................................................... 73
5.2.2. Basic value types ................................................................................................... 73
5.2.3. Types de valeur définis par l'utilisateur ................................................................... 75
5.3. Mapper une classe plus d'une fois ...................................................................................... 76
5.4. SQL quoted identifiers ...................................................................................................... 76
5.5. alternatives Metadata ........................................................................................................ 76
5.5.1. utilisation de XDoclet ............................................................................................ 76
5.5.2. Utilisation des annotations JDK 5.0 ........................................................................ 78
5.6. Propriétés générées ........................................................................................................... 79
5.7. Objets auxiliaires de la base de données ............................................................................. 79
6. Mapping des collections ............................................................................................................ 81
HIBERNATE - Persistance relationnelle en Java standard
Hibernate 3.2final iii
6.1. Collections persistantes .................................................................................................... 81
6.2. Mapper une collection ...................................................................................................... 81
6.2.1. Les clefs étrangères d'une collection ....................................................................... 83
6.2.2. Les éléments d'une collection ................................................................................. 83
6.2.3. Collections indexées .............................................................................................. 83
6.2.4. Collections de valeurs et associations plusieurs-vers-plusieurs .................................. 84
6.2.5. Association un-vers-plusieurs ................................................................................. 86
6.3. Mappings de collection avancés ........................................................................................ 87
6.3.1. Collections triées ................................................................................................... 87
6.3.2. Associations bidirectionnelles ................................................................................ 87
6.3.3. Associations bidirectionnelles avec des collections indexées .................................... 89
6.3.4. Associations ternaires ............................................................................................ 90
6.3.5. Utiliser un <idbag> ................................................................................................ 90
6.4. Exemples de collections .................................................................................................... 91
7. Mapper les associations ............................................................................................................. 94
7.1. Introduction ..................................................................................................................... 94
7.2. Association unidirectionnelle ............................................................................................ 94
7.2.1. plusieurs à un ........................................................................................................ 94
7.2.2. un à un .................................................................................................................. 94
7.2.3. un à plusieurs ........................................................................................................ 95
7.3. Associations unidirectionnelles avec tables de jointure ....................................................... 96
7.3.1. un à plusieurs ........................................................................................................ 96
7.3.2. plusieurs à un ........................................................................................................ 96
7.3.3. un à un .................................................................................................................. 97
7.3.4. plusieurs à plusieurs .............................................................................................. 97
7.4. Associations bidirectionnelles ........................................................................................... 98
7.4.1. un à plusieurs / plusieurs à un ................................................................................. 98
7.4.2. Un à un ................................................................................................................. 99
7.5. Associations bidirectionnelles avec table de jointure ........................................................... 99
7.5.1. un à plusieurs / plusieurs à un ................................................................................. 99
7.5.2. Un à un ............................................................................................................... 100
7.5.3. plusieurs à plusieurs ............................................................................................ 101
7.6. Des mappings plus complexes ......................................................................................... 101
8. Mapping de composants .......................................................................................................... 103
8.1. Objects dépendants ......................................................................................................... 103
8.2. Collection d'objets dépendants ........................................................................................ 104
8.3. Utiliser les composants comme index de map ................................................................... 105
8.4. Utiliser un composant comme identifiant ......................................................................... 105
8.5. Composant Dynamique .................................................................................................. 107
9. Mapping d'héritage de classe .................................................................................................. 108
9.1. Les trois stratégies .......................................................................................................... 108
9.1.1. Une table par hiérarchie de classe ......................................................................... 108
9.1.2. Une table par classe fille ...................................................................................... 109
9.1.3. Une table par classe fille, en utilisant un discriminant ............................................ 109
9.1.4. Mélange d'une table par hiérarchie de classe avec une table par classe fille .............. 110
9.1.5. Une table par classe concrète ................................................................................ 110
9.1.6. Une table par classe concrète, en utilisant le polymorphisme implicite .................... 111
9.1.7. Mélange du polymorphisme implicite avec d'autres mappings d'héritage ................. 112
9.2. Limitations .................................................................................................................... 112
10. Travailler avec des objets ...................................................................................................... 114
10.1. États des objets Hibernate ............................................................................................. 114
10.2. Rendre des objets persistants ......................................................................................... 114
HIBERNATE - Persistance relationnelle en Java standard
Hibernate 3.2final iv
10.3. Chargement d'un objet .................................................................................................. 115
10.4. Requêtage .................................................................................................................... 116
10.4.1. Exécution de requêtes ........................................................................................ 116
10.4.1.1. Itération de résultats ................................................................................ 117
10.4.1.2. Requêtes qui retournent des tuples ........................................................... 117
10.4.1.3. Résultats scalaires ................................................................................... 117
10.4.1.4. Lier des paramètres ................................................................................. 118
10.4.1.5. Pagination .............................................................................................. 118
10.4.1.6. Itération "scrollable" ............................................................................... 118
10.4.1.7. Externaliser des requêtes nommées .......................................................... 119
10.4.2. Filtrer des collections ......................................................................................... 119
10.4.3. Requêtes Criteria ............................................................................................... 120
10.4.4. Requêtes en SQL natif ....................................................................................... 120
10.5. Modifier des objets persistants ...................................................................................... 121
10.6. Modifier des objets détachés ......................................................................................... 121
10.7. Détection automatique d'un état ..................................................................................... 122
10.8. Suppression d'objets persistants ..................................................................................... 123
10.9. Réplication d'objets entre deux entrepôts de données ...................................................... 123
10.10. Flush de la session ...................................................................................................... 124
10.11. Persistance transitive .................................................................................................. 125
10.12. Utilisation des méta-données ....................................................................................... 126
11. Transactions et accès concurrents ......................................................................................... 127
11.1. Gestion de session et délimitation de transactions ........................................................... 127
11.1.1. Unité de travail .................................................................................................. 127
11.1.2. Longue conversation .......................................................................................... 128
11.1.3. L'identité des objets ........................................................................................... 129
11.1.4. Problèmes communs .......................................................................................... 130
11.2. Démarcation des transactions ........................................................................................ 131
11.2.1. Environnement non managé ............................................................................... 131
11.2.2. Utilisation de JTA ............................................................................................. 132
11.2.3. Gestion des exceptions ....................................................................................... 134
11.2.4. Timeout de transaction ....................................................................................... 134
11.3. Contrôle de consurrence optimiste ................................................................................. 135
11.3.1. Gestion du versionnage au niveau applicatif ........................................................ 135
11.3.2. Les sessions longues et le versionnage automatique. ............................................ 136
11.3.3. Les objets détachés et le versionnage automatique ............................................... 136
11.3.4. Personnaliser le versionnage automatique ............................................................ 137
11.4. Verouillage pessimiste .................................................................................................. 138
11.5. Mode de libération de Connection ................................................................................. 138
12. Les intercepteurs et les événements ....................................................................................... 140
12.1. Intercepteurs ................................................................................................................ 140
12.2. Système d'événements .................................................................................................. 141
12.3. Sécurité déclarative d'Hibernate .................................................................................... 143
13. Traitement par paquet .......................................................................................................... 144
13.1. Insertions en paquet ...................................................................................................... 144
13.2. Paquet de mises à jour .................................................................................................. 144
13.3. L'interface StatelessSession ........................................................................................... 145
13.4. Opérations de style DML .............................................................................................. 146
14. HQL: Langage de requêtage d'Hibernate .............................................................................. 149
14.1. Sensibilité à la casse ..................................................................................................... 149
14.2. La clause from ............................................................................................................. 149
14.3. Associations et jointures ............................................................................................... 149
HIBERNATE - Persistance relationnelle en Java standard
Hibernate 3.2final v
