学习映射类层次结构的三个易于实现的策略

概述
Hibernate 是一个纯 Java 的对象关系映射和持久性框架，它允许您用 XML 配置文件把普通 Java 对象映射到关系数据库表。使用 Hibernate 能够节约大量项目开发时间，因为整个 JDBC 层都由这个框架管理。这意味着您的应用程序的数据访问层位于 Hibernate 之上，完全是从底层数据模型中抽象出来的。

比起其他类似的对象关系映射技术（JDO、实体 bean、内部开发等），Hibernate 有许多优势：它是免费的、开源的，已经成熟到良好的程度，并得到广泛应用，而且还有一个非常活跃的社区论坛。

要把 Hibernate 集成到现有的 Java 项目，则需要执行以下步骤：

从 Hibernate 的 Web 站点下载 Hibernate 框架的最新发行版（请参阅参考资料一节中的链接。）
把必需的 Hibernate 库（JAR 文件）复制到应用程序的 CLASSPATH。
创建 XML 配置文件，用它把 Java 对象映射到数据库表。（我们将在本文中描述这个过程。）
把 XML 配置文件复制到应用程序的 CLASSPATH。

您会注意到，不必修改任何 Java 对象，您就可以支持框架。例如，假设您对 Java 应用程序使用的数据库表做了些修改 —— 例如修改了列名。在修改完表之后，您要做的只是更新对应的 XML 配置文件。 您不需要重新编译任何 Java 代码。

Hibernate 查询语言（HQL）
Hibernate 提供了一个查询语言，叫作 Hibernate 查询语言（HQL），它与 SQL 很相似。如果您喜欢用老式的 SQL 查询，那么 Hibernate 也为您提供了使用它们的机会。但是我们使用的示例只用 HQL。

HQL 用起来相当简单。您会发现所有的关键字都与您熟悉的 SQL 中的关键字类似，例如 SELECT、 FROM 和 WHERE。HQL 与 SQL 的差异在于，您不用针对数据模型（即针对表和列等）直接编写查询，而是应该针对 Java 对象，使用 Java 对象的属性和关系编写查询。

清单 1 演示了一个基本的示例。这个 HQL 代码检索 firstName 为 “John.” 的所有 Individual。

清单 1. 基本 HQL 查询


SELECT * FROM eg.hibernate.mapping.dataobject.Individual WHERE firstName = "John"

如果想了解更多有关 HQL 语法的内容，那么您可以参阅 Hibernate 的 Web 站点上有关 HQL 的参考材料（请参阅参考资料，以获得链接）。

XML 配置文件
功能的核心在于 XML 配置文件。这些文件必须存在于应用程序的 CLASSPATH 中。我们把它们放在示例代码包的 config 目录中（您可以从参考资料下载）。

我们要研究的第一个文件是 hibernate.cfg.xml。它包含与数据源有关的信息（数据库 URL、模式名称、用户名、口令等），以及对包含映射信息的其他配置文件的引用。

其余的 XML 文件允许您把 Java 类映射到数据库表。稍后我再深入介绍这些文件，但重要的是要清楚它们的文件名要遵守 ClassName.hbm.xml 这个模式。

我们的支持示例
在本文中，我们要研究一个基本示例，演示 Hibernate 如何工作，如何良好地运用三个不同策略，利用 Hibernate 进行对象关系映射。我们的示例是一家保险公司使用的应用程序，公司必须保持客户投保的所有产权的法律记录。我们随本文提供了完整的源代码（请参阅参考资料）；这个代码提供了基本功能，您可以根据它构建全功能的应用程序，例如 Web 或 Swing 应用程序。

我们的示例采用了这类应用程序的经典用例。用户提供搜索参数，查找各种类型的客户（个人、公司、政府机构等），然后显示与指定参数匹配的所有客户列表 —— 即使这些客户的类型不同。用户可以访问同一列表中的某一特定客户更加详细的视图。

在我们的应用程序中，产权由 Right 类表示。 Right 可以是 Lease 也可以是 Property。 Right 由客户所有。为了表示我们的客户，我们要使用通用类 Person。 Person 即可以是 Individual 也可以是 Corporation。当然，保险公司必须知道这些 Right 被分配给哪个 Estate。您应当同意， Estate 这个术语代表的意义非常泛。所以，我们要用 Land 和 Building 类给我们的开发人员提供更具体的操作对象。

