Cet article présente quatre méthodes de cartographie avancées de JPA. 1. L'association bidirectionnelle spécifie le mainteneur de relation via MaptedBy pour permettre à l'utilisateur et à l'adresse de s'accéder les uns aux autres; 2. Association de plusieurs à plusieurs utilise @ManyTomany et @jointable pour gérer les tables intermédiaires, ou créer manuellement des classes d'entités pour étendre les fonctions de table intermédiaires; 3. L'objet Embed utilise @EMBEDDABLE et @EMBEDDED pour intégrer l'adresse dans le tableau de commande, prenant en charge la conception de la clé primaire composée; 4. La structure d'héritage utilise des stratégies Single_Table, Join et Table_Per_Class pour cartographier les sous-classes des employés et sélectionner les solutions appropriées en fonction des besoins de requête.

Lorsque vous utilisez l'API Java Persistance (JPA), en plus de la cartographie de base des entités, la ma?trise de certaines techniques de cartographie avancées peut nous aider à gérer plus de manière flexible des modèles de données complexes et une logique métier. Cet article présentera plusieurs méthodes de cartographie avancées JPA pratiques, notamment l'utilisation avancée des relations individuelles, un à plusieurs et plusieurs à plusieurs, ainsi que le traitement d'objets imbriqués et de structures héréditaires.

1. Relation bidirectionnelle: rendre la relation plus contr?lable

Dans le développement réel, dans de nombreux cas, nous avons besoin de deux entités pour pouvoir accéder les unes aux autres. Par exemple, l'utilisateur (utilisateur) et l'adresse (adresse), un utilisateur peut avoir une adresse et une adresse peut également appartenir à un certain utilisateur.

 @Entité
classe publique User {
    @Identifiant
    ID long privé;

    @Onetoone
    @JoinColumn (name = "Address_id")
    adresse privée;
}

@Entité
Adresse de classe publique {
    @Identifiant
    ID long privé;

    @OneToOne (maptedBy = "Address")
    utilisateur utilisateur privé;
}

La clé ici réside dans l'utilisation de mappedBy , qui dit à JPA quelle partie maintient la relation. Il est généralement recommandé que le ?propriétaire? gère les clés étrangères, et l'autre partie les fait référence par mappedBy .

Conseils:

• Les relations bidirectionnelles sont susceptibles de causer des problèmes de référence circulaires, en particulier lors de la sérialisation en JSON.
• L'utilisation @JsonManagedReference et @JsonBackReference peut éviter le problème de récursivité infinie de la sérialisation de Jackson.

2. Association de plusieurs à plusieurs: comment traiter les tables intermédiaires

Lorsqu'il existe une relation plusieurs à plusieurs entre deux entités, JPA fournit un support d'annotation concis, mais un tableau intermédiaire sera automatiquement généré derrière. Par exemple, la relation entre l'étudiant et le cours:

 @Entité
étudiant de classe publique {
    @Identifiant
    ID long privé;

    @Manytomany
    @Jointable (
        name = "Student_course",
        joinolumns = @joincumnn (name = "student_id"),
        inverseJoincolumns = @joincumnn (name = "Course_id")
    )
    set privé <Course> Courses = new HashSet <> ();
}

 @Entité
Cours de classe publique {
    @Identifiant
    ID long privé;

    @Manytomany (mappedby = "cours")
    ensemble privé <Student> Students = new HashSet <> ();
}

Si vous souhaitez effectuer des opérations supplémentaires sur la table intermédiaire (comme l'enregistrement du temps ou de l'état de création), vous devez créer manuellement la classe d'entité intermédiaire pour remplacer la conjointé par défaut.

Note:

• Lors de l'insertion de données beaucoup pour beaucoup, la partie référencée (comme le cours) doit être enregistrée en premier, sinon une exception peut être lancée.
• Soyez prudent lors de la modification d'une collection pour éviter l'incohérence des données dues à une synchronisation incorrecte de la relation à deux c?tés.

3. Embed objets et touches primaires composites: modélisation des données qui est plus proche de la réalité

Parfois, nous rencontrons certains champs d'une entité qui peut être abstrait dans un autre objet, mais n'a pas besoin d'exister en tant que table seul. à l'heure actuelle, vous pouvez utiliser @Embeddable et @Embedded Annotations.

Par exemple, une information d'adresse de commande peut être utilisée comme objet intégré:

 @EMBEDDABLE
Adresse de classe publique {
    Street à cha?ne privée;
    ville de cordes privée;
    Private String Zipcode;
}

@Entité
Ordre de classe publique {
    @Identifiant
    ID long privé;

    @Intégré
    Adresse privée ShipingAddress;
}

Dans la table de base de données générée de cette manière, le tableau de commandes contiendra directement les champs street , city , zipCode .

Si plusieurs champs se combinent pour former une clé primaire, vous pouvez également utiliser @Embeddable pour définir une classe de clé primaire composite et la référencer avec @EmbeddedId dans l'entité.

4. Cartographie de la structure des successions: comment persister les relations de succession des classes

JPA prend en charge trois stratégies de succession communes, adaptées à différents scénarios:

1. Single_Table : toutes les sous-classes partagent une table et utilisent une colonne de discriminatrice pour identifier le type.
2. Joint : Chaque sous-classe a sa propre table et la table de classe parent est connectée par des clés étrangères.
3. TABLE_PER_CLASS : Chaque sous-classe est une table complète sans structure de partage.

 @Entité
@Inheritance (Stratégie = HéritanceType.Single_Table)
@DiscriminatorColumn (name = "employee_type")
Employé de classe abstrait public {...}

@Entité
@DiscriminatorValue ("à plein temps")
classe publique à plein temps Employee étend l'employé {...}

Une pratique courante consiste à sélectionner une stratégie basée sur la fréquence de requête. Les tables simples conviennent aux requêtes fréquentes de type croisé, et jointe est plus conforme au paradigme mais a des performances de requête légèrement médiocres.

Fondamentalement, ces méthodes de mappage avancées JPA communes mais facilement négligées. Les ma?triser non seulement améliore la flexibilité du code, mais aussi mieux traiter avec des modèles commerciaux complexes. Ce n'est qu'en utilisant rationnellement les annotations et les stratégies que la plus grande valeur de JPA peut être atteinte.

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!