Quelle est la différence entre les annotations @JoinColumn et mappedBy lors de l'utilisation d'une JPA @OneToMany association

@JoinColumn pourrait être utilisé sur les deux côtés de la relation. La question était de savoir à l'aide de @JoinColumn sur le @OneToMany côté (cas rare). Et le point ici est dans physique dédoublement de l'information (nom de la colonne) avec pas optimisé requête SQL qui produisent une certaine mise à JOUR supplémentaire états.

Selon la documentation:

Depuis beaucoup à un sont (presque) toujours le propriétaire de côté d'une relation bidirectionnelle dans la JPA spec, l'un à de nombreuses association est annotée par @OneToMany(mappedBy=...)

@Entity
public class Troop {
    @OneToMany(mappedBy="troop")
    public Set<Soldier> getSoldiers() {
    ...
}

@Entity
public class Soldier {
    @ManyToOne
    @JoinColumn(name="troop_fk")
    public Troop getTroop() {
    ...
} 

Troupe a bidirectionnelle "un à plusieurs" de la relation avec un Soldat par la troupe de la propriété. Vous n'avez pas à (ne doit pas) définir physique de la cartographie dans les mappedBy côté.

À la carte bidirectionnelle un à plusieurs, avec la un-à-plusieurs côté que le propriétaire de côté, vous devez supprimer le mappedBy élément et réglez le nombre de un les annotations @JoinColumn comme insérable et pouvant être mis à jour à false. Cette solution n'est pas optimisé et produisent une certaine mise à JOUR supplémentaire consolidés.

@Entity
public class Troop {
    @OneToMany
    @JoinColumn(name="troop_fk") //we need to duplicate the physical information
    public Set<Soldier> getSoldiers() {
    ...
}

@Entity
public class Soldier {
    @ManyToOne
    @JoinColumn(name="troop_fk", insertable=false, updatable=false)
    public Troop getTroop() {
    ...
}

L'annotation mappedBy, idéalement, devrait toujours être utilisé dans le Parent du côté de l'Entreprise (classe) de la bi directionnelle de la relation, dans ce cas, il devrait être dans la Société de classe, pointant à la variable membre "société" de l'Enfant de la classe (Direction générale de la classe)

L'annotation les annotations@JoinColumn est utilisé pour spécifier une colonne mappés pour rejoindre une entité association, cette annotation peut être utilisée dans n'importe quelle classe (Parent ou Enfant), mais idéalement, il devrait être utilisé que dans un seul côté (soit dans la classe parent ou de l'Enfant de la classe pas dans les deux), ici, dans ce cas, je l'ai utilisé chez l'Enfant de côté (Direction générale de la classe) de la bi relation directionnelle indiquant la clé étrangère dans la Direction de la classe.

ci-dessous est le travail exemple :

classe parent , Société

@Entity
public class Company {


    private int companyId;
    private String companyName;
    private List<Branch> branches;

    @Id
    @GeneratedValue
    @Column(name="COMPANY_ID")
    public int getCompanyId() {
        return companyId;
    }

    public void setCompanyId(int companyId) {
        this.companyId = companyId;
    }

    @Column(name="COMPANY_NAME")
    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }

    @OneToMany(fetch=FetchType.LAZY,cascade=CascadeType.ALL,mappedBy="company")
    public List<Branch> getBranches() {
        return branches;
    }

    public void setBranches(List<Branch> branches) {
        this.branches = branches;
    }


}

enfant de la classe, de la Direction générale

@Entity
public class Branch {

    private int branchId;
    private String branchName;
    private Company company;

    @Id
    @GeneratedValue
    @Column(name="BRANCH_ID")
    public int getBranchId() {
        return branchId;
    }

    public void setBranchId(int branchId) {
        this.branchId = branchId;
    }

    @Column(name="BRANCH_NAME")
    public String getBranchName() {
        return branchName;
    }

    public void setBranchName(String branchName) {
        this.branchName = branchName;
    }

    @ManyToOne(fetch=FetchType.LAZY)
    @JoinColumn(name="COMPANY_ID")
    public Company getCompany() {
        return company;
    }

    public void setCompany(Company company) {
        this.company = company;
    }


}

Je suis en désaccord avec la accepté de répondre ici par Oscar López. La réponse est inexacte!

Il n'est PAS @JoinColumn qui indique que cette entité est le propriétaire de la relation. Au lieu de cela, c'est la @ManyToOne annotation qui le fait (dans son exemple).

La relation des annotations telles que @ManyToOne, @OneToMany et @ManyToMany dire JPA/Hibernate pour créer un mappage. Par défaut, cela se fait à travers une autre Table de Jointure.

Les annotations@JoinColumn

Le but de @JoinColumn est de créer un colonne de jointure si l'on n'
il existe déjà pas. Si c'est le cas, cette annotation peut être utilisée pour
nom la colonne de jointure.

MappedBy

Le but de la MappedBy paramètre est de demander à JPA: Ne PAS
créer une autre table de jointure que la relation est déjà mappé
par la en face de entité de cette relation.

Rappelez-vous: MappedBy est une propriété de la relation annotations dont le but est de générer un mécanisme permettant de lier deux entités qui, par défaut, ils le font par la création d'une table de jointure. MappedBy s'arrête que le processus dans un seul sens.

L'entité n'utilisant pas MappedBy est dit être le propriétaire de la relation, car la mécanique de la cartographie sont dictées à l'intérieur de sa catégorie grâce à l'utilisation de l'un des trois cartographie des annotations contre le champ de clé étrangère. Ce n'est pas seulement spécifie la nature de la cartographie mais indique également à la création d'une table de jointure. En outre, l'option pour supprimer la jointure de la table existe aussi en appliquant les annotations @JoinColumn annotation sur la clé étrangère qui la maintient à l'intérieur de la table de l'entité propriétaire à la place.

Donc en résumé: @JoinColumn crée une nouvelle colonne de jointure ou renomme un existant; tandis que la MappedBy paramètre travaille en collaboration avec la relation des annotations de l'autre (l'enfant) de la classe afin de créer un mappage soit par le biais d'une table de jointure ou par la création d'une colonne de clé étrangère dans la table associée de la propriétaire de l'entité.

Pour illustrer comment MapppedBy œuvres, considérez le code ci-dessous. Si MappedBy paramètre devaient être supprimés, Hibernate serait en fait de créer DEUX tables de jointure! Pourquoi? Car il y a une symétrie dans plusieurs-à-plusieurs liens et mise en veille prolongée n'a pas de justification pour la sélection d'une direction sur l'autre.

Nous utilisons donc la MappedBy dire Hibernate, nous avons choisi l'autre entité de dicter la cartographie de la relation entre les deux entités.

@Entity
public class Driver {
    @ManyToMany(mappedBy = "drivers")
    private List<Cars> cars;
}

@Entity
public class Cars {
    @ManyToMany
    private List<Drivers> drivers;
}

L'ajout d'annotations @JoinColumn(name = "driverID") dans le propriétaire de la classe (voir ci-dessous), permettra d'éviter la création d'une table de jointure et au lieu de cela, créer un driverID colonne de clé étrangère dans la table de Voitures à construire une cartographie:

@Entity
public class Driver {
    @ManyToMany(mappedBy = "drivers")
    private List<Cars> cars;
}

@Entity
public class Cars {
    @ManyToMany
    @JoinColumn(name = "driverID")
    private List<Drivers> drivers;
}