HIBERNATE - Relational Persistence for Idiomatic Java

Hibernate Reference Documentation

par Gavin King, Christian Bauer, Max Rydahl Andersen, Emmanuel Bernard, et Steve Ebersole

and thanks to James Cobb (Graphic Design), Cheyenne Weaver (Graphic Design), Vincent Ricard, Sebastien Cesbron, Michael Courcy, Vincent Giguère, Baptiste Mathus, Emmanuel Bernard, et Anthony Patricio

3.5.6-Final

Legal Notice

September 15, 2010

Préface

1. Tutoriel

1.1. Section 1 - Première application Hibernate

1.1.1. Configuration
1.1.2. La première classe
1.1.3. Le fichier de mappage
1.1.4. Configuration d'Hibernate
1.1.5. Construction avec Maven
1.1.6. Démarrage et aides
1.1.7. Charger et stocker des objets

1.2. Section 2 - Mapper des associations

1.2.1. Mapper la classe Person
1.2.2. Une association unidirectionnelle basée sur Set
1.2.3. Travailler avec l'association
1.2.4. Collection de valeurs
1.2.5. Associations bidirectionnelles
1.2.6. Travailler avec des liens bidirectionnels

1.3. Section 3 - L'application web EventManager

1.3.1. Écrire la servlet de base
1.3.2. Traiter et interpréter
1.3.3. Déployer et tester

1.4. Résumé

2. Architecture

2.1. Généralités
2.2. Etats des instances
2.3. Intégration JMX
2.4. Support JCA
2.5. Sessions contextuelles

3. Configuration

3.1. Configuration par programmation

3.2. Obtenir une SessionFactory

3.3. Connexions JDBC

3.4. Propriétés de configuration optionnelles

3.4.1. Dialectes SQL
3.4.2. Chargement par jointure externe
3.4.3. Flux binaires
3.4.4. Cache de second niveau et cache de requêtes
3.4.5. Substitution dans le langage de requêtes
3.4.6. Statistiques Hibernate

3.5. Journalisation

3.6. Sélectionne une NamingStrategy (stratégie de nommage)

3.7. Fichier de configuration XML

3.8. Intégration à un serveur d'applications J2EE

3.8.1. Configuration de la stratégie transactionnelle
3.8.2. SessionFactory associée au JNDI
3.8.3. Gestion du contexte de la session courante à JTA
3.8.4. Déploiement JMX

4. Classes persistantes

4.1. Un exemple simple de POJO

4.1.1. Implémenter un constructeur sans argument
4.1.2. Fournir une propriété d'identifiant (optionnel)
4.1.3. Favoriser les classes non finales (optionnel)
4.1.4. Déclarer les accesseurs et mutateurs des attributs persistants (optionnel)

4.2. Implémenter l'héritage

4.3. Implémenter equals() et hashCode()

4.4. Modèles dynamiques

4.5. Tuplizers

4.6. EntityNameResolvers

5. Mappage O/R de base

5.1. Déclaration de mappage

5.1.1. Doctype
5.1.2. Hibernate-mappage
5.1.3. Classe
5.1.4. id
5.1.5. La méthode getter de l'identifiant
5.1.6. Optimisation du générateur d'identifiants
5.1.7. composite-id
5.1.8. Discriminator
5.1.9. Version (optionnel)
5.1.10. Timestamp (optionnel)
5.1.11. Property
5.1.12. Plusieurs-à-un
5.1.13. Un-à-un
5.1.14. Natural-id
5.1.15. Component, dynamic-component
5.1.16. Propriétés
5.1.17. Subclass
5.1.18. Joined-subclass
5.1.19. Union-subclass
5.1.20. Join
5.1.21. Key
5.1.22. Éléments column et formula
5.1.23. Import
5.1.24. Any

5.2. Types Hibernate

5.2.1. Entités et valeurs
5.2.2. Types valeurs de base
5.2.3. Types de valeur personnalisés

5.3. Mapper une classe plus d'une fois

5.4. SQL quoted identifiers

5.5. Métadonnées alternatives

5.5.1. Utilisation de XDoclet
5.5.2. Utilisation des annotations JDK 5.0

5.6. Propriétés générées

5.7. Column read and write expressions

5.8. Objets auxiliaires de la base de données

6. Mapper une collection

6.1. Collections persistantes

6.2. Mapper une collection

6.2.1. Les clés étrangères d'une collection
6.2.2. Les éléments d'une collection
6.2.3. Collections indexées
6.2.4. Collections de valeurs et associations plusieurs-à-plusieurs
6.2.5. Associations un-à-plusieurs

