别让Hibernate偷走了您的身份(转)

企业级Java应用程序常常把数据在Java对象和相关数据库之间来回移动。从手工编写SQL代码到诸如Hibernate这 样成熟的对象关系映射（ORM）解决方案，有很多种方法可以实现这个过程。无论采用什么样的技术，一旦开始将Java对象持久存储到数据库中，身份将成为 一个复杂且难以管理的课题。可能出现的情况是：您实例化了两个不同的对象，而它们却代表数据库中的同一行。为了解决这个问题，您可能采取的措施是在持久性 对象中实现equals()和hashCode()，可是要恰当地实现这两个方法比乍看之下要有技巧一些。让问题更糟糕的是，那些传统的思路（包括 Hibernate官方文档所提倡的）对于新的项目并不一定能提出最实用的解决方案。

对象身份在虚拟机（VM）中和在数据库中的差异是问题滋生的温床。在虚拟机中，您并不会得到对象的ID，您只是简单地持有对象的直接引用。而在幕后，虚拟 机确实给每个对象指派了一个8字节大小的ID，这个ID才是对象的真实引用。当您将对象持久存储到数据库中的时候，问题开始产生了。假定您创建了一个 Person对象并将它存入数据库（我们可以叫它person1）。而您的其他某段代码从数据库中读取了这个Person对象的数据，并将它实例化为另一 个新的Person对象（我们可以叫它Person2）。现在您的内存中有了两个映射到数据库中同一行的对象。一个对象引用只能指向它们的其中一个，可是 我们需要一种方法来表示这两个对象实际上表示着同一个实体。这就是（在虚拟机中）引入对象身份的原因。

在Java语言中，对象身份是由每个对象都持有的equals()方法（以及相关的hashCode()方法）来定义的。无论两个对象是否为同一个实例， equals()方法都应该能够判别出它们是否表示同一个实体。hashCode()方法和equals()方法有关联是因为所有相等的对象都应该返回相 同的hashCode。默认情况下，equals()方法仅仅比较对象引用。一个对象和它自身是相等的，而和其他任何实例都不相等。对于持久性对象来说， 重写这两个方法，让代表着数据库中同一行的两个对象被视为相等是很重要的。而这对于Java中Collection（Set、Map和List）的正确工 作更是尤为重要。

为了阐明实现equal()和hashCode()的不同途径，让我们考虑一个准备持久存储到数据库中的简单对象Person。

   

 1public class Person {
 2    private Long id;
 3    private Integer version;
 4
 5    public Long getId() {
 6        return id;
 7    }
 8    public void setId(Long id) {
 9        this.id = id;
10    }
11    public Integer getVersion() {
12        return version;
13    }
14    public void setVersion(Integer version) {
15        this.version = version;
16    }
17
18    // person-specific properties and behavior
19}
20
21

　　在这个例子中，我们遵循了同时持有id字段和version字段的最佳实践。Id字段保存了在数据库中作为主键使用的值，而version字段 则是一个从0开始增长的增量，随着对象的每次更新而变化（这帮助我们避免并发更新的问题）。为了更清楚一些，让我们看看允许Hibernate把这个对象 持久存储到数据库的Hibernate映射文件：

 1<?xml version="1.0"?>
 2<!DOCTYPE hibernate-mapping SYSTEM
 3    "http://hibernate.sourceforge.net/
 4    hibernate-mapping-3.0.dtd">
 5
 6<hibernate-mapping package="my.package">
 7
 8  <class name="Person" table="PERSON">
 9
10    <id name="id" column="ID"
11        unsaved-value="null">
12      <generator class="sequence">
13        <param name="sequence">PERSON_SEQ</param>
14      </generator>
15    </id>
16
17    <version name="version" column="VERSION" />
18
19    <!-- Map Person-specific properties here. -->
20
21  </class>
22
23</hibernate-mapping>
24
25

