实体映射策略

一，实体粒度设计

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