hibernate学习之第十篇
级联和关系维护
Cascade 用来说明当对主对象进行某种操作时，是否对其关联的从对象也作类似的操作，常用的cascade：none,all,save-update,delete,lock,refresh,evict,replicate,persist,merge,delete-orphan(one-to-many).一般对many-to-many，many-to-many不设置级联，在<one-to-one>和<one-to-one>中设置级联。
inverse表示“是否放弃维护关联关系 ”（在java里两个对象产生关联时，对数据库表的影响），在one-to-many和many-to-many的集合定义中使用，inverse=“true”表示该对象不维护关联关系；该属性的值一般在使用有序集合时设置成false（注意hibernate的缺省值是false ）。
one-to-many维护关联关系就是更新外键。many-to-many维护关联关系就是在中间表增减记录。
注：配置成one-to-one的对象不维护关联关系。
接着上面的部门和员工的例子：
department的映射配置文件为：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="hibernate.collections">
<class name="Department">
<id name="id">
<generator class="native" />
</id>
<property name="name"/>
<map name="emps">
<key column="depart_id" />
<map-key type="string" column="name"/>
<one-to-many class="Employee" />
</map>
</class>
</hibernate-mapping>
程序：
static void add(){
Department depart = new Department();
depart.setName("depart");
Employee e1 = new Employee();
e1.setName("e1");
Employee e2 = new Employee();
e2.setName("e2");
Map<String, Employee> emps = new HashMap<String, Employee>();
emps.put(e1.getName(), e1);
emps.put(e2.getName(), e2);
depart.setEmps(emps);
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
//s.save(e1);
//s.save(e2);
s.save(depart);
tx.commit();
}
执行以上代码，程序出现异常：严重: Could not synchronize database state with session
org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance before flushing: hibernate.collections.Employee
在代码中，department知道了employee.s1和s2未持久化，使得保存department时出现异常。 把配置文件做一下修改，
<map name="emps" cascade="save-update" >
<key column="depart_id" />
<map-key type="string" column="name"/>
<one-to-many class="Employee" />
</map>
再运行以上代码，就可以正确的保存s1和s2了，因为对他们进行了级联操作，保存department时，也save了employee。
级联操作，可以把上面的选项以逗号分隔开，逐一添加即可。如：
<map name="emps" cascade="save-update，delete，refresh" ></map>
但级联操作也要慎用，要根据自己具体的业务需求来进行相关配置。
还有：
在修改department.hbm.xml配置文件：
<map name="emps">
<key column="depart_id" />
<map-key type="string" column="name"/>
<one-to-many class="Employee" />
</map>
执行以下代码：
static void add() {
Department depart = new Department();
depart.setName("depart");
Employee e1 = new Employee();
e1.setName("e1");
e1.setDepart(depart);
Employee e2 = new Employee();
e2.setName("e2");
e2.setDepart(depart);
Map<String, Employee> emps = new HashMap<String, Employee>();
emps.put(e1.getName(), e1);
emps.put(e2.getName(), e2);
depart.setEmps(emps);
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
s.save(e1);
s.save(e2);
s.save(depart);
tx.commit();
}
hibernate输出以下sql语句：
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=?
Hibernate: update Employee set depart_id=?, name=? where id=?
Hibernate: update Employee set depart_id=?, name=? where id=?
上面的三条插入语句很容易理解。下面的四条更新语句分别对应：
e1.setDepart(depart);
e2.setDepart(depart);
depart.setEmps(emps);
可以验证，如果把 e1.setDepart(depart); e2.setDepart(depart);这两句注释掉，产生的更新语句只有两条：
Hibernate: insert into Employee (name, depart_id) values (?, ?)
Hibernate: insert into Department (name) values (?)
Hibernate: update Employee set depart_id=?, name=? where id=?
Hibernate: update Employee set depart_id=?, name=? where id=?
由此可见，hibernate根据程序代码的执行，采取相应的操作。其实更新语句只需做一次就够了 。对于数据库而言，在程序中，告诉部门有哪些员工，或者告诉员工，你属于那个部门。对于前者，部门需要维护关系。对于后者，员工需要维护关系。他们最终都可以在数据库表中表达出部门和员工的关系。在程序中对两者都手动设定了双方的关系，这样也可以，但显得有些冗余（做了两次更新）。因此，双方都会对关系进行维护，所以，双方都会向数据库提交设定关系的请求，这就带来了数据的重复设置，正如上面的四条更新语句。
解决问题的方案是：我们可以让其中一方放弃对关系的维护。 我们一般让一方放弃对关系的维护，让多方维护。这也比较好理解，正如现实生活中，老师不一定要记住所有学生，但学生记住老师则相对比较容易。
充：inverse不能在有序的集合中使用 。比如一般不这样配置：
<list name="emps" inverse="true"></list> 原因是，list需要维护添加的顺序，如果放弃了关系的维护，那么顺序就也不回得到hibernate的管理。这无疑是矛盾的。
只要在配置文件中做一下修改即可：
<map name="emps" inverse="true">
<key column="depart_id" />
<map-key type="string" column="name"/>
<one-to-many class="Employee" />
</map>
在执行以下代码：
Department depart = new Department();
depart.setName("depart");
Employee e1 = new Employee();
e1.setName("e1");
e1.setDepart(depart);
Employee e2 = new Employee();
e2.setName("e2");
e2.setDepart(depart);
Map<String, Employee> emps = new HashMap<String, Employee>();
emps.put(e1.getName(), e1);
emps.put(e2.getName(), e2);
depart.setEmps(emps);
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
s.save(e1);
s.save(e2);
s.save(depart);
tx.commit();
执行的sql语句为：
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=?
分析 ：inverse="true"表示放弃对关系的维护。所以上面的两条更新语句是由Employee的setDepart方法产生的。因为关系有Employee来维护。由于department放弃了关系的维护，即使在代码中做了 depart.setEmps(emps)操作，hibernate也会忽略。通过以上方法，可以有效的减少数据库的操作次数，同时不影响关系的建立。
所谓的关系维护，就是更新外键。
改进：
从以上显示的sql语句，可以看出，在插入employee数据是也是插入了depart_id的，只不过是空值，然后插入department，这时就有了depart_id了，这时就去更新employee表，把depart_id更新。其实可以先保存department，这时一开始就有depart_id了，就不会有更新语句了。
代码如下：
static void add() {
Department depart = new Department();
depart.setName("depart");
Employee e1 = new Employee();
e1.setName("e1");
e1.setDepart(depart);
Employee e2 = new Employee();
e2.setName("e2");
e2.setDepart(depart);
Map<String, Employee> emps = new HashMap<String, Employee>();
emps.put(e1.getName(), e1);
emps.put(e2.getName(), e2);
depart.setEmps(emps);
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
s.save(depart);
s.save(e1);
s.save(e2);
tx.commit();
}
输出的sql语句为：
Hibernate: insert into Employee (name, depart_id) values (?, ?)
Hibernate: insert into Employee (name, depart_id) values (?, ?)
心得： 根据程序执行过程中，打印输出的sql语句，只需冷静地分析程序的执行过程，不断地改进调优，可以有效的改善程序的性能。