Hibernate映射的关系问题

本文章目的是为了测试一对多的关系问题，所以配置信息都是以测试为目的的。

数据库：mysql

实体类：部门实体 Dept，员工实体 Employee

环境准备：

1 hibernate.cfg.xml配置文件
<hibernate-configuration>
<session-factory>
<!-- 1. 数据库连接配置 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql:///jdbc_demo</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<!-- 数据库方法配置     -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
<!-- 2. 其他相关配置 -->
<property name="hibernate.show_sql">true</property>
<property name="hibernate.format_sql">true</property>  -->
<property name="hibernate.hbm2ddl.auto">update</property>
<!-- 3. 加载所有映射 在测试类中手动的加载配置文件-->
</session-factory>
</hibernate-configuration>

2
Dept实体类
public class Dept {
private int deptId;
private String deptName;
// 【一对多】 部门对应的多个员工
private Set<Employee> emps = new HashSet<Employee>();
省略setter，getter...;
省略构造方法;
}
Employee 实体类
public class Employee {
private int empId;
private String empName;
private double salary;
// 【多对一】员工与部门
private Dept dept;
省略setter，getter...；
省略构造方法；
}

3 映射文件
Dept映射
<hibernate-mapping package="cn.itcast.b_one2Many">
<class name="Dept" table="t_dept">
<id name="deptId">
<generator class="native"></generator>
</id>
<property name="deptName" length="20"></property>
<set name="emps" cascade="save-update" inverse="true">
<key column="dept_id"></key>
<one-to-many class="Employee"/>
</set>
</class>
</hibernate-mapping>
Employee 映射
<hibernate-mapping package="cn.itcast.b_one2Many">
<class name="Employee" table="t_employee">
<id name="empId">
<generator class="native"></generator>
</id>
<property name="empName" length="20"></property>
<property name="salary" type="double"></property>
<many-to-one name="dept" column="dept_id" class="Dept" cascade="save-update"></many-to-one>
</class>
</hibernate-mapping>

上面的配置是一对多双向关联，呆会通过更改配置文件测试 一对多双向关联；多对一单向关联；一对多单向关联；三个的保存操作

测试：

1.一对多双向关联保存

public class App1_save {
private static SessionFactory sf;
static {
sf = new Configuration()
.configure()
.addClass(Dept.class)
.addClass(Employee.class)   // 测试使用，可以加载到映射文件，不用在hibernate.cfg.xml引入
.buildSessionFactory();
}

// 保存， 部门方 【一的一方法操作】
@Test
public void save() {
Session session = sf.openSession();
session.beginTransaction();
// 部门对象
Dept dept = new Dept();
dept.setDeptName("应用开发部");
// 员工对象
Employee emp_zs = new Employee();
emp_zs.setEmpName("张三2");
Employee emp_ls = new Employee();
emp_ls.setEmpName("李四2");
// 关系
dept.getEmps().add(emp_zs);
dept.getEmps().add(emp_ls);

// 保存
session.save(dept); // 保存部门，部门下所有的员工；在配置文件中有加入cascade="save-update",进行级联保存跟新
session.getTransaction().commit();
session.close();
}
}
保存成功。
/*  sql：
Hibernate: insert into t_dept (deptName) values (?)
Hibernate: insert into t_employee (empName, salary, dept_id) values (?, ?, ?)
Hibernate: insert into t_employee (empName, salary, dept_id) values (?, ?, ?)
Hibernate: update t_employee set dept_id=? where empId=?
Hibernate: update t_employee set dept_id=? where empId=?
*/

2.多对一单向关联；从多的一方保存

配置:多对一单向关联，顾名思义，就是在多的一方Employee保存，以及维护关系，所以在上面Dept类中可以设置private Set emps = new HashSet();该集合属性，映射文件也响删除该配置。

注:这里只贴出测试方法，类名和类的变量和上面一致

@Test
public void save4() {
Session session = sf.openSession();
session.beginTransaction();
// 部门对象
Dept dept = new Dept();
dept.setDeptName("应用开发部");
// 员工对象
Employee emp_zs = new Employee();
emp_zs.setEmpName("张三2");
Employee emp_ls = new Employee();
emp_ls.setEmpName("李四2");
// 关系,多的一方维护
emp_zs.setDept(dept);
emp_ls.setDept(dept);
// 保存
session.save(emp_zs);//在映射文件中一定要配置casecade="save-update"，否则不能实现关系的维护
session.save(emp_ls);
session.getTransaction().commit();
session.close();
}
保存成功，可以看出从多的一方保存，可以省去两条update语句。所以一般由多的一方维护关系，即在一的一方Dept中，set标签中设置inverse="true"
/*
Hibernate: insert into t_dept (deptName) values (?)
Hibernate: insert into t_employee (empName, salary, dept_id) values (?, ?, ?)
Hibernate: insert into t_employee (empName, salary, dept_id) values (?, ?, ?)
*/

3一对多单向关联

配置：在Employ实体类中可以删除， private Dept dept;该属性，相应的在映射文件中也删除配置，

注：实际上跟上面第一个测试是一样的测试代码，不同点是在配置文件上

@Test
public void save3() {
Session session = sf.openSession();
session.beginTransaction();
// 部门对象
Dept dept = new Dept();
dept.setDeptName("应用开发部");
// 员工对象
Employee emp_zs = new Employee();
emp_zs.setEmpName("张三2");
Employee emp_ls = new Employee();
emp_ls.setEmpName("李四2");
// 关系
dept.getEmps().add(emp_zs);
dept.getEmps().add(emp_ls);
// 保存
session.save(dept); // 保存部门，部门下所有的员工
session.getTransaction().commit();
session.close();
}
/*
Hibernate: insert into t_dept (deptName) values (?)
Hibernate: insert into t_employee (empName, salary) values (?, ?)
Hibernate: insert into t_employee (empName, salary) values (?, ?)
Hibernate: update t_employee set dept_id=? where empId=?
Hibernate: update t_employee set dept_id=? where empId=?
*/

总结：

1 没有设置cascade属性的话，在任何一方保存都会出现这个异常，因为在以一方维护，必须具有级联保存的权限

org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance before flushing:

2 在一对多单向关联单向关联中，设置了cascade=”save-update”外，不能将inverse设置为true，这个属性的作用是将控制权反转，默认为false，因为没了控制权，也就不能维护关联关系了

一对多的关系体现得最彻底的是父与子的关系，也就是一个父亲对应多个儿子，多个儿子对应一个父亲，儿子一定有父亲，父不一定有子。所以从这个关系上来说应该是以多的一方来维护关系，所以测试的第三个例子一般很少用，即单向一对多。

以上是自己的总结，如有疑问欢迎吐槽，渴望碰撞。