package com.jpa.yingshe;

import javax.persistence.*;

@Table(name = "JPA_DEPARTMENTS")
@Entity
public class Department {

    private Integer id;
    private String deptName;

    private Manager mgr;

    @GeneratedValue
    @Id
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Column(name = "DEPT_NAME")
    public String getDeptName() {
        return deptName;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }

    // 使用 @OneToOne 来映射 1-1 关联关系
    // 若需要在当前数据表中添加主键则需要使用 @JoinColumn 来进行映射
    // 1-1 关联关系, 需要添加 unique=true
    @JoinColumn(name = "MGR_ID", unique = true)
    @OneToOne()
    public Manager getMgr() {
        return mgr;
    }

    public void setMgr(Manager mgr) {
        this.mgr = mgr;
    }
}

package com.jpa.yingshe;

import javax.persistence.*;

@Table(name = "JPA_MANAGERS")
@Entity
public class Manager {

    private Integer id;
    private String mgrName;

    private Department dept;

    @GeneratedValue
    @Id
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Column(name = "MGR_NAME")
    public String getMgrName() {
        return mgrName;
    }

    public void setMgrName(String mgrName) {
        this.mgrName = mgrName;
    }

    // 对于不维护关联关系, 没有外键的一方, 使用 @OneToOne 来进行映射, 建议设置 mappedBy，减少update语句
    @OneToOne(mappedBy = "mgr")
    public Department getDept() {
        return dept;
    }

    public void setDept(Department dept) {
        this.dept = dept;
    }
}

package jpa.test;

import com.jpa.yingshe.Department;
import com.jpa.yingshe.Manager;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

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

public class JPAyingshe {
    private EntityManagerFactory entityManagerFactory;
    private EntityManager entityManager;
    private EntityTransaction transaction;

    @Before
    public void init() {
        entityManagerFactory = Persistence.createEntityManagerFactory("jpaname");
        entityManager = entityManagerFactory.createEntityManager();
        transaction = entityManager.getTransaction();
        transaction.begin();
    }

    @After
    public void destroy() {
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }

    // 双向 1-1 的关联关系, 建议先保存不维护关联关系的一方, 即没有外键的一方, 这样不会多出 UPDATE 语句
    @Test
    public void testOneToOnePersistence() {
        Manager mgr = new Manager();
        mgr.setMgrName("M-BB");

        Department dept = new Department();
        dept.setDeptName("D-BB");

        //设置关联关系
        mgr.setDept(dept);
        dept.setMgr(mgr);

        //执行保存操作
        entityManager.persist(mgr);
        entityManager.persist(dept);
    }
}

// 默认情况下, 获取维护关联关系的一方, 会通过左外连接获取其关联的对象，非懒加载模式
// 可以通过 @OntToOne 的 fetch 属性来修改加载策略
@Test
public void testOneToOneFind() {
    Department dept = entityManager.find(Department.class, 33);
    System.out.println(dept.getDeptName());
    System.out.println(dept.getMgr().getClass().getName());
}

@JoinColumn(name = "MGR_ID", unique = true)
@OneToOne(fetch = FetchType.LAZY)
public Manager getMgr() {
    return mgr;
}

// 默认情况下, 获取不维护关联关系的一方, 是通过左外连接获取其关联的对象
// 可以通过 @OneToOne 的 fetch 属性来修改加载策略. 但依然会再发送 SQL 语句来初始化其关联的对象
// 这说明在不维护关联关系的一方, 不建议修改 fetch 属性
@Test
public void testOneToOneFind2() {
    Manager mgr = entityManager.find(Manager.class, 34);
    System.out.println(mgr.getMgrName());

    System.out.println(mgr.getDept().getClass().getName());
}

// 对于不维护关联关系, 没有外键的一方, 使用 @OneToOne 来进行映射, 建议设置 mappedBy，减少update语句
@OneToOne(mappedBy = "mgr",fetch = FetchType.LAZY)
public Department getDept() {
    return dept;
}