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”方來維護的，那麼我把代碼改成：

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

這樣運行下來的結果：

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

比較結果很明顯，少了父加載兒子的過程，乍看下是成功更新了。實際上，結果和DB是不一致的。（原因很簡單就是父親p的children並沒有被更新）

那麼反過來改一下：

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)

改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 改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 改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詳解

01 穩定性（一）如何應對事故並做好覆盤？

一鍵自動化博客發佈工具,用過的人都說好(頭條篇)

Stream流常用方法總結

J2EE框架之Hibernate

《潛伏》中謝若琳的經典臺詞

hibernate inverse cascade詳解

發送接收 xml

關於印發天津市限價商品住房管理暫行辦法的通知

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結