hibernate inverse cascade详解

hibernate inverse cascade详解。Hibernate中Inverse和Cascade的区别2008-05-18 18:11 一直对两者之间的区别不是很清楚，认为既然Inverse似乎具有Cascade的某些特性，比如删除。今天实践了一下才知道，两者是截然不同的：

Inverse：负责控制关系，默认为false，也就是关系的两端都能控制，但这样会造成一些问题，更新的时候会因为两端都控制关系，于是重复更新。一般来说有一端要设为true。
Cascade：负责控制关联对象的级联操作，包括更新、删除等，也就是说对一个对象进行更新、删除时，其它对象也受影响，比如我删除一个对象，那么跟它是多对一关系的对象也全部被删除。
举例说明区别：删除“一”那一端一个对象O的时候，如果“多”的那一端的Inverse设为true，则把“多”的那一端所有与O相关联的对象外键清空；如果“多”的那一端的Cascade设为Delete，则把“多”的那一端所有与O相关联的对象全部删除。
Hibernate中的Inverse
[ 2007-3-1 8:59:00 | By: Cxiang ]
以前写HBM，用一对多或多对多的时候默认总是加上“inverse=true”。当时想法很简单就是由双方来维护之间的关联关系。今天才终于明白inverse的真正含义了！

其实inverse不复杂，但是要真正明白还是要稍微看一下源码。inverse的真正作用就是指定由哪一方来维护之间的关联关系。当一方中指定了“inverse=false”（默认），那么那一方就有责任负责之间的关联关系，说白了就是hibernate如何生成Sql来维护关联的记录！举个最简单的一对多父子关系。那么代码就写成：

父亲中的关系映射
{set name=”children” lazy=”true” inverse=”true”}
{key column=”parent_id”/}
{one-to-many class=”test.Child”/}
{/set}

儿子中关系映射
{many-to-one name=”parent” column=”parent_id” not-null=”true”/}
Parent p = new Parent();
Child c = new Child();
c.setParent(p); //维护父子之间关系
p.getChildren().add(c);

session.save(p);
session.flush();

注意：{many-to-one}总是设成“inverse=false”的，而且这个属性在Mapping中是不存在的！

这样运行的下来的结果就是：

Hibernate: insert into parent (id) s (?)
Hibernate: insert into child (parent_id, id) s (?, ?)

那么假如c.setParent(p)注释掉，结果就是：

Hibernate: insert into parent (id) s (?)

比较结果显而易见！此外，inverse还有一个重要特点就是会优化Sql。（具体可以把SHOW_SQL这个属性打开，然后观察一下就知道了）

接下来再看看update，还是父子的例子：

Parent p = (Parent) session.load(Parent.class, parentId);
Parent p2 = (Parent) session.load(Parent.class, parentId2);

c = (Child) session.find(
“from Child as child where child.parent = ?”,
p, Hibernate.entity(Parent.class)).get(0);

// 改变儿子c的关系
p.getChildren().remove(c);
p2.getChildren().add(c);
c.setParent(p2);

这样运行下来的结果就是：

Hibernate: select parent0_.id as id from parent parent0_ where parent0_.id=? //get parent 1
Hibernate: select parent0_.id as id from parent parent0_ where parent0_.id=? //get parent 2
Hibernate: select child0_.id as id, child0_.parent_id as parent_id from child child0_ where (child0_.parent_id=? )

Hibernate: select child0_.id as id__, child0_.id as id, child0_.parent_id as parent_id from child child0_ where child0_.parent_id=?
Hibernate: select child0_.id as id__, child0_.id as id, child0_.parent_id as parent_id from child child0_ where child0_.parent_id=?

Hibernate: update child set parent_id=? where id=?（正确更新了）

那么根据上面的结论，关系应该是由“inverse=false”方来维护的，那么我把代码改成：

Parent p = (Parent) session.load(Parent.class, parentId);
Parent p2 = (Parent) session.load(Parent.class, parentId2);