6.3. Mappages de collection avancés

6.3.1. Collections triées
6.3.2. Associations bidirectionnelles
6.3.3. Associations bidirectionnelles avec des collections indexées
6.3.4. Associations ternaires
6.3.5. Using an <idbag>

6.4. Exemples de collections

7. Mapper les associations

7.1. Introduction

7.2. Associations unidirectionnelles

7.2.1. plusieurs-à-un
7.2.2. Un-à-un
7.2.3. un-à-plusieurs

7.3. Associations unidirectionnelles avec tables de jointure

7.3.1. un-à-plusieurs
7.3.2. plusieurs-à-un
7.3.3. Un-à-un
7.3.4. Plusieurs-à-plusieurs

7.4. Associations bidirectionnelles

7.4.1. un-à-plusieurs / plusieurs-à-un
7.4.2. Un-à-un

7.5. Associations bidirectionnelles avec tables de jointure

7.5.1. un-à-plusieurs / plusieurs-à-un
7.5.2. un-à-un
7.5.3. Plusieurs-à-plusieurs

7.6. Des mappages d'associations plus complexes

8. Mappage de composants

8.1. Objets dépendants
8.2. Collection d'objets dépendants
8.3. Les composants en tant qu'indices de Map
8.4. Les composants en tant qu'identifiants composites
8.5. Les composants dynamiques

9. Mapping d'héritage de classe

9.1. Les trois stratégies

9.1.1. Une table par hiérarchie de classe
9.1.2. Une table par classe fille
9.1.3. Une table par classe fille, en utilisant un discriminant
9.1.4. Mélange d'une table par hiérarchie de classe avec une table par classe fille
9.1.5. Une table par classe concrète
9.1.6. Une table par classe concrète, en utilisant le polymorphisme implicite
9.1.7. Mélange du polymorphisme implicite avec d'autres mappages d'héritage

9.2. Limitations

10. Travailler avec des objets

10.1. États des objets Hibernate

10.2. Rendre des objets persistants

10.3. Chargement d'un objet

10.4. Requêtage

10.4.1. Exécution de requêtes
10.4.2. Filtrer des collections
10.4.3. Requêtes par critères
10.4.4. Requêtes en SQL natif

10.5. Modifier des objets persistants

10.6. Modifier des objets détachés

10.7. Détection automatique d'un état

10.8. Suppression d'objets persistants

10.9. Réplication d'objets entre deux entrepôts de données

10.10. Flush de la session

10.11. Persistance transitive

10.12. Utilisation des méta-données

11. Read-only entities

11.1. Making persistent entities read-only

11.1.1. Entities of immutable classes
11.1.2. Loading persistent entities as read-only
11.1.3. Loading read-only entities from an HQL query/criteria
11.1.4. Making a persistent entity read-only

11.2. Read-only affect on property type

11.2.1. Simple properties
11.2.2. Unidirectional associations
11.2.3. Bidirectional associations

12. Transactions et Accès concurrents

12.1. Portées des sessions et des transactions

12.1.1. Unité de travail
12.1.2. Longue conversation
12.1.3. L'identité des objets
12.1.4. Problèmes communs

12.2. Démarcation des transactions de base de données

12.2.1. Environnement non gérés
12.2.2. Utilisation de JTA
12.2.3. Gestion des exceptions
12.2.4. Timeout de transaction

12.3. Contrôle de concurrence optimiste

12.3.1. Vérification du versionnage au niveau applicatif
12.3.2. Les sessions longues et le versionnage automatique.
12.3.3. Les objets détachés et le versionnage automatique
12.3.4. Personnaliser le versionnage automatique

12.4. Verrouillage pessimiste

12.5. Modes de libération de connexion

13. Intercepteurs et événements

13.1. Intercepteurs
13.2. Système d'événements
13.3. Sécurité déclarative de Hibernate

14. Traitement par lot

14.1. Insertions en lot
14.2. Mise à jour des lots
14.3. L'interface StatelessSession
14.4. Opérations de style DML

15. HQL : langage d'interrogation d'Hibernate

15.1. Sensibilité à la casse
15.2. La clause from
15.3. Associations et jointures
15.4. Formes de syntaxes pour les jointures
15.5. Faire référence à la propriété identifiant
15.6. La clause select
15.7. Fonctions d'agrégation
15.8. Requêtes polymorphiques
15.9. La clause where
15.10. Expressions
15.11. La clause order by
15.12. La clause group by
15.13. Sous-requêtes
15.14. Exemples HQL
15.15. Nombreuses mises à jour et suppressions
15.16. Trucs & Astuces
15.17. Composants
15.18. Syntaxe des constructeurs de valeur de ligne

