Hibernate-一对多和多对一

一对多和多对一的实例有很多，下面我们以员工和部门为例子:

首先创建主配置文件，设置jdbc的配置和连接池

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>  
    <session-factory>
    	<!-- jdbc驱动类 -->
        <property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
        <!-- jdbc的url -->
        <property name="hibernate.connection.url">jdbc:oracle:thin:@127.0.0.1:1521:XE</property>
        <!-- jdbc的用户名 -->
        <property name="hibernate.connection.username">evan</property>
        <!-- jdbc的密码 -->
        <property name="hibernate.connection.password">123</property>
		<!-- 打印映射信息 -->
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">create</property>
        <!-- 方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</property>
        
        <!-- 配置c3p0连接池 -->
        <!-- 最大连接数 -->
        <property name="hibernate.c3p0.max_size">20</property>
        <!-- 最小连接数 -->
        <property name="hibernate.c3p0.min_size">1</property>
        <!-- 获取连接超时时间，若超过这个时间会抛出异常，单位:毫秒 -->
        <property name="hibernate.c3p0.timeout">5000</property>
        <!-- 创建PreparedStatement对象的最大数量 -->
        <property name="hibernate.c3p0.max_statements">100</property>
        <!-- 每个指定时间检查连接池中的空闲连接，时间单位:秒 -->
        <property name="hibernate.c3p0.idle_test_period">150</property>
        <!-- 当连接池使用完毕，c3p0再和数据库建立n个连接放置到连接池中 -->
        <property name="hibernate.c3p0.acquire_increment">2</property>
        <!-- 每次都验证连接是否可用 -->
        <property name="hibernate.c3p0.validate">true</property>
        <!-- 将session与当前线程绑定 -->
        <property name="current_session_context_class">thread</property>
        <!-- 映射路径 -->
        <!-- <mapping resource="cn/qblank/hibernate/entity/stu.hbm.xml"/> -->
        <!-- <mapping resource="cn/qblank/hibernate/entity/employee.hbm.xml"/>
        <mapping resource="cn/qblank/hibernate/entity/dept.hbm.xml"/> -->
   	</session-factory>
</hibernate-configuration>

创建dept实体类和employee实体类

Dept.java

package cn.qblank.hibernate.entity;

import java.util.HashSet;
import java.util.Set;

public class Dept {
	private int deptId;
	private String deptName;
	// 【一对多】 部门对应的多个员工
	private Set<Employee> emps = new HashSet<Employee>();
	
	
	public int getDeptId() {
		return deptId;
	}
	public void setDeptId(int deptId) {
		this.deptId = deptId;
	}
	public String getDeptName() {
		return deptName;
	}
	public void setDeptName(String deptName) {
		this.deptName = deptName;
	}
	public Set<Employee> getEmps() {
		return emps;
	}
	public void setEmps(Set<Employee> emps) {
		this.emps = emps;
	}
	@Override
	public String toString() {
		return "Dept [deptId=" + deptId + ", deptName=" + deptName + ", emps="
				+ emps + "]";
	}
	
	
}

Employee.java

package cn.qblank.hibernate.entity;

public class Employee {
	private int empId;
	private String empName;
	private double salary;
	// 【多对一】员工与部门
	private Dept dept;
	
	public int getEmpId() {
		return empId;
	}
	public void setEmpId(int empId) {
		this.empId = empId;
	}
	public String getEmpName() {
		return empName;
	}
	public void setEmpName(String empName) {
		this.empName = empName;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	public Dept getDept() {
		return dept;
	}
	public void setDept(Dept dept) {
		this.dept = dept;
	}
	@Override
	public String toString() {
		return "Employee [empId=" + empId + ", empName=" + empName
				+ ", salary=" + salary + ", dept=" + dept + "]";
	}
		
}

然后配置映射文件

employee.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.qblank.hibernate.entity">
	<class name="Employee" table="t_employee">
		<id name="empId" column="empid" type="int">
			<generator class="sequence">
				<param name="sequence">t_employee_seq</param>
			</generator>			
		</id>
		<property name="empName" column="empName" type="string"></property>
		<property name="salary" column="salary" type="double"></property>
		<!-- 与部门之间的关系  多对一 -->
		<!-- 
			多对一映射配置
			Employee 映射关键点：
			1.  映射的部门属性 (name) ：  dept
			2.  映射的部门属性，对应的外键字段(column): dept_id
			3.  部门的类型class : Dept
		 -->
		<many-to-one name="dept" column="dept_id" class="Dept"></many-to-one>
		
