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

Posted 我是修电脑的

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了一口一口吃掉Hibernate——多对一单向关联映射相关的知识,希望对你有一定的参考价值。

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——多对一单向关联映射的主要内容,如果未能解决你的问题,请参考以下文章

一口一口吃掉Hibernate——多对多关联映射

一口一口吃掉Hibernate——Hibernate中inverse的用法

一口一口吃掉Hibernate——继承映射

Hibernate框架学习之注解配置关系映射

Hibernate单向“多对一”关联

Hibernate,关系映射的多对一单向关联多对一双向关联一对一主键关联一对一外键关联多对多关系关联