Quelqu'un peut-il expliquer mappedBy dans JPA et Hibernate?

Je suis nouveau dans l'hibernation et j'ai besoin d'utiliser des relations un-à-plusieurs et plusieurs-à-un. C'est une relation bidirectionnelle dans mes objets, de sorte que je puisse traverser dans les deux sens. mappedByest la manière recommandée de s'y prendre, cependant, je ne pouvais pas la comprendre. Quelqu'un peut-il expliquer:

• quelle est la manière recommandée de l'utiliser?
• quel but résout-il?

Pour mon exemple, voici mes cours avec des annotations:

• Airline Possède de nombreux AirlineFlights
• Beaucoup AirlineFlights appartiennent à ONE Airline

Compagnie aérienne :

@Entity 
@Table(name="Airline")
public class Airline {
    private Integer idAirline;
    private String name;

    private String code;

    private String aliasName;
    private Set<AirlineFlight> airlineFlights = new HashSet<AirlineFlight>(0);

    public Airline(){}

    public Airline(String name, String code, String aliasName, Set<AirlineFlight> flights) {
        setName(name);
        setCode(code);
        setAliasName(aliasName);
        setAirlineFlights(flights);
    }

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name="IDAIRLINE", nullable=false)
    public Integer getIdAirline() {
        return idAirline;
    }

    private void setIdAirline(Integer idAirline) {
        this.idAirline = idAirline;
    }

    @Column(name="NAME", nullable=false)
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = DAOUtil.convertToDBString(name);
    }

    @Column(name="CODE", nullable=false, length=3)
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = DAOUtil.convertToDBString(code);
    }

    @Column(name="ALIAS", nullable=true)
    public String getAliasName() {
        return aliasName;
    }
    public void setAliasName(String aliasName) {
        if(aliasName != null)
            this.aliasName = DAOUtil.convertToDBString(aliasName);
    }

    @OneToMany(fetch=FetchType.LAZY, cascade = {CascadeType.ALL})
    @JoinColumn(name="IDAIRLINE")
    public Set<AirlineFlight> getAirlineFlights() {
        return airlineFlights;
    }

    public void setAirlineFlights(Set<AirlineFlight> flights) {
        this.airlineFlights = flights;
    }
}

Vols aériens:

@Entity
@Table(name="AirlineFlight")
public class AirlineFlight {
    private Integer idAirlineFlight;
    private Airline airline;
    private String flightNumber;

    public AirlineFlight(){}

    public AirlineFlight(Airline airline, String flightNumber) {
        setAirline(airline);
        setFlightNumber(flightNumber);
    }

    @Id
    @GeneratedValue(generator="identity")
    @GenericGenerator(name="identity", strategy="identity")
    @Column(name="IDAIRLINEFLIGHT", nullable=false)
    public Integer getIdAirlineFlight() {
        return idAirlineFlight;
    }
    private void setIdAirlineFlight(Integer idAirlineFlight) {
        this.idAirlineFlight = idAirlineFlight;
    }

    @ManyToOne(fetch=FetchType.LAZY)
    @JoinColumn(name="IDAIRLINE", nullable=false)
    public Airline getAirline() {
        return airline;
    }
    public void setAirline(Airline airline) {
        this.airline = airline;
    }

    @Column(name="FLIGHTNUMBER", nullable=false)
    public String getFlightNumber() {
        return flightNumber;
    }
    public void setFlightNumber(String flightNumber) {
        this.flightNumber = DAOUtil.convertToDBString(flightNumber);
    }
}

ÉDITER:

Schéma de la base de données:

AirlineFlights a l'idAirline comme ForeignKey et Airline n'a pas d'idAirlineFlights. Cela fait, AirlineFlights en tant que propriétaire / entité d'identification?

Théoriquement, j'aimerais que la compagnie aérienne soit propriétaire de la compagnie aérienneFlights.

En spécifiant @JoinColumnsur les deux modèles, vous n'avez pas de relation bidirectionnelle. Vous avez deux relations à sens unique, et une cartographie très déroutante de celle-ci. Vous dites aux deux modèles qu'ils «possèdent» la colonne IDAIRLINE. Un seul d'entre eux devrait vraiment le faire! La chose `` normale '' est de supprimer @JoinColumncomplètement le hors du @OneToManycôté et d'ajouter à la place mappedBy au @OneToMany.

@OneToMany(cascade = CascadeType.ALL, mappedBy="airline")
public Set<AirlineFlight> getAirlineFlights() {
    return airlineFlights;
}

Cela indique à Hibernate: "Allez chercher la propriété du bean nommée« compagnie aérienne »sur la chose dont j'ai une collection pour trouver la configuration."

