Hibernate笔记2--映射对象之间的关系

 今天心情好。。建了一个比笔记1那篇更简单的表来演示Foo程序：）

 

一。数据库格式

user表

address表

address表持有user_id外键，由此应该可以看出两张表表示的关系为： “1个用户可以拥有多个地址”

 

二。双向关联

下面生成POJO对象：

1. package model;
3. /**
4.  * Address entity.
5.  * 
6.  * @author MyEclipse Persistence Tools
7.  */
9. public class Address implements java.io.Serializable {
11.     // Fields
13.     private Integer addressId;
14.     private User user;
15.     private String addressDetail;
17.     // Constructors
19.     /** default constructor */
20.     public Address() {
21.     }
23.     /** minimal constructor */
24.     public Address(User user) {
25.         this.user = user;
26.     }
28.     /** full constructor */
29.     public Address(User user, String addressDetail) {
30.         this.user = user;
31.         this.addressDetail = addressDetail;
32.     }
34.     // Property accessors
36.     public Integer getAddressId() {
37.         return this.addressId;
38.     }
40.     public void setAddressId(Integer addressId) {
41.         this.addressId = addressId;
42.     }
44.     public User getUser() {
45.         return this.user;
46.     }
48.     public void setUser(User user) {
49.         this.user = user;
50.     }
52.     public String getAddressDetail() {
53.         return this.addressDetail;
54.     }
56.     public void setAddressDetail(String addressDetail) {
57.         this.addressDetail = addressDetail;
58.     }
60. }

1. package model;
3. import java.util.HashSet;
4. import java.util.Set;
6. /**
7.  * User entity.
8.  * 
9.  * @author MyEclipse Persistence Tools
10.  */
12. public class User implements java.io.Serializable {
14.     // Fields
16.     private Integer userId;
17.     private String userName;
18.     private Set addresses = new HashSet(0);
20.     // Constructors
22.     /** default constructor */
23.     public User() {
24.     }
26.     /** minimal constructor */
27.     public User(String userName) {
28.         this.userName = userName;
29.     }
31.     /** full constructor */
32.     public User(String userName, Set addresses) {
33.         this.userName = userName;
34.         this.addresses = addresses;
35.     }
37.     // Property accessors
39.     public Integer getUserId() {
40.         return this.userId;
41.     }
43.     public void setUserId(Integer userId) {
44.         this.userId = userId;
45.     }
47.     public String getUserName() {
48.         return this.userName;
49.     }
51.     public void setUserName(String userName) {
52.         this.userName = userName;
53.     }
55.     public Set getAddresses() {
56.         return this.addresses;
57.     }
59.     public void setAddresses(Set addresses) {
60.         this.addresses = addresses;
61.     }
63. }

由于是双向关联，因此生成的2个POJO对象都会持有对方对象。并且1对N中，1方持有N方Set集合，N方持有1方单个对象。

 

下面是生成的映射配置：

Address.hbm.xml

1. <?xml version="1.0" encoding="utf-8"?>
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4. <!-- 
5.     Mapping file autogenerated by MyEclipse Persistence Tools
6. -->
7. <hibernate-mapping>
8.     <class name="model.Address" table="address" catalog="email">
9.         <id name="addressId" type="java.lang.Integer">
10.             <column name="address_id" />
11.             <generator class="identity" />
12.         </id>
13.         <many-to-one name="user" class="model.User" fetch="select">
14.             <column name="user_id" not-null="true" />
15.         </many-to-one>
16.         <property name="addressDetail" type="java.lang.String">
17.             <column name="address_detail" length="45" />
18.         </property>
19.     </class>
20. </hibernate-mapping>

User.hbm.xml

2. <?xml version="1.0" encoding="utf-8"?>
3. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
5. <!-- 
6.     Mapping file autogenerated by MyEclipse Persistence Tools
7. -->
8. <hibernate-mapping>
9.     <class name="model.User" table="user" catalog="email">
10.         <id name="userId" type="java.lang.Integer">
11.             <column name="user_id" />
12.             <generator class="identity" />
13.         </id>
14.         <property name="userName" type="java.lang.String">
15.             <column name="user_name" length="45" not-null="true" />
16.         </property>
17.         <set name="addresses" inverse="true">
18.             <key>
19.                 <column name="user_id" not-null="true" />
20.             </key>
21.             <one-to-many class="model.Address" />
22.         </set>
23.     </class>
24. </hibernate-mapping>