16. Requêtes par critères

16.1. Créer une instance de Criteria
16.2. Restriction du résultat
16.3. Trier les résultats
16.4. Associations
16.5. Peuplement d'associations de manière dynamique
16.6. Requêtes par l'exemple
16.7. Projections, agrégation et regroupement
16.8. Requêtes et sous-requêtes détachées
16.9. Requêtes par identifiant naturel

17. SQL natif

17.1. Utiliser une requête SQLQuery

17.1.1. Requêtes scalaires
17.1.2. Requêtes d'entités
17.1.3. Gérer les associations et collections
17.1.4. Retour d'entités multiples
17.1.5. Retour d'entités non gérées
17.1.6. Gérer l'héritage
17.1.7. Paramètres

17.2. Requêtes SQL nommées

17.2.1. Utilisation de return-property pour spécifier explicitement les noms des colonnes/alias
17.2.2. Utilisation de procédures stockées pour les requêtes

17.3. SQL personnalisé pour créer, mettre à jour et effacer

17.4. SQL personnalisé pour le chargement

18. Filtrer les données

18.1. Filtres Hibernate

19. Mappage XML

19.1. Travailler avec des données XML

19.1.1. Spécifier le mappage XML et le mappage d'une classe ensemble
19.1.2. Spécifier seulement un mappage XML

19.2. Métadonnées du mappage XML

19.3. Manipuler des données XML

20. Améliorer les performances

20.1. Stratégies de chargement

20.1.1. Travailler avec des associations chargées en différé
20.1.2. Personnalisation des stratégies de chargement
20.1.3. Proxies pour des associations vers un seul objet
20.1.4. Initialisation des collections et des proxies
20.1.5. Utiliser le chargement par lot
20.1.6. Utilisation du chargement par sous select
20.1.7. Fetch profiles
20.1.8. Utiliser le chargement en différé des propriétés

20.2. Le cache de second niveau

20.2.1. Mappages de Cache
20.2.2. Stratégie : lecture seule
20.2.3. Stratégie : lecture/écriture
20.2.4. Stratégie : lecture/écriture non stricte
20.2.5. Stratégie : transactionelle
20.2.6. Support de stratégie de concurrence du fournisseur-cache

20.3. Gérer les caches

20.4. Le cache de requêtes

20.4.1. Enabling query caching
20.4.2. Query cache regions

20.5. Comprendre les performances des collections

20.5.1. Taxinomie
20.5.2. Les lists, les maps, les idbags et les ensembles sont les collections les plus efficaces pour la mise à jour
20.5.3. Les sacs et les listes sont les plus efficaces pour les collections inverses
20.5.4. Suppression en un coup

20.6. Moniteur de performance

20.6.1. Suivi d'une SessionFactory
20.6.2. Métriques

21. Guide de la boîte à outils

21.1. Génération automatique du schéma

21.1.1. Personnaliser le schéma
21.1.2. Exécuter l'outil
21.1.3. Propriétés
21.1.4. Utiliser Ant
21.1.5. Mises à jour incrémentales du schéma
21.1.6. Utiliser Ant pour des mises à jour de schéma par incrément
21.1.7. Validation du schéma
21.1.8. Utiliser Ant pour la validation du Schéma

22. Exemple : père/fils

22.1. Une note à propos des collections
22.2. Un-à-plusieurs bidirectionnel
22.3. Cycle de vie en cascade
22.4. Cascades et unsaved-value (valeurs non sauvegardées)
22.5. Conclusion

23. Exemple : application Weblog

23.1. Classes persistantes
23.2. Mappages Hibernate
23.3. Code Hibernate

24. Exemple : quelques mappages

24.1. Employeur/Employé (Employer/Employee)

24.2. Auteur/Travail

24.3. Client/Commande/Produit

24.4. Divers exemples de mappages

24.4.1. "Typed" association un-à-un
24.4.2. Exemple de clef composée
24.4.3. Plusieurs-à-plusieurs avec un attribut de clef composée partagée
24.4.4. Contenu basé sur une discrimination
24.4.5. Associations sur des clés alternées

25. Meilleures pratiques

26. Considérations de portabilité des bases de données

26.1. Aspects fondamentaux de la portabilité
26.2. Dialecte
26.3. Résolution de dialecte
26.4. Générer les identifiants
26.5. Fonctions de base de données
26.6. Type mappings

References

SuivantPréface