cascade和inverse分析

http://zhxing.iteye.com/blog/378434

cascade和inverse分析
首先感谢jianfeng008cn 的评论，让我能够再仔细回顾下之前的文章，由于之前的文章是从某地方转载的，那时对这两个概念也是有些模糊，导致转载到有错的文章了。转载的类似文章的地址：http://www.iteye.com/topic/200629

错误的地方：

Html代码
3.cascade和inverse有什么区别？  
 
可以这样理解，cascade定义的是关系两端对象到对象的级联关系；而inverse定义的是关系和对象的级联关系。在一对多映射中，一的一方要设<set (inverse="false") casecade="save-update" />，多的一方要设<many-to-one inverse=true (casecade="none") /> 

3.cascade和inverse有什么区别？

可以这样理解，cascade定义的是关系两端对象到对象的级联关系；而inverse定义的是关系和对象的级联关系。在一对多映射中，一的一方要设<set (inverse="false") casecade="save-update" />，多的一方要设<many-to-one inverse=true (casecade="none") />


在自己理解的基础上，然后结合hibernate 的文档，重新总结下这两个属性。。。如有错误，请给予指正，谢谢。。



1、cascade（级联）

   引用了《深入浅出 Hibernate》：级联（cascade）在Hibernate映射关系中，它指的是当主控方执行操作时，关联对象（被动方）是否同步执行同一操作，如主控方对象调用save-update或delete 方法时，是否同事对关联对象（被动方）进行save-update或delete。

  这里所说的主控方按我理解指的是:比如，User 类中有一Address属性，User和Address 是一对多的关系，然后当user.save(address);的时候，user就是主控方了。



2、inverse（控制方向反转）

   引用了《深入浅出 Hibernate》：在Hibernate 语义中，inverse指定了关联关系中的方向。关联关系中，inverse=false 的为主动方，由主动方负责维护关联关系。

   这里所说的关联关系按我理解指的是：为了维持两个实体类（表）的关系，而添加的一些属性，该属性可能在两个实体类（表）或者在一个独立的表里面，这个要看这双方直接的对应关系了：

ps：这里的维护指的是当主控放进行增删改查操作时，会同时对关联关系进行对应的更新。

   一对多：该属性在多的一方。应该在一方的设置 inverse=true ，多的一方设置 inverse=false（多的一方也可以不设置inverse属性，因为默认值是false），这说明关联关系由多的一方来维护。原因：该关联关系的属性在多的一方的表中，在维护关联关系的时候在多的一方容易维护。

   多对多：属性在独立表中。在任意一方设置inverse=true，另一方inverse=false；原因：如果两个多设置为true 的话，表示两方都对关联关系表（独立表）进行了同样的维护，其实只要一方维护就行了，效率上来说，这样设置是合理点的。

   一对一：其实是一对多的一个特例,inverse 的设置也是一样的，主要还是看关联关系的属性在哪一方，这一方的inverse=false。

   多对一：也就是一对多的反过来，没什么区别。

----------------------------------------------------------------------------------------------------------------------------

下面开始一个一对多双向关联的父子关系的例子，通过例子可以很好的理解这两者的概念.



父子类：

Java代码
public class Child {  
    private int id;  
    private String name;  
    private Parent parent;  
    public int getId() {  
        return id;  
    }  
 
        ````    other   geter 、setter`````  
}  
 
---------------------------------------------------------  
public class Parent {  
    private int id;  
    private String name;  
    private Set children;  
    public int getId() {  
        return id;  
    }  
        ````    other   geter 、setter`````  
} 

public class Child {
private int id;
private String name;
private Parent parent;
public int getId() {
return id;
}

        ````    other   geter 、setter`````
}

---------------------------------------------------------
public class Parent {
private int id;
private String name;
private Set children;
public int getId() {
return id;
}
        ````    other   geter 、setter`````
}

配置文件：

Xml代码
<hibernate-mapping> 
  <class name="model.Child"> 
    <id name="id"> 
      <generator class="native"></generator> 
    </id> 
    <property name="name"></property> 
    <many-to-one name="parent" column="parent_id" ></many-to-one> 
  </class> 
</hibernate-mapping> 
 
 
 
<hibernate-mapping> 
<class name="model.Parent" > 
   <id name="id"> 
     <generator class="native"></generator> 
   </id> 
   <property name="name" /> 
   <set name="children" cascade="all" inverse="true" >//请注意这里的变化  
     <key column="parent_id"/> 
     <one-to-many  class="model.Child"/> 
   </set> 
</class> 
</hibernate-mapping> 

<hibernate-mapping>
  <class name="model.Child">
    <id name="id">
      <generator class="native"></generator>
    </id>
    <property name="name"></property>
    <many-to-one name="parent" column="parent_id" ></many-to-one>
  </class>
</hibernate-mapping>



<hibernate-mapping>
<class name="model.Parent" >
   <id name="id">
     <generator class="native"></generator>
   </id>
   <property name="name" />
   <set name="children" cascade="all" inverse="true" >//请注意这里的变化
     <key column="parent_id"/>
     <one-to-many  class="model.Child"/>
   </set>
