JPA JoinColumn vs. mappedBy

Question

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

y

@Entity
public class Company {

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

Answer 1

Ich möchte nur hinzufügen, dass @JoinColumn muss nicht immer in Zusammenhang mit dem Standort der physischen Informationen como este Antwort suggeriert. Sie können kombinieren @JoinColumn avec @OneToMany auch wenn die übergeordnete Tabelle keine Tabellendaten hat, die auf die untergeordnete Tabelle zeigen.

Wie definiert man unidirektionale OneToMany-Beziehungen in JPA?

Unidirektionales OneToMany, kein inverses ManyToOne, keine Join-Tabelle

Es scheint nur verfügbar zu sein in JPA 2.x+ Allerdings. Es ist nützlich für Situationen, in denen Sie wollen, dass die untergeordnete Klasse nur die ID der übergeordneten Klasse enthält, nicht eine vollständige Referenz.

Answer 2

Ich will es einfach machen.
Sie können verwenden @JoinColumn auf beiden Seiten, unabhängig von der Kartierung.

Unterteilen wir dies in drei Fälle.
1) Unidirektionales Mapping von Filiale zu Unternehmen.
2) Bidirektionales Mapping vom Unternehmen zur Filiale.
3) Nur unidirektionales Mapping vom Unternehmen zur Filiale.

Jeder Anwendungsfall fällt also unter diese drei Kategorien. Lassen Sie mich also erklären, wie man @JoinColumn y mappedBy .
1) Unidirektionales Mapping von Filiale zu Unternehmen.
Verwenden Sie JoinColumn in der Verzweigungstabelle.
2) Bidirektionales Mapping vom Unternehmen zur Filiale.
Verwenden Sie mappedBy in der Unternehmenstabelle wie in der Antwort von @Mykhaylo Adamovych beschrieben.
3) Unidirektionales Mapping vom Unternehmen zur Filiale.
Verwenden Sie einfach @JoinColumn in der Unternehmenstabelle.

@Entity
public class Company {

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

Dies besagt, dass ich auf der Grundlage der Zuordnung des Fremdschlüssels "courseId" in der Tabelle branches eine Liste aller Zweigstellen erhalten soll. HINWEIS: In diesem Fall können Sie das Unternehmen nicht aus der Zweigstelle abrufen, da nur eine unidirektionale Zuordnung vom Unternehmen zur Zweigstelle besteht.

Answer 3

JPA ist eine mehrschichtige API, die verschiedenen Ebenen haben ihre eigenen Annotationen. Die höchste Ebene ist die (1) Entitätsebene, die persistente Klassen beschreibt, dann gibt es die (2) relationale Datenbankebene, die davon ausgeht, dass die Entitäten auf eine relationale Datenbank abgebildet werden, und (3) das Java-Modell.

Anmerkungen zur Stufe 1: @Entity , @Id , @OneToOne , @OneToMany , @ManyToOne , @ManyToMany . Sie können Persistenz in Ihre Anwendung einführen, indem Sie nur diese High-Level-Annotationen verwenden. Aber dann müssen Sie Ihre Datenbank entsprechend den Annahmen von JPA erstellen. Diese Annotationen spezifizieren das Entitäts-/Beziehungsmodell.

Anmerkungen der Stufe 2: @Table , @Column , @JoinColumn , ... Beeinflussen Sie die Zuordnung von Entitäten/Eigenschaften zu den Tabellen/Spalten der relationalen Datenbank, wenn Sie mit den Standardeinstellungen von JPA nicht zufrieden sind oder wenn Sie eine bestehende Datenbank abbilden müssen. Diese Annotationen können als Implementierungsannotationen angesehen werden, sie spezifizieren, wie das Mapping durchgeführt werden soll.

Meiner Meinung nach ist es am besten, sich so weit wie möglich an die hochrangigen Anmerkungen zu halten und dann je nach Bedarf die niedrigeren Anmerkungen einzuführen.

Zur Beantwortung der Fragen: die @OneToMany / mappedBy ist am einfachsten, weil es nur die Anmerkungen aus dem Entitätsbereich verwendet. Die @oneToMany / @JoinColumn ist auch in Ordnung, aber es verwendet eine Implementierungsanmerkung, wo dies nicht unbedingt notwendig ist.

Answer 4

@Entity
public class Company {

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

Die folgenden Hibernate-Protokolle werden angezeigt

Hibernate: select nextval ('hibernate_sequence')
Hibernate: select nextval ('hibernate_sequence')
Hibernate: insert into company (name, company_id) values (?, ?)
Hibernate: insert into branch (company_id_ref, name, id) values (?, ?, ?)
Hibernate: update branch set company_id_ref=? where id=?

Und

@Entity
public class Company {

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

Dies führt zu folgenden Hibernate-Protokollen

Hibernate: select nextval ('hibernate_sequence')
Hibernate: select nextval ('hibernate_sequence')
Hibernate: insert into company (name, company_id) values (?, ?)
Hibernate: insert into branch (company_id_ref, name, id) values (?, ?, ?)

Wir können deutlich sehen, dass @joinColumn wird zusätzliche Aktualisierungsabfragen verursachen. Sie müssen also die übergeordnete Entität nicht explizit auf die untergeordnete Entität setzen, Das müssen wir tun, wenn wir mappedBy Kinder mit einem Elternteil zu retten