　　Hibernate映射文件指明了Person的id字段代表数据库中的ID列（也就是说，它是PERSON表的主键）。包含在id标签中的 unsaved-value="null"属性告诉Hibernate使用id字段来判断一个Person对象之前是否被保存过。ORM框架必须依靠这个 来判断保存一个对象的时候应该使用SQL的INSERT子句还是UPDATE子句。在这个例子中，Hibernate假定一个新对象的id字段一开始为 null值，当它第一次被保存时id才被赋予一个值。generator标签告诉Hibernate当对象第一次保存时，应该从哪里获得指派的id。在这 个例子中，Hibernate使用数据库序列作为唯一ID的来源。最后，version标签告诉Hibernate使用Person对象的version 字段进行并发控制。Hibernate将会执行乐观锁定方案，根据这个方案，Hibernate在保存对象之前会根据数据库版本号检查对象的版本号。

我们的Person对象还缺少的是equals()方法和hashCode()方法的实现。既然这是一个持久性对象，我们并不想依赖于这两个方法的默认实 现，因为默认实现并不能分辨代表数据库中同一行的两个不同实例。一种简单而又显然的实现方法是利用id字段来进行equal()方法的比较以及生成 hashCode()方法的结果。

 1public boolean equals(Object o) {
 2    if (this == o) return true;
 3    if (o == null || !(o instanceof Person))
 4        return false;
 5
 6    Person other = (Person)o;
 7
 8    if (id == other.getId()) return true;
 9    if (id == null) return false;
10
11    // equivalence by id
12    return id.equals(other.getId());
13}
14
15public int hashCode() {
16    if (id != null) {
17        return id.hashCode();
18    } else {
19        return super.hashCode();
20    }
21}
22
23

　　不幸的是，这个实现存在着问题。当我们首次创建Person对象时id的值为null，这意味着任何两个Person对象只要尚未保存，就将被 认为是相等的。如果我们想创建一个Person对象并把它放到一个Set中，再创建一个完全不同的Person对象也把它放到同一个Set里面，事实上第 二个Person对象并不能被加入。这是因为Set会断定所有未保存的对象都是相同的。

您可能会试图去实现一个使用id（只在已设置id的情况下）的equals()方法。毕竟，如果两个对象都没有被保存过，我们可以假定它们是不同的对象。这是因为在它们被保存到数据库的时候，它们会被赋予不同的主键。

 1public boolean equals(Object o) {
 2    if (this == o) return true;
 3    if (o == null || !(o instanceof Person))
 4        return false;
 5
 6    Person other = (Person)o;
 7
 8    // unsaved objects are never equal
 9    if (id == null || other.getId() == null)
10        return false;
11
12    return id.equals(other.getId());
13}

　　这里有个隐含的问题。Java Collection框架在Collection的生命周期中需要基于不变字段的equals()和hashCode()方法。换句话来说，当一个对象处 在Collection中的时候，不可以改变equals()和hashCode()的值。举个例子，下面这段程序：

1Person p = new Person();
2Set set = new HashSet();
3set.add(p);
4System.out.println(set.contains(p));
5p.setId(new Long(5));
6System.out.println(set.contains(p));
7
8

　　输出结果：true false

对set.contains(p)的第2次调用返回false，这是因为Set再也找不到p了。用专业术语来讲，就是Set丢失了这个对象！这是因为当对象在集合中时，我们改变了hashCode()的值。

当您想要创建一个将其他域对象保存在Set、Map或是List中的域对象时，这是一个问题。为了解决这个问题，您必须为所有对象提供一种equals ()和hashCode()的实现，这种实现能够保证在它们在对象保存前后正确工作并且当对象在内存中时（返回值）不可变。Hibernate Reference Documentation (v. 3)提供了以下的建议：

“不要使用数据库标识符来实现相等性判断，而应该使用业务键（business key），这是一个唯一的、通常不改变的属性的组合体。当一个瞬态对象（transient object）被持久化的时候，数据库标识符会发生改变。当一个瞬态实例（常常与detached实例一起使用）保存在一个Set中时，哈希码的改变会破 坏Set的约定。业务键的属性并不要求和数据库主键一样稳定，只要保证当对象在同一个Set中时它们的稳定性。”（Hibernate Reference Documentation v. 3.1.1）。

