Comment définir des relations avec des annotations dans Hibernate 4 à l'aide de Spring ?

Définir des relations avec des annotations dans Hibernate 4 à l'aide de Spring

Pour implémenter différents types de relations à l'aide d'annotations dans Hibernate 4 pour les classes fournies, Foo et Bar, approfondissons les détails.

Relation unidirectionnelle un-à-plusieurs :

Configurez la classe Foo avec l'annotation @OneToMany et une liste< Barre> propriété. Laissez la classe Bar inchangée. Cela établit une relation un-à-plusieurs dans laquelle Foo peut avoir plusieurs objets Bar associés, mais Bar ne peut pas faire référence à Foo.

Relation bidirectionnelle un-à-plusieurs (gérée par Foo.class ):

Utilisez l'annotation @OneToOne avec cascade = CascadeType.ALL sur Foo.class. Ajoutez une annotation @JoinColumn spécifiant la colonne sur Bar.class qui doit être utilisée pour la jointure. Pour Bar.class, utilisez l'annotation @OneToOne et spécifiez mappedBy = "bar" pour indiquer que la relation est gérée par Foo.class.

Relation unidirectionnelle un-à-plusieurs à l'aide de User- Table de jointure gérée :

Utilisez l'annotation @OneToMany avec une annotation @JoinTable pour spécifier une table de jointure distincte. Définissez les colonnes de jointure avec les annotations @JoinColumn des deux côtés. Utilisez une classe supplémentaire pour représenter la table de jointure, si nécessaire.

Relation bidirectionnelle un-à-plusieurs utilisant le mappage de clés étrangères :

Sur Foo.class, utilisez @OneToMany(mappedBy = "bar") pour mapper la relation. Sur Bar.class, utilisez @ManyToOne(cascade = { CascadeTyep.PERSIST, CascadeType.MERGE, CascadeType.REFRESH }) avec une annotation @JoinColumn.

Many-to-Many bidirectionnel utilisant Hibernate -managed Join Table :

Utilisez @ManyToMany sur Foo.class et Bar.class, et utilisez une annotation @JoinTable pour la table de jointure, en spécifiant les colonnes de jointure.

Plusieurs-à-plusieurs bidirectionnels à l'aide d'un objet de table de jointure géré par l'utilisateur :

Semblable à l'exemple un-à-plusieurs unidirectionnel, utilisez @OneToMany avec une annotation @JoinTable. Créez une classe distincte pour représenter la table de jointure et mappez la relation sur Foo.class et Bar.class à l'aide de @ManyToOne.

Détermination du type de récupération :

Utilisez fetchType .LAZY pour retarder le chargement des collections associées jusqu'à ce qu'elles soient accessibles. Utilisez fetchType.EAGER pour charger la collection immédiatement, mais notez que cela peut avoir un impact sur les performances. Pensez à utiliser Hibernate.initialize() dans votre classe Service pour initialiser manuellement les collections chargées paresseusement pour des cas d'utilisation spécifiques.

Détermination de la direction de la cascade :

Utilisez l'annotation @Cascade pour spécifier les options en cascade. Généralement, les changements en cascade vont dans le sens de la relation de propriété. Évitez les mises à jour ou les suppressions en cascade de l'enfant vers le parent si cela n'a pas de sens dans le contexte de l'application.

Suppression des orphelins :

Définissez orphanRemoval = true sur l'annotation @OneToMany pour qu'Hibernate supprime automatiquement les objets orphelins (c'est-à-dire ceux qui ne sont associés à aucun autre objet parent) lorsqu'ils sont supprimés de la collection sur l'objet parent.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!