总结：直观来说所有双向关联须有有一段设置为inverse。在一对多的关联中它必须代表多(many)的那端。而在多对多(many-to-many)关联中，可以选取任意一端，因为两端之间并没有差别。

 

以下为转贴：

 

通过Hibernate Inverse的设置来决定是由谁来维护表和表之间的关系。最近有朋友问我Hibernate关于多对多关于删除中间表数据的问题,关键是Inverse的设置,下面引用网友的一篇文章。

Inverse是Hibernate双向关系中的基本概念，当然对于多数实体，我们并不需要双向关联，更多的可能会选择单向关联，况且我们大多数人 一般采用一对多关系，而一对多双向关联的另一端：多对一的Inverse属性是不存在，其实它默认就是Inverse=false.从而防止了在一对多端 胡乱设置Inverse也不至于出错。但是Inverse设置不当确实会带来很大的性能影响，这点是我们必须关注的。

 

关于inverse和cascade的区别

cascade：设置级联
  sava-update：级联保存、更新
  delete：级联删除
  none：不级联，默认值
  all：级联保存、更新、删除
inverse：在映射一对多关系时，一般将该属性设置为true，表示表间的关联关系由一方设置，减少update语句，提高性能

 

这篇文章已经详细分析了Hibernate Inverse设置不当带来的影响：http：//www.Hibernate.org/155.html,看了这篇文章，还是很有必要再写下一些总结的：

1）Hibernate Inverse中提及的side其实是指一个类或者表的概念，双向关联其实是指双方都可以取得对方的应用。

2）维护关系这个名词还是稍显模糊或者晦涩。我们一般说A类或者A表（这里的表的是指多对多的连接表）有责任维护关系，其实这里的意思是说，我在应 用在更新，创建，删除（读就不用说了，双向引用正是为了方便读而出现）A类或者A表时，此时创建的SQL语句必须有责任保证关系的正确修改。

3）Inverse=false的side（side其实是指Inverse＝false所位于的class元素）端有责任维护关系，而Inverse＝true端无须维护这些关系。

4）我们说Hibernate Inverse设立不当会导致性能低下，其实是说Inverse设立不当，会产生多余重复的SQL语句甚至致使JDBC exception的throw。这是我们在建立实体类关系时必须需要关注的地方。一般来说，Inverse＝true是推荐使用，双向关联中双方都设置 Inverse＝false的话，必会导致双方都重复更新同一个关系。但是如果双方都设立Inverse＝true的话，双方都不维护关系的更新，这也是 不行的，好在一对多中的一端：many-to-one默认是Inverse＝false，避免了这种错误的产生。但是多对多就没有这个默认设置了，所以很 多人经常在多对多的两端都使用Inverse＝true，结果导致连接表的数据根本没有记录，就是因为他们双分都没有责任维护关系。所以说，双向关联中最 好的设置是一端为Inverse＝true，一端为Inverse＝false。一般Inverse＝false会放在多的一端，那么有人提问了， many－to－many两边都是多的，Inverse到底放在哪儿？其实Hibernate建立多对多关系也是将他们分离成两个一对多关系，中间连接一 个连接表。所以通用存在一对多的关系，也可以这样说：一对多是多对多的基本组成部分。

看下面的多对多的定义大家更会清楚”多对多“与“一对多”的关系：其中我们注意<many-to-many />标签的特点就知道，它是定义了一个多对多关系，而不是<one-to-many/>。

Xml代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE Hibernate-mapping PUBLIC   "-//Hibernate/Hibernate Mapping DTD 2.0//EN"   "http：//Hibernate.sourceforge.net/Hibernate-mapping-2.0.dtd">  
  3. <Hibernate-mapping package="org.Hibernate.auction">  
  4.  <class name="TestA" table="TestA" dynamic-update="true"  
  5.   dynamic-insert="true">  
  6.   <id name="id" column="id" type="int" unsaved-value="any">  
  7.    <generator class="assigned">  
  8.    </generator>  
  9.   </id>  
  10.   <property name="name" type="java.lang.String" update="true"  
  11.    insert="true" column="name" />  
  12.   <set name="testBs" table="TestA_TestB" Inverse="false" cascade="all">  
  13.    <key column="testA" />  
  14.    <many-to-many column="testB" class="TestB" />  
  15.   </set>  
  16.  </class>  
  17.  <class name="TestB" table="TestB" dynamic-update="true"  
  18.   dynamic-insert="true">  
  19.   <id name="id" column="id" type="int" unsaved-value="any">  
  20.    <generator class="assigned">  
  21.    </generator>  
  22.   </id>  
  23.   <property name="name" type="java.lang.String" update="true"  
  24.    insert="true" column="name" />  
  25.   <set name="testAs" table="TestA_TestB" Inverse="true" cascade="all">  
  26.    <key column="testB" />  
  27.    <many-to-many column="testA" class="TestA" />  
  28.   </set>  
  29.  </class>  
  30. </Hibernate-mapping>   
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE Hibernate-mapping PUBLIC   "-//Hibernate/Hibernate Mapping DTD 2.0//EN"   
"http：//Hibernate.sourceforge.net/Hibernate-mapping-2.0.dtd"><Hibernate-mapping package="org.Hibernate.auction"> 
<class name="TestA" table="TestA" dynamic-update="true"  dynamic-insert="true">  <id name="id" column="id" type="int" unsaved-value="any">  
 <generator class="assigned">   </generator>  </id>  <property name="name" type="java.lang.String" update="true"   insert="true" column="name" />
  <set name="testBs" table="TestA_TestB" Inverse="false" cascade="all">   <key column="testA" />   <many-to-many column="testB" class="TestB" /> 
