8、雙向一對多的關聯關系（等同於雙向多對一。1的一方有對n的一方的集合的引用，同時n的一方有對1的一方的引用）

 

雙向一對多關聯關系

“雙向一對多關聯關系”等同於“雙向多對一關聯關系”：1的一方有對n的一方的集合的引用，同時n的一方有對1的一方的引用。

 

還是用客戶Customer和訂單Order來解釋：

“一對多”的物理意義：一個客戶可以有多個訂單，某個訂單只能歸宿於一個客戶。

“雙向”的物理意義：客戶知道自己有哪些訂單，訂單也知道自己歸宿於哪個客戶。也就是說，通過客戶對象可以檢索到其擁有哪些訂單；同時，通過訂單也可以查找到其對應的客戶信息。這是符合我們業務邏輯需求。

 

到現在為止（結合前面兩節的闡述）我們可以很深刻的理解“雙向”、“單向”、“一對多”、“多對一”這四個詞語了：

①、“一對多”講的是一個實體類中是否包含有對另外一個實體類的集合的引用。

②、“多對一”包含兩層含義：a、一個實體類Ea是否包含有對另外一個實體類Eb的引用；b、是否允許實體類Ea的多個對象{ea1, ea2, ea3,...}同時對實體類Eb的某個對象eb有引用關系（如果不允許“多個對一個”，那么就是后面要講的“一對一關聯關系”），如下Figure_1所示：

　　Figure_1. 允許多對一關聯

　　

③、“雙向”包含兩個缺一不可的層面：a、1的一方有對n的一方的集合的引用；b、同時，n的一方也有對1的一方的對象的引用；也就是同時滿足①、②兩點。

④、“單向”就是③中闡述的兩個層面只出現一個。也就是只滿足①、②兩點中的一點。

注：我們上面①~④所講的集合是實體類中的集合，同時集合之上還要有映射注解（或映射配置文件）進行相關的關聯映射。如果單單只是一個集合，卻沒有表示映射關系的注解或配置文件，那么這個集合就不是我們映射層面上的“集合”。實體類中的對象也是一樣的道理。

 

下面我們通過Customer和Order的關系來印證我們上面的這種理解：

List_1. Customer實體類（有對Order的集合的引用）

@Table(name=“t_double_one2many_customer”)
@Entity
public class Customer2 {

    private Integer id;
    private String lastName;

    private String email;
    private int age;
    
    private Date birthday;
    
    private Date createdTime;
    
    // 有對Order2的集合的引用 16     //（這個引用還要被注解表示為一種映射關系才行）
    private Set<Order2> orders = new HashSet<Order2>(); 18 
    // 省略getter、setter方法
}

List_2. Order實體類（有對Customer的實體的對象的引用）

@Table(name=“t_double_one2many_order”)
@Entity
public class Order2 {
    
    private Integer id;
    private String orderName;
    
    //n的一方有對1的一方的對象的引用  9     //①要有映射注解表明為映射；②、允許多對一，否則就是一對一
    private Customer2 customer; 11 
        // 省略getter、setter方法
}

 

從Customer實體類和Order實體類的屬性定義我們可以得出下面的東西：

1、滿足上面③的要求，所以是“雙向”。

2、同時還滿足①、②兩點要求（這里也可以推導出“雙向”）

從以上可以看出，Customer和Order是“雙向一對多”或“雙向多對一”關聯關系。

 

雙向關聯關系的默認策略和兩個單項是一致的：

1、對1的一端的集合引用的檢索采用采用延遲加載方式；對n的一端的對象引用的檢索采用立即加載方式；可以通過設置@ManyToOne或@OneToMany的fetch屬性來修改默認策略。

2、可以自由的刪除n的一方的某個對象；但是，對1的一方的對象而言，如果還有n的一方的某個對象引用它，那么就不能夠刪除1的一方的該對象。可以通過設置@ManyToOne或@OneToMany的cascade屬性來修改默認的刪除策略；

 

配置雙向多對一關聯關系的具體操作：

1、如果雙邊都維護關聯關系：

　　①n的一端做如下配置

　　List_3. n的一方的配置

@ManyToOne
@JoinColumn(name=“CUSTOMER_ID”)
public Customer2 getCustomer() {
    return customer;
}

　　②、1的一端做如下配置

　　list_4. 1的一方的配置

@OneToMany
@JoinColumn(name=“CUSTOMER_ID”)
public Set<Order2> getOrders() {
    return orders;
}

　　要注意的是，兩邊的@JoinColumn的name屬性要一致（這里都是CUSTOMER_ID）。最后建立得到的數據表效果就是在n的一方對應的數據表中有一列外鍵，而1的一方沒有外鍵列（可以想象，1的一方無法放置外鍵列）

　　這種雙邊都維護關聯關系的時候，保存對象不可避免的要發送多余的update語句，和單向一對多關聯關系一樣。無論你是先保存1的一端，還是先保存n的一端都無法避免update語句的發送。

 

2、只靠n的一方維護關聯關系（推薦使用）：

