在应用程序中，用来实现业务问题实体的（如，在电子商务应用程序中的Customer和Order） 类就是持久化类。不能认为所有的持久化类的实例都是持久的状态——一个实例的状态也可能 是瞬时的或脱管的。
如果这些持久化类遵循一些简单的规则，Hibernate能够工作得最好，这些规则被称作， 简单传统Java对象(POJO:Plain Old Java Object)编程模型。但是这些规则没有一个是必需的。 实际上，Hibernate3对于你的持久化类几乎不做任何设想。你可以用其他的方法来表达领域模型： 比如，使用Map实例的树型结构。
大多数Java程序需要用一个持久化类来表示猫科动物。
package eg;
import java.util.Set;
import java.util.Date;
public class Cat {
private Long id; // identifier
private Date birthdate;
private Color color;
private char sex;
private float weight;
private int litterId;
private Cat mother;
private Set kittens = newHashSet();
private void setId(Long id) {
this.id=id;
}
public Long getId() {
return id;
}
void setBirthdate(Date date) {
birthdate = date;
}
public Date getBirthdate() {
return birthdate;
}
void setWeight(float weight) {
this.weight = weight;
}
public float getWeight() {
return weight;
}
public Color getColor() {
return color;
}
void setColor(Color color) {
this.color = color;
}
void setSex(char sex) {
this.sex=sex;
}
public char getSex() {
return sex;
}
void setLitterId(int id) {
this.litterId = id;
}
public int getLitterId() {
return litterId;
}
void setMother(Cat mother) {
this.mother = mother;
}
public Cat getMother() {
return mother;
}
void setKittens(Set kittens) {
this.kittens = kittens;
}
public Set getKittens() {
return kittens;
}
// addKitten not needed byHibernate
public void addKitten(Catkitten) {
kitten.setMother(this);
kitten.setLitterId( kittens.size() );
kittens.add(kitten);
}
}
这里要遵循四条主要的规则：
5.1.1. 为持久化字段声明访问器(accessors)和是否可变的标志(mutators)
Cat为它的所有持久化字段声明了访问方法。很多其他ORM工具直接对实例变量进行持久化。我们相信从持久化机制中分离这种实现细节要好得多。 Hibernate持久化JavaBeans风格的属性，认可如下形式的方法名： getFoo, isFoo 和 setFoo。 如果需要，你总是可以切换特定的属性的指示字段的访问方法。
属性不需要要声明为public的。Hibernate默认使用 protected或private的get/set方法对，对属性进行持久化。
5.1.2. 实现一个默认的（即无参数的）构造方法（constructor）
Cat有一个无参数的构造方法。所有的持久化类都必须有一个 默认的构造方法（可以不是public的），这样的话Hibernate就可以使用 Constructor.newInstance()来实例化它们。 我们建议，在Hibernate中，为了运行期代理的生成，构造方法至少是 包(package)内可见的。
5.1.3. 提供一个标识属性（identifier property）（可选）
Cat有一个属性叫做id。这个属性映射数据库表的主 键字段。这个属性可以叫任何名字，其类型可以是任何的原始类型、原始类型的包装类型、java.lang.String 或者是 java.util.Date。 （如果你的老式数据库表有联合主键，你甚至可以用一个用户自定义的类，该类拥有这些类型的属性。参见后面的关于联合标识符的章节。）
标识符属性是可选的。可以不用管它，让Hibernate内部来追踪对象的识别。 不推荐使用这个属性。
实际上，一些功能只对那些声明了标识符属性的类起作用：
· 托管对象的传播性重新（和session）关联（级联更新或级联合并） ——参阅 第 11.11 节“传播性持久化(transitivepersistence)”
· Session.saveOrUpdate()
· Session.merge()
我们建议你对持久化类声明命名一致的标识属性。我们还建议你使用一个可以为空（也就是说，不是原始类型）的类型。
代理（proxies）是Hibernate的一个重要的功能，它依赖的条件是，持久 化类或者是非final的，或者是实现了一个所有方法都声明为public的接口。
你可以用Hibernate持久化一个没有实现任何接口的final类，但是你 不能使用代理来延迟关联加载，这会限制你进行性能优化的选择。
你也应该避免在非final类中声明 public final的方法。如果你想使用一 个有public final方法的类，你必须通过设置lazy="false" 来明确的禁用代理。
子类也必须遵守第一条和第二条规则。它从超类Cat继承了标识属性。
package eg;
public class DomesticCat extends Cat {
private String name;
public String getName() {
return name;
}
protected voidsetName(String name) {
this.name=name;
}
}
如果你有如下需求，你必须重载equals() 和 hashCode()方法：
· 想把持久类的实例放入Set中（当表示多值关联时，推荐这么做）
· 想重用脱管实例
Hibernate保证，持久化标识（数据库的行）和仅在特定会话范围内的Java标识是等值的。因此，一旦 我们混合了从不同会话中获取的实例，如果我们希望Set有明确的语义，我们必 须实现equals() 和hashCode()。
实现equals()/hashCode()最显而易见的方法是比较两个对象标识符的值。如果值相同，则两个对象对应于数据库的同一行，因此它们是相等的（如果都被添加到 Set，则在Set中只有一个元素）。不幸的是，对生成的标识不能 使用这种方法。Hibernate仅对那些持久化对象赋标识值，一个新创建的实例将不会有任何标识值。此外， 如果一个实例没有被保存(unsaved)，并且在一个Set中，保存它将会给这个对象 赋一个标识值。如果equals() 和 hashCode()是基于标识值 实现的，则其哈希码将会改变，违反Set的契约。建议去Hibernate的站点看关于这个问题的全部讨论。注意，这不是一个Hibernate问题，而是一般的Java对象标识和相等的语义问题。
我们建议使用业务键值相等(Business key equality)来实现equals() 和 hashCode()。业务键值相等的意思是，equals()方法 仅仅比较来自业务键的属性，一个业务键将标识在真实世界里（一个天生的候选键） 的实例。
public class Cat {
...
public boolean equals(Objectother) {
if (this == other) returntrue;
if ( !(other instanceof Cat)) return false;
final Cat cat = (Cat) other;
if (!cat.getLitterId().equals( getLitterId() ) ) return false;
if (!cat.getMother().equals( getMother() ) ) return false;
return true;
}
public int hashCode() {
int result;
result =getMother().hashCode();
result = 29 * result +getLitterId();
return result;
}
}
注意，业务键不必是象数据库的主键那样是固定不变的（参见第 12.1.3 节“关注对象标识(Considering objectidentity)”）。 对业务键而言，不可变或唯一的属性是好的候选。
注意，以下特性在当前是基于实验考虑的，可能会在将来改变。
运行期的持久化实体没有必要象POJO类或JavaBean对象一样表示。Hibernate也支持动态模型 （在运行期使用Map的Map）和象DOM4J的树模型那 样的实体表示。使用这种方法，你不用写持久化类，只写映射文件就行了。
Hibernate默认工作在普通POJO模式。你可以使用配置选项default_entity_mode， 对特定的SessionFactory，设置一个默认的实体表示模式。 （参见表 4.3 “ Hibernate配置属性”。）
下面是用Map来表示的例子。首先，在映射文件中，要声明 entity-name来代替（或外加）一个类名。
<hibernate-mapping>
<classentity-name="Customer">
<id name="id"
type="long"
column="ID">
<generatorclass="sequence"/>
</id>
<propertyname="name"
column="NAME"
type="string"/>
<propertyname="address"
column="ADDRESS"
type="string"/>
<many-to-onename="organization"
column="ORGANIZATION_ID"
class="Organization"/>
<bagname="orders"
inverse="true"
lazy="false"
cascade="all">
<keycolumn="CUSTOMER_ID"/>
<one-to-manyclass="Order"/>
</bag>
</class>
</hibernate-mapping>
注意，虽然是用目标类名来声明关联的，但是关联的目标类型除了是POJO之外，也可以 是一个动态的实体。
在使用dynamic-map为SessionFactory 设置了默认的实体模式之后，可以在运行期使用Map的 Map。
Session s = openSession();
Transaction tx = s.beginTransaction();
Session s = openSession();
// Create a customer
Map david = new HashMap();
david.put("name", "David");
// Create an organization
Map foobar = new HashMap();
foobar.put("name", "Foobar Inc.");
// Link both
david.put("organization", foobar);
// Save both
s.save("Customer", david);
s.save("Organization", foobar);
tx.commit();
s.close();
动态映射的好处是，使原型在不需要实体类实现的情况下，快速转变时间。然而，你无法进行编译期的类型检查，并可能由此会处理很多的运行期异常。幸亏有了Hibernate映射，它使得数 据库的schema能容易的规格化和合理化，并允许稍后添加正确的领域模型的最新实现。
实体表示模式也能在每个Session的基础上设置：
Session dynamicSession = pojoSession.getSession(EntityMode.MAP);
// Create a customer
Map david = new HashMap();
david.put("name", "David");
dynamicSession.save("Customer", david);
...
dynamicSession.flush();
dynamicSession.close()
...
// Continue on pojoSession
请注意，用EntityMode调用getSession()是在 Session的API中，而不是SessionFactory。 这样，新的Session共享底层的JDBC连接，事务，和其他的上下文信 息。这意味着，你不需要在第二个Session中调用 flush()和close()，同样的，把事务和连接的处理 交给原来的工作单元。
关于XML表示能力的更多信息可以在第 19 章 XML映射中找到。
TODO：在property和proxy的包里，用户扩展文件框架。
|
第 4 章 配置 |
第 6 章 对象/关系数据库映射基础(Basic O/R Mapping) |
http://docs.huihoo.com/hibernate/reference-v3_zh-cn/persistent-classes.html