映射：一对多（部门对员工）和多对一（员工对部门）
Posted 古兰精
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了映射：一对多（部门对员工）和多对一（员工对部门）相关的知识，希望对你有一定的参考价值。
package dao.po;
import java.util.Set;
//部门类
public class Department{
private int id;//部门的ID
private String name;//部门的名称
private Set<Employee> emps;//部门下的所有员工 (一对多关系)
}
package dao.po;
//员工类
public class Employee{
private int id;// 员工的ID
private String name;// 员工的名称
private Department depart;//员工所在部门 (是多对一关系)
}
XML：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="dao.po">
<class name="Department">
<id name="id">
<generator class="native"/>
</id>
<property name="name" not-null="true" length="255" column="name"/>
<set name="emps"> <!-- emps 是Department的一个属性 -->
<key column="depart_id"></key> <!-- 通过员工表的 depart_id字段来关联,它是字段名 -->
<one-to-many class="Employee"/> <!-- emps的类型是Employee -->
</set>
</class>
</hibernate-mapping>
下面是重点：
<set name="emps"> <!-- emps 是Department的一个属性 -->
<key column="depart_id"></key> <!-- 通过员工表的 depart_id字段来关联,它是字段名 -->
<one-to-many class="Employee"/> <!-- emps的类型是Employee -->
</set>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="dao.po">
<class name="Employee">
<id name="id">
<generator class="native"/>
</id>
<property name="name" not-null="true" length="255" column="`name`"/>
<!-- 这里做多对一映射 -->
<!-- name="depart"是Employee类的属性名 -->
<!-- column="depart_id" 是表中字段名 -->
<many-to-one name="depart" column="depart_id" not-null="true"></many-to-one>
</class>
</hibernate-mapping>
一对多 (一个部门 对 多个员工)：查询部门(部门下有员工)
public static void main(final String[] args){
final Department de = query(2);
final Set<Employee> set = de.getEmps(); //本部门的所有员工
for (final Employee em : set){
System.out.println(em.getName());
}
}
/**
* 查询部门(部门下有员工)
* @param id 部门ID
* @return 部门对象
*/
public static Department query(final int id){
Session session = null;
try{
session = HibernateUtil.getSeesion();
final Transaction tx = session.beginTransaction();
final Department de = (Department) session.get(Department.class, id); //按ID查
//因为 部门的 "员工" 属性会懒加载,
//在session关闭后,调用de.getEmps()无法取到员工信息
//所以这里用 Hibernate.initialize(de.getEmps()) 提前加载一下.
Hibernate.initialize(de.getEmps());
tx.commit();
return de;
}finally{
if (session != null){
session.close();
}
}
}
二、多对一（员工对部门）
package dao.po;
// 员工类
public class Employee {
private int id; // 员工的ID
private String name; // 员工的名称
private Department depart; //员工所在部门, 是多对一关系
}
package dao.po;
//部门类
public class Department {
private int id; //部门的ID
private String name; //部门的名称
}
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="dao.po">
<class name="Employee">
<id name="id">
<generator class="native"/>
</id>
<property name="name" not-null="true" length="255" column="`name`"/>
<!-- 这里做多对一映射 -->
<!-- name="depart"是Employee类的属性名 -->
<!-- column="depart_id" 是表中字段名 -->
<!-- 注意:下面没有非空 约束 , 很多情况,外键是有非空约束的, 一会后面说-->
<!--column="depart_id" 中的depart_id是Employee对象的depart属性映射为Employee表中的depart_id字段-->
<many-to-one name="depart" column="depart_id" ></many-to-one>
</class>
</hibernate-mapping>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="dao.po">
<class name="Department">
<id name="id">
<generator class="native"/>
</id>
<property name="name" not-null="true" length="255" column="`name`"/>
</class>
</hibernate-mapping>
保存员工 和 部门：
package dao;
import org.hibernate.Session;
import org.hibernate.Transaction;
import dao.po.Department;
import dao.po.Employee;
//多对一的例子 , 多个员工 对 一个部门
public class Many2One{
public static void main(final String[] args){
add(); //添加两个员工, 一个部门
}
//添加两个员工, 一个部门
public static void add(){
final Department depart = new Department(); //部门
depart.setName("技术部");
final Employee em1 = new Employee(); //员工 一
em1.setName("赵磊");
em1.setDepart(depart);
final Employee em2 = new Employee(); //员工 二
em2.setName("陈加俊");
em2.setDepart(depart);
Session session = null;
try{
session = HibernateUtil.getSeesion();
final Transaction tx = session.beginTransaction();
session.save(depart); //先插入部门
session.save(em1); //后插入员工, 因为员工的外键是 部门
session.save(em2);
tx.commit();
}finally{
if (session != null){
session.close();
}
}
}
}
注意：保存的顺序:
第一种：
session.save(depart); //先插入部门
session.save(em1); //后插入员工, 因为员工的外键是 部门
session.save(em2);
输出的SQL:
Hibernate: insert into Department (`name`) values (?)
Hibernate: insert into Employee (`name`, depart_id) values (?, ?)
Hibernate: insert into Employee (`name`, depart_id) values (?, ?)
第二种：
session.save(em1); //先插入员工
session.save(em2);
session.save(depart); //后插入部门
输出的SQL：
Hibernate: insert into Employee (`name`, depart_id) values (?, ?)
Hibernate: insert into Employee (`name`, depart_id) values (?, ?)
Hibernate: insert into Department (`name`) values (?)
Hibernate: update Employee set `name`=?, depart_id=? where id=?
Hibernate: update Employee set `name`=?, depart_id=? where id=?
这里多了两句 update，要 注意：如果Employee.hbm.xml 中外键有非空约束，如下：保存时只能用" 第一种 "顺序，用了第二种，先插入员工，但depart_id字段为空，会异常，不能插入。
<many-to-one name="depart" column="depart_id" not-null="true"></many-to-one>
我们来查询一个员工，注意"部门"：
//测试查询
public static void main(final String[] args){
final Employee em = query(7);
//员工的部门 , 执行Hibernate.initialize()后, 在session关闭前就取得了部门.
//若没有执行Hibernate.initialize(), 下面会抛异常.
System.out.println(em.getDepart().getName());
}
//查询一个员工出来
public static Employee query(final int id){
Session session = null;
try{
session = HibernateUtil.getSeesion();
final Transaction tx = session.beginTransaction();
final Employee em = (Employee) session.get(Employee.class, id); //按ID查
//因为 员工的 "部门" 属性会懒加载,
//在session关闭后,调用em.getDepart()无法取到部门信息
//所以这里用 Hibernate.initialize(em.getDepart()) 提前加载一下.
//是em.getDepart() 而不是em
Hibernate.initialize(em.getDepart());
tx.commit();
return em;
}finally{
if (session != null){
session.close();
}
}
}
输出的SQL是：
Hibernate: select employee0_.id as id1_0_, employee0_.`name` as name2_1_0_, employee0_.depart_id as depart3_1_0_ from Employee employee0_ where employee0_.id=?
以上是关于映射：一对多（部门对员工）和多对一（员工对部门）的主要内容，如果未能解决你的问题，请参考以下文章