　　在雙向多對一關聯關系中，1的一方沒有必要維護關聯關系，只靠n的一方維護就夠了。這樣做的好處就是：保存對象的時候先保存1的一端，后保存n的一端，可以避免發送update語句（和單向多對一關聯關系一樣）。

　　具體的配置方法就是：a、n的一方配置如 “List_3. n的一方的配置” 一樣； b、1的一方配置不能使用@JoinColumn(name=“CUSTOMER_ID”)注解（如果有此注解，則會報錯），同時在@OneToMany中配置mappedBy=“customer”屬性指定由n的一方的哪個屬性來維護關聯關系（注意，這里的customer是n一端的對象引用的名稱），如下List_5:

　　List_5. 1的一方不維護關聯關系

/**
 * 1、雙向1-n關聯的時候，一般1的一方放棄維護關聯關系，而由n的一方維護關聯關系。
 *    這樣做的好處就是：先保存1的一端，再保存n的一端的時候不會有多余的update sql語句
 * 2、使用@OneToMany(mappedBy=“customer”)來指明由n的一方的哪個屬性來維護關聯關系
 * 3、有一個值得注意的地方：如果指明了mappedBy=“customer”，那么就不能夠再使用@JoinColumn注解了。10  * 
 */
//    @JoinColumn(name=“CUSTOMER_ID”)
@OneToMany(mappedBy=“customer”)
public Set<Order2> getOrders() {
    return orders;
}

 

說明：就創建的兩張數據表而言，“雙邊維護關聯關系”與“單邊維護關聯關系”所創建的數據表沒有區別，都是由n的一方對應的數據表有一個外鍵參照列，而1的一方沒有任何外鍵列。兩張數據表如下：

Figure_2. Customer實體對應的數據表

Figure_3. Order實體對應的數據表

注意這里的“CUSTOMER_ID”是@JoinColumn(name=“CUSTOMER_ID”)中指定的CUSTOMER_ID。注意這里的Order實體表中有外鍵列，而Customer實體表中沒有外鍵列。

 

下面是Customer和Order實體類：

List_6. Customer2.java（作為1的一方，有對n的一方的集合的引用，不維護關聯關系）

package com.magicode.jpa.doubl.many2one;

import java.util.Date;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.TableGenerator;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.Transient;

/**
 * @Entity 用於注明該類是一個實體類
 * @Table(name=“t_customer”) 表明該實體類映射到數據庫的 t_customer 表
 */
@Table(name=“t_double_one2many_customer”)
@Entity
public class Customer2 {

    private Integer id;
    private String lastName;

    private String email;
    private int age;
    
    private Date birthday;
    
    private Date createdTime;
    
    private Set<Order2> orders = new HashSet<Order2>();  38 
    @TableGenerator(name=“ID_GENERATOR_2”,
            table=“t_id_generator”,
            pkColumnName=“PK_NAME”,
            pkColumnValue=“seedId_t_customer2”,
            valueColumnName=“PK_VALUE”,
            allocationSize=20,
            initialValue=10
            )
    @GeneratedValue(strategy=GenerationType.TABLE, generator=“ID_GENERATOR_2”)
    @Id
    @Column(name=“ID”)
    public Integer getId() {
        return id;
    }
    
    /**
     * 1、雙向1-n關聯的時候，一般1的一方放棄維護關聯關系，而由n的一方維護關聯關系。
     *       這樣做的好處就是：先保存1的一端，再保存n的一端的時候不會有多余的update sql語句
     * 2、使用@OneToMany(mappedBy=“customer”)來指明由n的一方的哪個屬性來維護關聯關系
     * 3、有一個值得注意的地方：如果指明了mappedBy=“customer”，那么久不能夠再使用@JoinColumn注解了。  59      */
    //@JoinColumn(name=“CUSTOMER_ID”)
    @OneToMany(mappedBy=“customer”)  62     public Set<Order2> getOrders() {
        return orders;
    }

    public void setOrders(Set<Order2> orders) {
        this.orders = orders;
    }
    
    @Column(name=“LAST_NAME”, length=50, nullable=false)
    public String getLastName() {
        return lastName;
    }
    
    @Column(name=“BIRTHDAY”)
    @Temporal(TemporalType.DATE)
    public Date getBirthday() {
        return birthday;
    }

    @Column(name=“CREATED_TIME”, columnDefinition=“DATE”)
    public Date getCreatedTime() {
        return createdTime;
    }
    
    @Column(name=“EMAIL”,columnDefinition=“TEXT”)
    public String getEmail() {
        return email;
    }
    
    /*
     * 工具方法，不需要映射為數據表的一列
     */
    @Transient
    public String getInfo(){
        return “lastName: ” + lastName + “ email: ” + email;
    }

    @Column(name=“AGE”)
    public int getAge() {
        return age;
    }

    @SuppressWarnings(“unused”)
    private void setId(Integer id) {
        this.id = id;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public void setCreatedTime(Date createdTime) {
        this.createdTime = createdTime;
    }
    
}

List_7. Order2.java（作為n的一方，有對1的一方的對象的引用，維護關聯關系）

package com.magicode.jpa.doubl.many2one;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.persistence.TableGenerator;

@Table(name=“t_double_one2many_order”)
@Entity
public class Order2 {
    
