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的集合的引用
     //（这个引用还要被注解表示为一种映射关系才行）
     private Set<Order2> orders = new HashSet<Order2>();

     // 省略getter、setter方法
 }

List_2. Order实体类（有对Customer的实体的对象的引用）

 @Table(name=“t_double_one2many_order”)
 @Entity
 public class Order2 {

     private Integer id;
     private String orderName;

     //n的一方有对1的一方的对象的引用
     //①要有映射注解表明为映射；②、允许多对一，否则就是一对一
     private Customer2 customer;

         // 省略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注解了。  *
  */
 //    @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>();

     @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注解了。
      */
     //@JoinColumn(name=“CUSTOMER_ID”)
     @OneToMany(mappedBy=“customer”)
     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;

     @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对象存放的数据库表的一个外键列
      * 用于维护关联关系
      */
     @ManyToOne
     @JoinColumn(name=“CUSTOMER_ID”)
     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);
     }
 }