*设为首页
*加入收藏
>> 首页 ┊ 业界新闻 ┊ 语言基础 ┊ 环境配置 ┊ 数据库应用 ┊ J2EE ┊ J2ME ┊ JAVA代码 ┊ 认证考试 ┊ 实用技巧
热门关键字：　JAVA
>>当前位置：Java大本营>环境配置>文章内容
hibernate3学习笔记(十八)｜关系映射：一对多
作者： 发布时间：2008-09-03 18:51:26

User对Room是多对一的关系，那么反过来Room对User就是一对多的关系了。

User.java：

  1. package com.hb3.pack_17.model;
  3. public class User {
  5.     private Integer id;
  6.     private String name;
  7.     
  8.     public User() {
  9.     }
  11.     public Integer getId() {
  12.         return id;
  13.     }
  14.     public void setId(Integer id) {
  15.         this.id = id;
  16.     }
  17.     public String getName() {
  18.         return name;
  19.     }
  20.     public void setName(String name) {
  21.         this.name = name;
  22.     }
  23. }

Room.java：

  1. package com.hb3.pack_17.model;
  3. import java.util.Set;
  5. public class Room {
  7.     private Integer id; 
  8.     private String address;
  9.     private Set<User> users;
  10.     
  11.     public Room() {
  12.     }
  13.     
  14.     public Integer getId() { 
  15.         return id; 
  16.     } 
  17.     public void setId(Integer id) { 
  18.         this.id = id; 
  19.     }
  20.     public String getAddress() { 
  21.         return address; 
  22.     }
  23.     public void setAddress(String address) { 
  24.         this.address = address; 
  25.     }
  26.     public Set<User> getUsers() {
  27.         return users;
  28.     }
  29.     public void setUsers(Set<User> users) {
  30.         this.users = users;
  31.     }
  32.     public void addUser(User user) {
  33.         users.add(user);        
  34.     }
  35.     public void removeUser(User user) {
  36.         users.remove(user);
  37.     }
  38. }

Room.hbm.xml：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping 
  3.     PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  6. <hibernate-mapping>
  8.     <class name="com.hb3.pack_17.model.Room" table="room"> 
  9.     
  10.         <id name="id" column="id"> 
  11.             <generator class="native"/> 
  12.         </id> 
  13.         
  14.         <property name="address" 
  15.                   column="address" 
  16.                   type="java.lang.String"/> 
  17.                   
  18.         <set name="users" table="user" cascade="all">
  19.             <key column="room_id"/>
  20.             <one-to-many class="com.hb3.pack_17.model.User"/>
  21.         </set>
  22.         
  23.     </class> 
  24. </hibernate-mapping>

User.hbm.xml：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping 
  3.     PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  6. <hibernate-mapping> 
  8.     <class name="com.hb3.pack_17.model.User" table="user">
  9.     
  10.         <id name="id" column="id" type="java.lang.Integer"> 
  11.             <generator class="native"/> 
  12.         </id> 
  14.         <property name="name" column="name" type="java.lang.String"/> 
  15.         
  16.     </class> 
  18. </hibernate-mapping>

测试代码：

  1. package com.hb3.pack_17;
  3. import java.io.IOException;
  4. import java.sql.SQLException;
  5. import java.util.HashSet;
  7. import org.hibernate.Session;
  8. import org.hibernate.SessionFactory;
  9. import org.hibernate.Transaction;
  10. import org.hibernate.cfg.Configuration;
  12. import com.hb3.pack_17.model.Room;
  13. import com.hb3.pack_17.model.User;
  16. public class BusinessService {
  18.     public static void main(String[] args) throws IOException, SQLException {
  19.         
  20.         Configuration config = new Configuration().configure();
  21.         SessionFactory sessionFactory = config.buildSessionFactory();      
  22.         Session session = sessionFactory.openSession();
  24.         
  25.         User user1 = new User();
  26.         user1.setName("yangye");      
  27.         User user2 = new User(); 
  28.         user2.setName("shenbin");       
  29.         User user3 = new User(); 
  30.         user3.setName("chenyan"); 
  32.         Room room1 = new Room(); 
  33.         room1.setUsers(new HashSet<User>());
  34.         room1.setAddress("NTU-M8-419");
  35.         room1.addUser(user1);
  36.         room1.addUser(user2);   
  37.         Room room2 = new Room();
  38.         room2.setUsers(new HashSet<User>());
  39.         room2.setAddress("NTU-G3-302");
  40.         room2.addUser(user3);
  41.                 
  42.         Transaction tx = session.beginTransaction();   
  43.         session.save(room1);
  44.         session.save(room2);    
  45.         tx.commit();
  47.         
  48.         session.close();
  49.         sessionFactory.close();
  50.     }
  51. }

