码迷，mamicode.com
首页 > Web开发 > 详细

一口一口吃掉Hibernate（四）——多对一单向关联映射

时间：2017-06-30 23:50:30      阅读：288      评论：0      收藏：0      [点我收藏+]

标签：相同   nal   jsb   有用   finally   t_sql   action   oid   nts   

hibernate对于数据库的操作，全部利用面向对象的思维来理解和实现的。一般的单独表的映射，相信大家都没有问题，但是对于一些表之间的特殊关系，Hibernate提供了一些独特的方式去简化它。

 

      今天就来说说多对一的关联映射。

 

      数据库中有多对一的关系，Hibernate自然也有对象的多对一的关联关系。比如用户和用户组，一个用户只属于一个组，一个组有多名用户。我们就可以说用户和用户组的关系就是多对一的关系。用对象的uml图表示一下：

技术分享

 

      在Hibernate中如何来实现呢？首先定义这两个实体类：

 

  1. package com.bjpowernode.hibernate;  
  2.   
  3. /** 
  4.  * 用户组 
  5.  * @author Longxuan 
  6.  * 
  7.  */  
  8. public class Group {  
  9.   
  10.     private int id;  
  11.     private String name;  
  12.     public int getId() {  
  13.         return id;  
  14.     }  
  15.     public void setId(int id) {  
  16.         this.id = id;  
  17.     }  
  18.     public String getName() {  
  19.         return name;  
  20.     }  
  21.     public void setName(String name) {  
  22.         this.name = name;  
  23.     }  
  24. }  
  25.   
  26.   
  27.   
  28. package com.bjpowernode.hibernate;  
  29.   
  30. /** 
  31.  * 用户类 
  32.  * @author Longxuan 
  33.  * 
  34.  */  
  35. public class User {  
  36.       
  37.     private int  id;  
  38.       
  39.     private String name;  
  40.   
  41.     private Group group;  
  42.       
  43.     public Group getGroup() {  
  44.         return group;  
  45.     }  
  46.   
  47.     public void setGroup(Group group) {  
  48.         this.group = group;  
  49.     }  
  50.   
  51.     public int getId() {  
  52.         return id;  
  53.     }  
  54.       
  55.     public void setId(int id) {  
  56.         this.id = id;  
  57.     }  
  58.   
  59.     public String getName() {  
  60.         return name;  
  61.     }  
  62.   
  63.     public void setName(String name) {  
  64.         this.name = name;  
  65.     }  
  66.   
  67. }  

 

hibernate.cfg.xml配置文件：

 

  1. <!DOCTYPE hibernate-configuration PUBLIC  
  2.     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
  3.     "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">  
  4.   
  5. <hibernate-configuration>  
  6.     <session-factory name="foo">    
  7.           
  8.         <property name="hibernate.dialect" >org.hibernate.dialect.MySQLDialect</property>  
  9.         <property name="hibernate.show_sql">true</property><!-- 设置是否显示生成sql语句 -->  
  10.         <property name="hibernate.format_sql">false</property><!-- 设置是否格式化sql语句-->  
  11.           
  12.         <mapping resource="com/bjpowernode/hibernate/Tables.hbm.xml" />  
  13.     </session-factory>  
  14. </hibernate-configuration>  

 

hibernate.properties配置文件:

 

  1. ## MySQL  
  2.   
  3. hibernate.dialect org.hibernate.dialect.MySQLDialect  
  4. #hibernate.dialect org.hibernate.dialect.MySQLInnoDBDialect  
  5. #hibernate.dialect org.hibernate.dialect.MySQLMyISAMDialect  
  6. hibernate.connection.driver_class com.mysql.jdbc.Driver  
  7. hibernate.connection.url jdbc:mysql://localhost:3306/hibernate_many2one  
  8. hibernate.connection.username root  
  9. hibernate.connection.password root  


      这是最基础的准备工作，多对一映射在对数据进行更改时，会有一些限制。当没有该用户组时，添加用户，就会出错，当该用户组有用户时，删除该用户组也会报错。

 

      我们当然可以按一般的方法来做。添加的时候，先手动添加组，再添加用户。删除时，先删除所有的用户，再删除用户组。但是Hibernate为我们提供了一种便捷的方式——many-to-one。在映射文件hbm.xml中配置后，就可以不用再想那些限制了。Hibernate会自动添加上所引用的数据。

 

      给出映射文件：

 

  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6.       
  7.     <class name="com.bjpowernode.hibernate.User" table="t_user">  
  8.         <id name="id">  
  9.             <generator class="native" />  
  10.         </id>  
  11.         <property name="name"></property>  
  12.         <many-to-one name="group" column="groupid" cascade="save-update"></many-to-one>  
  13.     </class>  
  14.           
  15.     <class name="com.bjpowernode.hibernate.Group" table="t_group">  
  16.         <id name="id">  
  17.             <generator class="native" />  
  18.         </id>  
  19.         <property name="name"></property>  
  20.     </class>  
  21.       
  22. </hibernate-mapping>  

 

       配置了many-to-one会自动在t_user表中创建外键groupid，与t_group的id映射。

技术分享

    many-to-one标签用到了cascade，指定两个对象之间的操作联动关系，对一个对象执行了操作之后，对其指定的级联对象也需要执行相同的操作。其属性值如下： 

  • all：在所有的情况下都执行级联操作；
  • none：在所有情况下都不执行级联操作；
  • save-update：在保存和更新的时候执行级联操作；、
  • delete：在删除的时候执行级联操作。

 

 

    测试类Many2OneTest：

 

  1. package com.bjpowernode.hibernate;  
  2.   
  3. import junit.framework.TestCase;  
  4.   
  5. import org.hibernate.Session;  
  6.   
  7. public class Many2OneTest extends TestCase {  
  8.   
  9.         /** 
  10.          * 测试添加用户 
  11.          */  
  12.         public void testSave3(){  
  13.         Session session = null;  
  14.         try{  
  15.             session = HibernateUtils.getSession();  
  16.             session.beginTransaction();  
  17.               
  18.             Group group = new Group();  
  19.             group.setName("提高班");  
  20.               
  21.             User user1 = new User();  
  22.             user1.setName("张三");  
  23.             user1.setGroup(group);  
  24.               
  25.             User user2 = new User();  
  26.             user2.setName("李四");  
  27.             user2.setGroup(group);  
  28.               
  29.             //普通方法 ：必须先保存group，再保存user  
  30.             //配置了many-to-one 则不用再手动save group了。  
  31.             //session.save(group);  
  32.             session.save(user1);  
  33.             session.save(user2);  
  34.               
  35.             session.getTransaction().commit();  
  36.         }catch(Exception e){  
  37.             e.printStackTrace();  
  38.             session.getTransaction().rollback();  
  39.         }finally{  
  40.             HibernateUtils.closeSession(session);  
  41.         }  
  42.     }  
  43.       
  44. }  

 

      结果图：

技术分享

 

 执行测试前：技术分享  ， 执行测试后： 技术分享 

 

      用many-to-one进行配置后，hibernate会自动去添加外键，而我们做的任何操作都不需要去考虑它的结构，也不用手动去维护这个关系，关系由Hibernate自动维护。这就是Hibernate的魅力所在。

 

一口一口吃掉Hibernate（四）——多对一单向关联映射

标签：相同   nal   jsb   有用   finally   t_sql   action   oid   nts   

原文地址：http://www.cnblogs.com/KingIceMou/p/7100981.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！