c = (Child) session.find(
“from Child as child where child.parent = ?”,
p, Hibernate.entity(Parent.class)).get(0);

//p.getChildren().remove(c);
//p2.getChildren().add(c);
c.setParent(p2);

这样运行下来的结果：

Hibernate: update child set parent_id=? where id=?

比较结果很明显，少了父加载儿子的过程，乍看下是成功更新了。实际上，结果和DB是不一致的。（原因很简单就是父亲p的children并没有被更新）

那么反过来改一下：

Parent p = (Parent) session.load(Parent.class, parentId);
Parent p2 = (Parent) session.load(Parent.class, parentId2);

c = (Child) session.find(
“from Child as child where child.parent = ?”,
p, Hibernate.entity(Parent.class)).get(0);

p.getChildren().remove(c);
p2.getChildren().add(c);
//c.setParent(p2);

这样结果就成了：

显而易见，关联更新没有被执行（更新是由“inverse=false”方负责的，而这里恰恰被注释了）。

１、到底在哪用cascade=”…”？

cascade属性并不是多对多关系一定要用的，有了它只是让我们在插入或删除对像时更方便一些，只要在

cascade的源头上插入或是删除，所有 cascade的关系就会被自己动的插入或是删除。便是为了能正确的

cascade，unsaved-value是个很重要的属性。Hibernate通过这个属性来判断一个对象应该save还是

update，如果这个对象的id是unsaved-value的话，那说明这个对象不是 persistence object要save

（insert)；如果id是非unsaved-value的话，那说明这个对象是persistence object（数据库中已存在

），只要update就行了。saveOrUpdate方法用的也是这个机制。

２、到底在哪用inverse=”ture”?
“set的inverse属性决定是否把对set的改动反映到数据库中去。inverse=false————反映；

inverse=true————不反映”inverse属性默认为false

inverse属性默认是false的，就是说关系的两端都来维护关系。这个意思就是说，如有一个Student,

Teacher和TeacherStudent表，Student和Teacher是多对多对多关系，这个关系由TeacherStudent这个表

来表现。那么什么时候插入或删除TeacherStudent表中的记录来维护关系呢？在用hibernate时，我们

不会显示的对 TeacherStudent表做操作。对TeacherStudent的操作是hibernate帮我们做的。hibernate

就是看hbm文件中指定的是”谁”维护关系，那个在插入或删除”谁”时，就会处发对关系表的操作。前提

是”谁”这个对象已经知道这个关系了，就是说关系另一头的对象已经set 或是add到”谁”这个对象里来了

。前面说过inverse默认是false，就是关系的两端都维护关系，对其中任一个操作都会处发对表系表的

操作。当在关系的一头，如Student中的bag或set中用了inverse＝”true”时，那就代表关系是由另一关

维护的（Teacher）。就是说当这插入Student时，不会操作TeacherStudent表，即使Student已经知道

了关系。只有当Teacher插入或删除时才会处发对关系表的操作。所以，当关系的两头都用

inverse=”true”是不对的，就会导致任何操作都不处发对关系表的操作。当两端都是inverse= “false”

或是default值是，在代码对关系显示的维护也是不对的，会导致在关系表中插入两次关系。

在一对多关系中inverse就更有意义了。在多对多中，在哪端inverse=”true”效果差不多（在效率上）。

但是在一对多中，如果要一方维护关系，就会使在插入或是删除”一”方时去update”多”方的每一个与这

个”一”的对象有关系的对象。而如果让”多”方面维护关系时就不会有update 操作，因为关系就是在多方

的对象中的，直指插入或是删除多方对象就行了。当然这时也要遍历”多”方的每一个对象显示的操作修

关系的变化体现到DB中。不管怎样说，还是让”多”方维护关系更直观一些。

（1）对one-to-many而言，改变set，会让hibernate执行一系列的update语句，不会

