Hibernate Inverse详解
通过HibernateInverse的设置来决定是由谁来维护表和表之间的关系。最近有朋友问我Hibernate关于多对多关于删除中间表数据的问题,关键是Inverse的设置,下面引用网友的一篇文章。
Inverse是Hibernate双向关系中的基本概念，当然对于多数实体，我们并不需要双向关联，更多的可能会选择单向关联，况且我们大多数人一般采用一对多关系，而一对多双向关联的另一端：多对一的Inverse属性是不存在，其实它默认就是Inverse=false.从而防止了在一对多端胡乱设置Inverse也不至于出错。但是Inverse设置不当确实会带来很大的性能影响，这点是我们必须关注的。
关于inverse和cascade的区别
cascade：设置级联
sava-update：级联保存、更新
delete：级联删除
none：不级联，默认值
all：级联保存、更新、删除
inverse：在映射一对多关系时，一般将该属性设置为true，表示表间的关联关系由一方设置，减少update语句，提高性能
这篇文章已经详细分析了HibernateInverse设置不当带来的影响：http：//www.Hibernate.org/155.html,看了这篇文章，还是很有必要再写下一些总结的：
1）HibernateInverse中提及的side其实是指一个类或者表的概念，双向关联其实是指双方都可以取得对方的应用。
2）维护关系这个名词还是稍显模糊或者晦涩。我们一般说A类或者A表（这里的表的是指多对多的连接表）有责任维护关系，其实这里的意思是说，我在应用在更新，创建，删除（读就不用说了，双向引用正是为了方便读而出现）A类或者A表时，此时创建的SQL语句必须有责任保证关系的正确修改。
3）Inverse=false的side（side其实是指Inverse＝false所位于的class元素）端有责任维护关系，而Inverse＝true端无须维护这些关系。
4）我们说HibernateInverse设立不当会导致性能低下，其实是说Inverse设立不当，会产生多余重复的SQL语句甚至致使JDBCexception的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.<?xmlversion="1.0"encoding="UTF-8"?>
2.<!DOCTYPEHibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD2.0//EN""http：//Hibernate.sourceforge.net/Hibernate-mapping-2.0.dtd">
3.<Hibernate-mappingpackage="org.Hibernate.auction">
4.<classname="TestA"table="TestA"dynamic-update="true"
5.dynamic-insert="true">
6.<idname="id"column="id"type="int"unsaved-value="any">
7.<generatorclass="assigned">
8.</generator>
9.</id>
10.<propertyname="name"type="java.lang.String"update="true"
11.insert="true"column="name"/>
12.<setname="testBs"table="TestA_TestB"Inverse="false"cascade="all">
13.<keycolumn="testA"/>
14.<many-to-manycolumn="testB"class="TestB"/>
15.</set>
16.</class>
17.<classname="TestB"table="TestB"dynamic-update="true"
18.dynamic-insert="true">
19.<idname="id"column="id"type="int"unsaved-value="any">
20.<generatorclass="assigned">
21.</generator>
22.</id>
23.<propertyname="name"type="java.lang.String"update="true"
24.insert="true"column="name"/>
25.<setname="testAs"table="TestA_TestB"Inverse="true"cascade="all">
26.<keycolumn="testB"/>
27.<many-to-manycolumn="testA"class="TestA"/>
28.</set>
29.</class>
30.</Hibernate-mapping>
<?xmlversion="1.0"encoding="UTF-8"?>
<!DOCTYPEHibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD2.0//EN""http：//Hibernate.sourceforge.net/Hibernate-mapping-2.0.dtd">
<Hibernate-mappingpackage="org.Hibernate.auction">
<classname="TestA"table="TestA"dynamic-update="true"
dynamic-insert="true">
<idname="id"column="id"type="int"unsaved-value="any">
<generatorclass="assigned">
</generator>
</id>
<propertyname="name"type="java.lang.String"update="true"
insert="true"column="name"/>
<setname="testBs"table="TestA_TestB"Inverse="false"cascade="all">
<keycolumn="testA"/>
<many-to-manycolumn="testB"class="TestB"/>
</set>
</class>
<classname="TestB"table="TestB"dynamic-update="true"
dynamic-insert="true">
<idname="id"column="id"type="int"unsaved-value="any">
<generatorclass="assigned">
</generator>
</id>
<propertyname="name"type="java.lang.String"update="true"
insert="true"column="name"/>
<setname="testAs"table="TestA_TestB"Inverse="true"cascade="all">
<keycolumn="testB"/>
<many-to-manycolumn="testA"class="TestA"/>
</set>
</class>
</Hibernate-mapping>在对多对中，因为一端维护关系另一端不维护关系的原因，我们必须注意避免在应用中用不维护关系的类建立关系，因为这样建立的关系是不会在数据库中存储的。基于上面的映射文件代码给出一个例子：
Java代码
1.packageorg.Hibernate.auction;
2.
3.importjava.util.*;
4.
5./**
6.**@authorAdministrator**Tochangethetemplateforthisgeneratedtype
7.*commentgoto*Window>Preferences>Java>CodeGeneration>Codeand
8.*Comments
9.*/
10.publicclassTestA{
11.intid;
12.Stringname;
13.SettestBs=newHashSet();
14.
15.publicTestA(){
16.}
17.
18.publicTestA(intid){
19.setId(id);
20.}
21.
22.publicintgetId(){
23.returnid;
24.}
25.
26.publicvoidsetId(intid){
27.this.id=id;
28.}
29.
30.publicStringgetName(){
31.returnname;
32.}
33.
34.publicvoidsetName(Stringname){
35.this.name=name;
36.}
37.
38.publicSetgetTestBs(){
39.returntestBs;
40.}
41.
42.publicvoidsetTestBs(Sets){
43.testBs=s;
44.}
45.
46.publicvoidaddTestB(TestBtb){
47.testBs.add(tb);
48.}
49.
50.publicstaticvoidmain(String[]args){
51.}
52.}
53.
54.publicclassTestB{
55.intid;
56.Stringname;
57.SettestAs=newHashSet();
58.
59.publicTestB(){
60.}
61.
62.publicTestB(intid){
63.setId(id);
64.}
65.
66.publicintgetId(){
67.returnid;
68.}
69.
70.publicvoidsetId(intid){
71.this.id=id;
72.}
73.
74.publicStringgetName(){
75.returnname;
76.}
77.
78.publicvoidsetName(Stringname){
79.this.name=name;
80.}
81.
82.publicSetgetTestAs(){
83.returntestAs;
84.}
85.
86.publicvoidsetTestAs(Sets){
87.testAs=s;
88.}
89.
90.publicvoidaddTestA(TestAta){
91.testAs.add(ta);
92.}
93.
94.publicstaticvoidmain(String[]args){
95.}
96.}
packageorg.Hibernate.auction;
importjava.util.*;
/**
**@authorAdministrator**Tochangethetemplateforthisgeneratedtype
*commentgoto*Window>Preferences>Java>CodeGeneration>Codeand
*Comments
*/
publicclassTestA{
intid;
Stringname;
SettestBs=newHashSet();
publicTestA(){
}
publicTestA(intid){
setId(id);
}
publicintgetId(){
returnid;
}
publicvoidsetId(intid){
this.id=id;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicSetgetTestBs(){
returntestBs;
}
publicvoidsetTestBs(Sets){
testBs=s;
}
publicvoidaddTestB(TestBtb){
testBs.add(tb);
}
publicstaticvoidmain(String[]args){
}
}
publicclassTestB{
intid;
Stringname;
SettestAs=newHashSet();
publicTestB(){
}
publicTestB(intid){
setId(id);
}
publicintgetId(){
returnid;
}
publicvoidsetId(intid){
this.id=id;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicSetgetTestAs(){
returntestAs;
}
publicvoidsetTestAs(Sets){
testAs=s;
}
publicvoidaddTestA(TestAta){
testAs.add(ta);
}
publicstaticvoidmain(String[]args){
}
}测试代码：
Java代码
1.publicvoiddoTest()throwsException{
2.TestAa1=newTestA(1);
3.TestAa2=newTestA(2);
4.TestAa3=newTestA(3);
5.TestBb1=newTestB(1);
6.TestBb2=newTestB(2);
7.TestBb3=newTestB(3);
8.a1.addTestB(b1);
9.a1.addTestB(b2);
10.a1.addTestB(b3);
11.b2.addTestA(a1);
12.b2.addTestA(a2);
13.Sessions=factory.openSession();
14.s=factory.openSession();
15.Sessionsession=factory.openSession();
16.session.save(a1);
17.session.flush();
18.session.close();
19.}
publicvoiddoTest()throwsException{
TestAa1=newTestA(1);
TestAa2=newTestA(2);
TestAa3=newTestA(3);
TestBb1=newTestB(1);
TestBb2=newTestB(2);
TestBb3=newTestB(3);
a1.addTestB(b1);
a1.addTestB(b2);
a1.addTestB(b3);
b2.addTestA(a1);
b2.addTestA(a2);
Sessions=factory.openSession();
s=factory.openSession();
Sessionsession=factory.openSession();
session.save(a1);
session.flush();
session.close();
}测试后连接表的数据为：
testatestb
11
12
13
根据Inverse规则，对这些代码：b2.addTestA(a1);b2.addTestA(a2);建立的关系，数据库并没有存储下来，因为TestB没有责任维护这些关系，所以产生的sql语句自然不会有针对Testa_testB表的操作了。假设应用中真的需要这些方法，那么我们可以修改TestB的方法，让他们注意在维护端类中执行相应的操作以使得关系能够在数据库中保存下来，更改TestB如下：
Java代码
1./**Createdon2004-7-25**Tochangethetemplateforthisgeneratedfilegoto*Window>Preferences>Java>CodeGeneration>CodeandComments*/packageorg.Hibernate.auction;
2.
3.importjava.util.*;
4.
5./**
6.**@authorAdministrator**Tochangethetemplateforthisgeneratedtype
7.*commentgoto*Window>Preferences>Java>CodeGeneration>Codeand
8.*Comments
9.*/
10.publicclassTestB{
11.intid;
12.Stringname;
13.SettestAs=newHashSet();
14.
15.publicTestB(){
16.}
17.
18.publicTestB(intid){
19.setId(id);
20.}
21.
22.publicintgetId(){
23.returnid;
24.}
25.
26.publicvoidsetId(intid){
27.this.id=id;
28.}
29.
30.publicStringgetName(){
31.returnname;
32.}
33.
34.publicvoidsetName(Stringname){
35.this.name=name;
36.}
37.
38.publicSetgetTestAs(){
39.returntestAs;
40.}
41.
42.publicvoidsetTestAs(Sets){
43.testAs=s;
44.}
45.
46.publicvoidaddTestA(TestAta){
47.testAs.add(ta);
48.ta.addTestB(this);
49.}
50.
51.publicstaticvoidmain(String[]args){
52.}
53.}
/**Createdon2004-7-25**Tochangethetemplateforthisgeneratedfilegoto*Window>Preferences>Java>CodeGeneration>CodeandComments*/packageorg.Hibernate.auction;
importjava.util.*;
/**
**@authorAdministrator**Tochangethetemplateforthisgeneratedtype
*commentgoto*Window>Preferences>Java>CodeGeneration>Codeand
*Comments
*/
publicclassTestB{
intid;
Stringname;
SettestAs=newHashSet();
publicTestB(){
}
publicTestB(intid){
setId(id);
}
publicintgetId(){
returnid;
}
publicvoidsetId(intid){
this.id=id;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicSetgetTestAs(){
returntestAs;
}
publicvoidsetTestAs(Sets){
testAs=s;
}
publicvoidaddTestA(TestAta){
testAs.add(ta);
ta.addTestB(this);
}
publicstaticvoidmain(String[]args){
}
}那么测试执行后连接表的数据为：
testatestb
12
13
11
22
测试通过。