从这个抽象出发，我们可以开发图 1 所示的类模型：

图 1. 完整的类模型

我们的数据库模型是为了介绍将在本文中讨论的三个不同策略而设计的。对于 Right 层次结构来说，我们要使用一个表（ TB_RIGHT），并用 DISCRIMINATOR 列映射到正确的类。对于 Person 结构，我们要使用一个称为超表（ TB_PERSON）的表，它与另外两个表（ TB_CORPORATION 和 TB_INDIVIDUAL）共享相同的 ID。第三个层次结构（ Estate）使用两个不同的表（ TB_BUILDING 和 TB_LAND），这两个表通过由两个列（ REF_ESTATE_ID 和 REF_ESTATE_TYPE）组合定义的外键连接在一起。

图 2 显示了这个数据模型:

图 2. 完整的数据模型

设置数据库
Hibernate 支持各种各样的 RDBMS，其中任何一种都可以使用我们的示例。但是，本文的示例代码和文本已经针对 HSQLDB（请参阅参考资料查找链接）进行了调整，这是一个完全用 Java 语言编写的全功能的关系数据库系统。在示例代码包的 sql 目录中，可以找到叫作 datamodel.sql 的文件。这个 SQL 脚本可以创建我们示例中使用的数据模型。

设置 Java 项目
虽然您总能用命令行构建并执行示例代码，但是您可能想在 IDE 中设置项目，以便更好地进行集成。在示例代码包里，您可以找到以下目录：

config，包含样本的所有 XML 配置文件（映射、Log4J 等）。
data，包含 HSQLDB 使用的配置文件。您还可以找到一个叫作 startHSQLDB.bat 的批处理文件，您可以用它启动数据库。
src，包含示例的所有源代码。

请确保把必需的 Java 库和 XML 配置文件复制到应用程序的 CLASSPATH。只需要 Hibernate 和 HSQLDB 库，这些代码就可以正确地编译和运行。您可以从参考资料一节下载这些包。

策略 1: 每个子类一个表（Persons）
在我们第一个策略中，我们要看看如何映射我们的 Person 层次结构。您会注意到，数据模型与我们的类模型非常接近。所以，我们要为层次结构中的每个类采用一个不同的表，但是所有这些表都必须共享相同的主键（我们很快就会详细说明）。Hibernate 在向数据库中插入新记录时，就会使用这个主键。在访问数据库时，它还会利用同一主键执行 JOIN 操作。

现在我们需要把对象层次结构映射到表模型。我们有三个表（ TB_PERSON、 TB_INDIVIDUAL、和 TB_CORPORATION）。前面我们提过，它们都有一个叫作 ID 的列，并将该列作为主键。表之间不一定非要有这样的共享列名称，但是这是一个很好的实践 —— 这样做的话，生成的 SQL 查询更容易阅读。

在清单 2 所示的 XML 映射文件中，您会注意到，在 Person 的映射定义中，声明了两个具体的 <joined-subclass> 类。XML 元素 <id> 映射到顶级表 TB_PERSON 的主键，同时 <key> 元素（来自每个子类）映射到 TB_INDIVIDUAL 的 TB_CORPORATION 表中匹配的主键。

清单 2. Person.hbm.xml


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>
  <class name="eg.hibernate.mapping.dataobject.Person" table="TB_PERSON" polymorphism="implicit">
    <id name="id" column="ID">
      <generator class="assigned"/>
    </id>
    <set name="rights" lazy="false">
      <key column="REF_PERSON_ID"/>
      <one-to-many class="eg.hibernate.mapping.dataobject.Right" />
    </set>
    
        <joined-subclass name="eg.hibernate.mapping.dataobject.Individual" table="TB_INDIVIDUAL">
      <key column="id"/>
      <property name="firstName" column="FIRST_NAME" type="java.lang.String" />
      <property name="lastName" column="LAST_NAME" type="java.lang.String" />
    </joined-subclass>
    
        <joined-subclass name="eg.hibernate.mapping.dataobject.Corporation" table="TB_CORPORATION">
      <key column="id"/>
      <property name="name" column="NAME" type="string" />
      <property name="registrationNumber" column="REGISTRATION_NUMBER" type="string" />
    </joined-subclass>
  </class>