</set>
 </class>
 <class name="TestB" table="TestB" dynamic-update="true"  dynamic-insert="true"> 
 <id name="id" column="id" type="int" unsaved-value="any">   <generator class="assigned">  
 </generator> 
 </id> 
 <property name="name" type="java.lang.String" update="true"   insert="true" column="name" /> 
 <set name="testAs" table="TestA_TestB" Inverse="true" cascade="all">  
 <key column="testB" />  
 <many-to-many column="testA" class="TestA" />  
</set> 
</class>
</Hibernate-mapping>

 在对多对中，因为一端维护关系另一端不维护关系的原因，我们必须注意避免在应用中用不维护关系的类建立关系，因为这样建立的关系是不会在数据库中存储的。基于上面的映射文件代码给出一个例子：

Java代码
  1. package org.Hibernate.auction;  
  2.   
  3. import java.util.*;  
  4.   
  5. /** 
  6.  * * @author Administrator * * To change the template for this generated type 
  7.  * comment go to * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and 
  8.  * Comments 
  9.  */  
  10. public class TestA {  
  11.     int id;  
  12.     String name;  
  13.     Set testBs = new HashSet();  
  14.   
  15.     public TestA() {  
  16.     }  
  17.   
  18.     public TestA(int id) {  
  19.         setId(id);  
  20.     }  
  21.   
  22.     public int getId() {  
  23.         return id;  
  24.     }  
  25.   
  26.     public void setId(int id) {  
  27.         this.id = id;  
  28.     }  
  29.   
  30.     public String getName() {  
  31.         return name;  
  32.     }  
  33.   
  34.     public void setName(String name) {  
  35.         this.name = name;  
  36.     }  
  37.   
  38.     public Set getTestBs() {  
  39.         return testBs;  
  40.     }  
  41.   
  42.     public void setTestBs(Set s) {  
  43.         testBs = s;  
  44.     }  
  45.   
  46.     public void addTestB(TestB tb) {  
  47.         testBs.add(tb);  
  48.     }  
  49.   
  50.     public static void main(String[] args) {  
  51.     }  
  52. }  
  53.   
  54. public class TestB {  
  55.     int id;  
  56.     String name;  
  57.     Set testAs = new HashSet();  
  58.   
  59.     public TestB() {  
  60.     }  
  61.   
  62.     public TestB(int id) {  
  63.         setId(id);  
  64.     }  
  65.   
  66.     public int getId() {  
  67.         return id;  
  68.     }  
  69.   
  70.     public void setId(int id) {  
  71.         this.id = id;  
  72.     }  
  73.   
  74.     public String getName() {  
  75.         return name;  
  76.     }  
  77.   
  78.     public void setName(String name) {  
  79.         this.name = name;  
  80.     }  
  81.   
  82.     public Set getTestAs() {  
  83.         return testAs;  
  84.     }  
  85.   
  86.     public void setTestAs(Set s) {  
  87.         testAs = s;  
  88.     }  
  89.   
  90.     public void addTestA(TestA ta) {  
  91.         testAs.add(ta);  
  92.     }  
  93.   
  94.     public static void main(String[] args) {  
  95.     }  
  96. }  
package org.Hibernate.auction;import java.util.*;
/** * * @author Administrator 
* * To change the template for this generated type 
* comment go to
 * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and 
* Comments */

