HIBERNATE - Persistance relationnelle en Java standard
     Suivant

HIBERNATE - Persistance relationnelle en Java standard

Documentation de référence d'Hibernate

3.3.1

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, 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

Préface
1. Introduction à Hibernate
1.1. Préface
1.2. Partie 1 - Première application Hibernate
1.2.1. La première classe
1.2.2. Le fichier de mapping
1.2.3. Configuration d'Hibernate
1.2.4. Construction avec Ant
1.2.5. Démarrage et aides
1.2.6. Charger et stocker des objets
1.3. Partie 2 - Mapper des associations
1.3.1. Mapper la classe Person
1.3.2. Une association unidirectionnelle basée sur Set
1.3.3. Travailler avec l'association
1.3.4. Collection de valeurs
1.3.5. Associations bidirectionnelles
1.3.6. Travailler avec des liens bidirectionnels
1.4. Part 3 - L'application web EventManager
1.4.1. Ecrire la servlet de base
1.4.2. Procéder et rendre
1.4.3. Déployer et tester
1.5. 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 Ouverte
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êtage
3.4.6. Statistiques Hibernate
3.5. Tracer
3.6. Implémenter une NamingStrategy
3.7. Fichier de configuration XML
3.8. Intégration à un serveur d'application J2EE
3.8.1. Configuration de la stratégie transactionnelle
3.8.2. SessionFactory associée au JNDI
3.8.3. Association automatique de la Session à 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'indentifiant (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. Extentsions
5. Mapping O/R basique
5.1. Déclaration de Mapping
5.1.1. Doctype
5.1.1.1. EntityResolver
5.1.2. hibernate-mapping
5.1.3. class
5.1.4. id
5.1.4.1. Generator
5.1.4.2. algorithme Hi/lo
5.1.4.3. UUID algorithm
5.1.4.4. Colonnes identifiantes et séquences
5.1.4.5. Identifiants assignés
5.1.4.6. Clefs primaires assignées par trigger
5.1.5. Enhanced identifier generators
5.1.6. Identifier generator optimization
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. many-to-one
5.1.13. Une association one-to-one vers une autre classe persistante est déclarée avec l'élément one-to-one.
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 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.
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.
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.
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>.
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. Hibernate Types
5.2.1. Entités et valeurs
5.2.2. Basic value types
5.2.3. Types de valeur définis par l'utilisateur
5.3. Mapper une classe plus d'une fois
5.4. SQL quoted identifiers
5.5. alternatives Metadata
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. Objets auxiliaires de la base de données
6. Mapping des collections
6.1. Collections persistantes
6.2. Mapper une collection
6.2.1. Les clefs é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-vers-plusieurs
6.2.5. Association un-vers-plusieurs
6.3. Mappings 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. Utiliser un <idbag>
6.4. Exemples de collections
7. Mapper les associations
7.1. Introduction
7.2. Association unidirectionnelle
7.2.1. plusieurs à un
7.2.2. one to one
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. one to one
7.3.4. plusieurs à plusieurs
7.4. Associations bidirectionnelles
7.4.1. un à plusieurs / plusieurs à un
7.4.2. one to one
7.5. Associations bidirectionnelles avec table de jointure
7.5.1. un à plusieurs / plusieurs à un
7.5.2. one to one
7.5.3. plusieurs à plusieurs
7.6. Des mappings plus complexes
8. Mapping de composants
8.1. Objects dépendants
8.2. Collection d'objets dépendants
8.3. Utiliser les composants comme index de map
8.4. Utiliser un composant comme identifiant
8.5. Composant Dynamique
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 mappings 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.1.1. Itération de résultats
10.4.1.2. Requêtes qui retournent des tuples
10.4.1.3. Résultats scalaires
10.4.1.4. Lier des paramètres
10.4.1.5. Pagination
10.4.1.6. Itération "scrollable"
10.4.1.7. Externaliser des requêtes nommées
10.4.2. Filtrer des collections
10.4.3. Requêtes Criteria
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. Transactions et accès concurrents
11.1. Gestion de session et délimitation de transactions
11.1.1. Unité de travail
11.1.2. Longue conversation
11.1.3. L'identité des objets
11.1.4. Problèmes communs
11.2. Démarcation des transactions
11.2.1. Environnement non managé
11.2.2. Utilisation de JTA
11.2.3. Gestion des exceptions
11.2.4. Timeout de transaction
11.3. Contrôle de consurrence optimiste
11.3.1. Gestion du versionnage au niveau applicatif
11.3.2. Les sessions longues et le versionnage automatique.
11.3.3. Les objets détachés et le versionnage automatique
11.3.4. Personnaliser le versionnage automatique
11.4. Verouillage pessimiste
11.5. Mode de libération de Connection
12. Les intercepteurs et les événements
12.1. Intercepteurs
12.2. Système d'événements
12.3. Sécurité déclarative d'Hibernate
13. Traitement par paquet
13.1. Paquet de mises à jour
13.2. L'interface StatelessSession
13.3. Notez que dans le code de l'exemple, les intances de Customer retournées par la requête sont immédiatement détachées. Elles ne sont jamais associées à un contexte de persistance.
13.4. La pseudo-syntaxe pour les expressions UPDATE et DELETE est : ( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?. Certains points sont à noter :
14. HQL: Langage de requêtage d'Hibernate
14.1. Sensibilité à la casse
14.2. La clause from
14.3. Associations et jointures
14.4. Formes de syntaxes pour les jointures
14.5. Refering to identifier property
14.6. La clause select
14.7. Fonctions d'aggrégation
14.8. Requêtes polymorphiques
14.9. La clause where
14.10. Expressions
14.11. La clause order by
14.12. La clause group by
14.13. Sous-requêtes
14.14. Exemples HQL
14.15. Mise à jour et suppression
14.16. Trucs & Astuces
14.17. translator-credits
14.18. Row value constructor syntax
15. Requêtes par critères
15.1. Créer une instance de Criteria
15.2. Restriction du résultat
15.3. Trier les résultats
15.4. Associations
15.5. Peuplement d'associations de manière dynamique
15.6. Requêtes par l'exemple
15.7. Projections, agrégation et regroupement
15.8. Requêtes et sous-requêtes détachées
15.9. Requêtes par identifiant naturel
16. SQL natif
16.1. Utiliser une SQLQuery
16.1.1. Scalar queries
16.1.2. Entity queries
16.1.3. Handling associations and collections
16.1.4. Returning multiple entities
16.1.4.1. Alias and property references
16.1.5. Returning non-managed entities
16.1.6. Handling inheritance
16.1.7. Parameters
16.2. Requêtes SQL nommées
16.2.1. Utilisation de return-property pour spécifier explicitement les noms des colonnes/alias
16.2.2. Utilisation de procédures stockées pour les requêtes
16.2.2.1. Règles/limitations lors de l'utilisation des procédures stockées
16.3. SQL personnalisé pour créer, mettre à jour et effacer
16.4. SQL personnalisé pour le chargement
17. Filtrer les données
17.1. Filtres Hibernate
18. Mapping XML
18.1. Travailler avec des données XML
18.1.1. Spécifier le mapping XML et le mapping d'une classe ensemble
18.1.2. Spécifier seulement un mapping XML
18.2. Métadonnées du mapping XML
18.3. Manipuler des données XML
19. Améliorer les performances
19.1. Stratégies de chargement
19.1.1. Travailler avec des associations chargées tardivement
19.1.2. Personnalisation des stratégies de chargement
19.1.3. Proxys pour des associations vers un seul objet
19.1.4. Initialisation des collections et des proxys
19.1.5. Utiliser le chargement par lot
19.1.6. Utilisation du chargement par sous select
19.1.7. Utiliser le chargement tardif des propriétés
19.2. Le cache de second niveau
19.2.1. Mapping de Cache
19.2.2. Strategie : lecture seule
19.2.3. Stratégie : lecture/écriture
19.2.4. Stratégie : lecture/écriture non stricte
19.2.5. Stratégie : transactionelle
19.2.6. Cache-provider/concurrency-strategy compatibility
19.3. Gérer les caches
19.4. Le cache de requêtes
19.5. Comprendre les performances des Collections
19.5.1. Classification
19.5.2. Les lists, les maps, les idbags et les sets sont les collections les plus efficaces pour la mise à jour
19.5.3. Les Bags et les lists sont les plus efficaces pour les collections inverse
19.5.4. Suppression en un coup
19.6. Moniteur de performance
19.6.1. Suivi d'une SessionFactory
19.6.2. Métriques
20. Guide des outils
20.1. Génération automatique du schéma
20.1.1. Personnaliser le schéma
20.1.2. Exécuter l'outil
20.1.3. Propriétés
20.1.4. Utiliser Ant
20.1.5. Mises à jour incrémentales du schéma
20.1.6. Utiliser Ant pour des mises à jour de schéma par incrément
20.1.7. Validation du schéma
20.1.8. Utiliser Ant pour la validation du Schéma
21. Exemple : Père/Fils
21.1. Une note à propos des collections
21.2. un-vers-plusieurs bidirectionnel
21.3. Cycle de vie en cascade
21.4. Cascades et unsaved-value
21.5. Conclusion
22. Exemple : application Weblog
22.1. Classes persistantes
22.2. Mappings Hibernate
22.3. Code Hibernate
23. Exemple : quelques mappings
23.1. Employeur/Employé (Employer/Employee)
23.2. Auteur/Travail (Author/Work)
23.3. Client/Commande/Produit (Customer/Order/Product)
23.4. Divers mappings d'exemple
23.4.1. "Typed" one-to-one association
23.4.2. Exemple de clef composée
23.4.3. Many-to-many avec une clef composée partagée
23.4.4. Contenu basé sur une discrimination
23.4.5. Associations sur des clefs alternées
24. Meilleures pratiques
     Suivant
     Préface