日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側工具欄

新聞中心

這里有您想知道的互聯(lián)網營銷解決方案
正確理解HibernateInverse

通過Hibernate Inverse的設置來決定是由誰來維護表和表之間的關系。最近有朋友問我Hibernate關于多對多關于刪除中間表數(shù)據(jù)的問題,關鍵是Inverse的設置,下面引用網友的一篇文章。

創(chuàng)新互聯(lián)公司-專業(yè)網站定制、快速模板網站建設、高性價比墊江網站開發(fā)、企業(yè)建站全套包干低至880元,成熟完善的模板庫,直接使用。一站式墊江網站制作公司更省心,省錢,快速模板網站建設找我們，業(yè)務覆蓋墊江地區(qū)。費用合理售后完善，十載實體公司更值得信賴。

Inverse是Hibernate雙向關系中的基本概念，當然對于多數(shù)實體，我們并不需要雙向關聯(lián)，更多的可能會選擇單向關聯(lián)，況且我們大多數(shù)人 一般采用一對多關系，而一對多雙向關聯(lián)的另一端：多對一的Inverse屬性是不存在，其實它默認就是Inverse=false.從而防止了在一對多端 胡亂設置Inverse也不至于出錯。但是Inverse設置不當確實會帶來很大的性能影響，這點是我們必須關注的。

這篇文章已經詳細分析了Hibernate Inverse設置不當帶來的影響：http：//www.Hibernate.org/155.html,看了這篇文章，還是很有必要再寫下一些總結的：

1）Hibernate Inverse中提及的side其實是指一個類或者表的概念，雙向關聯(lián)其實是指雙方都可以取得對方的應用。

2）維護關系這個名詞還是稍顯模糊或者晦澀。我們一般說A類或者A表（這里的表的是指多對多的連接表）有責任維護關系，其實這里的意思是說，我在應 用在更新，創(chuàng)建，刪除（讀就不用說了，雙向引用正是為了方便讀而出現(xiàn)）A類或者A表時，此時創(chuàng)建的SQL語句必須有責任保證關系的正確修改。

3）Inverse=false的side（side其實是指Inverse＝false所位于的class元素）端有責任維護關系，而Inverse＝true端無須維護這些關系。

4）我們說Hibernate Inverse設立不當會導致性能低下，其實是說Inverse設立不當，會產生多余重復的SQL語句甚至致使JDBC exception的throw。這是我們在建立實體類關系時必須需要關注的地方。一般來說，Inverse＝true是推薦使用，雙向關聯(lián)中雙方都設置 Inverse＝false的話，必會導致雙方都重復更新同一個關系。但是如果雙方都設立Inverse＝true的話，雙方都不維護關系的更新，這也是 不行的，好在一對多中的一端：many-to-one默認是Inverse＝false，避免了這種錯誤的產生。但是多對多就沒有這個默認設置了，所以很 多人經常在多對多的兩端都使用Inverse＝true，結果導致連接表的數(shù)據(jù)根本沒有記錄，就是因為他們雙分都沒有責任維護關系。所以說，雙向關聯(lián)中***的設置是一端為Inverse＝true，一端為Inverse＝false。一般Inverse＝false會放在多的一端，那么有人提問了， many－to－many兩邊都是多的，Inverse到底放在哪兒？其實Hibernate建立多對多關系也是將他們分離成兩個一對多關系，中間連接一 個連接表。所以通用存在一對多的關系，也可以這樣說：一對多是多對多的基本組成部分。

看下面的多對多的定義大家更會清楚”多對多“與“一對多”的關系：其中我們注意標簽的特點就知道，它是定義了一個多對多關系，而不是。

 
 
 
    
  
  
  
  1.    
    2. 
  
  
  
  2. 
  
  
  
  3. "-//Hibernate/Hibernate Mapping DTD 2.0//EN"   
    4. 
  
  
  
  4. "http：//Hibernate.sourceforge.net/Hibernate-mapping-2.0.dtd">   
    5. 
  
  
  
  5.    
    6. 
  
  
  
  6. 
  
  
  
  7. dynamic-update="true" dynamic-insert="true" >  
    8. 
  
  
  
  8.       
    9. 
  
  
  
  9.        
    10. 
  
  
  
  10.        
    11. 
  
  
  
  11.      
    12. 
  
  
  
  12.    
  
  
  
  13.     update="true" insert="true" column="name" />  
    14. 
  
  
  
  14.       
    15. 
  
  
  
  15.        
    16. 
  
  
  
  16.        
    17. 
  
  
  
  17.      
    18. 
  
  
  
  18.    
    19. 
  
  
  
  19. 
  
  
  
  20. dynamic-update="true" dynamic-insert="true" >  
    21. 
  
  
  
  21.       
    22. 
  
  
  
  22.        
    23. 
  
  
  
  23.        
    24. 
  
  
  
  24.      
    25. 
  
  
  
  25.  
    26. 
  
  
  
  26.    
  
  
  
  27.    insert="true" column="name" />  
    28. 
  
  
  
  28.  
    29. 
  
  
  
  29.       
    30. 
  
  
  
  30.        
    31. 
  
  
  
  31.        
    32. 
  
  
  
  32.      
    33. 
  
  
  
  33.    
    34. 
  
  
  
  34.  
    35.

在對多對中，因為一端維護關系另一端不維護關系的原因，我們必須注意避免在應用中用不維護關系的類建立關系，因為這樣建立的關系是不會在數(shù)據(jù)庫中存儲的。基于上面的映射文件代碼給出一個例子：

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

測試代碼：

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

測試后連接表的數(shù)據(jù)為：

testa              testb

1                  1

1                  2

1                  3

根據(jù)Inverse規(guī)則，對這些代碼：b2.addTestA(a1);   b2.addTestA(a2); 建立的關系，數(shù)據(jù)庫并沒有存儲下來，因為TestB沒有責任維護這些關系，所以產生的sql語句自然不會有針對Testa_testB表的操作了。假設應 用中真的需要這些方法，那么我們可以修改TestB的方法，讓他們注意在維護端類中執(zhí)行相應的操作以使得關系能夠在數(shù)據(jù)庫中保存下來，更改TestB如 下：

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

那么測試執(zhí)行后連接表的數(shù)據(jù)為：

testa          testb

1               2

1               3

1               1

2               2

測試通過。

【編輯推薦】

  1. 強人Hibernate文檔筆記（上）
  2. 強人Hibernate文檔筆記（中）
  3. 強人Hibernate文檔筆記（下）
  4. Hibernate一對多關系的處理
  5. Hibernate的性能優(yōu)化

當前名稱：正確理解HibernateInverse
當前路徑：http://m.5511xx.com/article/dhdscse.html