实体映射策略

一，实体粒度设计

fine-grained object model

grained object model(细粒度模型)：就是将原本业务模型中的对象加以细分，从而得到更加精细的对象模型（也就是划分出更多的对象）。对于Hibernate主要是针对实体类设计的对象细分。

对象的细分目的：
1，面向设计的粒度细分：通过对象细化，实现更加清晰的系统逻辑。
2，面向性能的粒度细分：针对业务逻辑，通过合理的细粒度对象，提高系统的能耗比（性能/资源消耗）。

（一），面向设计粒度细分
例如：配送单包含信息---订购客户姓名，所订购的货物品名、数量，配送单编号、配送地址、配送时间。
设计方法1，通过一个大型的“配送单”对象容纳所有的属性。
设计方法2，将其划分为3个对象：
1，User(String name);2,Item(String name,int count);3,Invoice(String serial,String address,Datetime datetime)
-----体现了更加清晰和合理的设计逻辑。（多表查询性能消耗怎么办？---将单表划分为多个对象，不是多个表,OK?）
对于单表的对象细分，在Hibernate中借助Component节点的定义完成。
Component--组件，从属于某个整体的一个组成部分。在Hibernate中，将某个实体对象中的一个逻辑组成称为Component。与实体对象的根本差别在于Component没有标识(identity)。它作为一个逻辑组成，完全从属于实体对象。---也可以理解为实体对象的属性。

T_User
id        int    <pk>
firstname varchar(50)
lastname  varchar(50)
address   varchar(50)
zipcode   varchar(10)
tel       varchar(20)
通过Component定义，将单表T_User映射到了3个类TUser,Contact和Name。---在传统关系型库表上，实现了面向对象的领域划分。

TUser.java
public class TUser implements Serializable{
    private Integer id;
    private Contact contact;
    private Name name;

    ......getter/setter......
}

Contact.java
public class Contact implements Serializable{
    private String address;
    private String zipcode;
    private String tel;

    ......getter/setter......
}

Name.java
public class Name implements Serializable{
    private String firstname;
    private String lastname;
   
    ......getter/setter......
}

Hibernate中通过Component节点对组件进行声明：
<hibernate-mapping>
  <class name="TUser" table="T_User">
    <id name="id" column="id" type="java.lang.Integer">
      <generator class="native"></generator>
    </id>
    <component name="name" class="Name">
      <property name="firstname" type="string" column="firstname"/>
      <property name="lastname" type="string" column="lastname"/>
    </component>
    <component name="contact" class="Contact">
      <property name="address" type="string" column="address"/>
      <property name="zipcode" type="string" column="zipcode"/>
      <property name="tel" type="string" column="tel"/>
    </component>
  </class>
</hibernate-mapping>

（二），面向性能的粒度细分
---针对业务逻辑，通过合理的细粒度对象，提高系统的能耗比（性能/资源消耗）。

实体类TUser
public class TUser implements Serializable{
    private Integer id;
    private String name;
    private Integer age;

    private Blob image;
    private Clob resume;

    ...getter/setter...
}

“重量级”字段类型，应该在确实需要显示的时候再读取。---Hibernate3提供了属性的延迟加载功能，通过这个功能，我们可以在调用TUser.getResume/getImage时才真正从数据库中读取数据。Hibernate2在继承层次上的粒度划分--将TUser对象拆分为TUserInfo和TUserProfile。

public class TUserInfo implements Serializable{
    private Integer id;
    private String name;
    private Integer age;

    ...getter/setter...
}
public class TUserProfile extends TUserInfo implements Serializable{
    private Blob image;
    private Clob resume;

    ...getter/setter...
}
通过继承关系，将一个对象进行纵向细分。---对于无需操作大对象而言就通过TUserInfo对数据进行加载，对于需要处理大对象就通过TUserProfile进行处理。

TUserInfo.hbm.xml
<hibernate-mapping>
  <class name="TUserInfo" table="T_User">
    <id name="id" column="id" type="java.lang.Integer">
      <generator class="native">
      </generator>
    </id>
    <property name="name" column="name" type="java.lang.String">
     <property name="age" column="age" type="java.lang.Integer">
  </class>
</hibernate-mapping>

TUserProfile.hbm.xml
<hibernate-mapping>
  <class name="TUserProfile" table="T_User" ploymorphism="explicit">
    <id name="id" column="id" type="java.lang.Integer">
      <generator class="native">
      </generator>
    </id>
    <property name="name" column="name" type="java.lang.String"/>
    <property name="age" column="age" type="java.lang.Integer"/>
    <property name="image" column="image" type="java.sql.Blob"/>
    <property name="resume" column="resume" type="java.sql.Clob"/>
  </class>
</hibernate-mapping>
通过polymorphism="explicit"声明了一个显示多态关系。声明为显示多态的类，只有在明确指定类名的时候才会返回此类实例。如：
List objects = createQuery("from TUserProfile").list();

总结：实体粒度设计主要细化手段：1，将一个表映射为多个类，各实体类彼此独立，一个主类，其余类为主类的属性，在映射文件上表现为主类的组件(Component)，组件从属于主类；2，采用继承纵向细分，细分的类具有继承关系，实体类映射文件各自独立，子类映射文件声明polymorphism="explicit"。

评论

1 楼 fishswing 2009-04-24  

楼主好文章。特别是“面向性能的粒度细分 ”，看了后受益匪浅。
但是我也有个问题不太明白，举个例子来说：我的两张表,
BaseDoc有三个字段：fileid,filename,filecontent,accer后面两个字段是blob类型的，
现在把这张表的实体类分成两个实体
BaseDoc 有 fileid和filename两个属性，
BaseDocProfile 有filecontent,accer两个字段,
映射文件也像你上面样配置好了。

现在我有另一张表 Userinfo有uid,uname,uage,fileid
这张表引用了BaseDoc的主键fileid列，映射实体时就是一对多的关系了。
那这张表的实体类就有一个BaseDoc表的实体类对象，现在这个实体类应该是BaseDoc还是BaseDocProfile。而我要查询这个用户下有那些文件的时候有两种情况，
      1,是只查询fileid和filename
     2,有时候又需要把filecontent,fileaccer两个blob字段的内容一起查出来
如果Userinfo类包含的对象是BaseDoc的话，遇到第2种情况时，就不能查询到filecontent和fileaccer了。
如果Userinfo类包含的对象是BaseDocProfile的话,那在第1种情况下，每回查询时都会把filecontent和fileaccer查询出来。

遇到这种情况时，应该怎么处理呢？