首先应该清楚多对一和一对多只是站在不同的角度看待问题，其本质是一样的。在思考这个问题的时候，不要把这两个概念混在一起，这样不容易理解，而要分开，站在不同的角度去解决同一个问题。
就拿员工和部门的例子来说，我们站在不同的角度，可能会遇到如下的几种情况：
站在员工的角度看，是多对一的关系：
1、来了新员工，但是还不知道该分配到哪个部门，只有先把员工保存到员工表中，部门那一列设为空，待以后再更新其部门信息
2、来了新员工，并且确定了该员工分配到哪个部门，则将员工的完整信息保存到员工表中
站在部门的角度看，是一对多的关系：
1、成立了新部门，要向其中添加一些新员工
2、要撤销一个部门，这时，这个部门中的员工的部门信息，全部置为空
此外应注意以下几个问题：
1、若是保存员工，说明表中还没有这个员工的id，在保存的时候，设置其id属性的时候，就不要设置，用默认的就可以，这样系统会自动给这个员工分配一个id的
2、若是更新某个员工，说明员工表中已经有了这个员工的id，在更新的时候，一定要指明其id，才可以找到这个员工
3、无论是站在部门还是站在员工的角度，即无论是一对多还是多对一的关系，映射到数据库中的表的关系都是一样的，就相当于是两个表的关系的两种实现方式，但最终的结果是一样的。
下面，我们来看看如何具体的去实现上面提到的几种情况：
首先建立两个类：Department和Employee
package com.suo.domain;
import java.util.Set;
public class Department {
private int id;
private String name;
private Set<Employee> emps;//用集合来存储员工
……//set/get方法
}
package com.suo.domain;
public class Employee {
private int id;
private String name;
private Department depart;//注意这里是以部门的对象来作为员工的属性的，这个思想很关键，是建立起部门和员工关联的关键
……//set/get方法
}
Employee的映射文件：
<hibernate-mapping package="com.suo.domain">
<class name="Employee">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="depart" column="depart_id"></many-to-one>
<!-- many-to-one指明了外键 ，会根据反射机制，找到要和Employee建立多对一关系的类，该列默认的是可以为空的-->
</class>
</hibernate-mapping>Department的映射文件：
<hibernate-mapping package="com.suo.domain">
<class name="Department">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="emps">
<key column="depart_id"/><!-- key指明了员工表中的外键-->
<one-to-many class="Employee"/><!-- one-to-many指明了和哪个类进行一对多的映射 -->
</set>
<!--
用set标签表示Department中的员工集合的属性，这个属性并没有映射到数据库中的部门表中，
即部门表中，并没有emps这样的一个列。
-->
</class>
</hibernate-mapping>配置文件就不贴出来了……
然后再建立一个dao层的类：Many_VS_One，方便调用：
package com.suo.hibernate.impl;
import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.suo.domain.Employee;
import com.suo.hibernate.util.HibernateUtil;
public class Many_VS_One {
public void saveObject(Object obj) {
Session session=null;
Transaction transaction=null;
try{
session=HibernateUtil.getSession();//获得一个连接
transaction=session.beginTransaction();//开启一个事务
session.save(obj);
transaction.commit();
}catch(HibernateException e){
if(transaction!=null){
transaction.rollback();
}
e.printStackTrace();
}finally{
if(session!=null){
session.close();
}
}
}
public void updateObject(Object obj) {
Session session=null;
Transaction transaction=null;
try{
session=HibernateUtil.getSession();//获得一个连接
transaction=session.beginTransaction();//开启一个事务
session.update(obj);
transaction.commit();
}catch(HibernateException e){
if(transaction!=null){
transaction.rollback();
}
e.printStackTrace();
}finally{
if(session!=null){
session.close();
}
}
}
public void deleteObject(Object obj) {
Session session=null;
Transaction transaction=null;
try{
session=HibernateUtil.getSession();//获得一个连接
transaction=session.beginTransaction();//开启一个事务
session.delete(obj);
transaction.commit();
}catch(HibernateException e){
if(transaction!=null){
transaction.rollback();
}
e.printStackTrace();
}finally{
if(session!=null){
session.close();
}
}
}
public Employee queryEmp(int empId){
Session session=null;
try{
session=HibernateUtil.getSession();
Employee emp=(Employee)session.get(Employee.class, empId);//这里会执行一次查询employee的语句
System.out.println(emp.getDepart().getName());//这里会执行一次查询department的语句
Hibernate.initialize(emp.getDepart());//初始化代理，即初始化一个持久态的对象，加上这一句，才能在外部查询
return emp;
}catch(HibernateException e){
e.printStackTrace();
return null;
}finally{
if(session!=null){
session.close();
}
}
}
}
接下来，加在Test中解决问题了：
站在员工的角度看，是多对一的关系：
1、来了新员工，但是还不知道该分配到哪个部门，只有先把员工保存到员工表中，部门那一列设为空，待以后再更新其部门信息
这个很简单，只要在设置新增的员工属性的时候，不要设置他的部门属性，就可以了，注意，也不要设置他的id属性，全都用默认值，代码如下：
public static void main(String[] args) {
Many_VS_One mvso=new Many_VS_One();
Employee e1=new Employee();
e1.setName("suo");
Employee e2=new Employee();
e2.setName("piao");
mvso.saveObject(e1);
mvso.saveObject(e2);
}
现在，确定了这两个员工的部门信息，那么就要更新这两个员工的部门了，这里我们假设将这两个员工都分配到了depart1，实现代码如下：
public static void main(String[] args) {
Many_VS_One mvso=new Many_VS_One();
Department depart=new Department();
depart.setId(1);
Employee e1=new Employee();
e1.setId(1);
e1.setName("suo");
e1.setDepart(depart);//这句看似简单，但是很关键，它建立起了两个对象之间的关联
Employee e2=new Employee();
e2.setId(2);
e2.setName("piao");
e2.setDepart(depart);
mvso.updateObject(e1);
mvso.updateObject(e2);
}
2、来了新员工，并且确定了该员工分配到哪个部门，则将员工的完整信息保存到员工表中
如果理解了1中的情况，那么这种情况，就很简单了，只要在保存员工的时候，设置上部门属性就可以了，但是不要忘了在new出来部门对象之后，要指定它在数据库中的id，否则，hibernate会认为这个部门对象是个瞬时状态的对象，没有在数据库中。而在new出来员工对象后，不要设置他的id属性啊，因为数据库中，还没有员工的信息，此时对象还处于瞬时状态。实现代码如下：
public static void main(String[] args) {
Many_VS_One mvso=new Many_VS_One();
Department depart=new Department();
depart.setId(1);
Employee e1=new Employee();
e1.setName("suo");
e1.setDepart(depart);//这句看似简单，但是很关键，它建立起了两个对象之间的关联
Employee e2=new Employee();
e2.setName("piao");
e2.setDepart(depart);
mvso.saveObject(e1);
mvso.saveObject(e2);
}
站在部门的角度看，是一对多的关系：
1、成立了新部门，要向其中添加一些新员工
public static void main(String[] args) {
Many_VS_One mvso=new Many_VS_One();
Employee e1=new Employee();
e1.setName("suo");
Employee e2=new Employee();
e2.setName("piao");
Department depart=new Department();
Set<Employee> emps=new HashSet<Employee>();
emps.add(e1);
emps.add(e2);
depart.setName("depart1");
depart.setEmps(emps);
mvso.saveObject(e1);
mvso.saveObject(e2);
mvso.saveObject(depart);
} 2、 要撤销一个部门，这时，这个部门中的员工的部门信息，全部置为空
这一步其实应该看数据库是怎么设置的，主表是否能在从表存在引用的条件下删除，本例中，默认的设置是允许的。删除的时候也很简单，只要指定部门的id即可，同理，删除员工也是如此。如下：
public static void main(String[] args) {
Many_VS_One mvso=new Many_VS_One();
Department depart=new Department();
depart.setId(1);
mvso.deleteObject(depart);
}Hibernate: update Employee set depart_id=null where depart_id=?
Hibernate: delete from Department where id=?
1386
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