</hibernate-mapping>

保存 Individual 的一个新实例，形成我们使用 Hibernate 的 Java 代码非常容易，如清单 3 所示：

清单 3. 保存 Individual 的一个新实例


public Object create(Object object) {
  Session session = null;
  try {
    session = sessionFactory.openSession();
    Transaction tx = session.beginTransaction();
    
        session.save(object);
    session.flush();
    tx.commit();
    ...
}

接着，Hibernate 生成两个 SQL INSERT 请求，如清单 4 所示。这两个请求面向的是一个 save()。

清单 4. SQL 插入查询


insert into TB_PERSON (ID) values (?)
insert into TB_INDIVIDUAL (FIRST_NAME, LAST_NAME, id) values (?, ?, ?)

要想访问数据库中的 Individual，只需在 HQL 查询中指定类名即可，如清单 5 所示。

清单 5. 调用 HQL 查询


public Person findIndividual(Integer id) {
  ...
  session.find(
        "select p from " + Individual.class.getName() + " as p where p.id = ?",
    new Object[] { id },
    new Type[] { Hibernate.INTEGER });	
  ...
}

Hibernate 会自动执行 SQL 的 JOIN，从两个表中检索所有必要信息，如清单 6 所示：

清单 6. 查找 Individual 的 SQL SELECT 查询


select individual0_.id as ID, individual0_.FIRST_NAME as FIRST_NAME55_, 
  individual0_.LAST_NAME as LAST_NAME55_ 
  from TB_INDIVIDUAL individual0_ 
  
        inner join TB_PERSON individual0__1_ on individual0_.id=individual0__1_.ID 
  where (individual0_.id=? )

查询抽象类
当查询抽象类时，Hibernate 会自动返回一个集合，由匹配的具体异构子类构成。例如，如果我们查询数据库中的每个 Person，Hibernate 会返回一列 Individual 和 Corporation 对象。

但是，当没有指定具体类时，Hibernate 需要执行 SQL 的 JOIN，因为它不知道要查询哪个表。在 HQL 查询返回的检索到的所有表的列中，还会返回一个额外的 dynamic 列。Hibernate 使用 clazz 列来初始化和填充返回的对象。我们把这个类叫作决定因子（determination dynamic），与我们在第二个策略中使用的方法相对。

清单 7 显示了如何指定抽象类的 id 属性查询抽象类 Person，清单 8 显示了 Hibernate 自动生成的 SQL 查询，其中包括表连接：

清单 7. find() 方法调用中的 HQL 查询


public Person find(Integer id) {
  ...
  session.find(
        "select p from " + Person.class.getName() + " as p where p.id = ?",
    new Object[] { id },
    new Type[] { Hibernate.INTEGER });	
  ...
}

清单 8. 查找任何类型的 Person 的 SQL SELECT 查询


select person0_.ID as ID0_,
        
  casewhen(person0__1_.id is not null, 1,  
  casewhen(person0__2_.id is not null, 2,  
  casewhen(person0_.ID is not null, 0, -1))) as clazz_0_, 
  person0__1_.FIRST_NAME as FIRST_NAME61_0_, 
  person0__1_.LAST_NAME as LAST_NAME61_0_, 
  person0__2_.NAME as NAME62_0_, 
  person0__2_.REGISTRATION_NUMBER as REGISTRA3_62_0_ 
  from TB_PERSON person0_ 
  left outer join TB_INDIVIDUAL person0__1_ on person0_.ID=person0__1_.id 
  left outer join TB_CORPORATION person0__2_ on person0_.ID=person0__2_.id 
  where person0_.ID=?

策略 2：每个类层次结构一个表（Rights）
对于我们的 Right 层次结构，我们只使用一个表（ TB_RIGHT）来保存整体类层次结构。您会注意到， TB_RIGHT 表拥有保存 Right 类层次结构的每个属性所需要的所有列。保存的实例值也就会保存在表中，每个没有使用的列则用 NULL 值填充。（因为它到处都是“洞”，所以我们经常把它叫作 瑞士奶酪表）

在图 3 中，您会注意到， TB_RIGHT 表中包含一个额外的列 DISCRIMINATOR。Hibernate 用这个列自动初始化对应的类并相应进行填充。这个类用映射文件中的 XML 元素 <discriminator> 进行映射。

图 3. TB_RIGHT 表的内容

简明性技巧
在每个大型项目中，您都会面临包含多级抽象类的复杂的类层次结构。幸运的是，您不必指定抽象类的 discriminator-value，只需为 Hibernate 实际要使用的具体类指定这个值即可。

正如清单 2 所示的 Person 映射文件，在清单 9 中，我们映射了抽象类（ Right）及其所有属性。要映射两个具体类（ Lease 和 Property），就要使用 <subclass> XML 标签。这个标签非常简单；它要求 name 属性，仅仅是因为 class 标签要求 discriminator-value 属性。Hibernate 将用后一个属性标识它要处理的类。

从图 1 的类图中您会注意到， discriminator 不是任何 Java 类都有的属性。实际上，它甚至没有映射。它仅仅是 Hibernate 和数据库之间共享的一个技术性的列。

清单 9. Right.hbm.xml


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
  "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
  "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping>
  <class name="eg.hibernate.mapping.dataobject.Right" table="TB_RIGHT" polymorphism="implicit">
    <id name="id" column="ID">
      <generator class="assigned"/>
    </id>
    
        <discriminator>
      <column name="DISCRIMINATOR"/>
    </discriminator>
    <property name="date" column="DATE" type="java.sql.Date" />
    <many-to-one name="person" class="eg.hibernate.mapping.dataobject.Person" column="REF_PERSON_ID"/>
    <any name="estate"
         meta-type="string"
         id-type="java.lang.Integer">
      <meta-value value="LND" class="eg.hibernate.mapping.dataobject.Land"/>
      <meta-value value="BLD" class="eg.hibernate.mapping.dataobject.Building"/>
      <column name="REF_ESTATE_TYPE"/>
      <column name="REF_ESTATE_ID"/>          
    </any>
    
    
        <subclass name="eg.hibernate.mapping.dataobject.Property" discriminator-value="PRO"/>
    
    <subclass name="eg.hibernate.mapping.dataobject.Lease" discriminator-value="LEA">
      <property name="duration" column="DURATION" type="java.lang.Integer" />
     
        </subclass>
  </class>
</hibernate-mapping>

在清单 9 的映射文件中，您会注意到 Right 和 Person 层次结构之间的“多对一”关系，它（实质上）与 Person 层次结构（一对多）的关系正好相反。还请注意 Right 和 Estate 层次结构之间的关系；稍后我们将在本文中介绍这层关系。

使用第一个策略时，Hibernate 在访问数据库时生成了非常有效的 SQL 语句。当我们查询具体类时，如清单 10 所示，会在 discriminator 的 Hibernate 过滤器上自动取值 —— 这是件好事，因为这意味着 Hibernate 只读取与指定类对应的列。

清单 10. 针对具体类的 SQL 查询


select property0_.ID as ID, property0_.DATE as DATE, 
	property0_.REF_PERSON_ID as REF_PERS4_, property0_.REF_ESTATE_TYPE as REF_ESTA5_, 
	property0_.REF_ESTATE_ID as REF_ESTA6_ 
	from TB_RIGHT property0_ where property0_.DISCRIMINATOR='PRO'

当我们查询抽象类时，事情变得有些复杂。因为 Hibernate 不知道您要查询哪个特定的类，所以必须读取每个列（包括 discriminator 类），然后才能决定要初始化哪个类，最后再填充它。接下来，discriminator 充当的角色与第一个策略中 clazz 列充当的角色相同。但是这个方法显然更死板，因为类名直接派生自 discriminator 的值。

清单 11. （抽象的） Right 类的 SQL 查询


select right0_.ID as ID, 
	right0_.DISCRIMINATOR as DISCRIMI2_, 
	right0_.DATE as DATE, right0_.REF_PERSON_ID as REF_PERS4_, 
	right0_.REF_ESTATE_TYPE as REF_ESTA5_, right0_.REF_ESTATE_ID as REF_ESTA6_, 
	right0_.DURATION as DURATION from TB_RIGHT right0_

策略的不兼容
按照 Hibernate 映射的 DTD 定义，本文中描述的前两个策略是相互排斥的，这意味着它们无法组合在一起，映射同一个层次结构。

数据库模型的完整性
关于第二个策略，有一个需要重点考虑的地方：为了让它工作，必须把所有非共享列设置为 NULLABLE。因为开发人员通常会依赖数据库的约束，所以生成的表可能非常难以处理。（毕竟，把有持续时间的 Lease 设置为 NULL 没多大意义！）

解决方案之一是用 数据库级检测约束。您可以根据 DISCRIMINATOR 的值，定义一套要实施的规则，如清单 12 所示。当然，数据库引擎必须支持这些特性。而且，由于必须同时为全部具体类用一个有效表达式表示这些约束，所以当层次结构发展的时候，维护会很困难。

清单 12. 数据完整性约束


alter table TB_RIGHT 
	add constraint CHK_RIGHT check(	
		(discriminant ='DPP' and date is null and duration is null)
	or	(discriminant ='DLM' and date is not null and duration is not null));

策略 3: 每个具体类一个表（Estates）
我们的第三个，也是最后一个策略可能是三个策略当中最有想象力的：每个具体类一个表，抽象超类 Estate 没有表。我们依靠 Hibernate 提供对 多态（polymorphism）的支持。在清单 3 所示的 XML 映射文件中，您会注意到，其中只映射了两个具体类（ Building 和 Land）：

清单 13. Estate.hbm.xml


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
  "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
  "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>
  <class name="eg.hibernate.mapping.dataobject.Land" table="TB_LAND" polymorphism="implicit">
    <id name="id" column="ID">
      <generator class="assigned"/>
    </id>
    <property name="description" column="DESCRIPTION" type="java.lang.String" />
    <property name="squareFeet" column="SQUARE_FEET" type="java.lang.Double"/>
  </class>

  <class name="eg.hibernate.mapping.dataobject.Building" table="TB_BUILDING" polymorphism="implicit">
    <id name="id" column="ID">
      <generator class="assigned"/>
    </id>
    <property name="description" column="DESCRIPTION" type="java.lang.String" />
    <property name="address" column="ADDRESS" type="java.lang.String"/>
  </class>
</hibernate-mapping>

在表间共享 ID 值
要点在于，在同一类层次结构中映射的两个表之间，不必共享相同的 ID 值。如果您进行映射，那么 Hibernate 会为同一 ID 返回多个不同的对象。这可能会使 Hibernate 弄混 —— 您也会弄混。

当您查看清单 13 中的映射文件时，您的第一个反应可能是说：“呵！这个映射与我每天使用的没什么不同啊！这里没什么重要的东西！”而且您这么想应当是对的。实际上，第三个策略只需要一个条件：需要把 polymorphism 属性设置为 implicit。

即使在映射文件中找不到 Estate 类，它仍然存在于类层次结构之中。而且，因为两个映射的类（ Building 和 Land）是从 Estate 中继承而来，所以我们可以在 HQL 查询中使用这个抽象超类，如清单 14 所示。Hibernate 会用 内省（introspection） 找到扩展这个抽象类的类，以便依次为每个子类执行对应的 SQL 查询。

清单 14. find() 方法调用中的 HQL 查询


public Estate find(Integer id) {
  ...
  List objects =
    session.find(
      "select e from " + Estate.class.getName() + " as e where e.id = ?",
        new Object[] { id },
        new Type[] { Hibernate.INTEGER });
  ...
}

为了找到与指定 ID 匹配的 Estate，Hibernate 必须把清单 15 中的两个查询提交给数据库。

清单 15. SQL 查询


select land0_.ID as ID, land0_.DESCRIPTION as DESCRIPT2_, land0_.SQUARE_FEET as SQUARE_F3_ 
from TB_LAND land0_ where (land0_.ID=? )

select building0_.ID as ID, building0_.DESCRIPTION as DESCRIPT2_, building0_.ADDRESS as ADDRESS 
from TB_BUILDING building0_ where (building0_.ID=? )

正如我们在第二个策略中看到的，在 Right 和 Estate 类之间存在着 多对一 关系。在一般的表述中，这两个表的关系可以这么表述：“一个 Estate 可以指向许多 Right。但是每个 Right 只能指向一个 Estate。”但是从我们数据模型的角度来看，我们没有一个惟一的表可以用来创建我们的外键约束，就像 TB_RIGHT 和 TB_PERSON 之间那样。这使得我们几乎不可能创建外键。幸运的是，Hibernate 为我们提供了一个非常强大的 XML 映射元素 —— <any> 标签，它的用法如清单 16 所示。

清单 16. any 关系的 XML 映射


<any name="estate"
	meta-type="string"
	id-type="java.lang.Integer">
  <meta-value value="LND" class="eg.hibernate.mapping.dataobject.Land"/>
  <meta-value value="BLD" class="eg.hibernate.mapping.dataobject.Building"/>
  <column name="REF_ESTATE_TYPE"/>
  <column name="REF_ESTATE_ID"/>          
</any>

禁止多态
对于多态支持被禁止的类（ <class...polymorphism="explicit"...>），如果针对它们的超类进行查询，会把它们排除在外。

我们进一步查看我们的新映射。我们的 虚拟外键 基于 TB_RIGHT 表的两个列。第一个列（ REF_ESTATE_TYPE）包含 discriminator 字符串，用这个字符串映射对应的类名。第二个（ REF_ESTATE_ID）是另外一个表的主键的列名。使用默认设置时，Hibernate 会在第一个列中保存映射的类名，这么做可能会非常消耗空间、没有效率（特别是在代码重构修改类名的时候）。谢天谢地，Hibernate 还提供了一个用 <meta-value> XML 元素把类名映射到字符串约束的方法。这些约束的作用与在第二个策略中讨论的 discriminator 的作用相同。再次声明，这些特性只包含 Hibernate 和数据库，所以不会改变类的层次结构。

数据库模型的完整性
虽然标准 SQL 不允许对多个表同时针对指定列进行参考约束，但是仍有可能添加触发器，根据读取的 discriminator 值，触发器会检测目录中是否有数据。但是，这样的 完整性实施 方法可能非常难以维护，也有可能降低数据的整体性能。

多态 —— 用到极限！
在使用 Hibernate 内置的多态时需要记住一件事：如果您一不小心，把所有的类都用 polymorphism 属性设置为 implicit，那么您检索到的信息可能要比您想要的多得多。清单 17 显示了一种使用两个词的 HQL 查询来检索 整个数据库 的方法。

清单 17. HQL 查询


public List all() {
  ...
  List objects = session.find("
        from Object");
  ...
}

该查询的功能非常强大，您觉得呢？当然，我们之中没有多少人需要只用一个 HQL 查询检索整个数据库。这个（没有实际意义）的示例的目的就是为了显示隐式多态的能力。您可以利用这个能力避免把无用的、耗费资源的 SQL 查询发送到数据库。

结束语
在本文中，我们试图向您提供一个相当简单的实现示例，演示 Hibernate 提供的三个映射策略。回头来看，每个策略都有自己的优势与不足：

对于第一个策略（每个子类一个表），Hibernate 每次初始化和填充对象时，会读取多个表。如果您的索引定义得很好，而且层次结构不是太深，那么这个操作可以产生良好的结果。但是，如果不是这种情况，那么您可能会遇到各种性能问题。
对于第二个策略（每个类层次结构一个表），您必须用 检测约束 定义您自己的完整性。但随着列的数量与时俱增，这个策略可能会变得难以维护。另一方面，您可能选择根本不用这样的约束，而依靠应用程序的代码来管理自己的数据完整性。
第三个策略（每个具体类一个表）有一些映射限制，而底层数据模型不能使用参照完整性，这意味着您不能发挥关系数据库引擎的所有潜力。但是，从好的方面说，该策略很常容易与另两个策略组合在一起。

不管您选择哪种策略，都要记住，在整个过程当中，无需修改 Java 类，这意味着业务对象与持续性框架之间一点联系都没有。正是这样高水平的灵活性使 Hibernate 在对象关系 Java 项目中如此流行。

参考资料

您可以参阅本文在 developerWorks 全球站点上的英文原文。
请单击本文顶部或底部的 Code 图标下载本文中使用的源代码示例。
Hibernate site 提供了您需要的与这个强大的对象持久性框架有关的所有信息。可以从这个站点下载运行示例应用程序所需的 Hibernate 文件。
HSQLDB 数据库是一个开源的轻量级数据库，完全用 Java 语言编写。可以从这个站点下载 HSQLDB，并把它用作示例应用程序的数据库。
请参阅 Hibernate 撰写的 HQL reference，来获得 Hibernate 查询语言的完整文档。
“ Using Hibernate to persist your Java objects to IBM DB2 Universal Database”，作者是 Javid Jamae 和 Kulvir Singh Bhogal（developerWorks，2003 年 6 月），该书提供了用 Hibernate 将类映射到数据库表的良好指导。
“ 无需容器的对象关系映射 ”，作者是 Richard Hightower，（developerWorks，2004 年 4 月），它对使用 Hibernate 和 Spring 框架开发事务性持久性层进行了介绍。
“ Developing Hibernate 应用程序s for use with WebSphere Application Server”，作者 Sunil Patil（ IBM WebSphere Developer Technical Journal， 2004 年 9 月），提供了创建 Hibernate 应用程序时使用 Websphere Application Server 连接和事务管理的详细指导。
“ Hibernate your data”，作者是 Davor Cengija（ONJava.com，2004 年 1 月），它提供了 Hibernate API 的所有基础知识，描述了如何利用 Hibernate API 的映射文件。
Hibernate in Action ，作者是 Christian Bauer 和 Gavin King（Independent Pub Group，2004 年），这是一份关于对象关系映射的理论与实践指南。由 Hibernate 小组编写。
Hibernate: A Developer's Notebook ，作者是 James Elliot（O'Reilly，2004 年），这是另一份 Hibernate 的精彩指南。
在 developerWorks Java 技术专区中，可以找到数百篇有关 Java 各个方面的技术文章。
请访问 Developer Bookstore，以获得技术书籍的完整清单，其中包括数百本 Java 相关主题的书籍。

下载

Name	Size	Download method
j-hibernate-source.zip		FTP

关于下载方法的信息

作者简介

Xavier Coulon 六年前以 IT 专家的身份加入 IBM 的法国分部，并开始从事各类平台上的 ERP 咨询工作。最近两年，他一直在处理一个大型 J2EE 项目，这个项目包含诸如 Struts 和 Hibernate 之类的开源框架。您可以通过 xavier.coulon@fr.ibm.com 与 Xavier 联系。

作者照片 Christian Brousseau 是一个了不起的加拿大人，他一直在开发软件，有十多年的经验。最初他做了大量 Windows 开发（C++、Visual Basic、MFC、ActiveX），后来，从 Java 语言的 1.0 版本起，他开始转移到 Java 项目上。做 J2EE 顾问时积累的专业知识为他提供了一个去法国的好机会，在法国，他协助设计、开发、部署了一些重要的企业级 J2EE 项目。可以通过 cbrous@fr.ibm.com 与 Christian 联系。

posted on 2005-05-17 18:27 笨笨阅读(570) 评论(0) 编辑收藏所属分类: J2EE 、HibernateAndSpring 、ALL

新用户注册刷新评论列表


只有注册用户登录后才能发表评论。




网站导航: 博客园 IT新闻知识库 C++博客博问管理
相关文章: 简化JavaMail：小巧 Jakarta Commons-Email 简单教程读"Under the Hood of J2EE Clustering" J2EE集群 Phase x509数字证书介绍 SSL※ X509 了解安全性断言标记语言架构蓝图--软件架构 "4+1" 视图模型主动对象 Profile,Stereotype,TaggedValue与OCL漫谈 Drools 为你的业务逻辑提供框架（翻译）

kapok

常用链接

留言簿(28)

随笔分类

随笔档案

Corba

EAI

Online Document

Open Source

Portal

RSS Links

Weblogic

不错的链接

工具集合

数据仓库相关

搜索

最新评论

阅读排行榜

评论排行榜