１、到底在哪用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"?
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中。不管怎样说，还是让"多"方维护关系更直观一些。
３、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 不设置级联删除。
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/yangxueli817/archive/2007/06/11/1647546.aspx
以前写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) values (?)
Hibernate: insert into child (parent_id, id) values (?, ?)
那么假如c.setParent(p)注释掉，结果就是：
Hibernate: insert into parent (id) values (?)
比较结果显而易见！此外，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: 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: 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);
这样结果就成了：
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=? ) //get children
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=?
显而易见，关联更新没有被执行（更新是由“inverse=false”方负责的，而这里恰恰被注释了）。
大多数情况下，很少使用“inverse=false”，但是我还是想仔细研究一下（这样可以更加理解“inverse=true”）。 ^_^
为什么很少使用“inverse=false”？原因很简单之前也提到过，就是不会对双向关系进行优化。
还是来看一个父子的例子：
父亲中的关系映射
{set name=children lazy=true inverse=false}
{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();
p.getChildren().add(c);
c.setParent(p);
session.save(p);
session.save(c);
session.flush();
结果：
Hibernate: insert into parent (id) values (?)
Hibernate: insert into child (parent_id, id) values (?, ?)
Hibernate: update child set parent_id=? where id=?
看到这里就应该明白我之前为什么说“inverse=true”会优化Sql了吧！还有之前也说过是由“inverse=false”来维护关系了，那这里就是由父亲来维护了。假设我在save(p)和save(c)之间掉flush()，结果又会是如何？事实上，是不可以这么做的！因为父亲负责维护关系，如果我在之间加入了flush()，那么就是无法关联更新了（父亲需要一个已经持久化的儿子来触发关联更新）
接下来再来看看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);
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=? )
//get first child for parent 1
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=? // child.setParent
Hibernate: update child set parent_id=null where parent_id=? //remove
Hibernate: update child set parent_id=? where id=? // add
结果说明当设成“inverse=false”时，关系是由父亲和儿子来维护的。这种效率和之前我说的“inverse=true”低很多。
那么关系是由父亲来维护的，我又把代码改了一下：
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);
p2.getChildren().add(c);
结果：
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=? )
//get first child for parent 1
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=? // add
乍看之下对的，但是父亲p和p2的children的状态是不一致的！
小结：使用“inverse=true”可以优化代码，同时，推荐在建立双向关系的时候使用“inverse=true”！
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/zengbo0710/archive/2007/04/16/1565906.aspx
3438
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