delete/insert数据
（2）对many-to-many而言，改变set,只修改关系表的数据，不会影响many-to-many的另一方。
（3）虽然one-to-many和many-to-many的数据库操作不一样，但目的都是一个：维护数据的一致性

。

３、cascade和inverse有什么区别？
可以这样理解，cascade定义的是关系两端对象到对象的级联关系；而inverse定义的是关系和对象的级

联关系。
inverse只对set+one-to-many(或many-to-many)有效，对many-to-one, one-to-one无效。cascade对关

系标记都有效。

inverse对集合对象整体起作用，cascade对集合对象中的一个一个元素起作用，如果集合为空，那么

cascade不会引发关联操作。
比如将集合对象置为null， school.setStudentSet(null)
inverse导致hibernate执行:udpate STUDENT set SCHOOL_ID=null where SCHOOL_ID=?
cascade则不会执行对STUDENT表的关联更新，因为集合中没有元素。
再比新增一个school, session.save(school)
inverse导致hibernate执行：
for( 对(school的每一个student ){
udpate STUDENT set SCHOOL_ID=? where STUDENT_ID=? //将学生的school_id改为新的school的

id
}
cascade导致hibernate执行：
for( 对school的每一个student ){
session.save(aStudent); //对学生执行save操作
}
extends:如果改变集合中的部分元素（比如新增一个元素），
inverse: hibernate先判断哪些元素改变了，对改变的元素执行相应的sql
cascade: 它总是对集合中的每个元素执行关联操作。
（在关联操作中，hibernate会判断操作的对象是否改变）
两个起作用的时机不同：
cascade：在对主控方操作时，级联发生。
inverse: 在flush时（commit会自动执行flush)，对session中的所有set，hibernate判断每个set

是否有变化，
对有变化的set执行相应的sql，执行之前，会有个判断：if( inverse == true ) return;可以看出

cascade在先，inverse在后。
inverse 对set + one-to-many 和 set + many-to-many 起的作用不同。hibernate生成的sql不同。
对one-to-many，hibernate对many方的数据库表执行update语句。
对many-to-many, hibernate对关系表执行insert/update/delte语句，注意不是对many方的数据

库表而是关系表。
cascase 对set都是一致的，不管one-to-many还是many-to-many。都简单地把操作传递到set中的每

个元素。所以它总是更新many方的数据库表。

4、cascade和inverse有什么相同？
这两个属性本身互不影响，但起的作用有些类似，都能引发对关系表的更新。

5、建议：只对set + many-to-many设置inverse=false，其他的标记不考虑inverse属性，都设为

inverse=true。对cascade，一般对many-to-one，many-to-many，constrained=true的one-to-one 不

设置级联删除。

Inverse和cascade是Hibernate映射中最难掌握的两个属性。两者都在对象的关联操作中发挥作用。
1.inverse属性：inverse所描述的是对象之间关联关系的维护方式。
inverse只存在于集合标记的元素中。Hibernate提供的集合元素包括<set/> <map/> <list/> <array /> <bag />
Inverse属性的作用是：是否将对集合对象的修改反映到数据库中。
inverse属性的默认值为false，表示对集合对象的修改会被反映到数据库中
inverse=”true” 表示对集合对象的修改不会被反映到数据库中。
<one-to-many>中inverse的属性的设置
例：Person中包含一个Child集合，Child包含一个Person对象。
要求：新建Person和Child对象，Child属于此Person对象
分析：在数据库中，就是新增一条Child记录
//one-to-many的inverse的配置
public void testInverse() {
Qx qx = new Qx();
qx.setQx(“天山区”);
Jd jd = new Jd();
jd.setJd(“人民路”);
qx.getJds().add(jd);
jd.setQx(qx);
super.add(qx);
super.add(jd);
}
配置Inverse=”false”，Hibernate的操作：
（1）Hibernate: insert into TBL_QX (qx) values (?)
（2）Hibernate: insert into TBL_JD (jd, qxid) values (?, ?)
（3）Hibernate: update TBL_JD set qxid=? where jdid=?
配置Inverse=”true”，Hibernate的操作
（1）Hibernate: insert into TBL_QX (qx) values (?)
（2）Hibernate: insert into TBL_JD (jd, qxid) values (?, ?)
可以看出：Inverse=”true”，SQL少执行一条更新操作（Java代码不会少）