“我们推荐通过判断业务键相等性来实现equals()和hashCode()。业务键相等性意味着equals()方法只比较能够区分现实世界中实例的业务键（普通候选键）的属性。”（Hibernate Reference Documentation v. 3.1.1）。

换句话说，普通键用于equals()和hashCode()，而Hibernate生成的代理项键用于对象的id。这要求对于每个对象有一个相关的不可 变的业务键。可是，并不是每个对象类型都有这样的一种键，这时候您可能会尝试使用会改变但不经常改变的字段。这和业务键不必与数据库主键一样稳定的思想相 吻合。如果这种键在对象所在集合的生存期中不改变，那这就“足够好”了。这是一种危险的观点，因为这意味着您的应用程序可能不会崩溃，但是前提是没有人在 特定的情况下更新了特定的字段。所以，应当有一种更好的解决方案，这种解决方案确实也存在。

不要让Hibernate管理您的id。

试图创建和维护对象及数据库行的各自身份定义是目前为止所有讨论问题的根源。如果我们统一所有身份形式，这些问题都将不复存在。也就是说，作为以数据库为 中心和以对象为中心的ID的替代品，我们应该创建一种通用的、特定于实体的ID来代表数据实体，这种ID应该在数据第一次输入的时候创建。无论这个唯一数 据实体是保存在数据库中，是作为对象驻留在内存中，还是存储在其他格式的介质中，这个通用ID都应该可以识别它。通过使用数据实体第一次创建时指派的实体 ID，我们可以安全地回到equals()和hashCode()的原始定义，它们只需使用这个id：

 1public class Person {
 2    // assign an id as soon as possible
 3    private String id = IdGenerator.createId();
 4    private Integer version;
 5
 6    public String getId() {
 7        return id;
 8    }
 9    public void setId(String id) {
10        this.id = id;
11    }
12
13    public Integer getVersion() {
14        return version;
15    }
16    public void setVersion(Integer version) {
17        this.version = version;
18    }
19
20    // Person-specific fields and behavior here
21
22    public boolean equals(Object o) {
23        if (this == o) return true;
24        if (o == null || !(o instanceof Person))
25            return false;
26
27        Person other = (Person)o;
28
29        if (id == null) return false;
30        return id.equals(other.getId());
31    }
32
33    public int hashCode() {
34        if (id != null) {
35            return id.hashCode();
36        } else {
37            return super.hashCode();
38        }
39    }
40}
41
42

　　这个例子使用对象id作为equals()方法判断相等的标准，以及hashCode()返回哈希码的来源。这就简单了许多。但是，要让它正常 工作，我们需要两样东西。首先，我们需要保证每个对象在被保存之前都有一个id值。在这个例子里，当id变量被声明的时候，它就被指派了一个值。其次，我 们需要一种判断这个对象是新生成的还是之前保存过的的手段。在我们最早的例子中，Hibernate通过检查id字段是否为null来判断对象是否为新 的。既然对象id永不为null，很显然这种方法不再有效。通过配置Hibernate，让它检查version字段，而不是id字段是否为null, 我们可以很容易地解决这个问题。version字段是一个更恰当的用来判断对象是否被保存过的指示符。

下面是我们改进过的Person类的Hibernate映射文件。

 1<?xml version="1.0"?>
 2<!DOCTYPE hibernate-mapping SYSTEM
 3"http://hibernate.sourceforge.net/
 4hibernate-mapping-3.0.dtd">
 5
 6<hibernate-mapping package="my.package">
 7
 8  <class name="Person" table="PERSON">
 9
10    <id name="id" column="ID">
11      <generator class="assigned" />
12    </id>
13
14    <version name="version" column="VERSION"
15        unsaved-value="null" />
16
17    <!-- Map Person-specific properties here. -->
18
19  </class>
20
21</hibernate-mapping>
22
23

