组合映射详解

一、组合映射

        组合是关联关系的一种特殊情况，是关联关系耦合度最高的一种关系，组合的主对象和子对象拥有相同的生命周期，主对像消亡的话子对象也会消亡。这里使用雇主和用户作为示例，用户和雇主都拥有联系方式属性，如果这里站在对象角度思考的话，常常会把对象模型绘制成为组合的方式，抽象出来一个共同的联系方式类，然后两种人分别包含相应的联系方式对象即可，向应的对象模型时它的对象示例如下图所示：

        组合对象模型在生成相应的关系模型后会把对应的子类包含到主表中，所以对应的表结构会将相应的属性生成到对应的表中，相应的表结构如下：

  1.1 Employee类及映射文件

         在对象模型中Employee和Contact之间拥有包含关系，在编写代码时需要将Contact对象包含在Employee中。对应的映射文件中也需要有Contact对象的映射，需要使用<component>标签来标明组合的对象，并把对象的属性添加到对象标签中。

      清单一：Employee.java，类文件中除了基本的属性外还需要分装Contact对象，因为它们之间有一层包含关系。

1. package com.src.hibernate;  
2.   
3. public class Employee {  
4.     //id号  
5.     private int id;  
6.     public int getId() {  
7.         return id;  
8.     }  
9.     public void setId(int id) {  
10.         this.id = id;  
11.     }  
12.       
13.     //名称  
14.     private String name;  
15.     public String getName() {  
16.         return name;  
17.     }  
18.     public void setName(String name) {  
19.         this.name = name;  
20.     }  
21.       
22.     //联系对象  
23.     private Contact userContact;  
24.     public Contact getUserContact() {  
25.         return userContact;  
26.     }  
27.     public void setUserContact(Contact userContact) {  
28.         this.userContact = userContact;  
29.     }  
30.       
31. }  

     清单二：Employee.hbm.xml，添加对应的映射文件，映射的组合对象要使用<component>来标明，并在该标签中添加对应的对象属性，具体如下代码：

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.     <class name="com.src.hibernate.Employee" table="t_employee">  
7.         <id name="id">  
8.             <generator class="native"/>  
9.         </id>  
10.           
11.         <property name="name"/>  
12.         <component name="employeeContact">  
13.             <property name="email"/>  
14.             <property name="address"/>  
15.             <property name="zipCode"/>  
16.             <property name="contactTel"/>  
17.         </component>  
18.     </class>  
19. </hibernate-mapping>  

  1.2 User类及配置文件

      清单三：User.java，它的内容结构和Employee.java的相同，其它的不再多说，看代码：

1. <pre name="code" class="java">package com.src.hibernate;  
2.   
3. public class User {  
4.     //id号  
5.     private int id;  
6.     public int getId() {  
7.         return id;  
8.     }  
9.     public void setId(int id) {  
10.         this.id = id;  
11.     }  
12.       
13.     //姓名  
14.     private String name;  
15.     public String getName() {  
16.         return name;  
17.     }  
18.     public void setName(String name) {  
19.         this.name = name;  
20.     }  
21.       
22.     //联系对象  
23.     private Contact userContact;  
24.     public Contact getUserContact() {  
25.         return userContact;  
26.     }  
27.     public void setUserContact(Contact userContact) {  
28.         this.userContact = userContact;  
29.     }  
30.       
31. }  

        清单四：User.hbm.xml，它的内容结构同Employee.hbm.xml内容，主要是<component>标签的使用，很简单，代码如下：

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.     <class name="com.src.hibernate.User" table="t_user">  
7.         <id name="id">  
8.             <generator class="native"/>  
9.         </id>  
10.           
11.         <property name="name"/>  
12.         <component name="userContact">  
13.             <property name="email"/>  
14.             <property name="address"/>  
15.             <property name="zipCode"/>  
16.             <property name="contactTel"/>  
17.         </component>  
18.     </class>  
19. </hibernate-mapping>  

   1.3 Contact.java类

       该类文件没有什么需要注意的地方，添加基本的属性即可，也不需要为该类配置对应的映射，所以它的内容相当的简单。

