映射双向一对一的关联关系

一张Manager表, 一张Department表, 一个部门只有一个经理,一个经理也只对应一个部门

Manager.java页面代码

@Entity
@Table(name="manager")
public class Manager {
    
    private Integer id;
    private String managername;
    private Department dept;
    
    @Id
    @GeneratedValue
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getManagername() {
        return managername;
    }
    public void setManagername(String managername) {
        this.managername = managername;
    }
    
    //对于不维护关联关系的一端,没有外键的一端,使用@OneToOne来进行映射,需要设置mappedBy属性
    @OneToOne(mappedBy="manager")
    public Department getDept() {
        return dept;
    }
    public void setDept(Department dept) {
        this.dept = dept;
    }
}

Department.java页面代码

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

    private Integer id;
    private String deptname;
    private Manager manager;
    
    @Id
    @GeneratedValue
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getDeptname() {
        return deptname;
    }
    public void setDeptname(String deptname) {
        this.deptname = deptname;
    }
    
    //使用@OneToOne来映射1-1的关联关系
    //若需要在当前数据表中添加外键,则需要使用@JoinColumn来进行映射.
    //注意:1-1关联关系时,必须设置unique=true
    @OneToOne(fetch=FetchType.LAZY,cascade={CascadeType.REMOVE})
    @JoinColumn(name="mar_id",unique=true)
    public Manager getManager() {
        return manager;
    }
    public void setManager(Manager manager) {
        this.manager = manager;
    }
}
 

Test映射双向一对一的关联关系的CRUD

public class JPATest {

    private EntityManager entityManager;
    private EntityTransaction transaction;
    private EntityManagerFactory entityManagerFactory;

    @Before
    public void setUp() throws Exception {
        entityManagerFactory = Persistence.createEntityManagerFactory("jpa-1");
        entityManager = entityManagerFactory.createEntityManager();
        transaction = entityManager.getTransaction();
        transaction.begin();
    }

    @After
    public void destroy() {
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }
    
    @Test
    public void testOneToOneUpdate(){
        Department department = entityManager.find(Department.class, 1);
        department.getManager().setManagername("jiangli");
    }
    
    @Test
    public void testOneToOneRemove(){
//        Manager manager = entityManager.find(Manager.class, 1);
//        entityManager.remove(manager);
        Department department = entityManager.find(Department.class, 2);
        entityManager.remove(department);
    }
    
    //默认情况下,若获取维护关联关系的一端,则会通过左外连接获取其关联的对象,发送2条SQL语句
    //但可以通过@OneToOne(fetch=FetchType.LAZY)来修改加载策略,只发送1条SQL语句
    //fetch=FetchType.LAZY 懒加载也叫延迟加载
    @Test
    public void testOneToOneFind2(){
        Department dept = entityManager.find(Department.class, 1);
        System.out.println(dept.getDeptname());
        System.out.println(dept.getManager().getClass().getName());
    }
    
    //默认情况下,若获取不维护关联关系的一端,也会通过左外连接获取其关联的对象,只发送1条SQL语句
    //所以在不维护关联关系的一端,不简易修改fetch属性
    @Test
    public void testOneToOneFind1(){
        Manager manager = entityManager.find(Manager.class, 1);
        System.out.println(manager.getManagername());
        System.out.println(manager.getDept().getClass().getName());
    }
    
    //双向1-1的关联关系,先保存不维护关联关系的一端,即没有外键的一端,这样不会多出update语句
    @Test
    public void testOneToOnePersist(){
        Manager manager = new Manager();
        manager.setManagername("MMM");
        Department dept = new Department();
        dept.setDeptname("DDD");
        //设置关联关系
        manager.setDept(dept);
        dept.setManager(manager);
        //执行保存操作
        entityManager.persist(manager);
        entityManager.persist(dept);
    }
}