首页 > 代码库 > 一口一口吃掉Hibernate（四）——多对一单向关联映射

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

2024-10-14 16:51:39   218人阅读

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（四）——多对一单向关联映射


联系
我们