6.5 Hibernate之映射组成关系

柔光的暖阳◎ 2022-06-01 02:30 187阅读 0赞

在域模型中，有些类由一个或多个部分类组成，部分类的生命周期依赖于整体类的生命周期，整体消失时，部分也就随之消失。

这种整体与部分的关系称之为聚集关系。

通俗一点说，天天我们接触的电脑，就是一个聚集体，由很多部分构件组合而成。例如，机箱，键盘，鼠标，显示器，驱动，打印机等。

而这里面的部分构件下可能存在很多小的部分构件。

在现实生活中，部分类可能被多个整体类共享。

比如，家里的遥控，既能控制电视，也能控制录像机。也即，既是电视的部分类，也是录像机的组成部分。

在现实生活中，部分类也可能只属于一个整体类。

比如，一个人的手，只能属于特定的某个人。

1.建立精粒度对象模型

假如在Customer（客户）类中定义家庭地址和公司地址。

**\[java\]** view plain copy

print ?

1.  private String homeProvince;//家庭地址所在省份  
2.  private String homeCity;//家庭地址所在城市  
3.  private String homeStreet;//家庭地址所在街道  
4.  private String homeZipCode;//家庭地址邮编  
5.  private String compProvince;//公司地址所在省份  
6.  private String compCity;//公司地址所在城市  
7.  private String compStreet;//公司地址所在街道  
8.  private String compZipCode;//公司地址邮编

private String homeProvince;//家庭地址所在省份
        private String homeCity;//家庭地址所在城市
        private String homeStreet;//家庭地址所在街道
        private String homeZipCode;//家庭地址邮编
        private String compProvince;//公司地址所在省份
        private String compCity;//公司地址所在城市
        private String compStreet;//公司地址所在街道
        private String compZipCode;//公司地址邮编

如果，以后另外一个表Employee（员工）类中需要用到同样的地址信息，再在Employee表中添加以上一堆字段，显得重复累赘。

为了避免这种情况，提高代码的重复利用率和可维护性，将地址部分的属性，单独提出来，做为一个类，地址类Address,而

Customer类和Employee类作为整体类，Address类做为部分类，整体类可以引用部分类，使用时Customer和Employee引用

Address类。

通过这种对象设计思想创建的模型称为精粒度对象模型。

整体与部分类的关系特征如下，Customer和Address：

（1）Address的生命周期依赖于Customer对象的生命周期,随着Customer对象的消失而不存在。每次删除掉Customer对象时，

需要把对象的Address对象删掉，不然，Address中出现’脏数据’。

（2）每个Address对象只能属于特定的Customer对象。一个人只能对应一个当前的家庭住址。

2.建立粗精度关系数据模型

在设计类或者数据库时，都要遵守不要导致数据冗余，减少外键的参照。如果每次对数据库进行增，删，改，查时都需要去做

大量的表关联，严重影响性能。好比如写一个1000行的sql，涉及到很多表，各种函数，视图，过程，关联，可能执行很慢，相对

关系简单，关联少的会更快。

CUSTOMERS表与ADDRESS之间有两种设计方式：

（1）将ADDRESS单独设计成一个表，专存地址，而CUSTOMERS表存信息，CUSTOMERS和ADDRESS之间建立关联。

![Center][]

每次查询用户完成信息时，需要建立两个表之间的关联关系，比如查询名字叫’小明’的信息，可以根据需要在sql中加输出字段。

**\[sql\]** view plain copy

print ?

1.  SELECT PROVINCE,CITY FROM CUSTOMERS cus,ADDRESS ads   
2.  WHERE cus.home\_address\_id = ads.id AND cus.name = ‘小明’

SELECT PROVINCE,CITY FROM CUSTOMERS cus,ADDRESS ads 
    WHERE cus.home_address_id = ads.id AND cus.name = '小明'

这种查询需要建立连接，比较耗时。

（2）第二种设计方案就是把address的字段融合到customers中，建立一个customers表，单独可以从customers表中就能查询出一个用户的详细

信息，不需要建立关联后再进行查询。

3.映射组成关系

建立域模型和数据库有所不同。域模型由程序代码组成，通过细化持久化类，可以达到代码重用的目标，增加可读性，简化编程的复杂度。

关系数据模型，如果数据存在冗余，需要拆分成具有外键参考的表；如果没有冗余，应尽量减少表的数量，简化关联关系，提高查询效率。

建立域模型和数据库关系模型原则不太一样，导致，持久化类和数据库表并不是能够完全对应。有时一个表可能对应多个持久化类。

看一下Customer类的homeAddress，compAddress与CUSTOMERS表字段的对应关系：

![Center 1][]

Customer类：

**\[java\]** view plain copy

print ?