</class>
</hibernate-mapping>

测试代码：

Java代码
public void testSaveParent(){  
    Session session=HibernateUtils.getSession();  
      
    session.beginTransaction();  
      
    Parent parent=new Parent();  
      
    Child child=new Child();      
    child.setName("child");  
    child.setParent(parent);  
           //session.save(child);  
      
    Set children=new HashSet();  
    children.add(child);  
      
    parent.setName("parent");  
    parent.setChildren(children);  
    //保存parent  
    session.save(parent);  
      
    session.flush();  
    session.getTransaction().commit();  
      
} 

public void testSaveParent(){
Session session=HibernateUtils.getSession();

session.beginTransaction();

Parent parent=new Parent();

Child child=new Child();
child.setName("child");
child.setParent(parent);
            //session.save(child);

Set children=new HashSet();
children.add(child);

parent.setName("parent");
parent.setChildren(children);
//保存parent
session.save(parent);

session.flush();
session.getTransaction().commit();

}


下面分几种情况对上面配置文件中注意的地方进行修改：





1、不设置cascade和inverse 属性

Xml代码
<set name="children" > 

<set name="children" > 日志中发出的两条语句和出错信息：

Java代码
Hibernate: insert into Parent (name) values (?)  
Hibernate: update Child set parent_id=? where id=?  
953  [main] ERROR org.hibernate.event.def.AbstractFlushingEventListener  - Could not synchronize database state with session  
org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance before flushing: model.Child 

Hibernate: insert into Parent (name) values (?)
Hibernate: update Child set parent_id=? where id=?
953  [main] ERROR org.hibernate.event.def.AbstractFlushingEventListener  - Could not synchronize database state with session
org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance before flushing: model.Child 分析：第一条语句是保存parent ，因为测试代码中，session.save(parent);，使得parent 从瞬时对象转到持久对象，并同步到数据库中，第二条语句是更新parent，因为parent 在维护关系，往而child表更新parent_id,但发现child不存在，所以发生了错误，（在事务打开到事务结束整个过程 child 还是瞬时对象），如果在session.save(parent);之前，进行session.save(child);，也对child 变成持久对象的话，就不会发生错误了，如下信息，会产生四条语句，两天插入语句，两天更新语句（两者都在维护关系）。

Xml代码
Hibernate: insert into Child (name, parent_id) values (?, ?)  
Hibernate: insert into Parent (name) values (?)  
Hibernate: update Child set name=?, parent_id=? where id=?  
Hibernate: update Child set parent_id=? where id=? 

Hibernate: insert into Child (name, parent_id) values (?, ?)
Hibernate: insert into Parent (name) values (?)
Hibernate: update Child set name=?, parent_id=? where id=?
Hibernate: update Child set parent_id=? where id=?

2、只设置inverse属性

Xml代码
<set name="children" inverse="true" > 

   <set name="children" inverse="true" > 日志中发出一条语句：

Xml代码
Hibernate: insert into Parent (name) values (?) 

Hibernate: insert into Parent (name) values (?) 分析：虽然设置了inverse=true 把关系的维护交给了child 来维护，但在事务打开到事务结束整个过程，child 一直都是个瞬时对象，由于没有涉及到child，所以没有发生错误。



3、只设置cascade 属性

Xml代码
<set name="children" cascade="all"  > 

   <set name="children" cascade="all"  > 日志中发出三条语句：

Xml代码
Hibernate: insert into Parent (name) values (?)  
Hibernate: insert into Child (name, parent_id) values (?, ?)  
Hibernate: update Child set parent_id=? where id=? 

Hibernate: insert into Parent (name) values (?)
Hibernate: insert into Child (name, parent_id) values (?, ?)
Hibernate: update Child set parent_id=? where id=?  分析：由于设置了cascade级联属性，第一条语句是保存了parent ，然后保存parent的时候由于设置了级联属性，发现child没有保存，会先保存child（该语句也包括child维护关系）,所以发出了第二条语句，真正parent维护关系的时候是第三条语句。



4、同时设置cascade 属性和inverse属性

Xml代码
<set name="children" cascade="all" inverse="true" > 

   <set name="children" cascade="all" inverse="true" > 日志中发出两条语句：

Xml代码
Hibernate: insert into Parent (name) values (?)  
Hibernate: insert into Child (name, parent_id) values (?, ?) 

Hibernate: insert into Parent (name) values (?)
Hibernate: insert into Child (name, parent_id) values (?, ?)  分析：第一条语句是由于保存parent 发出的，第二条语句是由于parent时候由于设置了级联属性，而发出的。相对与3 的结论，少了一条parent 维护关系的语句，是因为parent中设置了inverse="true" ，因此parent不维护关系了，而由child维护。



总结：

  在一对多的关联关系中，合理的设置cascade 属性和inverse属性，可以达到数据库优化的效果，大大提高了程序的性能。





以前写的时候可能一时糊涂搞乱思路，所以错误了点，现已经更正了，谢谢大家的指正。。