　　注意，id下面的generator标签包含了属性class="assigned"。这个属性告诉Hibernate我们不是从数据库指派 id值，而是在代码中指派id值。Hibernate会简单地认为即使是新的未保存的对象也有id值。我们也给version标签新增了一个属性： unsaved-value="null"。这个属性告诉Hibernate应该把version值而不是id值为null作为对象是新创建而成的指示 器。我们也可以简单地告诉Hibernate把负值作为对象未保存的指示符，如果您喜欢把version字段的类型设置为int而不是Integer，这 将是很有用的。

我们已经从转移到纯对象id中获取了不少好处。我们对equals()和hashCode()方法的实现更加简单而且更易阅读。这些方法再也不易出错而且 无论在保存对象之前还是之后，它们都能与Collection一起正常工作。Hibernate也变得更快一些，这是因为在保存新的对象之前它再也不需要 从数据库读取一个序列值。此外，新定义的equals()和hashCode()对于所有包含id对象的对象来说是通用的。这意味着我们可以把这些方法移 至一个抽象父类。我们不再需要为每个域对象重新实现equals()和hashCode()，而且我们也不再需要考虑对于每个类来说哪些字段组合是唯一且 不变的。我们只要简单地扩展这个抽象父类。当然，我们没必要强迫域对象从父类中扩展出来，所以我们定义了一个接口来保证设计的灵活性。

 1public interface PersistentObject {
 2    public String getId();
 3    public void setId(String id);
 4
 5    public Integer getVersion();
 6    public void setVersion(Integer version);
 7}
 8
 9public abstract class AbstractPersistentObject
10        implements PersistentObject {
11
12    private String id = IdGenerator.createId();
13    private Integer version;
14
15    public String getId() {
16        return id;
17    }
18    public void setId(String id) {
19        this.id = id;
20    }
21
22    public Integer getVersion() {
23        return version;
24    }
25    public void setVersion(Integer version) {
26        this.version = version;
27    }
28
29    public boolean equals(Object o) {
30        if (this == o) return true;
31        if (o == null ||
32            !(o instanceof PersistentObject)) {
33
34            return false;
35        }
36
37        PersistentObject other
38            = (PersistentObject)o;
39
40        // if the id is missing, return false
41        if (id == null) return false;
42
43        // equivalence by id
44        return id.equals(other.getId());
45    }
46
47    public int hashCode() {
48        if (id != null) {
49            return id.hashCode();
50        } else {
51            return super.hashCode();
52        }
53    }
54
55    public String toString() {
56        return this.getClass().getName()
57            + "[id=" + id + "]";
58    }
59}
60
61

　　现在我们有了一个简单而高效的方法来创建域对象。它们扩展了AbstractPersistentObject，该父类能在它们第一次创建时自 动赋予一个id，并且恰当地实现了equals()和hashCode()。域对象也得到了一个toString()方法的合理默认实现，这个方法可以有 选择地被重写。如果这是一个查询例子的测试对象或者示例对象，id可以被修改或者被设为null。否则它是不应当被改变的。如果因为某些原因我们需要创建 一个扩展其他类的域对象，这个对象就应当实现PersistentObject接口而不是扩展抽象类。

Person类现在就简单多了：

1public class Person
2    extends AbstractPersistentObject {
3
4    // Person-specific fields and behavior here
5
6}
7
8

　　从上一个例子开始Hibernate映射文件就不会再改变了。我们不想麻烦Hibernate去了解抽象父类，我们只要保证每个 PersistentObject映射文件包含一个id项（和一个“被指派的”生成器）和一个带有unsaved-value="null"属性的 version标签。机敏的读者可能已经注意到，每当一个持久性对象被实例化的时候，它的id得到了指派。这意味着当Hibernate在内存中创建一个 已保存对象的实例时，虽然这个对象是已经存在并从数据库中读取的，它也会得到一个新的id。这说好了。然后Hibernate会接着调用对象的setId ()方法，用保存的id来替换新分配的id。额外的id生成并不是什么问题，因为id生成算法是廉价的（也就是说，它并不牵扯到数据库）。

到现在为止一切都很好，但是我们遗漏了一个重要的细节：如何实现IdGenerator.createId()。我们可以为理想中的键生成（key-generation）算法定义一些标准：