1.  package com.lanhuigu.hibernate.entity;  
2.    
3.  import java.io.Serializable;  
4.  import java.util.Date;  
5.    
6.  import com.sun.jmx.snmp.Timestamp;  
7.    
8.  /\*\* 
9.   \* 创建java持久化类，就是需要被持久化到数据库中的实体类  
10.  \*/  
11. public class Customer implements Serializable\{  
12.   
13.     private static final long serialVersionUID = 9026723017886524518L;  
14.     private Long id;  
15.     private String name;  
16.     private String email;  
17.     private String password;  
18.     private int phone;  
19.     private boolean married;  
20.     private String address;  
21.     private char sex;  
22.     private String description;  
23.     private byte\[\] image;  
24.     private Date birthday;  
25.     private Timestamp registeredTime;  
26.     private Address homeAddress;  
27.     private Address compAddress;  
28.       
29.     //省略掉get and set method  
30. \}

package com.lanhuigu.hibernate.entity;
    
    import java.io.Serializable;
    import java.util.Date;
    
    import com.sun.jmx.snmp.Timestamp;
    
    /**
     * 创建java持久化类，就是需要被持久化到数据库中的实体类 
     */
    public class Customer implements Serializable{
    
        private static final long serialVersionUID = 9026723017886524518L;
        private Long id;
        private String name;
        private String email;
        private String password;
        private int phone;
        private boolean married;
        private String address;
        private char sex;
        private String description;
        private byte[] image;
        private Date birthday;
        private Timestamp registeredTime;
        private Address homeAddress;
        private Address compAddress;
    
        //省略掉get and set method
    }

Address类：

**\[java\]** view plain copy

print ?

1.  package com.lanhuigu.hibernate.entity;  
2.    
3.  import java.io.Serializable;  
4.  /\*\* 
5.   \* 地址实体类 
6.   \*/  
7.  public class Address implements Serializable\{  
8.    
9.      private static final long serialVersionUID = -1450327776636898762L;  
10.     private String province;  
11.     private String city;  
12.     private String street;  
13.     private Short zipcode;  
14.     private Customer customer;  
15.       
16.     //省略掉get and set method  
17. \}

package com.lanhuigu.hibernate.entity;
    
    import java.io.Serializable;
    /**
     * 地址实体类
     */
    public class Address implements Serializable{
    
        private static final long serialVersionUID = -1450327776636898762L;
        private String province;
        private String city;
        private String street;
        private Short zipcode;
        private Customer customer;
    
        //省略掉get and set method
    }

在配置Customer.hbm.xml对象映射文件时，就不能用<property/>来配置homeAddress,compAddress,因为这个时候homeAddress并不是单个属性，而是

一个Address属性，用组件标签将Address配置进入。

Customer.hbm.xml配置文件如下：

**\[html\]** view plain copy

print ?

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.    
6.  <hibernate-mapping  package=“com.lanhuigu.hibernate.entity”>  
7.          <class name=“Customer” table=“CUSTOMERS” select-before-update=“true”>  
8.              <!– 设置主键 –>  
9.              <id name=“id” column=“ID” type=“long”>  
10.                 <!– 主键生成方式–>  
11.                 <generator class=“increment”/>  
12.             </id>  
13.             <!– 基本属性，基本属性必须设置在主键之口–>  
14.             <property name=“name” column=“NAME” type=“string” length=“25” not-null=“true” access=“property”/>  
15.             <property name=“email” column=“EMAIL” type=“string” not-null=“true” />  
16.             <property name=“password” column=“PASSWORD” type=“string” not-null=“true” />  
17.             <property name=“phone” column=“PHONE” type=“int” />  
18.             <property name=“address” column=“ADDRESS” type=“string” />  
19.             <property name=“sex” column=“SEX” type=“character” />  
20.             <property name=“married” column=“IS\_MARRIED” type=“boolean” />  
21.             <property name=“description” column=“DESCRIPTION” type=“text” />  
22.             <property name=“image” column=“IMAGE” type=“binary” />  
23.             <property name=“birthday” column=“BIRTHDAY” type=“date” />  
24.             <property name=“registeredTime” column=“REGISTERED\_TIME” type=“timestamp” insert=“false” update=“false”/>  
25.             <!– 部分类 –>  
26.             <component name=“homeAddress” class=“Address”>  
27.                 <parent name=“customer”/>  
28.                 <property name=“province” type=“string” column=“HOME\_PROVINCE”></property>  
29.                 <property name=“city” type=“string” column=“HOME\_CITY”></property>  
30.                 <property name=“street” type=“string” column=“HOME\_STREET”></property>  
31.                 <property name=“zipcode” type=“short” column=“HOME\_ZIPCODE”></property>  
32.             </component>  
33.               
34.             <component name=“compAddress” class=“Address”>  
35.                 <parent name=“customer”/>  
36.                 <property name=“province” type=“string” column=“COMP\_PROVINCE”></property>  
37.                 <property name=“city” type=“string” column=“COMP\_CITY”></property>  
38.                 <property name=“street” type=“string” column=“COMP\_STREET”></property>  
39.                 <property name=“zipcode” type=“short” column=“COMP\_ZIPCODE”></property>  
40.             </component>  
41.         </class>  
42.       
43. </hibernate-mapping>

