第 4 章 持久化类(Persistent Classes)

在应用程序中,用来实现业务问题实体的(如,在电子商务应用程序中的Customer和Order) 类就是持久化类。不能认为所有的持久化类的实例都是持久的状态——一个实例的状态也可能 是瞬时的或脱管的。

如果这些持久化类遵循一些简单的规则,Hibernate能够工作得更好,这些规则也被称作 简单传统Java对象(POJO:Plain Old Java Object)编程模型。但是这些规则并不是必需的。 实际上,Hibernate3对于你的持久化类几乎不做任何设想。你可以用其他的方法来表达领域模型: 比如,使用Map实例的树型结构。

4.1. 一个简单的POJO例子

大多数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 = new HashSet();

    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 by Hibernate
    public void addKitten(Cat kitten) {
    	kitten.setMother(this);
	kitten.setLitterId( kittens.size() ); 
        kittens.add(kitten);
    }
}

这里要遵循四条主要的规则:

4.1.1. 实现一个默认的(即无参数的)构造方法(constructor)

Cat有一个无参数的构造方法。所有的持久化类都必须有一个 默认的构造方法(可以不是public的),这样的话Hibernate就可以使用 Constructor.newInstance()来实例化它们。 我们强烈建议,在Hibernate中,为了运行期代理的生成,构造方法至少是 包(package)内可见的。

4.1.2. 提供一个标识属性(identifier property)(可选)

Cat有一个属性叫做id。这个属性映射数据库表的主 键字段。这个属性可以叫任何名字,其类型可以是任何的原始类型、原始类型的包装类型、 java.lang.String 或者是 java.util.Date。 (如果你的遗留数据库表有联合主键,你甚至可以用一个用户自定义的类,该类拥有这些类型 的属性。参见后面的关于联合标识符的章节。)

标识符属性是可选的。可以不用管它,让Hibernate内部来追踪对象的识别。 但是我们并不推荐这样做。

实际上,一些功能只对那些声明了标识符属性的类起作用:

我们建议你对持久化类声明命名一致的标识属性。我们还建议你使用一 个可以为空(也就是说,不是原始类型)的类型。

4.1.3. 使用非final的类 (可选)

代理(proxies)是Hibernate的一个重要的功能,它依赖的条件是,持久 化类或者是非final的,或者是实现了一个所有方法都声明为public的接口。

你可以用Hibernate持久化一个没有实现任何接口的final类,但是你 不能使用代理来延迟关联加载,这会限制你进行性能优化的选择。

你也应该避免在非final类中声明 public final的方法。如果你想使用一 个有public final方法的类,你必须通过设置lazy="false" 来明确地禁用代理。

4.1.4. 为持久化字段声明访问器(accessors)和是否可变的标志(mutators)(可选)

Cat为它的所有持久化字段声明了访问方法。很多其他ORM工具直接对 实例变量进行持久化。我们相信,在关系数据库schema和类的内部数据结构之间引入间接层(原文为"非直接",indirection)会好一些。默认情况下Hibernate持久化JavaBeans风格的属性,认可 getFooisFoosetFoo这种形式的方法名。 如果需要,你可以对某些特定属性实行直接字段访问。

属性不需要要声明为public的。Hibernate可以持久化一个有 defaultprotectedprivate的get/set方法对 的属性进行持久化。

4.2. 实现继承(Inheritance)

子类也必须遵守第一条和第二条规则。它从超类Cat继承了标识属性。

package eg;

public class DomesticCat extends Cat {
        private String name;

        public String getName() {
                return name;
        }
        protected void setName(String name) {
                this.name=name;
        }
}

4.3. 实现equals()hashCode()

如果你有如下需求,你必须重载 equals()hashCode()方法:

  • 想把持久类的实例放入Set中(当表示多值关联时,推荐这么做)

  • 想重用脱管实例

Hibernate保证,仅在特定会话范围内,持久化标识(数据库的行)和Java标识是等价的。因此,一旦 我们混合了从不同会话中获取的实例,如果希望Set有明确的语义,就必 须实现equals()hashCode()

实现equals()/hashCode()最显而易见的方法是比较两个对象 标识符的值。如果值相同,则两个对象对应于数据库的同一行,因此它们是相等的(如果都被添加到 Set,则在Set中只有一个元素)。不幸的是,对生成的标识不能 使用这种方法。Hibernate仅对那些持久化对象赋标识值,一个新创建的实例将不会有任何标识值。此外, 如果一个实例没有被保存(unsaved),并且它当前正在一个Set中,保存它将会给这个对象 赋一个标识值。如果equals()hashCode()是基于标识值 实现的,则其哈希码将会改变,这违反了Set的契约。建议去Hibernate的站点阅读关于这个 问题的全部讨论。注意,这不是Hibernate的问题,而是一般的Java对象标识和Java对象等价的语义问题。