• 键可以不牵扯到数据库而很廉价地生成。
• 即使跨越不同的虚拟机和不同机器，键也要保证唯一性。
• 如果可能，键可以由其他程序、编程语言和数据库生成，但是至少要能与它们兼容。

　　我们所需的是通用唯一标识符（universally unique identifier，UUID）。UUID由16个字节（128位）的数字组成，遵守标准格式。UUID的String版本看起来类似如下：

2cdb8cee-9134-453f-9d7a-14c0ae8184c6

里面的字符是简单的字节16进制表示，横线把数字的不同部分分隔开来。这种格式简单而且易于处理，只是36个字符有点长了。因为横线总是被安置在相同的位 置，所以可以把它们去掉，从而把字符的数目减少到32个。为了更为简洁地表示，可以创建一个byte[16]的数组或是两个8字节大小的long来保存这 些数字。如果您使用的是Java 1.5或更高版本，可以直接使用UUID类，虽然这不是它在内存中最简洁的格式。有关更多信息，请参阅Wikipedia UUID条目和JavaDoc UUID类条目。

UUID生成算法有多种实现。既然最终UUID是一种标准格式，我们在IdGenerator类中采用哪一种实现都没有关系。既然无论采用什么算法每个 id都会被保证唯一，我们甚至可以在任何时候改变算法的实现或是混合匹配不同的实现。如果您使用的是Java 1.5或更高版本，最方便的实现是java.util.UUID类：

1public class IdGenerator {
2    public static String createId() {
3        UUID uuid = java.util.UUID.randomUUID();
4        return uuid.toString();
5    }
6}
7
8

　　对不使用Java 1.5或更高版本的人来说，至少有两种扩展库实现了UUID并且与1.5之前的Java版本兼容：Apache Commons ID项目和Java UUID Generator (JUG)项目。它们在Apache License之下都是可用的（在LGPL之下JUG也是可用的）。

这是使用JUG库实现IdGenerator的例子：

 1import org.safehaus.uuid.UUIDGenerator;
 2public class IdGenerator {
 3
 4    public static final UUIDGenerator uuidGen
 5        = UUIDGenerator.getInstance();
 6
 7    public static String createId() {
 8        UUID uuid
 9            = uuidGen.generateRandomBasedUUID();
10        return uuid.toString();
11    }
12}
13
14

　　Hibernate中内置的UUID生成器算法又如何呢？这是获得对象身份的UUID的适当途径吗？如果您想让对象身份独立于对象持久性，这就 不是一个好方法。虽然Hibernate确实提供了生成UUID的选项，但这样的话我们又回到了最早的那个问题上：对象ID的获得并不在它们被创建的时 候，而是在它们被保存的时候。

使用UUID作为数据库主键的最大障碍是它们在数据库中（而不是在内存中）的大小，在数据库中索引和外键的复合会促使主键大小的增加。您必须在不同情况下 使用不同的表示方法。使用String表示，数据库的主键大小将会是32或36字节。数字也可以直接以字节存储，这样大小就减少一半，但是如果直接查询数 据库，标识符将变得难以理解。这些方法对您的项目是否可行取决于您的需求。

如果数据库不接受UUID作为主键，您可以考虑使用数据库序列。但总是应该在新对象创建的时候被指派一个ID而不是让Hibernate管理ID。在这种 情况下，创建新域对象的业务对象可以调用一个使用数据访问对象（DAO）从数据库序列中检索id的服务。如果使用一个Long数据类型来表示对象id，一 个单独的数据库序列（以及服务方法）对您的域对象来说就已经足够了。

结束语

　　当对象持久存储到数据库中时，对象身份总是很难被恰当地实现。尽管如此，问题其实完全在于，对象在保存之前允许对象没有id就存在。我们可以通 过从诸如Hibernate这样的对象关系映射框架中获得指派对象ID的职责来解决这个问题。一旦对象被实例化，它就应该被指派一个ID。这使对象身份变 得简单而不易出错，也减少了域模型中需要的代码量。

作者简介
	James Brundege 目前是一位独立承包商，并在其拥有的公司Synaptocode Software LLC.中担当顾问。