7、单向一对多的关联关系（1的一方有n的一方的集合属性，n的一方却没有1的一方的引用）

单向一对多的关联关系

具体体现：1的一方有n的一方的集合的引用，n的一方却没有1的一方的引用

举个例子：顾客Customer对订单Order是一个单向一对多的关联关系。Customer一方有对Order的集合的引用。而Order却没有对Customer的引用；

“一对多”的物理意义就是：一个客户可以有多个订单，而一个订单只能归属于一个客户。

“单向”的物理意义就是：客户知道自己有哪些订单，但是订单却不知道自己属于哪个客户（这个容易让人接受一点儿！！！但是，不满足某些业务需求）

同样的，下面看看“单向一对多”的“Customer对Order”会有什么变化：

Order实体的属性（Order中没有对Customer的引用）：

@Table(name="t_single_one2many_order")
@Entity
public class Order1 {
    
    private Integer id;
    private String orderName;

    //省略getter、setter方法...  
}

Customer实体的属性（Customer中有对Order的集合的引用）：

@Table(name="t_single_one2many_customer")
@Entity
public class Customer1 {

    private Integer id;
    private String lastName;

    private String email;
    private int age;
    
    private Date birthday;
    
    private Date createdTime;
    
    //Customer1中有对Order1的集合引用  
    private Set<Order1> orders = new HashSet<Order1>();

    //省略getter、setter方法...
}

映射单向一对多的关联关系有两个要点：

1、利用@OneToMany注解进行一对多的映射；

2、利用@JoinColumn来映射外键列的名称；

注意的点：

1、@OneToMany的默认检索策略为延迟加载策略，可以通过设置其属性fetch=FetchType.EAGER来修改为立即检索策略；

2、@OneToMany设置的单向一对多关联在其默认情况下可以删除1的一方。

　　处理方式：首先将其关联的n的一方数据表的所有外键都设置为null，然后再删除1的一方。可以通过设置@OneToMany的属性cascade={CascadeType.REMOVE}来设置为级联删除（删除1的一方的同时把多的一方也同时删除，还可以设置其它的删除策略）

在实体类中，属性可以分为两种：1、集合属性； 2、非集合属性；

一个大体的原则就是：1、对集合属性默认采用懒加载策略；2、对非集合属性默认采用立即检索策略；

这种默认检索策略是有道理的：1、检索的时候我们并不知道集合中到底包含了多少条记录，可能是几条，也可能是几十亿条记录。如果对一个庞大的集合属性采用立即检索策略，那么很有可能直接将内存全部占用了（比如说，集合中包含了100亿条记录），系统直接崩溃。2、对一个非集合属性而言，即便是一个其它实体类的引用（该引用中的集合依然会采用延迟检索）所占资源也是十分有限，不会像检索集合那样直接脱离我们的掌控。所以，对于非集合属性默认采用立即检索策略。

对于单向1-n而言，保存的顺序没有差别，都会有update语句发送。

List_1. Order1实体的代码（不包含对1的一方的引用，不需要做任何关于映射的注解）

package com.magicode.jpa.single.one2many;

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

@Table(name="t_single_one2many_order")
@Entity
public class Order1 {
    
    private Integer id;
    private String orderName;
    
    @TableGenerator(name="order_id_generator_1",
            table="t_id_generator",
            pkColumnName="PK_NAME",
            pkColumnValue="seedId_t_order_1",
            valueColumnName="PK_VALUE",
            initialValue=0,
            allocationSize=20)
    @GeneratedValue(generator="order_id_generator_1", strategy=GenerationType.TABLE)
    @Id
    @Column(name="ID")
    public Integer getId() {
        return id;
    }
    
    @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_2. Customer1实体的代码（包含有对n的一方的集合的引用）

package com.magicode.jpa.single.one2many;

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

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.TableGenerator;
//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_single_one2many_customer")
@Entity
public class Customer1 {

    private Integer id;
    private String lastName;

    private String email;
    private int age;
    
    private Date birthday;
    
    private Date createdTime;
    
    private Set<Order1> orders = new HashSet<Order1>();

    @TableGenerator(name="ID_GENERATOR_1",
            table="t_id_generator",
            pkColumnName="PK_NAME",
            pkColumnValue="seedId_t_customer_1",
            valueColumnName="PK_VALUE",
            allocationSize=20,
            initialValue=10
            )
    @GeneratedValue(strategy=GenerationType.TABLE, generator="ID_GENERATOR_1")
    @Id
    @Column(name="ID")
    public Integer getId() {
        return id;
    }
    
    /**
     * 1、单向一对多的关联关系使用@OneToMany注解进行映射
     * 2、利用@JoinColumn来映射外键列的名称
     * 3、@OneToMany在默认情况下使用懒加载的检索策略，可以通过fetch=FetchType.EAGER
     *    来修改为立即加载策略；
     * 4、单向一对多可以删除1的一方，此时JPA的做法是将多的一方的外键全部置为null，然后再删除1的一方
     *    可以通过设置cascade={CascadeType.REMOVE}来设置为级联删除（删除1的一方的同时把多的
     *    一方也同时删除，还可以设置其它的删除策略）
     */
    @OneToMany(fetch=FetchType.EAGER, cascade={CascadeType.REMOVE})
    @JoinColumn(name="CUSTOMER_ID")
    public Set<Order1> getOrders() {
        return orders;
    }

    public void setOrders(Set<Order1> 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_3. 测试代码

package com.magicode.jpa.single.one2many;

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 One2ManyTest {
    
    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(){
        
        for(int i = 0; i < 3; i++){
            char c = (char) ('A' + i);
            String strName = (" " + c + c).trim();
            int age = 25 + i;
            
            Customer1 customer = new Customer1();
            customer.setAge(age);
            customer.setEmail(strName + "@163.com");
            customer.setLastName(strName);
            customer.setBirthday(new Date());
            customer.setCreatedTime(new Date());
            
            Order1 order1 = new Order1();
            order1.setOrderName("O-" + strName + "-1");
            
            Order1 order2 = new Order1();
            order2.setOrderName("O-" + strName + "-2");
            
            //设置关联关系
            customer.getOrders().add(order1);
            customer.getOrders().add(order2);
            
            /**
             * 保存的顺序没有区别，无论什么顺序都会有update语句发送
             */
            em.persist(customer);
            em.persist(order1);
            em.persist(order2);
        }
    }
    
}