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

单向多对一的关联关系

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

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

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

“单向”的物理意义就是：订单知道它属于哪个客户，而客户却不知道自己有哪些订单。（多么反人类的逻辑！！！）

下面看看客户和订单的实体类的属性，很清楚“单向多对一”这种关联关系：

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

 @Table(name="t_order")
 @Entity
 public class Order {

     private Integer id;
     private String orderName;

     // n 的一方有对 1 的一方的引用
     private Customer customer;

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

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

 @Table(name="t_customer")
 @Entity
 public class Customer {

     private Integer id;
     private String lastName;

     private String email;
     private int age;

     private Date birthday;

     private Date createdTime;

     //省略getter、setter方法
 }

映射方法：主要是对n的一方使用@ManyToOne和@JoinColumn注解。而1的一方不需要做任何映射性的标注。具体的映射方法：

1、采用@ManyToOne注解映射多对一的关联关系。检索n的时候，对其包含的1的一方的引用在默认情况下采用“左外连接”的方式来进行加载。可以通过配置@ManyToOne(fetch=FetchType.LAZY)的来设定为延迟加载（延迟加载要注意懒加载异常的出现）。

2、通过@JoinColumn注解来映射外键，其name属性用来指定外键列的列名。外键列在n的一方对应的数据表中。

对应于Customer和Order而言：在检索Order的时候，对Order.customer采用左外连接的方式进行检索（立即加载）。为什么要这样呢？？

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

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

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

在持久化多对一的时候有一个可以优化的地方值得注意一下：先保存1的一方，后保存n的一方，按这个顺序进行保存就不需要发送update语句。

下面列出清单：

List_1. Customer作为1的一方，没有Order的集合属性

 package com.magicode.jpa.helloworld;

 import java.util.Date;

 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;
 //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_customer")
 @Entity
 public class Customer {

     private Integer id;
     private String lastName;

     private String email;
     private int age;

     private Date birthday;

     private Date createdTime;

     /**
      * @TableGenerator 标签的属性解释：
      *
      *     ①、allocationSize 属性需要赋一个整数值。表示了bucket的容量。其默认值为50。
      *     ②、table 属性用于指定辅助表的表名。这里指定为t_id_generator数据表
      *
      * 其基本思想就是：从table指定的辅助表中读取一个bucket段id号范围内的第一个数值，记为first_id。在后面持久化过程中的id号是从first_id开始依次递增1得到
      * 当递增到first_id + allocationSize 的时候，就会再一次从辅助表中读取一个first_id开始新一轮的id生成过程。
      *
      * 我们知道，要从数据库中确定一个值，则必须确定其“行”和“列”。JPA自动产生的t_id_generator只有两列。当然，如果该表
      * 为n个表产生id，则会在t_id_generator表中保存“n行2列”。
      * 那么，如何从数据表t_id_generator中确定出seed_id用于为Customer实体计算id呢？？JPA会依据Customer实体的
      * @TableGenerator 属性值来依据下面的规则的到seed_id：
      *     ③、valueColumnName 属性指定了seed_id的列名。valueColumnName="PK_VALUE"也就是指定了
      *        seed_id位于PK_VALUE列中。同时，规定了这一列必须是数值型（int,long等）。
      *             剩下的任务就是如何从n行中确定出是哪一行？？
      *     ④、pkColumnName="PK_NAME",pkColumnValue="seed_t_customer_id" 两个一起来确定具体的行：
      *            在PK_NAME列中，值为seed_t_customer_id的那一行。
      *     ⑤、由上面③和④中确定出来的“行”和“列”就可以得到一个int型的整数值。这个值就是first_id。
      *
      * 注意：我们的数据库中可以没有t_id_generator这张表，JPA会自动帮助我们完成该表的创建工作。自动创建的表只有两列：
      * PK_NAME(VARCHAR)和PK_VALUE(int)。同时会自动添加一条记录(seed_t_customer_id, 51) 依据优化策略的不同，辅助表中记录的数值有区别
      */
     @TableGenerator(name="ID_GENERATOR",
             table="t_id_generator",
             pkColumnName="PK_NAME",
             pkColumnValue="seedId_t_customer",
             valueColumnName="PK_VALUE",
             allocationSize=20,
             initialValue=10
             )
     @GeneratedValue(strategy=GenerationType.TABLE, generator="ID_GENERATOR")
     @Id
     @Column(name="ID")
     public Integer getId() {
         return id;
     }

     /**
      * @Column 指明lastName属性映射到表的 LAST_NAME 列中
      * 同时还可以指定其长度、能否为null等数据限定条件
      */
     @Column(name="LAST_NAME", length=50, nullable=false)
     public String getLastName() {
         return lastName;
     }

     /**
      * 利用 @Temporal 来限定birthday为DATE型
      */
     @Column(name="BIRTHDAY")
     @Temporal(TemporalType.DATE)
     public Date getBirthday() {
         return birthday;
     }

     /*
      * 通过 @Column 的 columnDefinition 属性将CREATED_TIME列
      * 映射为“DATE”类型
      */
     @Column(name="CREATED_TIME", columnDefinition="DATE")
     public Date getCreatedTime() {
         return createdTime;
     }

     /*
      * 通过 @Column 的 columnDefinition 属性将email列
      * 映射为“TEXT”类型
      */
     @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;
     }

 }

