9、JPA_映射双向一对一的关联关系

双向一对一的关联关系

举例说明：经理Manager和部门Department是双向一对一关联关系。则Manager实体类中有Department实体对象的引用，反之亦然。

其实体属性定义如下：

List_1. Manager实体类属性定义（有对Department实体对象的引用）

 @Table(name="t_manager")
 @Entity
 public class Manager {
 
     private Integer id;
     private String mgrName;
 
     //有对实体Department对象的引用
     private Department dept;

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

List_2. Department实体类属性定义（有对Manager实体对象的引用）

 @Table(name="t_department")
 @Entity
 public class Department {
 
     private Integer id;
     private String deptName;
 
     //有对Manager实体对象的引用
     private Manager mgr;

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

双向一对一的关联关系映射方法有两种：基于外键的映射、基于主键的映射。

这里讲使用较多的基于外键的映射。其映射步骤如下（例子中假定由Manager一方维护关联关系，Department一方放弃维护关联关系）：

1、双方都使用使用@OneToOne注解来映射关联关系；

2、只需要一方维护关联关系（任何一方都可以）：

①、放弃维护关联关系的一方需要配置@OneToOne的mappedBy属性，用于指定由对方的哪个属性来映射，同时不能使用@JoinColum注解（和前面讲的双向一对多关联关系是一样的）。放弃维护关联关系的一方所对应的数据表没有外键列。如下Department实体中的映射注解：

List_3. Department实体类的映射注解（放弃维护关联关系，指定由对方的dept属性来进行关联；不能使用@JoinColumn注解）

@OneToOne(mappedBy="dept")
public Manager getMgr() {
    return mgr;
}

②、维护关联的一方需要使用@JoinColumn注解来指定外键列的列名，同时还要指定外键列的唯一约束：@JoinColumn(name="DEPT_ID", unique=true)。维护关联关系的一方实体对应的数据表有一个外键列，列名由name属性指定。如下Manager实体类中的映射注解：

List_4. Manager实体类的映射注解（由@JoinColumn注解的name属性指定表的外键列的列名，同时指定外键列的唯一约束）

@JoinColumn(name="DEPT_ID", unique=true)
@OneToOnepublic Department getDept() {
    return dept;
}

再讲一下映射的默认属性，同上面一样由Manager一方维护关联关系：

1、默认情况下，双方对实体类对象的引用均采用立即加载的检索策略，这是符合前面 8、双向一对多关联关系 一节所阐述的“默认情况下，对象属性采用立即检索，集合属性采用延迟检索”。

2、修改默认检索策略：

①、维护关联关系的一方（如Manager）所对应的数据表有外键列，可以通过设置@OneToOne的属性fetch=FetchType.LAZY来设置延迟加载策略。

②、放弃维护关联关系的一方（如Department）所对应的数据表中没有外键，即便设置了fetch=FetchType.LAZY也不能够达到延迟加载的效果。相反，如果设置了fetch=FetchType.LAZY以后还会多发送一条sql语句（两条select语句）；没有设置的时候，只发送一条sql语句（一条带left outer join的select语句）。

3、保存顺序，先保存放弃维护关联关系的一方实体，后保存维护关联关系的一方实体。这样可以避免发送update语句。

下面是实验代码清单：

List_5. Department实体（放弃维护关联关系，指定由对方的dept属性来进行关联；不能使用@JoinColumn注解）

 package com.magicode.jpa.doubl.one2one;
 
 import javax.persistence.Column;
 import javax.persistence.Entity;
 import javax.persistence.GeneratedValue;
 import javax.persistence.Id;
 import javax.persistence.OneToOne;
 import javax.persistence.Table;
 
 @Table(name="t_department")
 @Entity
 public class Department {
 
     private Integer id;
     private String deptName;
 
     private Manager mgr;
 
     @Column(name="ID")
     @GeneratedValue
     @Id
     public Integer getId() {
         return id;
     }
 
     @Column(name="DEPT_NAME", length=25)
     public String getDeptName() {
         return deptName;
     }
 
     /**
      * 通过mapptedBy指定由关联对象的那个属性建立起连接
      * Manger实体对应的数据表没有外键，无法使用延迟加载策略
      * 所以使用默认的检索方式就好。
      * 如果设置了fetch=FetchType.LAZY反而会多发送一条sql语句。
      */
     @OneToOne(mappedBy="dept")
     public Manager getMgr() {
         return mgr;
     }
 
     @SuppressWarnings("unused")
     private void setId(Integer id) {
         this.id = id;
     }
 
     public void setDeptName(String deptName) {
         this.deptName = deptName;
     }
 
     public void setMgr(Manager mgr) {
         this.mgr = mgr;
     }
 }

List_6. Manager实体（由@JoinColumn注解的name属性指定表的外键列的列名，同时指定外键列的唯一约束）

package com.magicode.jpa.doubl.one2one;
 
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;
 
@Table(name="t_manager")
@Entity
public class Manager {
 
    private Integer id;
    private String mgrName;
 
    private Department dept;
 
    @Column(name="ID")
    @GeneratedValue
    @Id
    public Integer getId() {
        return id;
    }
 
    @Column(name="MGR_NAME", length=25)
    public String getMgrName() {
        return mgrName;
    }
 
    /**
     * 默认情况下对Department属性的检索采用立即检索策略。
     * 由于Manager实体对应的数据表有外键列，所以可以设置
     * fetch=FetchType.LAZY来修改为延迟加载策略。
     *
     * 注意：对没有外键类的一方（Department一方）则无法实现
     * 延迟加载策略。设置 fetch=FetchType.LAZY以后反而会
     * 多发送一条sql语句。
     */
    @JoinColumn(name="DEPT_ID", unique=true)
    @OneToOne(fetch=FetchType.LAZY)
    public Department getDept() {
        return dept;
    }
 
    @SuppressWarnings("unused")
    private void setId(Integer id) {
        this.id = id;
    }
 
    public void setMgrName(String mgrName) {
        this.mgrName = mgrName;
    }
 
    public void setDept(Department dept) {
        this.dept = dept;
    }
 
}

List_7. 测试代码：

package com.magicode.jpa.doubl.one2one;
 
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 DoubleOne2OneTest {
 
    private EntityManagerFactory emf = null;
    private EntityManager em = null;
    private 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(){
        Department dept = new Department();
        dept.setDeptName("Dept-AA");
 
        Manager mgr = new Manager();
        mgr.setMgrName("Mgr-AA");
 
        //创建关联关系
        dept.setMgr(mgr);
        mgr.setDept(dept);
 
        /**
         * 持久化的时候，先持久化没有外键的那个对象，在持久化有
         * 外间的对象。这样就会避免发送update语句。
         */
        em.persist(dept);
        em.persist(mgr);
    }
 
    @Test
    public void testFind(){
        /**
         * 默认情况下，双向1-1关联关系中，在检索的时候都采用立即
         * 检索的策略（通过左外连接的方式查找与其相关联的属性）。
         *
         * 有外键的那一方实体可以通过设置@OneToOne注解的fetch=FetchType.LAZY来
         * 修改默认检索策略。将其设置为延迟加载（对实体对象索引的检索）。
         *
         * 对于没有外键的那一方而言，我们不需要修改其默认的检索方式。因为，无论你是否设置
         * fetch=FetchType.LAZY都会立即加载其关联的那一方实体（其没有对应的外键列，
         * 如果在检索的时候不加载，以后就无法找到其关联的实体对象了）。
         * 而且，如果设置了fetch=FetchType.LAZY还会稍微的有一点儿影响性能：默认情况下
         * 采用左外连接的方式，只会发送一条sql语句；而如果设置了fetch=FetchType.LAZY
         * 则会发送两条sql语句。
         */
//        Manager mgr = em.find(Manager.class, 2);
//        System.out.println(mgr.getMgrName());
//        System.out.println(mgr.getDept().getClass().getName());
//
//        System.out.println("--------------->");
 
        Department dept = em.find(Department.class, 3);
//        System.out.println(dept.getDeptName());
//        System.out.println(dept.getMgr().getClass().getName());
 
    }
 
}