双向关联：

以上多对一，一对多的关系都是单向关联，也就是一方联系到另一方，而另一方不知道自己被关联。

如果上方都意识到另一方的存在，则形成双向关联。现将上面的代码改写如下：

在User类中追加Room类型的字段：

  1. package com.hb3.pack_20.model;
  3. public class User {
  5.     private Integer id;
  6.     private String name;
  7.     private Room room;
  8.     
  9.     public Room getRoom() {
  10.         return room;
  11.     }
  13.     public void setRoom(Room room) {
  14.         this.room = room;
  15.     }
  17.     public User() {
  18.     }
  20.     public Integer getId() {
  21.         return id;
  22.     }
  23.     public void setId(Integer id) {
  24.         this.id = id;
  25.     }
  26.     public String getName() {
  27.         return name;
  28.     }
  29.     public void setName(String name) {
  30.         this.name = name;
  31.     }
  32. }

User.hbm.xml中也同样追加关于Room的信息：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping 
  3.     PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  6. <hibernate-mapping> 
  8.     <class name="com.hb3.pack_20.model.User" table="user">
  9.     
  10.         <id name="id" column="id" type="java.lang.Integer"> 
  11.             <generator class="native"/> 
  12.         </id> 
  14.         <property name="name" column="name" type="java.lang.String"/> 
  15.         
  16.         <many-to-one name="room" 
  17.                      column="room_id" 
  18.                      class="com.hb3.pack_20.model.Room"
  19.                      cascade="save-update"
  20.                      outer-join="true"/> 
  21.         
  22.     </class> 
  24. </hibernate-mapping>

这里我们将Room.hbm.xml文件里set的cascade属性也设为save-update：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping 
  3.     PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  6. <hibernate-mapping>
  8.     <class name="com.hb3.pack_20.model.Room" table="room"> 
  9.     
  10.         <id name="id" column="id"> 
  11.             <generator class="native"/> 
  12.         </id> 
  13.         
  14.         <property name="address" 
  15.                   column="address" 
  16.                   type="java.lang.String"/> 
  17.                   
  18.         <set name="users" table="user" cascade="save-update">
  19.             <key column="room_id"/>
  20.             <one-to-many class="com.hb3.pack_20.model.User"/>
  21.         </set>
  22.         
  23.     </class> 
  24. </hibernate-mapping>

这样我们可以用多对一的方式来维持管理：

  1. package com.hb3.pack_20;
  3. import org.hibernate.Session;
  4. import org.hibernate.SessionFactory;
  5. import org.hibernate.Transaction;
  6. import org.hibernate.cfg.Configuration;
  8. import com.hb3.pack_20.model.Room;
  9. import com.hb3.pack_20.model.User;
  11. public class BusinessService {
  13.     public static void main(String[] args) {
  14.         
  15.         Configuration config = new Configuration().configure();
  16.         SessionFactory sessionFactory = config.buildSessionFactory();      
  17.         Session session = sessionFactory.openSession();
  19.         
  20.         User user1 = new User();
  21.         user1.setName("chenyan"); 
  22.                 
  23.         User user2 = new User(); 
  24.         user2.setName("shenbin"); 
  26.         Room room1 = new Room(); 
  27.         room1.setAddress("NTU-M8-419");
  29.         user1.setRoom(room1);
  30.         user2.setRoom(room1);
  31.                 
  32.         Transaction tx = session.beginTransaction();     
  33.         session.save(user1);
  34.         session.save(user2);
  35.         tx.commit();
  38.         session.close();
  39.         sessionFactory.close();
  40.     }
  41. }

或者反过来由一对多的方式来维持关系：

  1. package com.hb3.pack_20;
  3. import java.util.HashSet;
  5. import org.hibernate.Session;
  6. import org.hibernate.SessionFactory;
  7. import org.hibernate.Transaction;
  8. import org.hibernate.cfg.Configuration;
  10. import com.hb3.pack_20.model.Room;
  11. import com.hb3.pack_20.model.User;
  13. public class BusinessService {
  15.     public static void main(String[] args) {
  16.         
  17.         Configuration config = new Configuration().configure();
  18.         SessionFactory sessionFactory = config.buildSessionFactory();      
  19.         Session session = sessionFactory.openSession();
  21.         
  22.         User user1 = new User();
  23.         user1.setName("chenyan"); 
  24.                 
  25.         User user2 = new User(); 
  26.         user2.setName("shenbin"); 
  28.         Room room1 = new Room(); 
  29.         room1.setUsers(new HashSet<User>());
  30.         room1.setAddress("NTU-M8-419");
  31.         room1.addUser(user1);
  32.         room1.addUser(user2);
  33.                 
  34.         Transaction tx = session.beginTransaction();  
  35.         session.save(room1); 
  36.         tx.commit();
  39.         session.close();
  40.         sessionFactory.close();
  41.     }
  42. }