<many-to-many>中inverse的属性的设置
在多对多的关系中，可以在关联的两边都不设置inverse属性（默认的false）,那么说明关联的双方都可以维护两个对象之间的关联关系。
注：在设置多对多关系的inverse属性时，不能两个对象都将其设置为true

2.cascade属性
cascade属性的作用是描述关联对象进行操作时的级联特性。因此，只有涉及到关系的元素才有cascade属性。
具有cascade属性的标记包括<many-to-one /> <one-to-one /> <any /> <set /><bag /> <idbag /> <list /> <array />
注意：<ont-to-many />和 <many-to-many />是用在集合标记内部的，所以是不需要cascade属性的。
级联操作：指当主控方执行某项操作时，是否要对被关联方也执行相同的操作。

3.inverse和cascade的区别
作用的范围不同：
Inverse是设置在集合元素中的。
Cascade对于所有涉及到关联的元素都有效。
<many-to-one/><ont-to-many/>没有inverse属性，但有cascade属性
执行的策略不同
Inverse 会首先判断集合的变化情况，然后针对变化执行相应的处理。
Cascade 是直接对集合中每个元素执行相应的处理
执行的时机不同
Inverse是在执行SQL语句之前判断是否要执行该SQL语句
Cascade则在主控方发生操作时用来判断是否要进行级联操作
执行的目标不同
Inverse对于<ont-to-many>和<many-to-many>处理方式不相同。
对于<ont-to-many>，inverse所处理的是对被关联表进行修改操作。
对于<many-to-many>，inverse所处理的则是中间关联表
Cascade不会区分这两种关系的差别，所做的操作都是针对被关联的对象。

总结：
<one-to-many>中，建议inverse=”true”，由“many”方来进行关联关系的维护
<many-to-many>中，只设置其中一方inverse=”false”，或双方都不设置
Cascade，通常情况下都不会使用。特别是删除，一定要慎重。

说明约定-如：
1.表属性 :T1oo->id,name
T2oo->id,avg,aid( 外键 ),version

2.代码过程是：Save->t1oo对象(T1oo 外键 T2oo)
T1oo t1oo = new T1oo();
t1oo.setName(“xx”);
t1oo.setT2ooSet(new HashSet());
T2oo t2oo2 = new T2oo(24);
//t2oo2.setT1oo(t1oo); (在下面的本用例表中的第3属性 )
t1oo.getT2ooSet().add(t2oo2); (在下面的本用例表中的第2属性 )
session.save(t1oo);

4.执行 Hibernate语句：
Hibernate: insert into t1oo (name, id) values (?, ?)
Hibernate: insert into t2oo (version, avg, aid, id) values (?, ?, ?, ?)
5.结果为：
mysql> select * from t2oo;
+—-+—–+——+———+
| id | avg | aid | version |
+—-+—–+——+———+
| 2 | 24 | NULL | 0 | //主要就是看 aid属性
+—-+—–+——+———+
1 row in set (0.00 sec)
mysql> select * from t1oo; // 因为 T1oo总是可以 Save 下面就不再提了
+—-+——+
| id | name |
+—-+——+
| 2 | xx |
+—-+——+
1 row in set (0.00 sec)

可改项：
+——-+——-+——-+———-+———-+
|hbn.xml|inverse|cascade|t1oo->t2oo|t2oo->t1oo|
+——-+——-+——-+———-+———-+
| t1oo | 可改4 | 可改2 | | |
+——-+——-+——-+ | 可改1 |
| t2oo | | 可改3 | | |
+——-+——-+——-+———-+———-+