	</class>
</hibernate-mapping>

dept.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
      
<hibernate-mapping package="cn.qblank.hibernate.entity">
	<class name="Dept" table="t_dept">
		<id name="deptId" column="deptId" type="int">
			<generator class="sequence">
				<param name="sequence">t_dept_seq</param>
			</generator>
		</id>
		<property name="deptName" column="deptName" type="string"></property>
		<!-- 一对多-->
		<!-- 
			一对多关联映射配置  （通过部门管理到员工）
			Dept 映射:
			1.  指定 映射的集合属性(name)： "emps"
			2.  集合属性对应的集合表： "t_employee"
			3.  集合表的外键字段   "t_employee. dept_id"
			4.  集合元素的类型
			inverse=false  set集合映射的默认值: 表示有控制权
		 -->
		<set name="emps" table="t_employee" cascade="save-update,delete">
			<key column="dept_id"></key>
			<one-to-many class="Employee"/>
		</set>
	</class>	
</hibernate-mapping>

这样就配置完成了，下面我们就来测试一下（一对多中的一）少的一方

static {
	factory = new Configuration()
		.configure("hibernate.cfg.xml")
		.addClass(Dept.class)   
		.addClass(Employee.class)   // 测试时候使用
		.buildSessionFactory();
}
public static void main(String[] args) {
	save1();
}
public static void save1() {
	Session session = factory.openSession();
	// 部门对象
	Dept dept = new Dept();
	dept.setDeptName("应用开发部");
	// 员工对象
	Employee emp_zs = new Employee();
	Employee emp_ls = new Employee();
	emp_zs.setEmpName("张三");
	emp_ls.setEmpName("李四");
	// 关系
	dept.getEmps().add(emp_zs);
	dept.getEmps().add(emp_ls);
	try {
		trans = session.beginTransaction();
		// 保存
		session.save(emp_zs);
		session.save(emp_ls);
		session.save(dept); // 保存部门，部门下所有的员工  
		
		trans.commit();
		
	} catch (HibernateException e) {
		e.printStackTrace();
		trans.rollback();
	}finally{
		session.close();
	}
}

运行结果:

打印的sql语句如下:

插入对应的表数据

Hibernate: select t_employee_seq.nextval from dual
Hibernate: select t_employee_seq.nextval from dual
Hibernate: select t_dept_seq.nextval from dual
Hibernate: insert into t_employee (empName, salary, dept_id, empid) values (?, ?, ?, ?)
Hibernate: insert into t_employee (empName, salary, dept_id, empid) values (?, ?, ?, ?)
Hibernate: insert into t_dept (deptName, deptId) values (?, ?)

将两个表进行关联起来（即将dept_id的值修改为与dept表对应的数据）

Hibernate: update t_employee set dept_id=? where empid=?
Hibernate: update t_employee set dept_id=? where empid=?

下面我们就来测试多的一方（一对多中的多）

public static void save2() {
	Session session = factory.openSession();
	// 部门对象
	Dept dept = new Dept();
	dept.setDeptName("软件测试部");
	// 员工对象
	Employee emp_zs = new Employee();
	emp_zs.setEmpName("王大大");
	Employee emp_ls = new Employee();
	emp_ls.setEmpName("evan");
	// 关系
	emp_zs.setDept(dept);
	emp_ls.setDept(dept);	
	try {
		trans = session.beginTransaction();
		// 保存
		session.save(dept); // 先保存一的方法
		session.save(emp_zs);
		session.save(emp_ls);// 再保存多的一方，关系回自动维护(映射配置完)
		trans.commit();
	} catch (HibernateException e) {
		e.printStackTrace();
		trans.rollback();
	}finally{
		session.close();
	}
}

运行结果如下:

打印的sql语句如下:

Hibernate: select t_dept_seq.nextval from dual
Hibernate: select t_employee_seq.nextval from dual
Hibernate: select t_employee_seq.nextval from dual
Hibernate: insert into t_dept (deptName, deptId) values (?, ?)
Hibernate: insert into t_employee (empName, salary, dept_id, empid) values (?, ?, ?, ?)
Hibernate: insert into t_employee (empName, salary, dept_id, empid) values (?, ?, ?, ?)

我们可以发现，这种相对于上面少了两条update语句

这是因为先插入的是dept表获取到数据后再插入employee表,所以不需要再将数据进行修改

因此我们推荐使用第二种方法：先插入少的一方的表，再插入多的一方的表