但是一对多的方式来维持的话，先看一下生成的SQL文：

Hibernate: insert into room (address) values (?)
Hibernate: insert into user (name, room_id) values (?, ?)
Hibernate: insert into user (name, room_id) values (?, ?)
Hibernate: update user set room_id=? where id=?
Hibernate: update user set room_id=? where id=?

 

可见，如果把一的一方Room作为主控方，多的一方User因为不知道Room的room_id是多少，所以必须等Room和User存储之后再更新room_id。所以在多对一，一对多形成双向关联的时候，应该把控制权交给多的一方，这样比较有效率。理由很简单，就像在公司里一样，老板记住所有员工的名字来得快，还是每个员工记住老板的名字来得快。

 

基于这个理由，我们对Room.hbm.xml再稍作修改：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping 
  3.     PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  6. <hibernate-mapping>
  8.     <class name="com.hb3.pack_20.model.Room" table="room"> 
  9.     
  10.         <id name="id" column="id"> 
  11.             <generator class="native"/> 
  12.         </id> 
  13.         
  14.         <property name="address" 
  15.                   column="address" 
  16.                   type="java.lang.String"/> 
  17.                   
  18.         <set name="users" table="user" cascade="save-update" inverse="true">
  19.             <key column="room_id"/>
  20.             <one-to-many class="com.hb3.pack_20.model.User"/>
  21.         </set>
  22.         
  23.     </class> 
  24. </hibernate-mapping>

如此控制权就交给了多的一方。当直接存储一的一方前，必须让多的一方意识的一的一方的存在。

  1. package com.hb3.pack_20;
  3. import java.io.IOException;
  4. import java.sql.SQLException;
  5. import java.util.HashSet;
  7. import org.hibernate.Session;
  8. import org.hibernate.SessionFactory;
  9. import org.hibernate.Transaction;
  10. import org.hibernate.cfg.Configuration;
  12. import com.hb3.pack_20.model.Room;
  13. import com.hb3.pack_20.model.User;
  15. public class BusinessService {
  17.     public static void main(String[] args) throws IOException, SQLException {
  18.         
  19.         Configuration config = new Configuration().configure();
  20.         SessionFactory sessionFactory = config.buildSessionFactory();      
  21.         Session session = sessionFactory.openSession();
  23.         
  24.         User user1 = new User();
  25.         user1.setName("bush"); 
  26.                 
  27.         User user2 = new User(); 
  28.         user2.setName("caterpillar"); 
  30.         Room room1 = new Room(); 
  31.         room1.setUsers(new HashSet<User>());
  32.         room1.setAddress("NTU-M8-419");
  33.         room1.addUser(user1);
  34.         room1.addUser(user2);
  36.         //多方必须认识到单方的存在
  37.         user1.setRoom(room1);
  38.         user2.setRoom(room1);
  39.                 
  40.         Transaction tx = session.beginTransaction();     
  41.         session.save(room1); 
  42.         tx.commit();
  45.         session.close();
  46.         sessionFactory.close();
  47.     }
  48. }

此时生成的SQL文为：

Hibernate: insert into room (address) values (?)
Hibernate: insert into user (name, room_id) values (?, ?)
Hibernate: insert into user (name, room_id) values (?, ?)

从而提高了效率。

 

如果把代码中user1.setRoom(room1);和user2.setRoom(room1);这2行移去，你会发现数据库中room_id的值为null。这个结果就好比在多对一的关系中没有分配给User一个Room，那么理所当然room_id的值为null了。


· Injecting the security token into t(09-03)
 · 扩展DataView实现（MultiSelect）多行(09-02)
· java取系统时间(09-02)
 · Ext实现页面表单Enter全键盘导航(09-02)
· ajax和dwr入门学习(09-02)
 · 用java写的程序：1-100随机数相加(09-02)
· Struts 2视频开发教程--第二讲，第一(09-02)
 · 不同版本MyEclipse生成的HibernateSes(09-02)
· 关于Http和Hibernatet里面Session的区(09-02)
 · 从http协议看无法获取网页charset的原(09-02)
·Tomcat安装配置 (01-20)
 ·Windows下JAVA和ANT的环境变量设置 (01-07)
复制地址发给您的好友: [推荐文章] [返回顶部] [关闭窗口]
版权所有 Java大本营 1999-2007 转载请注明出处