主本:
+——-+——-+——-+———-+———-+
|hbn.xml|inverse|cascade|t1oo->t2oo|t2oo->t1oo|
+——-+——-+——-+———-+———-+
| t1oo | true | all | | |
+——-+——-+——-+ true | true |
| t2oo | | all | | |
+——-+——-+——-+———-+———-+
Hibernate: insert into t1oo (name, id) values (?, ?)
Hibernate: insert into t2oo (version, avg, aid, id) values (?, ?, ?, ?)
mysql> select * from t2oo;
+—-+—–+——+———+
| id | avg | aid | version |
+—-+—–+——+———+
| 1 | 24 | 1 | 0 |
+—-+—–+——+———+
1 row in set (0.00 sec)
改1
+——-+——-+——-+———-+———-+
|hbn.xml|inverse|cascade|t1oo->t2oo|t2oo->t1oo|
+——-+——-+——-+———-+———-+
| t1oo | true | all | | |
+——-+——-+——-+ true | false |
| t2oo | | all | | |
+——-+——-+——-+———-+———-+
Hibernate: insert into t1oo (name, id) values (?, ?)
Hibernate: insert into t2oo (version, avg, aid, id) values (?, ?, ?, ?)
mysql> select * from t2oo;
+—-+—–+——+———+
| id | avg | aid | version |
+—-+—–+——+———+
| 1 | 24 | NULL| 0 |
+—-+—–+——+———+
1 row in set (0.00 sec)

改2 改1
+——-+——-+——-+———-+———-+
|hbn.xml|inverse|cascade|t1oo->t2oo|t2oo->t1oo|
+——-+——-+——-+———-+———-+
| t1oo | true | | | |
+——-+——-+——-+ true | false |
| t2oo | | all | | |
+——-+——-+——-+———-+———-+
Hibernate: insert into t1oo (name, id) values (?, ?)
Empty set (0.00 sec)
改3
+——-+——-+——-+———-+———-+
|hbn.xml|inverse|cascade|t1oo->t2oo|t2oo->t1oo|
+——-+——-+——-+———-+———-+
| t1oo | true | all | | |
+——-+——-+——-+ true | true |
| t2oo | | | | |
+——-+——-+——-+———-+———-+
Hibernate: insert into t1oo (name, id) values (?, ?)
Hibernate: insert into t2oo (version, avg, aid, id) values (?, ?, ?, ?)
mysql> select * from t2oo;
+—-+—–+——+———+
| id | avg | aid | version |
+—-+—–+——+———+
| 1 | 24 | 1 | 0 |
+—-+—–+——+———+
1 row in set (0.00 sec)

改3 改2
+——-+——-+——-+———-+———-+
|hbn.xml|inverse|cascade|t1oo->t2oo|t2oo->t1oo|
+——-+——-+——-+———-+———-+
| t1oo | true | | | |
+——-+——-+——-+ true | true |
| t2oo | | | | |
+——-+——-+——-+———-+———-+
Hibernate: insert into t1oo (name, id) values (?, ?)
Empty set (0.00 sec)
改3 改1
+——-+——-+——-+———-+———-+
|hbn.xml|inverse|cascade|t1oo->t2oo|t2oo->t1oo|
+——-+——-+——-+———-+———-+
| t1oo | true | all | | |
+——-+——-+——-+ true | false |
| t2oo | | | | |
+——-+——-+——-+———-+———-+
Hibernate: insert into t1oo (name, id) values (?, ?)
Hibernate: insert into t2oo (version, avg, aid, id) values (?, ?, ?, ?)
mysql> select * from t2oo;
+—-+—–+——+———+
| id | avg | aid | version |
+—-+—–+——+———+
| 1 | 24 | NULL | 0 |
+—-+—–+——+———+
1 row in set (0.00 sec)

