双方向JPA OneToMany / ManyToOneアソシエーションでは、「アソシエーションの逆側」とはどういう意味ですか？
TopLink JPAアノテーションリファレンス のこれらの例では：
例1-59 @OneToMany-ジェネリックを含む顧客クラス
@Entity
public class Customer implements Serializable {
...
@OneToMany(cascade=ALL, mappedBy="customer")
public Set<Order> getOrders() {
return orders;
}
...
}
例1-60 @ManyToOne-ジェネリックを含む注文クラス
@Entity
public class Order implements Serializable {
...
@ManyToOne
@JoinColumn(name="CUST_ID", nullable=false)
public Customer getCustomer() {
return customer;
}
...
}
Customerエンティティがアソシエーションの所有者であるように思えます。ただし、同じドキュメントのmappedBy属性の説明には、次のように書かれています。
関係が双方向の場合、例1-60に示すように、関連付けの逆（非所有）側のmappedBy要素を、関係を所有するフィールドまたはプロパティの名前に設定します。
しかし、私が間違っていない場合、例ではmappedByが実際には非所有側ではなく、関連付けの所有側で指定されているように見えます。
だから私の質問は基本的に：
双方向（1対多/多対1）の関連付けでは、どのエンティティが所有者ですか？片側を所有者として指定するにはどうすればよいですか？多側を所有者として指定するにはどうすればよいですか？
「関連の逆側」とはどういう意味ですか？片側を反転として指定するにはどうすればよいですか？多側を逆に指定するにはどうすればよいですか？
これを理解するには、一歩後退する必要があります。 OOでは、顧客が注文を所有します（注文は顧客オブジェクトのリストです）。顧客なしで注文することはできません。したがって、顧客は注文の所有者のようです。
しかし、SQLの世界では、1つのアイテムに実際に他のアイテムへのポインターが含まれます。 N個の注文に対して1人の顧客がいるため、各注文には所属する顧客への外部キーが含まれています。これは「接続」であり、これは順序が接続（情報）を「所有する」（または文字通り含む）ことを意味します。これは、オブジェクト指向/モデルの世界とは正反対です。
これは理解するのに役立つかもしれません：
public class Customer {
// This field doesn't exist in the database
// It is simulated with a SQL query
// "OO speak": Customer owns the orders
private List<Order> orders;
}
public class Order {
// This field actually exists in the DB
// In a purely OO model, we could omit it
// "DB speak": Order contains a foreign key to customer
private Customer customer;
}
逆側は、オブジェクトのOO「所有者」、この場合は顧客です。顧客には、注文を保存する列がテーブルにないため、注文テーブルのどこにこのデータを保存できるかを伝える必要があります（mappedByを介して行われます）。
別の一般的な例は、親と子の両方になるノードを持つツリーです。この場合、2つのフィールドは1つのクラスで使用されます。
public class Node {
// Again, this is managed by Hibernate.
// There is no matching column in the database.
@OneToMany(cascade = CascadeType.ALL) // mappedBy is only necessary when there are two fields with the type "Node"
private List<Node> children;
// This field exists in the database.
// For the OO model, it's not really necessary and in fact
// some XML implementations omit it to save memory.
// Of course, that limits your options to navigate the tree.
@ManyToOne
private Node parent;
}
これは、「外部キー」の多対1の設計作業について説明しています。別のテーブルを使用して関係を維持する2番目のアプローチがあります。つまり、最初の例では、3つのテーブルがあります。1つは顧客、1つは注文、2列の主キーのペア（customerPK、orderPK）のテーブルです。
このアプローチは、上記のアプローチよりも柔軟性があります（1対1、多対1、1対多、さらには多対多でも簡単に処理できます）。価格は
- 少し遅くなります（別のテーブルと結合を維持するために、2つではなく3つのテーブルを使用する必要がある）、
- 結合構文はより複雑です（たとえば、何かをデバッグしようとする場合など、多くのクエリを手動で記述する必要がある場合は退屈です）
- 接続テーブルを管理するコードに何か問題が発生すると、突然多くの結果が得られたり、結果が少なすぎたりする可能性があるため、エラーが発生しやすくなります。
そのため、このアプローチを推奨することはめったにありません。
信じられないことに、関係をマッピングする両方の方法の例であなたの素晴らしい質問に答えた人は誰もいませんでした。
他の人が述べたように、「所有者」側にはデータベース内のポインター（外部キー）が含まれています。どちらの側を所有者として指定することもできますが、一方の側を所有者として指定すると、関係は双方向になりません（逆の「多」側は「所有者」の情報を持ちません）。これは、カプセル化/疎結合に望ましい場合があります。
// "One" Customer owns the associated orders by storing them in a customer_orders join table
public class Customer {
@OneToMany(cascade = CascadeType.ALL)
private List<Order> orders;
}
// if the Customer owns the orders using the customer_orders table,
// Order has no knowledge of its Customer
public class Order {
// @ManyToOne annotation has no "mappedBy" attribute to link bidirectionally
}
唯一の双方向マッピングソリューションは、「多く」側が「1」へのポインターを所有し、@ OneToMany「mappedBy」属性を使用することです。 「mappedBy」属性がないと、Hibernateは二重マッピングを予期します（データベースには結合列と結合テーブルの両方がありますが、これは冗長です（通常は望ましくありません））。
// "One" Customer as the inverse side of the relationship
public class Customer {
@OneToMany(cascade = CascadeType.ALL, mappedBy = "customer")
private List<Order> orders;
}
// "many" orders each own their pointer to a Customer
public class Order {
@ManyToOne
private Customer customer;
}
データベース内に外部キーを持つテーブルを持つエンティティは所有エンティティであり、指し示されている他のテーブルは逆エンティティです。
双方向関係の単純なルール：
1.多対1の双方向リレーションシップの場合、多サイドは常にリレーションシップの所有側です。例：1つの部屋には多くの人がいます（人は1つの部屋にのみ属します）->所有側は人
2. 1対1の双方向関係の場合、所有側は対応する外部キーを含む側に対応します。
3.多対多の双方向関係では、どちらの側が所有側になる場合があります。
希望はあなたを助けることができます。
2つのエンティティクラスCustomerとOrderについて、hibernateは2つのテーブルを作成します。
可能なケース：
mappedByはCustomer.JavaおよびOrder.Javaクラスでは使用されませんthen->
顧客側では、CUSTOMER_IDとORDER_IDのマッピングを保持する新しいテーブルが作成されます[name = CUSTOMER_ORDER]。これらは、顧客テーブルと注文テーブルの主キーです。注文側では、対応するCustomer_IDレコードマッピングを保存するために追加の列が必要です。
mappedByはCustomer.Javaで使用されます[問題文で示されているとおり]追加のテーブル[CUSTOMER_ORDER]は作成されません。注文表の1列のみ
mappedbyはOrder.Javaで使用されます。hibernate。[name = CUSTOMER_ORDER]によって追加のテーブルが作成されます。OrderTableには、マッピング用の追加列[Customer_ID]がありません。
どの側も関係の所有者にすることができます。ただし、xxxToOne側を選択することをお勧めします。
コーディング効果->エンティティの所有側のみが関係ステータスを変更できます。以下の例では、BoyFriendクラスが関係の所有者です。たとえ彼女が別れたいと思っても、彼女はできません。
import javax.persistence.*;
import Java.util.ArrayList;
import Java.util.List;
@Entity
@Table(name = "BoyFriend21")
public class BoyFriend21 {
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "Boy_ID")
@SequenceGenerator(name = "Boy_ID", sequenceName = "Boy_ID_SEQUENCER", initialValue = 10,allocationSize = 1)
private Integer id;
@Column(name = "BOY_NAME")
private String name;
@OneToOne(cascade = { CascadeType.ALL })
private GirlFriend21 girlFriend;
public BoyFriend21(String name) {
this.name = name;
}
public BoyFriend21() {
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public BoyFriend21(String name, GirlFriend21 girlFriend) {
this.name = name;
this.girlFriend = girlFriend;
}
public GirlFriend21 getGirlFriend() {
return girlFriend;
}
public void setGirlFriend(GirlFriend21 girlFriend) {
this.girlFriend = girlFriend;
}
}
import org.hibernate.annotations.*;
import javax.persistence.*;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.Table;
import Java.util.ArrayList;
import Java.util.List;
@Entity
@Table(name = "GirlFriend21")
public class GirlFriend21 {
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "Girl_ID")
@SequenceGenerator(name = "Girl_ID", sequenceName = "Girl_ID_SEQUENCER", initialValue = 10,allocationSize = 1)
private Integer id;
@Column(name = "GIRL_NAME")
private String name;
@OneToOne(cascade = {CascadeType.ALL},mappedBy = "girlFriend")
private BoyFriend21 boyFriends = new BoyFriend21();
public GirlFriend21() {
}
public GirlFriend21(String name) {
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public GirlFriend21(String name, BoyFriend21 boyFriends) {
this.name = name;
this.boyFriends = boyFriends;
}
public BoyFriend21 getBoyFriends() {
return boyFriends;
}
public void setBoyFriends(BoyFriend21 boyFriends) {
this.boyFriends = boyFriends;
}
}
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import Java.util.Arrays;
public class Main578_DS {
public static void main(String[] args) {
final Configuration configuration = new Configuration();
try {
configuration.configure("hibernate.cfg.xml");
} catch (HibernateException e) {
throw new RuntimeException(e);
}
final SessionFactory sessionFactory = configuration.buildSessionFactory();
final Session session = sessionFactory.openSession();
session.beginTransaction();
final BoyFriend21 clinton = new BoyFriend21("Bill Clinton");
final GirlFriend21 monica = new GirlFriend21("monica lewinsky");
clinton.setGirlFriend(monica);
session.save(clinton);
session.getTransaction().commit();
session.close();
}
}
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import Java.util.List;
public class Main578_Modify {
public static void main(String[] args) {
final Configuration configuration = new Configuration();
try {
configuration.configure("hibernate.cfg.xml");
} catch (HibernateException e) {
throw new RuntimeException(e);
}
final SessionFactory sessionFactory = configuration.buildSessionFactory();
final Session session1 = sessionFactory.openSession();
session1.beginTransaction();
GirlFriend21 monica = (GirlFriend21)session1.load(GirlFriend21.class,10); // Monica lewinsky record has id 10.
BoyFriend21 boyfriend = monica.getBoyFriends();
System.out.println(boyfriend.getName()); // It will print Clinton Name
monica.setBoyFriends(null); // It will not impact relationship
session1.getTransaction().commit();
session1.close();
final Session session2 = sessionFactory.openSession();
session2.beginTransaction();
BoyFriend21 clinton = (BoyFriend21)session2.load(BoyFriend21.class,10); // Bill clinton record
GirlFriend21 girlfriend = clinton.getGirlFriend();
System.out.println(girlfriend.getName()); // It will print Monica name.
//But if Clinton[Who owns the relationship as per "mappedby" rule can break this]
clinton.setGirlFriend(null);
// Now if Monica tries to check BoyFriend Details, she will find Clinton is no more her boyFriend
session2.getTransaction().commit();
session2.close();
final Session session3 = sessionFactory.openSession();
session1.beginTransaction();
monica = (GirlFriend21)session3.load(GirlFriend21.class,10); // Monica lewinsky record has id 10.
boyfriend = monica.getBoyFriends();
System.out.println(boyfriend.getName()); // Does not print Clinton Name
session3.getTransaction().commit();
session3.close();
}
}