<?xml version="1.0"?>
    <!DOCTYPE hibernate-mapping PUBLIC 
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    
    <hibernate-mapping  package="com.lanhuigu.hibernate.entity">
            <class name="Customer" table="CUSTOMERS" select-before-update="true">
                
                <id name="id" column="ID" type="long">
                    
                    <generator class="increment"/>
                </id>
                
                <property name="name" column="NAME" type="string" length="25" not-null="true" access="property"/>
                <property name="email" column="EMAIL" type="string" not-null="true" />
                <property name="password" column="PASSWORD" type="string" not-null="true" />
                <property name="phone" column="PHONE" type="int" />
                <property name="address" column="ADDRESS" type="string" />
                <property name="sex" column="SEX" type="character" />
                <property name="married" column="IS_MARRIED" type="boolean" />
                <property name="description" column="DESCRIPTION" type="text" />
                <property name="image" column="IMAGE" type="binary" />
                <property name="birthday" column="BIRTHDAY" type="date" />
                <property name="registeredTime" column="REGISTERED_TIME" type="timestamp" insert="false" update="false"/>
                
                <component name="homeAddress" class="Address">
                    <parent name="customer"/>
                    <property name="province" type="string" column="HOME_PROVINCE"></property>
                    <property name="city" type="string" column="HOME_CITY"></property>
                    <property name="street" type="string" column="HOME_STREET"></property>
                    <property name="zipcode" type="short" column="HOME_ZIPCODE"></property>
                </component>
    
                <component name="compAddress" class="Address">
                    <parent name="customer"/>
                    <property name="province" type="string" column="COMP_PROVINCE"></property>
                    <property name="city" type="string" column="COMP_CITY"></property>
                    <property name="street" type="string" column="COMP_STREET"></property>
                    <property name="zipcode" type="short" column="COMP_ZIPCODE"></property>
                </component>
            </class>
    
    </hibernate-mapping>

特别注意，该映射文件用于执行建表，得到的表如下,控制台输出：

drop table if exists CUSTOMERS;

**\[sql\]** view plain copy

print ?

1.  create table CUSTOMERS (  
2.          ID bigint not null,  
3.          NAME varchar(25) not null,  
4.          EMAIL varchar(255) not null,  
5.          PASSWORD varchar(255) not null,  
6.          PHONE integer,  
7.          ADDRESS varchar(255),  
8.          SEX char(1),  
9.          IS\_MARRIED boolean,  
10.         DESCRIPTION longtext,  
11.         IMAGE tinyblob,  
12.         BIRTHDAY date,  
13.         REGISTERED\_TIME datetime,  
14.         HOME\_PROVINCE varchar(255),  
15.         HOME\_CITY varchar(255),  
16.         HOME\_STREET varchar(255),  
17.         HOME\_ZIPCODE smallint,  
18.         COMP\_PROVINCE varchar(255),  
19.         COMP\_CITY varchar(255),  
20.         COMP\_STREET varchar(255),  
21.         COMP\_ZIPCODE smallint,  
22.         primary key (ID)  
23.     )

create table CUSTOMERS (
            ID bigint not null,
            NAME varchar(25) not null,
            EMAIL varchar(255) not null,
            PASSWORD varchar(255) not null,
            PHONE integer,
            ADDRESS varchar(255),
            SEX char(1),
            IS_MARRIED boolean,
            DESCRIPTION longtext,
            IMAGE tinyblob,
            BIRTHDAY date,
            REGISTERED_TIME datetime,
            HOME_PROVINCE varchar(255),
            HOME_CITY varchar(255),
            HOME_STREET varchar(255),
            HOME_ZIPCODE smallint,
            COMP_PROVINCE varchar(255),
            COMP_CITY varchar(255),
            COMP_STREET varchar(255),
            COMP_ZIPCODE smallint,
            primary key (ID)
        )

从对象-映射文件可以看出，component包含parent子元素和property元素，parent用于指明Address的整体类customer,其中在Address中

一定定义整体类，同时给定get和set方法。

property元素配置Address的属性和数据库CUSTOMERS表的映射关系。

3.1区分值(value)类型和实体(entity)类型

从Address类中，可以看出，Address类并没有OID，如果没有OID就不能通过session对Address对象进行，保存，修改，删除等操作。