改4
+——-+——-+——-+———-+———-+
|hbn.xml|inverse|cascade|t1oo->t2oo|t2oo->t1oo|
+——-+——-+——-+———-+———-+
| t1oo | false | all | | |
+——-+——-+——-+ true | true |
| t2oo | | all | | |
+——-+——-+——-+———-+———-+
Hibernate: insert into t1oo (name, id) values (?, ?)
Hibernate: insert into t2oo (version, avg, aid, id) values (?, ?, ?, ?)
Hibernate: update t2oo set aid=? where id=?
mysql> select * from t2oo;
+—-+—–+——+———+
| id | avg | aid | version |
+—-+—–+——+———+
| 1 | 24 | 1 | 0 |
+—-+—–+——+———+
1 row in set (0.02 sec)

改4 改1
+——-+——-+——-+———-+———-+
|hbn.xml|inverse|cascade|t1oo->t2oo|t2oo->t1oo|
+——-+——-+——-+———-+———-+
| t1oo | false | all | | |
+——-+——-+——-+ true | false |
| t2oo | | all | | |
+——-+——-+——-+———-+———-+
Hibernate: insert into t1oo (name, id) values (?, ?)
Hibernate: insert into t2oo (version, avg, aid, id) values (?, ?, ?, ?)
Hibernate: update t2oo set aid=? where id=?
mysql> select * from t2oo;
+—-+—–+——+———+
| id | avg | aid | version |
+—-+—–+——+———+
| 1 | 24 | 1 | 0 |
+—-+—–+——+———+
1 row in set (0.00 sec)

改4 改3
+——-+——-+——-+———-+———-+
|hbn.xml|inverse|cascade|t1oo->t2oo|t2oo->t1oo|
+——-+——-+——-+———-+———-+
| t1oo | false | all | | |
+——-+——-+——-+ true | true |
| t2oo | | | | |
+——-+——-+——-+———-+———-+
Hibernate: insert into t1oo (name, id) values (?, ?)
Hibernate: insert into t2oo (version, avg, aid, id) values (?, ?, ?, ?)
Hibernate: update t2oo set aid=? where id=?
mysql> select * from t2oo;
+—-+—–+——+———+
| id | avg | aid | version |
+—-+—–+——+———+
| 1 | 24 | 1 | 0 |
+—-+—–+——+———+
1 row in set (0.00 sec)

改4 改1 改2
+——-+——-+——-+———-+———-+
|hbn.xml|inverse|cascade|t1oo->t2oo|t2oo->t1oo|
+——-+——-+——-+———-+———-+
| t1oo | false | | | |
+——-+——-+——-+ true | false |
| t2oo | | all | | |
+——-+——-+——-+———-+———-+
Hibernate: insert into t1oo (name, id) values (?, ?)
Hibernate: update t2oo set aid=? where id=?
Empty set (0.00 sec)
改4 改1 改3
+——-+——-+——-+———-+———-+
|hbn.xml|inverse|cascade|t1oo->t2oo|t2oo->t1oo|
+——-+——-+——-+———-+———-+
| t1oo | false | all | | |
+——-+——-+——-+ true | false |
| t2oo | | | | |
+——-+——-+——-+———-+———-+
Hibernate: insert into t1oo (name, id) values (?, ?)
Hibernate: insert into t2oo (version, avg, aid, id) values (?, ?, ?, ?)
Hibernate: update t2oo set aid=? where id=?
mysql> select * from t2oo;
+—-+—–+——+———+
| id | avg | aid | version |
+—-+—–+——+———+
| 1 | 24 | 1 | 0 |
+—-+—–+——+———+
1 row in set (0.02 sec)

本文链接地址: hibernate inverse cascade详解http://www.hongyanliren.com/2014m12/23774.html

红颜丽人

追求技术就像追求#$！不抛弃，不放弃！

hibernate inverse cascade详解

相关文章