博客
关于我
强烈建议你试试无所不能的chatGPT，快点击我
hibernate一对多关联关系配置经验
阅读量：7099 次
发布时间：2019-06-28

本文共 5674 字，大约阅读时间需要 18 分钟。

hot3.png

假使有一个order表和一个customer表，那么它们两者的关系是一个customer可以有多个order，一个order只能属于一个customer，在hibernate中，他们的配置如下：

Xml代码
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping  
  3. PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping >  
  6.   
  7.   <class name="mypack.Customer" table="CUSTOMERS" >  
  8.     <id name="id" type="long" column="ID">  
  9.       <generator class="increment"/>  
  10.     </id>  
  11.   
  12.     <property name="name" type="string" >  
  13.         <column name="NAME" length="15" />  
  14.     </property>  
  15. <!--  
  16.   
  17.     <set   
  18.         name="orders"  
  19.         cascade="all-delete-orphan"   
  20.         inverse="true"  
  21.          >  
  22.           
  23.         <key column="CUSTOMER_ID" />  
  24.         <one-to-many class="mypack.Order" />  
  25.      </set>     
  26. -->  
  27.     <set   
  28.         name="orders"  
  29.         inverse="true"  
  30.         cascade="save-update"   
  31.         >  
  32.           
  33.         <key column="CUSTOMER_ID" />  
  34.         <one-to-many class="mypack.Order" />  
  35.      </set>     
  36.   
  37.   </class>  
  38. </hibernate-mapping>  

 

Xml代码
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping  
  3. PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping >  
  6.   
  7.    <class name="mypack.Order" table="ORDERS">  
  8.        
  9.       <id name="id" type="long" column="ID">  
  10.         <generator class="increment"/>  
  11.       </id>  
  12.      
  13.       <property name="orderNumber" type="string" >  
  14.         <column name="ORDER_NUMBER" length="15" />  
  15.       </property>  
  16.         
  17.       <many-to-one  
  18.         name="customer"  
  19.         column="CUSTOMER_ID"  
  20.         class="mypack.Customer"  
  21.         cascade="save-update"  
  22.        />  
  23.   
  24.     </class>  
  25.    
  26. </hibernate-mapping>  

 

他们的业务类中则有以下方法：

Java代码
  1. package mypack;  
  2.   
  3. import org.hibernate.*;  
  4. import org.hibernate.cfg.Configuration;  
  5. import java.util.*;  
  6.   
  7. public class BusinessService{  
  8.   public static SessionFactory sessionFactory;  
  9.   private Long idOfTom;  
  10.   private Long idOfTomOrder;  
  11.   private Long idOfJack;  
  12.   private Long idOfJackOrder;  
  13.   
  14.   static{  
  15.      try{  
  16.        Configuration config = new Configuration();  
  17.        config.configure();  
  18.        sessionFactory = config.buildSessionFactory();  
  19.     }catch(RuntimeException e){e.printStackTrace();throw e;}  
  20.   }  
  21.   
  22.   public void printOrdersOfCustomer(Long customerId){  
  23.     Session session = sessionFactory.openSession();  
  24.     Transaction tx = null;  
  25.     try {  
  26.       tx = session.beginTransaction();  
  27.       Customer customer=(Customer)session.get(Customer.class,customerId);  
  28.       printOrders(customer.getOrders());  
  29.       tx.commit();  
  30.     }catch (RuntimeException e) {  
  31.       if (tx != null) {  
  32.          tx.rollback();  
  33.       }  
  34.       throw e;  
  35.     } finally {  
  36.        session.close();  
  37.     }  
  38.   }  
  39.   
  40.   public void saveCustomerAndOrderWithCascade(){  
  41.     Session session = sessionFactory.openSession();  
  42.     Transaction tx = null;  
  43.     try {  
  44.       tx = session.beginTransaction();  
  45.   
  46.       Customer customer=new Customer("Tom",new HashSet());  
  47.       Order order=new Order();  
  48.       order.setOrderNumber("Tom_Order001");  
  49.   
  50.       order.setCustomer(customer);  
  51.       customer.getOrders().add(order);  
  52.   
  53.       session.save(customer);  
  54.       tx.commit();  
  55.       idOfTom=customer.getId();  
  56.       idOfTomOrder=order.getId();    
  57.                     
  58.     }catch (RuntimeException e) {  
  59.       if (tx != null) {  
  60.         tx.rollback();  
  61.       }  
  62.       e.printStackTrace();  
  63.     } finally {  
  64.       session.close();  
  65.     }  
  66.   }  
  67.   
  68.     public void associateCustomerAndOrder(){  
  69.     Session session = sessionFactory.openSession();  
  70.     Transaction tx = null;  
  71.     try {  
  72.       tx = session.beginTransaction();  
  73.       Customer customer=(Customer)session.load(Customer.class,idOfJack);  
  74.       Order order=(Order)session.load(Order.class,idOfJackOrder);  
  75.       order.setCustomer(customer);  
  76.       customer.getOrders().add(order);  
  77.       tx.commit();  
  78.     }catch (RuntimeException e) {  
  79.       if (tx != null) {  
  80.         tx.rollback();  
  81.       }  
  82.        e.printStackTrace();  
  83.     } finally {  
  84.       session.close();  
  85.     }  
  86.   }  
  87.   
  88.   public void saveCustomerAndOrderSeparately(){  
  89.     Session session = sessionFactory.openSession();  
  90.     Transaction tx = null;  
  91.     try {  
  92.       tx = session.beginTransaction();  
  93.   
  94.       Customer customer=new Customer();  
  95.       customer.setName("Jack");  
  96.   
  97.       Order order=new Order();  
  98.       order.setOrderNumber("Jack_Order001");  
  99.   
  100.       session.save(customer);  
  101.       session.save(order);  
  102.         
  103.       tx.commit();  
  104.       idOfJack=customer.getId();  
  105.       idOfJackOrder=order.getId();   
  106.     }catch (RuntimeException e) {  
  107.       if (tx != null) {  
  108.         tx.rollback();  
  109.       }  
  110.        e.printStackTrace();  
  111.     } finally {  
  112.       session.close();  
  113.     }  
  114.   }  
  115.   
  116.   public void deleteCustomer(Long customerId){  
  117.     Session session = sessionFactory.openSession();  
  118.     Transaction tx = null;  
  119.     try {  
  120.       tx = session.beginTransaction();  
  121.       Customer customer=(Customer)session.load(Customer.class,customerId);  
  122.       session.delete(customer);  
  123.       tx.commit();  
  124.   
  125.     }catch (RuntimeException e) {  
  126.       if (tx != null) {  
  127.         tx.rollback();  
  128.       }  
  129.        e.printStackTrace();  
  130.     } finally {  
  131.       session.close();  
  132.     }  
  133.   }  
  134.   
  135.   public void removeOrderFromCustomer(Long customerId){  
  136.     Session session = sessionFactory.openSession();  
  137.     Transaction tx = null;  
  138.     try {  
  139.       tx = session.beginTransaction();  
  140.       Customer customer=(Customer)session.load(Customer.class,customerId);  
  141.       Order order=(Order)customer.getOrders().iterator().next();  
  142.   
  143.       //½â³ýCustomerºÍOrderµÄ¹ØÁª¹Øϵ  
  144.       customer.getOrders().remove(order);  
  145.       order.setCustomer(null);  
  146.       tx.commit();  
  147.   
  148.     }catch (RuntimeException e) {  
  149.       if (tx != null) {  
  150.         tx.rollback();  
  151.       }  
  152.        e.printStackTrace();  
  153.     } finally {  
  154.       session.close();  
  155.     }  
  156.   }  
  157.   
  158.   public void printOrders(Set orders){  
  159.       for (Iterator it = orders.iterator(); it.hasNext();) {  
  160.          Order order=(Order)it.next();  
  161.          System.out.println("OrderNumber of "+order.getCustomer().getName()+ " :"+order.getOrderNumber());  
  162.       }  
  163.   }  
  164.   
  165.    public void saveCustomerAndOrderWithInverse(){  
  166.       saveCustomerAndOrderSeparately();  
  167.       associateCustomerAndOrder();  
  168.    }  
  169.    public void test(){  
  170.   
  171.       saveCustomerAndOrderWithCascade();  
  172.       saveCustomerAndOrderWithInverse();  
  173.       printOrdersOfCustomer(idOfTom);  
  174.       deleteCustomer(idOfJack);  
  175.       removeOrderFromCustomer(idOfTom);  
  176.   }  
  177.   
  178.   public static void main(String args[]){  
  179.     new BusinessService().test();  
  180.     sessionFactory.close();  
  181.   }  
  182. }  

 