我们建议使用业务键值相等(Business key equality)来实现equals()hashCode()。业务键值相等的意思是,equals()方法 仅仅比较形成业务键的属性,它能在现实世界里标识我们的实例(是一个自然的候选码)。

public class Cat {

    ...
    public boolean equals(Object other) {
        if (this == other) return true;
        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;
    }

}

注意,业务键不必像数据库的主键那样固定不变(参见第 11.1.3 节 “关注对象标识(Considering object identity)”)。 对业务键而言,不可变或唯一的属性是不错的选择。

4.4. 动态模型(Dynamic models)

注意,以下特性在当前处于试验阶段,将来可能会有变化。

运行期的持久化实体没有必要一定表示为像POJO类或JavaBean对象那样的形式。Hibernate也支持动态模型 (在运行期使用MapMap)和象DOM4J的树模型那 样的实体表示。使用这种方法,你不用写持久化类,只写映射文件就行了。

Hibernate默认工作在普通POJO模式。你可以使用配置选项default_entity_mode, 对特定的SessionFactory,设置一个默认的实体表示模式。 (参见表 3.3 “ Hibernate配置属性 ”。)

下面是用Map来表示的例子。首先,在映射文件中,要声明 entity-name来代替一个类名(或作为一种附属)。

<hibernate-mapping>

    <class entity-name="Customer">

        <id name="id"
            type="long"
            column="ID">
            <generator class="sequence"/>
        </id>

        <property name="name"
            column="NAME"
            type="string"/>

        <property name="address"
            column="ADDRESS"
            type="string"/>

        <many-to-one name="organization"
            column="ORGANIZATION_ID"
            class="Organization"/>

        <bag name="orders"
            inverse="true"
            lazy="false"
            cascade="all">
            <key column="CUSTOMER_ID"/>
            <one-to-many class="Order"/>
        </bag>

    </class>
    
</hibernate-mapping>

注意,虽然是用目标类名来声明关联的,但是关联的目标类型除了是POJO之外,也可以 是一个动态的实体。

在使用dynamic-mapSessionFactory 设置了默认的实体模式之后,可以在运行期使用MapMap

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表示能力的更多信息可以在第 18 章 XML映射中找到。

4.5. 元组片断映射(Tuplizers)

org.hibernate.tuple.Tuplizer,以及其子接口,负责根据给定的org.hibernate.EntityMode,来复现片断数据。如果给定的片断数据被认为其是一种数据结构,"tuplizer"就是一个知道如何创建这样的数据结构,以及如何给这个数据结构赋值的东西。比如说,对于POJO这种Entity Mode,对应的tuplizer知道通过其构造方法来创建一个POJO,再通过其属性访问器来访问POJO属性。有两大类高层Tuplizer,分别是org.hibernate.tuple.entity.EntityTuplizerorg.hibernate.tuple.entity.ComponentTuplizer接口。EntityTuplizer负责管理上面提到的实体的契约,而ComponentTuplizer则是针对组件的。

用户也可以插入其自定义的tuplizer。或许您需要一种不同于dynamic-map entity-mode中使用的java.util.HashMapjava.util.Map实现;或许您需要与默认策略不同的代理生成策略(proxy generation strategy)。通过自定义tuplizer实现,这两个目标您都可以达到。Tuplizer定义被附加到它们期望管理的entity或者component映射中。回到我们的customer entity例子:

<hibernate-mapping>
    <class entity-name="Customer">
        <!--
            Override the dynamic-map entity-mode
            tuplizer for the customer entity
        -->
        <tuplizer entity-mode="dynamic-map"
                class="CustomMapTuplizerImpl"/>

        <id name="id" type="long" column="ID">
            <generator class="sequence"/>
        </id>

        <!-- other properties -->
        ...
    </class>
</hibernate-mapping>


public class CustomMapTuplizerImpl
        extends org.hibernate.tuple.entity.DynamicMapEntityTuplizer {
    // override the buildInstantiator() method to plug in our custom map...
    protected final Instantiator buildInstantiator(
            org.hibernate.mapping.PersistentClass mappingInfo) {
        return new CustomMapInstantiator( mappingInfo );
    }

    private static final class CustomMapInstantiator
            extends org.hibernate.tuple.DynamicMapInstantitor {
        // override the generateMap() method to return our custom map...
	    protected final Map generateMap() {
		    return new CustomMap();
	    }
    }
}

TODO:property和proxy包里的用户扩展框架文档。