hibernate级联保存更新、删除

1、级联保存和更新
当Hibernate持久化一个临时对象时，在默认情下，他不会自动持久化所关联的其他临时对象，如果希望当持久化对象时把他所关联的所有临时对象进行持久化的话，可以把的cascade属性设置为："save-update" ，cascade的默认属性值为none。

cascade:设置操作对象时的级联操作，即层级之间的连锁操作，可取：
- save-update ：表示当保存和更新当前对象(即insert和update语句时)，会级联保存和更新与他关联的对象
- all ：表示任何情况下都会进行级联操作，即对一个对象进行操作，也会对和他关联的其他对象进行同样的操作
- delete ：表示在执行delete时，进行级联操作，删除和他关联的对象
- none ：表示任何情况下，都不会进行级联操作

2、<set>元素的inverse属性：

在运行上面的程序时，如果hibernate的"show-sql"设置为true时，就会看到Hibernate会生成很多sql语句，其实很多sql语句都是重复的，为了解决这个问题，我们可以利用在<set>标签中加上inverse属性。术语：inverse是指反转的意思，在Hibernate中，表示关联关系中的方向关联关系中，inverse="false"的主控方，由主动方负责维护对象关系我们在customer对象的对象配置文件中加上

<set name="orders"  cascade="save-update" inverse="true">
<key  column="c_id" > </key>
<one-to-many class="net.mbs.mypack.Order " />
</set>

声明在Customer和Order的双向关联关系中，Customer端的关联只是Order端关联的镜象（即Order端是主空端，负责维护Customer和order对象之间的关联关系），当hibernate探测到持久化对象Customer或Order的状态发生变化时(主要是关联关系的改变),仅按照Order对象的状态的变化来同步更新数据库。
按次配置，如果在程序中，我们仅仅使用Customer.getOrder().add(order)（涉及了和Order的关联关系的改变），是不能让数据库跟对象的变化来进行数据库同步更新的，只有利用Order对象的方法改变的Order对象状态(eg：order.setCustomer(customer)----涉及到了和Customer的关联关系的改变)时，数据库才会根据变化来同步更新数据库，即只有主控方的状态（涉及到了和另一方面的关联关系的改变）发生了变化后，才会触发对象和数据库的同步更新。

实例：

Customer 和 Orders 是一对多的关系，Orders和Customer是多对一关系，即这两个双向关联.

Customer 和Bid是一对一的关系，一对一的关系就不存在双向和单向了

 

如下是他们的类：

customer.java

 

Java代码  

1. package com.reflesh;
2. 
   
3. import java.util.Date;
4. import java.util.HashSet;
5. import java.util.Set;
6. 
   
7. public class Customer {
8. 
   
9. private int id;
10. private String name;
11. private Date date;
12. private String tele;
13. private Bid bidId;
14. private Set ordersId = new HashSet();           //省略set 和get 方法
15. }

 

orders.java

Java代码  

1. public class Orders {
2. private Long orderId;
3. private String name;
4. private Customer customer;

Java代码  

1. // 省略掉equals和haseCode（）

Java代码  

1. Bid.java

Java代码  

1. <pre class="java" name="code">private Long bidId;
2. private String name;
3. private Customer customerBId;
4. 
   
5. 
   
6. }</pre>
7. 
   

Java代码  

1. customer.hbm.xml

Java代码  

1. <id name="id" column="customerId" type="int">
2. <generator class="sequence">
3. <param name="sequence">customerId</param>
4. </generator>
5. </id>
6. <property name="name"  column="name"  type="string" />
7. <property name="date"     column="orderDate"     type="date"/>
8. <property name="tele"  column="telephone"  type="string"/>
9. <set name="ordersId"   cascade="save-update" inverse="true">
10. <key column="customerOId"/>
11. <one-to-many class="com.reflesh.Orders" />
12. </set>
13. 
    
14. <one-to-one name="bidId" class="com.reflesh.Bid" property-ref="customerBId" cascade="save-update"/>
15. 
    

 orders.hbm.xml

Java代码  