Customer.java

List_2. Order作为n的一方，有对Customer的引用，需要配置关联关系

 package com.magicode.jpa.many2one;

 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.ManyToOne;
 import javax.persistence.Table;
 import javax.persistence.TableGenerator;

 import com.magicode.jpa.helloworld.Customer;

 @Table(name="t_order")
 @Entity
 public class Order {

     private Integer id;
     private String orderName;

     private Customer customer;　　// n 的一方有对 1 的一方的引用
     @TableGenerator(name="order_id_generator",
             table="t_id_generator",
             pkColumnName="PK_NAME",
             pkColumnValue="seedId_t_order",
             valueColumnName="PK_VALUE",
             initialValue=0,
             allocationSize=20)
     @GeneratedValue(generator="order_id_generator", strategy=GenerationType.TABLE)
     @Id
     @Column(name="ID")
     public Integer getId() {
         return id;
     }

     @Column(name="ORDER_NAME")
     public String getOrderName() {
         return orderName;
     }

     /**
      * 1、通过 @ManyToOne 来配置单向多对一的关联关系，同时可以配置fetch=FetchType.LAZY
      * 来指定懒加载查询策略；
      * 2、@JoinColumn来映射外键
      */
     //@ManyToOne(fetch=FetchType.LAZY)
　　　　@ManyToOne
     @JoinColumn(name="CUSTOMER_ID")
     public Customer getCustomer() {
         return customer;
     }

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

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

     public void setOrderName(String orderName) {
         this.orderName = orderName;
     }

 }

List_3. persistence.xml的配置文件

 <?xml version="1.0" encoding="UTF-8"?>
 <persistence version="2.0"
     xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">

     <!-- 注意这里的 persistence-unit标签的name属性值，main函数中会用到它 -->
     <persistence-unit name="jpa-1" transaction-type="RESOURCE_LOCAL">

         <!-- 配置使用什么样的ORM产品作为JPA的实现
             1、实际上配置的是 javax.persistence.spi.PersistenceProvider 接口的实现类
             2、若JPA项目中只有一个JPA的实现产品，则可以不配置provider节点
         -->
         <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

         <!-- 添加持久化类 -->
         <class>com.magicode.jpa.helloworld.Customer</class>
         <class>com.magicode.jpa.many2one.Order</class>

         <properties>
             <!-- 连接数据库的基本信息 -->
             <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
             <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa" />
             <property name="javax.persistence.jdbc.user" value="root" />
             <property name="javax.persistence.jdbc.password" value="tiger123" />

             <!-- 配置JPA实现产品的基本属性：配置Hibernate的基本属性 -->
             <property name="hibernate.format_sql" value="true" />
             <property name="hibernate.show_sql" value="true" />
             <property name="hibernate.hbm2ddl.auto" value="update" />
             <!--
                 Setting is relevant when using @GeneratedValue.
                 It indicates whether or not the new IdentifierGenerator implementations
                 are used for javax.persistence.GenerationType.AUTO,
                 javax.persistence.GenerationType.TABLE and
                 javax.persistence.GenerationType.SEQUENCE.
                 Default to false to keep backward compatibility.
              -->
             <property name="hibernate.id.new_generator_mappings" value="true"/>

         </properties>

     </persistence-unit>
 </persistence>

List_4. 测试方法分别测试了增、删、改、查

 package com.magicode.jpa.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;

 import com.magicode.jpa.helloworld.Customer;

 public class Many2OneTest {

     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();
     }

     /**
      * 先持久化 1 的一方，后持久化 n 的一方会少发送3条update SQL语句
      */
     @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;

             Customer customer = new Customer();
             customer.setAge(age);
             customer.setEmail(strName + "@163.com");
             customer.setLastName(strName);
             customer.setBirthday(new Date());
             customer.setCreatedTime(new Date());

             Order order1 = new Order();
             order1.setOrderName("O-" + strName + "-1");

             Order order2 = new Order();
             order2.setOrderName("O-" + strName + "-2");

             //设置关联关系
             order1.setCustomer(customer);
             order2.setCustomer(customer);

             //持久化操作
             em.persist(customer);
             em.persist(order1);
             em.persist(order2);
         }
     }

     /**
      * 查询单向多对一关联关系的时候，默认情况下采用的是left outer join策略。
      * 可以通过 @ManyToOne(fetch=FetchType.LAZY) 来配置为懒加载查询策略
      */
     @Test
     public void testFind(){
         Order order = em.find(Order.class, 1);

         System.out.println("-----1------");
         System.out.println("orderName: " + order.getOrderName());

         System.out.println("-----2------");
         System.out.println("order.customer.email: " + order.getCustomer().getEmail());
     }

     @Test
     public void testRemove(){
         //删除多的一端可以随便删除
 //        Order order = em.find(Order.class, 1);
 //        em.remove(order);

         //删除1的一端的时候，如果还有多的一端引用它，则会删除失败
         Customer customer = em.find(Customer.class, 11);
         em.remove(customer);
     }

     @Test
     public void testUpdate(){
         Customer customer = em.find(Customer.class, 12);
         customer.setAge(1000);

         Order order = em.find(Order.class, 5);
         order.setOrderName("OOOO");
         order.getCustomer().setAge(1000);
     }
 }