转载：hibernate基于注解的维护权反转：@OneToMany(mappedBy=)

背景说明：首先是SSH环境下，对象基于注解的方式映射到数据库；

昨天遇到一个比较纠结的问题，@OneToMany(mappedBy="xxx")， mappedBy属性有什么用，然后是写在哪一边？

还有一个问题是：@JoinColumn(name="xxxxx")，JoinColumn有什么用？

先贴出最初的代码：一些基本的注解，在一对多的关系上没有使用JoinColumn和mappedBy属性

部门类：主要是第33、34行

package com.lizhou.entity.test;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;

/**
 * 部门：与员工一对多关系
 * @author bojiangzhou
 *
 */
@Entity
@Table(name="department")
public class Department {
    
    @Id
    @GeneratedValue(generator="_native")
    @GenericGenerator(name="_native", strategy="native")
    private int id; //ID
    
    @Column(length=20)
    private String dname; //部门名称
    
    @OneToMany
    private List<Employee> employeeList = new ArrayList<>(); //部门下的员工集合

    // get/set方法59     
}

员工类：主要是第32、33行

package com.lizhou.entity.test;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;

/**
 * 员工：与部门多对一关系
 * @author bojiangzhou
 *
 */
@Entity
@Table(name="employee")
public class Employee {

    @Id
    @GeneratedValue(generator="_native")
    @GenericGenerator(name="_native", strategy="native")
    private int id; //ID
    
    @Column(length=20)
    private String ename; //员工姓名
    
    @Column(length=20)
    private String phone; //电话
    
    @ManyToOne
    private Department department; //所属部门
    
    
    //get/set方法67     
}

最初的注解配置里，在一对多的关系上，即employeeList和department没有使用JoinColumn。

看下图，employee表会自动添加一个外键列department_id，虽然关系映射上是正确了，但是有一个问题，数据库里多了一张表出来，这不是想要的结果。

解决方法：在employeeList和department字段上加上@JoinColumn注解

1 @OneToMany
2 @JoinColumn(name="departmentId")
3 private List<Employee> employeeList = new ArrayList<>(); //部门下的员工集合

1 @ManyToOne//
2 @JoinColumn(name="departmentId")//
3 private Department department; //所属部门

这样一来的话就只有两张表了，所以在一对多或者一对一的关系下，需要加上@JoinColumn来指定外键列，避免生成一张中间表。

而且经试验，多的一方(Employee)里的department必须加上@JoinColumn，Department里不加不会影响表的结构，不知道会不会有其它影响；

但是如果Employee属于多的一方，如果没有指定外键列，还是会自动生成一个department_id外键列。

接下来讨论mappedBy属性：mappedBy属性主要是针对外键而言。与之相对应的是xml中的inverse属性。

如下是测试类代码：此时还没有设置mappedBy属性，映射时，默认是都由自身维护关联关系。

package com.lizhou.action.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.lizhou.entity.test.Department;
import com.lizhou.entity.test.Employee;

/**
 * 测试类
 * @author bojiangzhou
 *
 */

public class TestAction {
    
    private static SessionFactory sessionFactory = null;
    
    static {
        //读取classpath中applicationContext.xml配置文件
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取session中配置的sessionFactory对象
        sessionFactory = (SessionFactory) applicationContext.getBean("sessionFactory");
    }
    
    @Test
    public void testSave(){
        //创建一个部门对象
        Department d1 = new Department();
        d1.setDname("研发部");
        
        //创建两个员工对象
        Employee e1 = new Employee();
        e1.setEname("张三");
        e1.setPhone("13111111111");
        Employee e2 = new Employee();
        e2.setEname("李四");
        e2.setPhone("18523222222");
        
        //设置对象关联
        d1.getEmployeeList().add(e1);
        d1.getEmployeeList().add(e2);
        e1.setDepartment(d1);
        e2.setDepartment(d1);
        
        //获取Session
        Session session = sessionFactory.openSession();
        //开始事务
        Transaction t = session.beginTransaction();
        try {
            //添加数据
            session.save(d1);
            session.save(e1);
            session.save(e2);
            //提交事务
            t.commit();
        } catch (RuntimeException e) {
            //有异常则回滚事务
            t.rollback();
            e.printStackTrace();
        } finally {
            //关闭session
            session.close();
        }
    }
    
    
}

执行testSave后，控制台打印如下语句：

1 Hibernate: insert into department (dname) values (?)
2 Hibernate: insert into employee (departmentId, ename, phone) values (?, ?, ?)
3 Hibernate: insert into employee (departmentId, ename, phone) values (?, ?, ?)
4 Hibernate: update employee set departmentId=? where id=?
5 Hibernate: update employee set departmentId=? where id=?

可以看到多了两条update语句，这是因为两边都维护关系，先插入的部门，再插入员工，插入员工时，已经设置好外键了，但部门方也维护关系，会再执行一次更新操作，为员工设置外键，这样就导致多出了两条update语句，这里是有性能损耗的。

一种解决办法是：将第46、47行去掉，即对象上部门不关联员工

package com.lizhou.action.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.lizhou.entity.test.Department;
import com.lizhou.entity.test.Employee;

/**
 * 测试类
 * @author bojiangzhou
 *
 */

public class TestAction {
    
    private static SessionFactory sessionFactory = null;
    
    static {
        //读取classpath中applicationContext.xml配置文件
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取session中配置的sessionFactory对象
        sessionFactory = (SessionFactory) applicationContext.getBean("sessionFactory");
    }
    
