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属性,可以达到数据库优化的效果,大大提高了程序的性能。
以前写的时候可能一时糊涂搞乱思路,所以错误了点,现已经更正了,谢谢大家的指正。。
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属性,可以达到数据库优化的效果,大大提高了程序的性能。
以前写的时候可能一时糊涂搞乱思路,所以错误了点,现已经更正了,谢谢大家的指正。。