Hibernate.orgCommunity Documentation

HIBERNATE - Relational Persistence for Idiomatic Java

Hibernate Reference Documentation

3.6.10.Final

Legal Notice

February 8, 2012


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.1.1. Minimal architecture
2.1.2. Comprehensive architecture
2.1.3. Basic APIs
2.2. Intégration JMX
2.3. 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. Implementing a PersisterClassProvider
3.8. Fichier de configuration XML
3.9. Java EE Application Server integration
3.9.1. Configuration de la stratégie transactionnelle
3.9.2. SessionFactory associée au JNDI
3.9.3. Gestion du contexte de la session courante à JTA
3.9.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. Provide an identifier property
4.1.3. Prefer non-final classes (semi-optional)
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. Entity
5.1.2. Identifiers
5.1.3. Optimistic locking properties (optional)
5.1.4. Property
5.1.5. Embedded objects (aka components)
5.1.6. Inheritance strategy
5.1.7. Mapping one to one and one to many associations
5.1.8. Natural-id
5.1.9. Any
5.1.10. Propriétés
5.1.11. Some hbm.xml specificities
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. Propriétés générées
5.6. Column transformers: read and write expressions
5.7. Objets auxiliaires de la base de données
6. Types
6.1. Value types
6.1.1. Basic value types
6.1.2. Composite types
6.1.3. Collection types
6.2. Entity types
6.3. Significance of type categories
6.4. Custom types
6.4.1. Custom types using org.hibernate.type.Type
6.4.2. Custom types using org.hibernate.usertype.UserType
6.4.3. Custom types using org.hibernate.usertype.CompositeUserType
6.5. Type registry
7. Mapper une collection
7.1. Collections persistantes
7.2. How to map collections
7.2.1. Les clés étrangères d'une collection
7.2.2. Collections indexées
7.2.3. Collections of basic types and embeddable objects
7.3. Mappages de collection avancés
7.3.1. Collections triées
7.3.2. Associations bidirectionnelles
7.3.3. Associations bidirectionnelles avec des collections indexées
7.3.4. Associations ternaires
7.3.5. Using an <idbag>
7.4. Exemples de collections
8. Mapper les associations
8.1. Introduction
8.2. Associations unidirectionnelles
8.2.1. plusieurs-à-un
8.2.2. Un-à-un
8.2.3. un-à-plusieurs
8.3. Associations unidirectionnelles avec tables de jointure
8.3.1. un-à-plusieurs
8.3.2. plusieurs-à-un
8.3.3. Un-à-un
8.3.4. Plusieurs-à-plusieurs
8.4. Associations bidirectionnelles
8.4.1. un-à-plusieurs / plusieurs-à-un
8.4.2. Un-à-un
8.5. Associations bidirectionnelles avec tables de jointure
8.5.1. un-à-plusieurs / plusieurs-à-un
8.5.2. un-à-un
8.5.3. Plusieurs-à-plusieurs
8.6. Des mappages d'associations plus complexes
9. Mappage de composants
9.1. Objets dépendants
9.2. Collection d'objets dépendants
9.3. Les composants en tant qu'indices de Map
9.4. Les composants en tant qu'identifiants composites
9.5. Les composants dynamiques
10. Mapping d'héritage de classe
10.1. Les trois stratégies
10.1.1. Une table par hiérarchie de classe
10.1.2. Une table par classe fille
10.1.3. Une table par classe fille, en utilisant un discriminant
10.1.4. Mélange d'une table par hiérarchie de classe avec une table par classe fille
10.1.5. Une table par classe concrète
10.1.6. Une table par classe concrète, en utilisant le polymorphisme implicite
10.1.7. Mélange du polymorphisme implicite avec d'autres mappages d'héritage
10.2. Limitations
11. Travailler avec des objets
11.1. États des objets Hibernate
11.2. Rendre des objets persistants
11.3. Chargement d'un objet
11.4. Requêtage
11.4.1. Exécution de requêtes
11.4.2. Filtrer des collections
11.4.3. Requêtes par critères
11.4.4. Requêtes en SQL natif
11.5. Modifier des objets persistants
11.6. Modifier des objets détachés
11.7. Détection automatique d'un état
11.8. Suppression d'objets persistants
11.9. Réplication d'objets entre deux entrepôts de données
11.10. Flush de la session
11.11. Persistance transitive
11.12. Utilisation des méta-données
12. Read-only entities
12.1. Making persistent entities read-only
12.1.1. Entities of immutable classes
12.1.2. Loading persistent entities as read-only
12.1.3. Loading read-only entities from an HQL query/criteria
12.1.4. Making a persistent entity read-only
12.2. Read-only affect on property type
12.2.1. Simple properties
12.2.2. Unidirectional associations
12.2.3. Bidirectional associations
13. Transactions et Accès concurrents
13.1. Portées des sessions et des transactions
13.1.1. Unité de travail
13.1.2. Longue conversation
13.1.3. L'identité des objets
13.1.4. Problèmes communs
13.2. Démarcation des transactions de base de données
13.2.1. Environnement non gérés
13.2.2. Utilisation de JTA
13.2.3. Gestion des exceptions
13.2.4. Timeout de transaction
13.3. Contrôle de concurrence optimiste
13.3.1. Vérification du versionnage au niveau applicatif
13.3.2. Les sessions longues et le versionnage automatique.
13.3.3. Les objets détachés et le versionnage automatique
13.3.4. Personnaliser le versionnage automatique
13.4. Verrouillage pessimiste
13.5. Modes de libération de connexion
14. Intercepteurs et événements
14.1. Intercepteurs
14.2. Système d'événements
14.3. Sécurité déclarative de Hibernate
15. Traitement par lot
15.1. Insertions en lot
15.2. Mise à jour des lots
15.3. L'interface StatelessSession
15.4. Opérations de style DML
16. HQL : langage d'interrogation d'Hibernate
16.1. Sensibilité à la casse
16.2. La clause from
16.3. Associations et jointures
16.4. Formes de syntaxes pour les jointures
16.5. Faire référence à la propriété identifiant
16.6. La clause select
16.7. Fonctions d'agrégation
16.8. Requêtes polymorphiques
16.9. La clause where
16.10. Expressions
16.11. La clause order by
16.12. La clause group by
16.13. Sous-requêtes
16.14. Exemples HQL
16.15. Nombreuses mises à jour et suppressions
16.16. Trucs & Astuces
16.17. Composants
16.18. Syntaxe des constructeurs de valeur de ligne
17. Requêtes par critères
17.1. Créer une instance de Criteria
17.2. Restriction du résultat
17.3. Trier les résultats
17.4. Associations
17.5. Peuplement d'associations de manière dynamique
17.6. Requêtes par l'exemple
17.7. Projections, agrégation et regroupement
17.8. Requêtes et sous-requêtes détachées
17.9. Requêtes par identifiant naturel
18. SQL natif
18.1. Utiliser une requête SQLQuery
18.1.1. Requêtes scalaires
18.1.2. Requêtes d'entités
18.1.3. Gérer les associations et collections
18.1.4. Retour d'entités multiples
18.1.5. Retour d'entités non gérées
18.1.6. Gérer l'héritage
18.1.7. Paramètres
18.2. Requêtes SQL nommées
18.2.1. Utilisation de return-property pour spécifier explicitement les noms des colonnes/alias
18.2.2. Utilisation de procédures stockées pour les requêtes
18.3. SQL personnalisé pour créer, mettre à jour et effacer
18.4. SQL personnalisé pour le chargement
19. Filtrer les données
19.1. Filtres Hibernate
20. Mappage XML
20.1. Travailler avec des données XML
20.1.1. Spécifier le mappage XML et le mappage d'une classe ensemble
20.1.2. Spécifier seulement un mappage XML
20.2. Métadonnées du mappage XML
20.3. Manipuler des données XML
21. Améliorer les performances
21.1. Stratégies de chargement
21.1.1. Travailler avec des associations chargées en différé
21.1.2. Personnalisation des stratégies de chargement
21.1.3. Proxies pour des associations vers un seul objet
21.1.4. Initialisation des collections et des proxies
21.1.5. Utiliser le chargement par lot
21.1.6. Utilisation du chargement par sous select
21.1.7. Fetch profiles
21.1.8. Utiliser le chargement en différé des propriétés
21.2. Le cache de second niveau
21.2.1. Mappages de Cache
21.2.2. Stratégie : lecture seule
21.2.3. Stratégie : lecture/écriture
21.2.4. Stratégie : lecture/écriture non stricte
21.2.5. Stratégie : transactionelle
21.2.6. Support de stratégie de concurrence du fournisseur-cache
21.3. Gérer les caches
21.4. Le cache de requêtes
21.4.1. Enabling query caching
21.4.2. Query cache regions
21.5. Comprendre les performances des collections
21.5.1. Taxinomie
21.5.2. Les lists, les maps, les idbags et les ensembles sont les collections les plus efficaces pour la mise à jour
21.5.3. Les sacs et les listes sont les plus efficaces pour les collections inverses
21.5.4. Suppression en un coup
21.6. Moniteur de performance
21.6.1. Suivi d'une SessionFactory
21.6.2. Métriques
22. Guide de la boîte à outils
22.1. Génération automatique du schéma
22.1.1. Personnaliser le schéma
22.1.2. Exécuter l'outil
22.1.3. Propriétés
22.1.4. Utiliser Ant
22.1.5. Mises à jour incrémentales du schéma
22.1.6. Utiliser Ant pour des mises à jour de schéma par incrément
22.1.7. Validation du schéma
22.1.8. Utiliser Ant pour la validation du Schéma
23. Additional modules
23.1. Bean Validation
23.1.1. Adding Bean Validation
23.1.2. Configuration
23.1.3. Catching violations
23.1.4. Database schema
23.2. Hibernate Search
23.2.1. Description
23.2.2. Integration with Hibernate Annotations
24. Exemple : père/fils
24.1. Une note à propos des collections
24.2. Un-à-plusieurs bidirectionnel
24.3. Cycle de vie en cascade
24.4. Cascades et unsaved-value (valeurs non sauvegardées)
24.5. Conclusion
25. Exemple : application Weblog
25.1. Classes persistantes
25.2. Mappages Hibernate
25.3. Code Hibernate
26. Exemple : quelques mappages
26.1. Employeur/Employé (Employer/Employee)
26.2. Auteur/Travail
26.3. Client/Commande/Produit
26.4. Divers exemples de mappages
26.4.1. "Typed" association un-à-un
26.4.2. Exemple de clef composée
26.4.3. Plusieurs-à-plusieurs avec un attribut de clef composée partagée
26.4.4. Contenu basé sur une discrimination
26.4.5. Associations sur des clés alternées
27. Meilleures pratiques
28. Considérations de portabilité des bases de données
28.1. Aspects fondamentaux de la portabilité
28.2. Dialecte
28.3. Résolution de dialecte
28.4. Générer les identifiants
28.5. Fonctions de base de données
28.6. Type mappings
References