1. <id name="orderId" column="orderId2" type="long">
2. <generator class="sequence">
3. <param name="sequence">seq_order</param>
4. </generator>
5. </id>
6. <property name="name"  column="name"  type="string" />
7. <many-to-one
8. name="customer"
9. class="com.reflesh.Customer"
10. column="customerOId"
11. 
    
12. />

 bid.hbm.xml

Java代码  

1. <id name="bidId" column="bidId" type="long">
2. <generator class="sequence" >
3. <param name="sequence">seq_bid</param>
4. </generator>
5. </id>
6. <property name="name"  column="name"  type="string" />

Java代码  

1. <many-to-one name="customerBId" class="com.reflesh.Customer"
2. column="customerBId"  unique="true" />

 test.java

Java代码  

1. Session session =HibernateSessionFactory.getSession();
2. 
   

Java代码  

1. /* 关联类*/
2. Customer c = new Customer();
3. c.setName("bellwind");
4. Date date = RefleshActionHelper.FormatDate("2004-05-09", "yyyy-mm-dd");
5. c.setDate(date);
6. c.setTele("123456");
7. Serializable  id = null;
8. Orders o = new Orders();
9. o.setName("订单1dfdf");
10. o.setCustomer(c);
11. Orders o2 = new Orders();
12. o2.setName("订单2");
13. o2.setCustomer(c);
14. c.getOrdersId().add(o);
15. c.getOrdersId().add(o2);
16. Bid bid = new Bid();
17. bid.setName("ijd");
18. bid.setCustomerBId(c);
19. c.setBidId(bid);

Java代码  

1. /* 关联类完*/
2. try {
3. tr = session.beginTransaction();
4. id = session.save(c); //三个都保存
5. tr.commit();
6. } catch (Exception e) {
7. e.printStackTrace();
8. tr.rollback();
9. }
10. finally {
11. session.close();
12. }
13. return id;

 

说明：a,b,c为级联的步骤

a.在set属性上加 cascade="save-update"

b. 关联类 见代码test.java的注释

c. 保存customer一个就行了，因为customer表是主表，orders表的外键customerOId和Bid表的外键customerBId    都关系到customer表的主键；

注意：

a.一般都选择保存customer来级联保存orders和bids，不选择保存orders或者bids来级联保存customer；

b. 没有.inverse="true",执行如下语句

insert into customer (name, orderDate, telephone, customerId) values (?, ?, ?, ?)
Hibernate: insert into orders (name, customerOId, orderId2) values (?, ?, ?)
Hibernate: insert into orders (name, customerOId, orderId2) values (?, ?, ?)
Hibernate: insert into bid (name, customerBId, bidId) values (?, ?, ?)
Hibernate: update orders set customerOId=? where orderId2=?
Hibernate: update orders set customerOId=? where orderId2=?

有了inverse="true",执行如下语句
insert into customer (name, orderDate, telephone, customerId) values (?, ?, ?, ?)
Hibernate: insert into orders (name, customerOId, orderId2) values (?, ?, ?)
Hibernate: insert into orders (name, customerOId, orderId2) values (?, ?, ?)
Hibernate: insert into bid (name, customerBId, bidId) values (?, ?, ?)
可以看出减少了2条语句，提高了性能

 

 

customer单向关联orders的步骤：

1.

customer.hbm.xml

Java代码  

1. <set name="ordersId"   cascade="save-update" inverse="true">
2. <key column="customerOId"/>
3. <one-to-many class="com.reflesh.Orders" />
4. </set>

 

2.orders.hbm.xml 不用配关联到customer， 删除<many-to-one >元素

3.orders类的customer属性删除

4.只需单向关联

Customer c = new Customer();

 Bid bid = new Bid();
c.setBidId(bid);

5.save(c) 就行了

注意：

如果是customer单向关联orders，那么inverse="true" 不可以少，否则orders表的外键为null，它需要

Hibernate: update orders set customerOId=? where orderId2=?
Hibernate: update orders set customerOId=? where orderId2=?

这两句来更新orders表的外键