由以上代码执行时的效率和打印的sql语句，我们可以得出以下经验：1.应把one的一方的<set>元素的inverse属性，设置为true，因此hibernate不会因为customer对象的属性变化来同步更新数据库，以提高性能。  2.在建立关联关系之后，在进行更新操作的时候，最好操作关联两端的对象的相关属性。如：

Java代码
  1. order.setCustomer(customer);  
  2. customer.getOrders().add(order);  

 这样会是程序更加健壮，提高业务逻辑的独立性，使代码不收hibernate实现的影像。同理，当解除双向关联关系时，也该操作关联双发的对应属性，如：

Java代码
  1. customer.getOrders().remove(order);  
  2. order.setCustomer(null);  

 

转载于:https://my.oschina.net/bluesroot/blog/222524

你可能感兴趣的文章
hibernate系列（四）一对一关联关系
查看>>
Ajax 回忆录
查看>>
android开发之实现动态打勾效果(DrawHookView)
查看>>
btrace一些你不知道的事(源码入手)
查看>>
深入浅出jackrabbit之十四 分布式文档提取
查看>>
[算法系列之八]大数问题（高精度运算）
查看>>
WPF和WinRT中的导航问题
查看>>
apiCloud使用微信转发时的注意事项
查看>>
安卓开发者的小程序入门整理 页面跳转&生命周期
查看>>
14.当心命名函数表达式笨拙的作用域
查看>>
在HotFix SDK中接入Tinker
查看>>
我想邀请你和我一起学Android
查看>>
angular6 子组件向父组件通信
查看>>
flutter demo （四）：对话框
查看>>
Redux compose()方法解析：
查看>>
JavaScript中Map与JSON转换要小心
查看>>
安卓手机上传图片后无响应
查看>>
Android防护扫盲篇
查看>>
spring 集成 webservice 进过反复测试终于完成了
查看>>
原型----《你不知道的js》
查看>>
喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！
当前时间: 2025-02-08 19:53:53   当前IP: 3.15.226.195   联系邮箱:javaeecc@qq.com     Copyright © 2020 - 2022 baihongyu.com 京ICP备2021015314号-2
强烈建议你试试无所不能的CHAT-GPT，快点击我
强烈建议你试试无所不能的CHAT-GPT，快点击我