    @Test
    public void testSave(){
        //创建一个部门对象
        Department d1 = new Department();
        d1.setDname("研发部");
        
        //创建两个员工对象
        Employee e1 = new Employee();
        e1.setEname("张三");
        e1.setPhone("13111111111");
        Employee e2 = new Employee();
        e2.setEname("李四");
        e2.setPhone("18523222222");
        
        //设置对象关联
//        d1.getEmployeeList().add(e1);
//        d1.getEmployeeList().add(e2);
        e1.setDepartment(d1);
        e2.setDepartment(d1);
        
        //获取Session
        Session session = sessionFactory.openSession();
        //开始事务
        Transaction t = session.beginTransaction();
        try {
            //添加数据
            session.save(d1);
            session.save(e1);
            session.save(e2);
            //提交事务
            t.commit();
        } catch (RuntimeException e) {
            //有异常则回滚事务
            t.rollback();
            e.printStackTrace();
        } finally {
            //关闭session
            session.close();
        }
    }
    
    
}

1 Hibernate: insert into department (dname) values (?)
2 Hibernate: insert into employee (departmentId, ename, phone) values (?, ?, ?)
3 Hibernate: insert into employee (departmentId, ename, phone) values (?, ?, ?)

这样部门方就不会去维护外键关系了。但是有一个问题，对象上就没有关联了，我们要做的是对象上要互相关联，数据库方面只让一方去维护关系即可。

对象上如果不关联，因为部门和员工添加到数据库后，是持久化状态，存在于session缓存中，那session操作缓存中这几个对象时，部门就没有关联员工了，那么就还得再查询一次数据库，这不是想要的结果。

这时就要用到mappedBy属性了。

在一的一方配置@OneToMany(mappedBy="department")，将维护权交由多的一方来维护；

那为什么不让多的一方交出维护权，让一的一方来维护呢？上面的实验也表明了如果让一的一方来维护，始终都会多出两条update语句，因为外键是在多的这一方的，所以维护权应该交由多的一方。

部门类的配置：第36行和第37行的配置，部门部门交出维护权利，让对方来维护

package com.lizhou.entity.test;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.CascadeType;
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.OneToMany;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;

/**
 * 部门：与员工一对多关系
 * @author bojiangzhou
 *
 */
@Entity
@Table(name="department")
public class Department {
    
    @Id
    @GeneratedValue(generator="_native")
    @GenericGenerator(name="_native", strategy="native")
    private int id; //ID
    
    @Column(length=20)
    private String dname; //部门名称
    
    @OneToMany(mappedBy="department")
    private List<Employee> employeeList = new ArrayList<>(); //部门下的员工集合

    // get/set方法62     
}

员工类的配置不变。

调用testSave时，部门和员工再对象上依然是关联的：第46-49行

package com.lizhou.action.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.lizhou.entity.test.Department;
import com.lizhou.entity.test.Employee;

/**
 * 测试类
 * @author bojiangzhou
 *
 */

public class TestAction {
    
    private static SessionFactory sessionFactory = null;
    
    static {
        //读取classpath中applicationContext.xml配置文件
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取session中配置的sessionFactory对象
        sessionFactory = (SessionFactory) applicationContext.getBean("sessionFactory");
    }
    
    @Test
    public void testSave(){
        //创建一个部门对象
        Department d1 = new Department();
        d1.setDname("研发部");
        
        //创建两个员工对象
        Employee e1 = new Employee();
        e1.setEname("张三");
        e1.setPhone("13111111111");
        Employee e2 = new Employee();
        e2.setEname("李四");
        e2.setPhone("18523222222");
        
        //设置对象关联
        d1.getEmployeeList().add(e1);
        d1.getEmployeeList().add(e2);
        e1.setDepartment(d1);
        e2.setDepartment(d1);
        
        //获取Session
        Session session = sessionFactory.openSession();
        //开始事务
        Transaction t = session.beginTransaction();
        try {
            //添加数据
            session.save(d1);
            session.save(e1);
            session.save(e2);
            //提交事务
            t.commit();
        } catch (RuntimeException e) {
            //有异常则回滚事务
            t.rollback();
            e.printStackTrace();
        } finally {
            //关闭session
            session.close();
        }
    }
    
    
}

控制台打印的语句：只有三条插入语句，没有更新语句了

1 Hibernate: insert into department (dname) values (?)
2 Hibernate: insert into employee (departmentId, ename, phone) values (?, ?, ?)
3 Hibernate: insert into employee (departmentId, ename, phone) values (?, ?, ?)

这里遇到一个问题：如果配置mappedBy属性的同时加上@JoinColumn会抛出异常，所以不能同时使用@JoinColumn和mappedBy；因为@JoinColumn本身就是自己来维护外键，和mappedBy冲突了。--->>>不知道这样理解正确否！！^_^

总结：mappedBy属性跟xml配置文件里的inverse一样。在一对多或一对一的关系映射中，如果不表明mappedBy属性，默认是由本方维护外键。但如果两方都由本方来维护的话，会多出一些update语句，性能有一定的损耗。

解决的办法就是在一的一方配置上mappedBy属性，将维护权交给多的一方来维护，就不会有update语句了。

至于为何要将维护权交给多的一方，可以这样考虑：要想一个国家的领导人记住所有人民的名字是不可能的，但可以让所有人民记住领导人的名字！

注意，配了mappedBy属性后，不要再有@JoinColumn，会冲突！

OK!!!