public class TestA {
int id;
String name;
Set testBs = new HashSet();
public TestA() {}
public TestA(int id) 
{setId(id);}
public int getId() 
{return id;}
public void setId(int id) {this.id = id;}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public Set getTestBs() {return testBs;}
public void setTestBs(Set s) {testBs = s;}
public void addTestB(TestB tb) {testBs.add(tb);}
public static void main(String[] args) {}}
public class TestB {
int id;
String name;
Set testAs = new HashSet();
public TestB() {}
public TestB(int id) {setId(id);}
public int getId() {return id;}
public void setId(int id) {this.id = id;}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public Set getTestAs() {return testAs;}
public void setTestAs(Set s) {testAs = s;}
public void addTestA(TestA ta) {testAs.add(ta);}
public static void main(String[] args) {}}

  测试代码：

Java代码
  1.  public void doTest() throws Exception {  
  2.   TestA a1 = new TestA(1);  
  3.   TestA a2 = new TestA(2);  
  4.   TestA a3 = new TestA(3);  
  5.   TestB b1 = new TestB(1);  
  6.   TestB b2 = new TestB(2);  
  7.   TestB b3 = new TestB(3);  
  8.   a1.addTestB(b1);  
  9.   a1.addTestB(b2);  
  10.   a1.addTestB(b3);  
  11.   b2.addTestA(a1);  
  12.   b2.addTestA(a2);  
  13.   Session s = factory.openSession();  
  14.   s = factory.openSession();  
  15.   Session session = factory.openSession();  
  16.   session.save(a1);  
  17.   session.flush();  
  18.   session.close();  
  19.  }  
 public void doTest() throws Exception {  
TestA a1 = new TestA(1);
  TestA a2 = new TestA(2);
  TestA a3 = new TestA(3); 
 TestB b1 = new TestB(1);  
TestB b2 = new TestB(2);  
TestB b3 = new TestB(3); 
 a1.addTestB(b1);
  a1.addTestB(b2);
  a1.addTestB(b3); 
 b2.addTestA(a1);  
b2.addTestA(a2);
  Session s = factory.openSession(); 
 s = factory.openSession();  
Session session = factory.openSession();
  session.save(a1); 
 session.flush(); 
 session.close(); 
}

 测试后连接表的数据为：

testa              testb

1                  1

1                  2

1                  3

根据Inverse规则，对这些代码：b2.addTestA(a1);   b2.addTestA(a2); 建立的关系，数据库并没有存储下来，因为TestB没有责任维护这些关系，所以产生的sql语句自然不会有针对Testa_testB表的操作了。假设应 用中真的需要这些方法，那么我们可以修改TestB的方法，让他们注意在维护端类中执行相应的操作以使得关系能够在数据库中保存下来，更改TestB如 下：

Java代码
  1. /*   * Created on 2004-7-25
  2.   *   * To change the template for this generated file go to   * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments   */package org.Hibernate.auction;  
  3.   
  4. import java.util.*;  
  5.   
  6. /** 
  7.  * * @author Administrator * * To change the template for this generated type 
  8.  * comment go to * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and 
  9.  * Comments 
  10.  */  
  11. public class TestB {  
  12.     int id;  
  13.     String name;  
  14.     Set testAs = new HashSet();  
  15.   
  16.     public TestB() {  
  17.     }  
  18.   
  19.     public TestB(int id) {  
  20.         setId(id);  
  21.     }  
  22.   
  23.     public int getId() {  
  24.         return id;  
  25.     }  
  26.   
  27.     public void setId(int id) {  
  28.         this.id = id;  
  29.     }  
  30.   
  31.     public String getName() {  
  32.         return name;  
  33.     }  
  34.   
  35.     public void setName(String name) {  
  36.         this.name = name;  
  37.     }  
  38.   
  39.     public Set getTestAs() {  
  40.         return testAs;  
  41.     }  
  42.   
  43.     public void setTestAs(Set s) {  
  44.         testAs = s;  
  45.     }  
  46.   
  47.     public void addTestA(TestA ta) {  
  48.         testAs.add(ta);  
  49.         ta.addTestB(this);  
  50.     }  
  51.   
  52.     public static void main(String[] args) {  
  53.     }  
  54. }  
/*   * Created on 2004-7-25   *   * To change the template for this generated file go to   * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments   */package org.Hibernate.auction;import java.util.*;/** * * @author Administrator * * To change the template for this generated type * comment go to * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and * Comments */public class TestB {int id;String name;Set testAs = new HashSet();public TestB() {}public TestB(int id) {setId(id);}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Set getTestAs() {return testAs;}public void setTestAs(Set s) {testAs = s;}public void addTestA(TestA ta) {testAs.add(ta);ta.addTestB(this);}public static void main(String[] args) {}}

  那么测试执行后连接表的数据为：

testa          testb

1               2

1               3

1               1

2               2

测试通过。