    private Integer id;
    private String orderName;
    
    private Customer2 customer; 21     
    @TableGenerator(name=“order_id_generator_2”,
            table=“t_id_generator”,
            pkColumnName=“PK_NAME”,
            pkColumnValue=“seedId_t_order2”,
            valueColumnName=“PK_VALUE”,
            initialValue=0,
            allocationSize=20)
    @GeneratedValue(generator=“order_id_generator_2”, strategy=GenerationType.TABLE)
    @Id
    @Column(name=“ID”)
    public Integer getId() {
        return id;
    }

    /**
     * 這里的name=“CUSTOMER_ID”會作為Order對象存放的數據庫表的一個外鍵列 38      * 用於維護關聯關系
     */
 @ManyToOne 41     @JoinColumn(name=“CUSTOMER_ID”) 42     public Customer2 getCustomer() {
        return customer;
    }

    public void setCustomer(Customer2 customer) {
        this.customer = customer;
    }

    @Column(name=“ORDER_NAME”)
    public String getOrderName() {
        return orderName;
    }
    
    @SuppressWarnings(“unused”)
    private void setId(Integer id) {
        this.id = id;
    }
    
    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

}

List_8. 測試代碼

package com.magicode.jpa.doubl.many2one;

import java.util.Date;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;



public class DoubleMany2OneTest {
    
    EntityManagerFactory emf = null;
    EntityManager em = null;
    EntityTransaction transaction = null;
    
    @Before
    public void before(){
        emf = Persistence.createEntityManagerFactory(“jpa-1”);
        em = emf.createEntityManager();
        transaction = em.getTransaction();
        transaction.begin();
    }
    
    @After
    public void after(){
        transaction.commit();
        em.close();
        emf.close();
    }
    
    @Test
    public void testPersist(){
        
        int i = 1;
        
        char c = (char) ('A' + i);
        String strName = (“ ” + c + c).trim();
        int age = 25 + i;
        
        Customer2 customer = new Customer2();
        customer.setAge(age);
        customer.setEmail(strName + “@163.com”);
        customer.setLastName(strName);
        customer.setBirthday(new Date());
        customer.setCreatedTime(new Date());
        
        Order2 order1 = new Order2();
        order1.setOrderName(“O-” + strName + “-1”);
        
        Order2 order2 = new Order2();
        order2.setOrderName(“O-” + strName + “-2”);
        
        //設置關聯關系
        customer.getOrders().add(order1);
        customer.getOrders().add(order2);
        
        order1.setCustomer(customer);
        order2.setCustomer(customer);
        
        //持久化操作
        /**
         * 雙向1-n的關聯關系中，1的一方放棄維護關聯關系，由n的一方維護關聯關系。
         * 建議“先保存1的一端，再保存n的一端”，這樣就不會有多余的update sql語句
         */
        em.persist(customer);
        em.persist(order1);
        em.persist(order2);
    }
    
    @Test
    public void testFind(){
        /**
         * 雙向多對一在查詢時默認的策略如下：
         * 1、檢索1的一方的時候，其包含的對n的集合屬性的檢索默認采用延遲加載，
         *     可以設置@OneToMany(fetch=FetchType.EAGER)來修改為立即加載策略；
         * 
         * 2、檢索n的一方的時候，對其包含的1的一方默認采用立即加載策略，
         *     可以設置@ManyToOne(fetch=FetchType.LAZY)來修改為延遲加載策略；
         * 
         * 很容易記混淆。但是我們可以深入思考一下，這樣做是有道理的：
         * ①、1的一方包含了對n的一方的集合屬性，在檢索的時候集合中到底有多少個元素我們根本
         * 就不知道，可能是幾個，也可能是1000000個呢！！！如果默認采用立即檢索策略，可以想
         * 象后果有多嚴重。
         * ②、n的一方包含了1的一方的一個對象，這和一個Integer或者是String類型的對象
         * 沒有區別。也不會像集合那樣可能占用巨大的內存資源。
         * 
         */
        Customer2 customer = em.find(Customer2.class, 11);
        
        System.out.println(“---------”);
        System.out.println(customer.getOrders().iterator().next().getOrderName());
        
        System.out.println(“---------”);
        Order2 order = em.find(Order2.class, 1);
        System.out.println(“---------”);
        System.out.println(order.getCustomer().getEmail());
    }
    
    @Test
    public void testRemove(){
        /**
         * 雙向n-1關聯關系，在默認的情況下，如果1的一方集合中還保存有n的一方的引用，那么是無法刪除1的一方的；
         * 但是可以任意刪除n的一方。
         * 可以設置@OneToMany(cascade={CascadeType.REMOVE})來進行級聯刪除：刪除1的同時，把其
         * 關聯的n的一方同時刪除；
         */
//        Customer2 customer = em.find(Customer2.class, 11);
//        em.remove(customer);
        
        Order2 order = em.find(Order2.class, 1);
        em.remove(order);
    }
}