MappedBy signale l'hibernation que la clé de la relation se trouve de l'autre côté.

Cela signifie que même si vous liez 2 tables ensemble, seule 1 de ces tables a une contrainte de clé étrangère sur l'autre. MappedBy vous permet de créer un lien depuis la table ne contenant pas la contrainte vers l'autre table.

mappedbyparle de lui-même, il dit à hibernate de ne pas mapper ce champ. il est déjà mappé par ce champ [name = "field"].
le champ est dans l'autre entité (name of the variable in the class not the table in the database).

Si vous ne le faites pas, hibernate mappera ces deux relations car ce n'est pas la même relation

nous devons donc dire à hibernate de faire le mappage d'un seul côté et de coordonner entre eux.

mappedby = "objet d'entité de même classe créé dans une autre classe"

Remarque: -Mappé par ne peut être utilisé que dans une classe car une table doit contenir une contrainte de clé étrangère. si mappé par peut être appliqué des deux côtés, il supprime la clé étrangère des deux tables et sans clé étrangère, il n'y a pas de relation entre deux tables.

Remarque: - il peut être utilisé pour les annotations suivantes: - 1. @ OneTone 2. @ OneToMany 3. @ ManyToMany

Remarque --- Il ne peut pas être utilisé pour l'annotation suivante: - 1. @ ManyToOne

Dans un à un: - Exécutez de n'importe quel côté du mappage mais exécutez d'un seul côté. Il supprimera la colonne supplémentaire de contrainte de clé étrangère sur la table sur laquelle elle est appliquée.

Pour par exemple. Si nous appliquons mappé par dans la classe Employee sur l'objet Employee, la clé étrangère de la table Employee sera supprimée.

Relation de table vs relation d'entité

Dans un système de base de données relationnelle, une one-to-manyrelation de table se présente comme suit:

Notez que la relation est basée sur la colonne Clé étrangère (par exemple, post_id) dans la table enfant.

Il existe donc une seule source de vérité lorsqu'il s'agit de gérer une one-to-manyrelation de table.

Maintenant, si vous prenez une relation d'entité bidirectionnelle qui correspond à la one-to-manyrelation de table que nous avons vue précédemment:

Si vous regardez le diagramme ci-dessus, vous pouvez voir qu'il existe deux façons de gérer cette relation.

Dans l' Postentité, vous avez la commentscollection:

@OneToMany(
    mappedBy = "post",
    cascade = CascadeType.ALL,
    orphanRemoval = true
)
private List<PostComment> comments = new ArrayList<>();

Et, dans le PostComment, l' postassociation est mappée comme suit:

@ManyToOne(
    fetch = FetchType.LAZY
)
@JoinColumn(name = "post_id")
private Post post;

Étant donné qu'il existe deux façons de représenter la colonne de clé étrangère, vous devez définir quelle est la source de vérité lorsqu'il s'agit de traduire le changement d'état d'association en modification de la valeur de la colonne de clé étrangère équivalente.

Mappé par

L' mappedByattribut indique que le @ManyToOnecôté est en charge de la gestion de la colonne de clé étrangère, et la collection est utilisée uniquement pour récupérer les entités enfants et pour mettre en cascade les changements d'état de l'entité parente aux enfants (par exemple, la suppression du parent devrait également supprimer les entités enfants).

Synchronisez les deux côtés d'une association bidirectionnelle

Désormais, même si vous avez défini l' mappedByattribut et que l' @ManyToOneassociation côté enfant gère la colonne de clé étrangère, vous devez toujours synchroniser les deux côtés de l'association bidirectionnelle.

La meilleure façon de le faire est d'ajouter ces deux méthodes utilitaires:

public void addComment(PostComment comment) {
    comments.add(comment);
    comment.setPost(this);
}

public void removeComment(PostComment comment) {
    comments.remove(comment);
    comment.setPost(null);
}

Les méthodes addCommentet removeCommentgarantissent que les deux côtés sont synchronisés. Donc, si nous ajoutons une entité enfant, l'entité enfant doit pointer vers le parent et l'entité parente doit avoir l'enfant contenu dans la collection enfant.

Pour plus d'informations sur la meilleure façon de synchroniser tous les types d'association d'entités bidirectionnelles, consultez cet article .

Vous avez commencé avec le mappage ManyToOne, puis vous avez également mis le mappage OneToMany pour la manière BiDirectionnelle. Ensuite, du côté OneToMany (généralement votre table / classe parent), vous devez mentionner "mappedBy" (le mappage est effectué par et dans la table / classe enfant), donc hibernate ne créera pas de table de mappage EXTRA dans DB (comme TableName = parent_child).