程序博客网 > 淘宝拍摄模特

hibernate3学习笔记(十八)｜关系映射：一对多

来源：互联网 发布：淘宝拍摄模特 编辑：程序博客网 时间：2024/05/22 06:32
 

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了。

淘宝拍摄模特 淘宝拍摄模特
原创粉丝点击
热门IT博客
ubuntu chrome flashubuntu chrome flash
摄影书籍推荐知乎摄影书籍推荐知乎
蒙泰打印管理系统端口
mac安装hbuilder
网络造谣被拘留
购物系统数据库设计
linux 解压7z
meta分析数据提取表格
java sring转换成date
邯郸 邺 知乎
河北网络干部学院app
淘宝购买万艾可的流程
mac pageup page down
linux配置samba服务
机械厂适合的软件
怎么领取淘宝优惠券
淘宝定做戒指
刘亦菲干爹 知乎
关闭mysql服务
网络调研报告的格式
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 测视力度数 深视力检测仪 夜间视力检测仪 体检视力测试表 去医院测视力 测视力的表 测量视力 测视力多少算近视 自己如何测视力 眼镜店测视力 测视力的距离是多少 视力检查报告 测眼睛视力的图 测视力看不见 1.5视力训练仪 自测视力 近视测试图 近视测试 手机怎么自测视力 小孩多大可以检查视力 职业测评师 网络安全测评师 环境测评师考试科目 心理测评师是什么 等保测评师 笔记本测评网 好运棋牌测评网 电视测评网 焦虑测评量表 多动症测评量表 抑郁测评表 抑郁症测评表 焦虑症测评表 抑郁自测量表在线测评 自闭症量表在线测评 焦虑测评表 心理测评表 抑郁症测评量表 抑郁测评量表 散光度数测试图1到3 测试农业1

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里