`
langgufu
  • 浏览: 2305591 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

正确理解Hibernate Inverse (转)

阅读更多

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

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

这篇文章已经详细分析了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/>。

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

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

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

测试代码:

  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. }

测试后连接表的数据为:

testa testb

1 1

1 2

1 3

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

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

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

testa testb

1 2

1 3

1 1

2 2

测试通过。

分享到:
评论

相关推荐

    彻底明白Hibernate中的Inverse

    总结来说,理解并合理运用Hibernate中的`Inverse`属性对于优化数据操作、提高代码可读性和维护性具有重要意义。通过精确控制关联的维护责任,我们可以更好地管理对象关系,实现高效且一致的数据库操作。

    hibernate inverse 个人总结.doc

    在探讨Hibernate的`inverse`属性之前,我们先要理解Hibernate中的对象关系映射(ORM)以及持久化机制。Hibernate是一个流行的Java ORM框架,它允许开发者将数据库操作转换为面向对象的编程模型,使得数据操作更加...

    hibernate inverse和cascade的详细讲解

    - **多对多**:例如,一个`Student`和多个`Course`课程的关系,`inverse`属性通常放在独立的关系表中,并且只能在一方设置为`true`,另一方为`false`,以确保关系的正确维护。 #### 三、Cascade 属性详解 `cascade...

    JavaEE学习笔记之Hibernate表关系之一对多(inverse详解)

    综上所述,理解并正确使用Hibernate中的`inverse`属性对于优化JavaEE应用的数据库操作和提高代码质量具有重要意义。通过深入掌握这一特性,开发者能够更好地管理对象之间的关联,提升应用的性能和稳定性。

    Hibernate中cascade和inverse应用

    在实际应用中,需要根据业务需求谨慎选择 `cascade` 和 `inverse` 的值,以确保数据的正确性和效率。 总之,`cascade` 和 `inverse` 是 Hibernate 中用来优化对象关系管理的两个关键特性,它们可以帮助开发者更有效...

    hibernate常用注解

    ### Hibernate常用注解详解 #### 一、JPA与Hibernate注解基础 JPA(Java Persistence API)是一种标准规范,用于实现对象关系映射(ORM),允许...理解和熟练掌握这些注解对于使用Hibernate进行持久化操作至关重要。

    inverse=true的总结

    在开发中,理解并正确使用`inverse`属性对IDEA、Eclipse等开发工具的实体类生成和数据库同步功能至关重要。这些工具通常会根据`inverse`属性生成相应的SQL语句,因此理解这一特性有助于避免由工具生成的代码产生...

    Hibernate电子书(全)

    正确设置`inverse`可以确保Hibernate在处理关联关系时的行为符合预期。 #### 一对一与多对多实体映射 Hibernate支持一对一和多对多关系的映射,分别通过`@OneToOne`和`@ManyToMany`注解实现。这些映射策略使得复杂...

    hibernate

    根据提供的文件信息,我们可以深入探讨Hibernate框架中的几个关键概念,特别是`fetch`, `lazy`, `cascade`, 和 `inverse`关键字的使用与理解。这四个概念在处理对象关系映射(ORM)时非常重要,尤其是在Java环境下...

    hibernate bag 集合映射

    源码分析有助于理解Hibernate的工作原理,而工具可能是简化配置或调试的辅助手段。 在文件名“bagMapping”中,我们可能假设这是一个示例或教程,包含有关如何设置和使用bag映射的配置文件、Java实体类和可能的测试...

    关联映射cascade,inverse讲解

    通过阅读和实践这些代码,你可以更深入地理解Hibernate的关联映射,掌握cascade和inverse的实际应用技巧。 总之,理解并熟练运用Hibernate的关联映射、cascade和inverse是提升Java持久化编程能力的关键步骤。它们...

    Hibernate常见问题

    理解并正确使用Hibernate的`cascade`和`inverse`属性对于优化数据操作和避免数据一致性问题至关重要。在实际开发中,应根据业务逻辑和数据模型谨慎设定这些属性,以确保数据操作的正确性和高效性。

    hibernate延迟加载解决

    2. **调试考虑:**在调试时,如果使用了延迟加载,要注意查看代理对象的实际类型,以确保正确理解其行为。 3. **性能考量:**虽然延迟加载可以减少初始加载时间,但过多的延迟加载也可能导致更多的数据库往返,因此...

Global site tag (gtag.js) - Google Analytics