1. package com.src.hibernate;  
2.   
3. public class Contact {  
4.       
5.     //email地址  
6.     private String email;  
7.     public String getEmail() {  
8.         return email;  
9.     }  
10.     public void setEmail(String email) {  
11.         this.email = email;  
12.     }  
13.       
14.     //住址  
15.     private String address;  
16.     public String getAddress() {  
17.         return address;  
18.     }  
19.     public void setAddress(String address) {  
20.         this.address = address;  
21.     }  
22.       
23.     //邮编号  
24.     private String zipCode;  
25.     public String getZipCode() {  
26.         return zipCode;  
27.     }  
28.     public void setZipCode(String zipCode) {  
29.         this.zipCode = zipCode;  
30.     }  
31.       
32.     //联系电话  
33.     private String contactTel;  
34.     public String getContactTel() {  
35.         return contactTel;  
36.     }  
37.     public void setContactTel(String contactTel) {  
38.         this.contactTel = contactTel;  
39.     }  
40. }  

  1.4  生成结果

      经过上面的文件配置后接下来就可以生成相应的数据库表结构了，生成的SQL语句如下：

1. drop table if exists t_employee  
2. drop table if exists t_user  
3. create table t_employee (id integer not null auto_increment, name varchar(255), email varchar(255), address varchar(255), zipCode varchar(255), contactTel varchar(255), primary key (id))  
4. create table t_user (id integer not null auto_increment, name varchar(255), email varchar(255), address varchar(255), zipCode varchar(255), contactTel varchar(255), primary key (id))  

      生成的数据库表结构如下：

二、数据操作

     

      组合映射得到的表结构是一个完整的表，所以在写入和读取数据时采用最原始的方法就可以实现，这里还使用前几篇文章中用到的测试方法来写入和读取数据，分别是使用save和load方法，具体操作见下文。

   2.1 插入数据

       这里使用User作为示例，Employee的写入操作同User。在写入数据时需要创建两个对象，一个是联系对象，另外一个是用户对象，在保存时只需要保存用户对象即可，相应的联系对象会连带着保存。

1. public void testSave1(){  
2.     //声明会话对象  
3.     Session session=null;  
4.       
5.     try{  
6.         //获取会话对象  
7.         session=HibernateUtils.getSession();  
8.         //开启会话  
9.         session.beginTransaction();  
10.           
11.         //创建连接对象  
12.         Contact userContact=new Contact();  
13.         userContact.setAddress("北京市");  
14.         userContact.setContactTel("1243435");  
15.         userContact.setEmail("123@gamil.com");  
16.         userContact.setZipCode("zipCode");  
17.           
18.         //创建用户对象  
19.         User user=new User();  
20.         user.setName("zhangsan");  
21.         user.setUserContact(userContact);  
22.           
23.         session.save(user);  
24.         //提交会话  
25.         session.getTransaction().commit();  
26.     }catch(Exception e){  
27.         e.printStackTrace();  
28.         session.getTransaction().rollback();  
29.     }finally{  
30.         HibernateUtils.closeSession(session);  
31.     }  
32. }  

        生成的SQL语句：

1. insert into t_user (name, email, address, zipCode, contactTel) values (?, ?, ?, ?, ?)  

    查看表结构如下：

  2.2读取操作

        同样使用User作为示例，Employee的操作同User对象。读取操作相当的简单，代码如下：

1. public void testLoad1(){  
2.     //声明会话对象  
3.     Session session=null;  
4.       
5.     try{  
6.         //获取会话对象  
7.         session=HibernateUtils.getSession();  
8.         //开启会话  
9.         session.beginTransaction();  
10.   
11.         //获取user对象  
12.         User user=(User)session.load(User.class, 1);  
13.           
14.         System.out.println("用户姓名： "+user.getName());   
15.         //提交会话  
16.         session.getTransaction().commit();  
17.     }catch(Exception e){  
18.         e.printStackTrace();  
19.         session.getTransaction().rollback();  
20.     }finally{  
21.         HibernateUtils.closeSession(session);  
22.     }  
23. }  

     生成对应的结果如下：

1. Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_, user0_.email as email0_0_, user0_.address as address0_0_, user0_.zipCode as zipCode0_0_, user0_.contactTel as contactTel0_0_ from t_user user0_ where user0_.id=?  
2. 用户姓名： zhangsan  

结语

   组合映射需要使用<component>标签，在该标签中添加需要包含的对象，然后Hibernate会把它生成相应的关系模型，相应的写入数据和读取数据的操作也会很简单。组合映射就介绍到这里，下篇文章将会讨论最后一种映射--集合映射。