这种没有OID的对象就是值类型，而Customer对象就是实体类，而当我们删除Customer对象时，会把Address删除掉，从数据库表结构

可以看出这点，因为Customer删除是根据OID删除，也就是数据库主键删除，Address只是部分信息，后面的几个字段，而主键删除是

条数据删除掉。

3.2创建应用程序关系持久化

**\[java\]** view plain copy

print ?

1.  package com.lanhuigu.hibernate.test;  
2.    
3.  import org.hibernate.Session;  
4.  import org.hibernate.SessionFactory;  
5.  import org.hibernate.Transaction;  
6.  import org.hibernate.cfg.Configuration;  
7.    
8.  import com.lanhuigu.hibernate.entity.Address;  
9.  import com.lanhuigu.hibernate.entity.Customer;  
10.   
11. public class TestHibernate \{  
12.     public static void main(String\[\] args) \{  
13.         SessionFactory sessionFactory;  
14.         Configuration configuration = new Configuration().configure();  
15.         //创建自定义命名策略  
16.         //configuration.setNamingStrategy(new ClassMyNamingStrategy()).addClass(Customer.class);  
17.         //加载customer类  
18.         sessionFactory = configuration.buildSessionFactory();  
19.         Session session = sessionFactory.openSession();  
20.         Transaction tr = session.beginTransaction();  
21.         //保存(insert)  
22.         Customer customer = new Customer();  
23.         customer.setId(new Long(1));  
24.         customer.setName(”test”);  
25.         customer.setEmail(”123456789@qq.com”);  
26.         customer.setPassword(”123456”);  
27.         customer.setAddress(”世外桃源”);  
28.           
29.         Address homeAddress = new Address();  
30.         homeAddress.setProvince(”1”);  
31.         homeAddress.setCity(”1”);  
32.         homeAddress.setStreet(”1”);  
33.         homeAddress.setCustomer(customer);  
34.           
35.         Address compAddress = new Address();  
36.         compAddress.setProvince(”2”);  
37.         compAddress.setCity(”2”);  
38.         compAddress.setStreet(”2”);  
39.         compAddress.setCustomer(customer);  
40.           
41.         customer.setHomeAddress(homeAddress);  
42.         customer.setCompAddress(compAddress);  
43.           
44.         session.save(customer);  
45.         tr.commit();  
46.         session.close();  
47.           
48.     \}  
49. \}

package com.lanhuigu.hibernate.test;
    
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    import org.hibernate.cfg.Configuration;
    
    import com.lanhuigu.hibernate.entity.Address;
    import com.lanhuigu.hibernate.entity.Customer;
    
    public class TestHibernate {
        public static void main(String[] args) {
            SessionFactory sessionFactory;
            Configuration configuration = new Configuration().configure();
            //创建自定义命名策略
            //configuration.setNamingStrategy(new ClassMyNamingStrategy()).addClass(Customer.class);
            //加载customer类
            sessionFactory = configuration.buildSessionFactory();
            Session session = sessionFactory.openSession();
            Transaction tr = session.beginTransaction();
            //保存(insert)
            Customer customer = new Customer();
            customer.setId(new Long(1));
            customer.setName("test");
            customer.setEmail("123456789@qq.com");
            customer.setPassword("123456");
            customer.setAddress("世外桃源");
    
            Address homeAddress = new Address();
            homeAddress.setProvince("1");
            homeAddress.setCity("1");
            homeAddress.setStreet("1");
            homeAddress.setCustomer(customer);
    
            Address compAddress = new Address();
            compAddress.setProvince("2");
            compAddress.setCity("2");
            compAddress.setStreet("2");
            compAddress.setCustomer(customer);
    
            customer.setHomeAddress(homeAddress);
            customer.setCompAddress(compAddress);
    
            session.save(customer);
            tr.commit();
            session.close();
    
        }
    }

执行控制台输出：

Hibernate: select max(ID) from CUSTOMERS  
Hibernate: insert into CUSTOMERS (NAME, EMAIL, PASSWORD, PHONE, ADDRESS, SEX, IS\_MARRIED, DESCRIPTION, IMAGE, BIRTHDAY, HOME\_PROVINCE, HOME\_CITY, HOME\_STREET, HOME\_ZIPCODE, COMP\_PROVINCE, COMP\_CITY, COMP\_STREET, COMP\_ZIPCODE, ID) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)  
  
注意：

homeAddress和compAddress就是整体的组件，组件下面有很多小零件，最后组成Customer整体类，整体持久化到数据库。

[Center]: /images/20220601/047d7d45f7134cddae53d552177119c5.png
[Center 1]: /images/20220601/18bc50a1da9d4ae48bf09bd05ebc5aeb.png