Was ist der Unterschied zwischen @JoinColumn und mappedBy bei Verwendung einer JPA @ OneToMany-Verknüpfung?

Was ist der Unterschied zwischen:

@Entity
public class Company {

    @OneToMany(cascade = CascadeType.ALL , fetch = FetchType.LAZY)
    @JoinColumn(name = "companyIdRef", referencedColumnName = "companyId")
    private List<Branch> branches;
    ...
}

und

@Entity
public class Company {

    @OneToMany(cascade = CascadeType.ALL , fetch = FetchType.LAZY, mappedBy = "companyIdRef")
    private List<Branch> branches;
    ...
}

InformationsquelleAutor der Frage Mykhaylo Adamovych | 2012-08-13

437

Annotation @JoinColumn zeigt an, dass diese Einheit ist der Besitzer der Beziehung (sprich: die entsprechende Tabelle hat eine Spalte mit einem Fremdschlüssel auf die referenzierte Tabelle), während das Attribut mappedBy zeigt an, dass die Entität in dieser Seite ist die umkehrfunktion der Beziehung, und der Besitzer wohnt in der "anderen" Person. Dies bedeutet auch, dass Sie Zugriff auf die andere Tabelle aus der Klasse, die hast du kommentiert mit "mappedBy" (vollständig bidirektionale Beziehung).

Insbesondere für den code in der Frage der korrekten Anmerkungen würde wie folgt Aussehen:
```
@Entity
public class Company {
    @OneToMany(fetch = FetchType.LAZY, mappedBy = "company")
    private List<Branch> branches;
}

@Entity
public class Branch {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "companyId")
    private Company company;
}
```
InformationsquelleAutor der Antwort Óscar López
159

@JoinColumn könnte verwendet werden, auf beiden Seiten der Beziehung. Die Frage wurde über die Verwendung @JoinColumn auf die @OneToMany Seite (seltener Fall). Und der Punkt ist hier in physische Vervielfältigung von Informationen (Spalte name) zusammen mit nicht optimierten SQL-Abfrage zu erzeugen einige zusätzliche UPDATE-Anweisungen.

Laut Dokumentation:

Seit viele sind (fast) immer Besitzer Seite eine bidirektionale Beziehung in der JPA-Spezifikation, die eins-zu-viele-Assoziation wird kommentiert von @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() {
    ...
} 
```
Truppe hat eine bidirektionale eins-zu-viele-Beziehung mit Soldaten durch die Truppe Eigenschaft. Sie müssen nicht (dürfen nicht) definieren Sie die physikalische Kartierung in der mappedBy-Seite.

Map eine bidirektionale eins-zu-viele, mit der eins-zu-viele-Seite der besitzenden Seitemüssen Sie die mappedBy-element, und legen Sie die viele zu einer @JoinColumn als einsetzbar und aktualisierbar auf false. Diese Lösung ist nicht optimiert und produzieren einige zusätzliche UPDATE-Anweisungen.
```
@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() {
    ...
}
```
InformationsquelleAutor der Antwort Mykhaylo Adamovych

Annotation mappedBy idealerweise sollte immer verwendet werden, in der Übergeordneten Seite (Unternehmens-Klasse) der bi-direktionale Beziehung, in diesem Fall sollte es in der Gesellschaft Klassen zeigen auf die member-variable "Firma" von der Kind-Klasse (Zweig Klasse)

Annotation @JoinColumn wird verwendet, um anzugeben, eine zugeordnete Spalte für den Beitritt zu einer Einheit Verband, diese Anmerkung kann verwendet werden in jeder Klasse (Elternteil oder Kind), sondern es sollte idealerweise verwendet werden, die nur in einer Seite (entweder in der übergeordneten Klasse oder Untergeordnete Klasse nicht in beiden) hier in diesem Fall habe ich es in der Untergeordneten Seite (Zweig-Klasse) der bi-direktionale Beziehung, die angibt, die den Fremdschlüssel in der Filiale Klasse.

unten ist das Beispiel :

übergeordneten Klasse , Unternehmen

@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;
    }


}

Kind-Klasse, Zweig

@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;
    }


}

InformationsquelleAutor der Antwort Soumyaansh

16

Ich möchte nur hinzufügen, dass @JoinColumn müssen nicht immer mit dem physikalische Informationen Ort als diese Antwort vorschlägt. Sie können kombinieren @JoinColumn mit @OneToMany selbst wenn die übergeordnete Tabelle hat keine Daten zur Tabelle verweist auf die Kind-Tabelle.

Wie definieren unidirektionale OneToMany-Beziehung in JPA

Unidirektionale OneToMany, Keine Inverse ManyToOne, Keine Join-Tabelle

Scheint es nur in JPA 2.x+ obwohl. Es ist nützlich für Situationen, wo Sie wollen, dass die Kind-Klasse, nur enthält die ID des übergeordneten, nicht eine vollständige Referenz.

InformationsquelleAutor der Antwort Snekse
0

Als ich erklärte, in dieser Artikelwenn Sie die @OneToMany annotation mit @JoinColumndann haben Sie eine unidirektionale Assoziation.

Wenn Sie die @OneToMany mit der mappedBy - Attribut gesetzt ist, müssen Sie eine bidirektionale Assoziation, das heißt, Sie brauchen, um eine @ManyToOne Verein auf die untergeordnete Seite, die die mappedBy Referenzen.

Den unidirektional @OneToMany Verein nicht durchführen sehr gutso sollten Sie es vermeiden.

Sind Sie besser dran mit der bidirektionale @OneToManywelche effizienter ist.

InformationsquelleAutor der Antwort Vlad Mihalcea

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.