JPA-映射-(@OneToOne)双向一对一

一个管理对应一个部门，一个部门对应一个管理，例中由部门维护关联关系

Department：部门类

import lombok.Data;

import javax.persistence.*;

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

    @Id
    @GeneratedValue
    private Integer id;

    @Column(name = "DEPT_NAME")
    private String deptName;

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

Manager：管理类

import lombok.Data;

import javax.persistence.*;

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

    @Id
    @GeneratedValue
    private Integer id;

    @Column(name = "MGR_NAME")
    private String mgrName;

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

测试

添加

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

@PrimaryKeyJoinColumn

基于主键映射