双向1：N关系基本配置很容易套格式，要注意的是在1方配置inverse="true"，意思就是将控制方向交给N方会比较高效一点：）。具体后面解释inverse的概念。

 

下面是一个简单的TestCase，演示保存操作：）

1. import java.util.HashSet;
2. import java.util.Set;
4. import model.Address;
5. import model.User;
7. import org.hibernate.HibernateException;
8. import org.hibernate.Session;
9. import org.hibernate.SessionFactory;
10. import org.hibernate.cfg.Configuration;
11. import org.junit.Before;
12. import org.junit.Test;
14. public class TestCase2 {
16.     Session session = null;
18.     @Before
19.     // 读取classpath下的配置文件hibernate.cfg.xml
20.     // current_session_context_class=thread,show_sql=true
21.     public void getSession() {
22.         try {
23.             Configuration cfg = new Configuration().configure();
24.             SessionFactory sf = cfg.buildSessionFactory();
25.             session = sf.getCurrentSession();
26.         } catch (HibernateException e) {
27.             e.printStackTrace();
28.         }
29.     }
30.     
31.     @Test
32.     public void BothSide() {
33.         session.beginTransaction();
34.         User u = new User();
35.         u.setUserName("hello");
36.         
37.         //new Address
38.         Address add = new Address();
39.         add.setAddressDetail("luoyu road 1037#");
40.         u.getAddresses().add(add);
41.         
42.         session.save(u);
43.         session.getTransaction().commit();
44.     }
45. }

BothSide()方法中创建了一个User，一个Address，然后save，run一下用例，查看到Hibernate执行了下面的操作：

    insert     into      user         (user_name)      values         (?)

只保存了user，如果目的就是象方法所写 save(u),那么就是对的。但是更新了User的同时也想保存这个Address怎么办？

 

想同时保存User和Address，需要做如下两处修改：

1.在User.hbm.xml 17行写上cascade="all"（对User的所有操作均级联到Address表上）

2.在BothSide() 39-40行中添加  add.setUser(u); （由于address的user_id外键字段不需为空，不给它赋值就会报错）

具体见下：

User.hbm.xml

1. <?xml version="1.0" encoding="utf-8"?>
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4. <!-- 
5.     Mapping file autogenerated by MyEclipse Persistence Tools
6. -->
7. <hibernate-mapping>
8.     <class name="model.User" table="user" catalog="email">
9.         <id name="userId" type="java.lang.Integer">
10.             <column name="user_id" />
11.             <generator class="identity" />
12.         </id>
13.         <property name="userName" type="java.lang.String">
14.             <column name="user_name" length="45" not-null="true" />
15.         </property>
16.         <set name="addresses" inverse="true" cascade="all">
17.             <key>
18.                 <column name="user_id" not-null="true" />
19.             </key>
20.             <one-to-many class="model.Address" />
21.         </set>
22.     </class>
23. </hibernate-mapping

1.     @Test
2.     public void BothSide() {
3.         session.beginTransaction();
4.         User u = new User();
5.         u.setUserName("hello");
6.         
7.         //new Address
8.         Address add = new Address();
9.         add.setAddressDetail("luoyu road 1037#");
10.         add.setUser(u);
11.         //add Address to user
12.         u.getAddresses().add(add);
13.         
14.         session.save(u);
15.         session.getTransaction().commit();
16.     }

      上面这段代码之所以需要添加add.setUser(u)，最根本的原因就是上面提到的：我在在User方配置了inverse=true.意思就是“双方的关系交给Address你来管理，User我不负责维护关系”，因此User也不会主动去填充Address方的user_id.

      然而，在维护关系的Address一方，我们访问每一个Address对象的时候，都可以获取到User对象.