现在，越来越多的企业项目需要一种将 java 对象绑定到关系数据 ? 并且在众多关系数据库上进行绑定 ? 的可靠方法。遗憾的是，（许多人已体会到其中的艰难）内部解决方案很难构建，而对其进行长期维护和扩展就更难了。在本文中，bruce snyder 向您介绍了使用 castor jdo 的基础知识，castor jdo 是一种开放源码数据绑定框架，它恰好基于百分之百纯 java 技术。
castor jdo（java 数据对象 (java data objects)）是一种开放源码的、百分之百 java 数据绑定框架。castor jdo 最早发布于 1999 年 12 月，它是第一批可用的开放源码数据绑定框架之一。自那时以来，这项技术已获得了长足的发展。现在，往往将 castor jdo 同许多其它技术（既有开放源码的，也有商业的）结合使用，以将 java 对象模型绑定到关系数据库、xml 文档以及 ldap 目录上。

在本文中，您将了解使用 castor jdo 的基本知识。我们将从关系数据模型和 java 对象模型开始，然后讨论在二者之间进行映射的基础知识。接下来，我们将讨论 castor jdo 的一些特性。通过使用一个基于产品的简单示例，您将了解一些基本内容，如（关系的和面向对象的）继承、从属与相关关系、castor 的对象查询语言（object query language）实现以及 castor 中短事务和长事务的比较。因为本文只是对 castor 的简介，所以我们在这里将使用非常简单的示例，而且我们也不对任何一个主题进行深入讨论。读完本文之后，您将对这项技术在整体上有了一个较好的了解，也为将来的探索打下了较好的基础。

请注意，本文将不深入讨论对象-关系映射这一一般性的主题。想了解关于对象-关系映射的更多知识，请参阅参考资料一节。

如果您想了解 castor jdo 与 sun jdo 规范之间的差异，那么请参阅“castor 与 sun jdo 规范有何差异？”。

开始
有时我喜欢通过对数据建模来开始项目；而有时我喜欢通过对对象建模来开始项目。针对本文的目的，我们将从数据模型开始。castor 附带了一些 jdo 示例，它们给出了围绕某个产品概念的数据模型和对象模型。我们将使用其中的一个示例，将其贯穿应用于本文的几个不同阶段。图 1 是该示例数据模型的实体-关系（er）图。为简单起见，该图不含显式的外键。然而，需要注意的是表之间确实存在标识引用。

获取源代码
castor 项目的源代码是通过一种称为 exolab 许可证的 bsd 样式许可证发布到 java 技术社区的。请参阅参考资料以下载 castor jdo。
图 1. castor jdo 示例数据模型


图 2 是该示例对象模型的 uml 类图。jdo 示例提供了表到对象的一对一表示。

图 2. castor jdo 示例对象模型


castor 的 java 对象很象 javabeans 组件。因此，（除非将特性映射成直接访问）对象的每个特性通常都有一对取值（accessor）和赋值（mutator）方法（getter/setter）。更加复杂的关系可以含有用于其它目的的额外的逻辑。对象-关系映射可以迅速变得极其复杂；然而，这些示例实际上却十分简单。

清单 1 显示了 product 对象的源代码。注：对于 product 表中包括标识在内的每一列，代码都含有对应的特性。对于刚接触对象-关系映射的人来说，对应于标识符的特性可能显得很奇怪，但这种构造的确十分常见，而且也在其它对象-关系框架中使用。castor 在内部使用对象标识来跟踪对象。此外，还有两个 java.util.vector 用于关联的 productdetail 和 category 对象。还要注意的是，对象包括一个 tostring() 方法，它在调试应用程序时可用作日志记录用途。

清单 1. product.java
package myapp;

import java.util.vector;
import java.util.enumeration;
import org.exolab.castor.jdo.database;
import org.exolab.castor.jdo.persistent;

public class product implements persistent
{
private int _id;
private string _name;
private float _price;
private productgroup _group;
private database _db;
private vector _details = new vector();
private vector _categories = new vector();

public int getid()
{
return _id;
}

public void setid( int id )
{
_id = id;
}

public string getname()
...

public void setname( string name )
...

public float getprice()
...

public void setprice( float price )
...

public productgroup getgroup()
...

public void setgroup( productgroup group )
...

public productdetail createdetail()
{
return new productdetail();
}

public vector getdetails()
{
return _details;
}

public void adddetail( productdetail detail )
{
_details.add( detail );
detail.setproduct( this );
}

public vector getcategories()
{
return _categories;
}

public void addcategory( category category )
{
if ( _categories.contains( category ) ) {
_categories.addelement( category ); category.addproduct( this );
}
}

...

public string tostring()
{
return _id + " " + _name;
}
}



在查看图 2 时，请注意 product 与 productdetail 对象和 category 对象有不同的关系：

一个 product 可以包含多个 productdetail。这是一对多关系。
多个 product 可以包含多个 category 对象。这是多对多关系。
adddetail() 和 addcategory() 方法用于将对象添加到每个 java.util.vector 以管理它们各自的关系。

映射描述符的因果
正如有些人相信生活的关键是要正确理解并接受个人的命运一样，我发现使用 castor jdo 的关键是要正确理解并实现映射描述符。映射描述符提供关系数据库表和 java 对象之间的连接（映射）。映射描述符的格式是 xml ? 这是有充分理由的。castor 项目的另一半是 castor xml（参阅参考资料）。castor xml 提供出色的 java 到 xml 和 xml 到 java 数据绑定框架。castor jdo 利用 castor xml 的能力来将 xml 文档数据分解到 java 对象模型，以便读取映射描述符。

将对象和特性映射成元素和属性
每个 java 对象都由一个 <class> 元素表示，而对象中的每个特性都由一个 <field> 元素表示。此外，关系表内的每列都由一个 <sql> 元素表示。清单 2 显示了上面所见到的 product 对象的映射。先请看该清单，接下来我们将讨论该代码的一些亮点。

清单 2. product 的映射
<class name="myapp.product" identity="id">
<description>product definition</description>
<map-to table="prod" xml="product" />
<field name="id" type="integer">
<sql name="id" type="integer" />
</field>
<field name="name" type="string">
<sql name="name" type="char" />
</field>
<field name="price" type="float">
<sql name="price" type="numeric" />
</field>

<!-- product has reference to productgroup,
many products may reference same group -->
<field name="group" type="myapp.productgroup">
<sql name="group_id" />
</field>

<!-- product has reference to productdetail
many details per product -->
<field name="details" type="myapp.productdetail" required="true"
collection="vector">
<sql many-key="prod_id"/>
</field>

<!-- product has reference to category with
many-many relationship -->
<field name="categories" type="myapp.category" required="true"
collection="vector">
<sql name="category_id"
many-table="category_prod" many-key="prod_id" />
</field>
</class>



<class> 元素支持一些重要的属性和元素。例如，product 映射使用 identify 属性来指示对象的哪个特性充当对象标识符。<class> 元素还支持 <map-to> 元素，该元素告诉 castor 每个对象映射到什么关系表上。<field> 元素也支持一些属性。

请注意，所有 <field> 和 <sql> 元素的映射都包含 type 属性。类型属性向 castor 指示：该在内部使用什么 typeconvertor 来在对象和关系数据类型之间进行转换。

定义关系
对于每个“对多”关系，都存在类型属性的特殊情形。如同以前所提到的那样，product 中的两个 java.util.vector 处理一对多和多对多关系。一对多关系存在于称为 details 的 <field> 元素中。details 元素中的信息告诉 castor：特性是 java.util.vector 类型的 collection；collection 包含 productdetail 类型的对象；并且它是 required（即，不能为空值）。<sql> 元素告诉 castor：<field> 的对象映射含有一个称为 prod_id 的 sql 列，该列将被用于标识一对多关系。

多对多关系存在于称为 categories 的 <field> 元素中。categories 元素告诉 castor：特性是 java.util.vector 类型的 collection；该 collection 含有 category 类型的对象；并且它是 required（即，它不能为空值）。<sql> 元素告诉 castor：该关系利用一个称为 category_prod 的额外的表。它还声明该 <field> 的对象映射含有一个称为 prod_id 的 sql 列，该列应该同 category_id 一起用来标识多对多关系。

productgroup 和 product 之间还存在另一种关系。该关系是一对多关系，通过这一关系，许多 product 就能够与同一个 productgroup 之间存在关系。虽然该关系与 product 和 productdetail 之间的一对多关系相同，但其运行却相反（多对一），因此我们只在映射中看到了关系的“对一”的一方。

castor 中的继承
castor 使用两种类型的继承：java 继承和关系继承。清单 3 含有 computer 的映射。正如您能从图 1 中回忆起来的一样，computer 是 product 的继承。

当 java 对象只是继承一般基类或实现一个接口时，无须在映射描述符中反映该继承。然而，因为 product 和 computer 都是已映射的类，所以必须为 castor 注明继承以正确地反映它。<class> 元素的 extends 属性用于表示 computer 和 product 之间的关系。在图 1 中请注意 comp（计算机）表并不包括来自 prod（产品）表的列。相反，prod 表包含基本信息，comp 表继承了该表。

清单 3. computer 的映射
<class name="myapp.computer" extends="myapp.product" identity="id">
<description>computer definition, extends generic
product</description>
<map-to table="computer" xml="computer" />
<field name="id" type="integer">
<sql name="id" type="integer" />
</field>
<field name="cpu" type="string">
<sql name="cpu" type="char"/>
</field>
</class>



从属关系 vs. 相关关系
castor 对两个对象之间的关系进行了区分，分为从属或相关，并且对每种类型的关系维护不同的生命周期。至此，我们只讨论了独立（或相关）对象。独立对象是那些未在映射描述符的 <class> 元素中指定 depends 属性的对象。如果您想在独立对象上执行任何 crud（创建、读取、更新和删除）操作，那么您可以直接在对象上执行这些操作。

清单 4 包含从属对象 productdetail 的映射。请注意，<class> 元素包含 depends 属性。这就告诉 castor：productdetail 的所有操作都从属于 product。在这里，product 是主对象而 productdetail 是从属对象。如果您想在 productdetail 对象上执行任何 crud 操作，那么您只能通过其主对象来执行这些操作。也就是，您必须首先获取一个 product 并使用取值方法导航到 productdetail。每个独立对象可能只有一个主对象。

清单 4. productdetail 的映射
<class name="myapp.productdetail" identity="id" depends="myapp.product">
<description>product detail</description>
<map-to table="prod_detail" xml="detail" />
<field name="id" type="integer">
<sql name="id" type="integer"/>
</field>
<field name="product" type="myapp.product">
<sql name="prod_id" />
</field>
<field name="name" type="string">
<sql name="name" type="char"/>
</field>
</class>



在对象模型上执行查询
castor 实现了对象查询语言（oql）的 odmg 3.0 规范的一个子集。oql 的语法类似于 sql 的语法，但它却使您能够查询对象模型，而不是直接查询数据库。在支持多个数据库时，这可能是一项强大的功能。castor 的 oql 实现在内部将 oql 查询转换成用于数据库的适当的 sql。使用 bind() 方法将参数绑定到查询上。以下是 oql 查询的一些简单示例。

castor 的 oql 实现并不在整个查询中继续使用全限定对象名，相反它支持对象别名的使用。在下面的这些查询中，c 就是这样的一个别名。

如果想要查询以找出所有 computer，可以执行下列查询：


select c from myapp.computer c



如果想要查询以找出标识等于 1234 的 computer，可以以：


select c from myapp.computer c where c.id= $1



开始，后跟：


query.bind( 1234 )



要查询名称与特殊字符串相似的 computer，可以执行下列查询：


select c from myapp.computer c where c.name like $1



后跟：


query.bind( "%abcd%" )



要查询其标识符属于一列标识符之内的 computer，可以执行下列查询：


select c from myapp.computer c where c.id in list ( $1, $2, $3 )



后跟：


query.bind( 97 )
query.bind( 11 )
query.bind( 7 )


对 castor oql 实现的更详细讨论超出了本文的范围。要了解更多信息，请参阅参考资料一节中的参考资料。

castor 中的事务
castor 的持久性操作在事务上下文内进行。然而，castor 不是事务管理器。相反，它更象是高速缓存管理器，因为它利用事务的原子性来将对象持久保存到数据库。这种设置允许应用程序更加容易地提交或回滚对对象图的任何更改。运行于非受管环境下的应用程序必须显式提交或回滚事务。当应用程序服务器运行于受管环境下时，应用程序服务器可以管理事务性上下文。

短事务 vs. 长事务
castor 中正常的事务被称为短事务。castor 还提供了长事务这一概念，长事务由两个短事务组成。我们可以使用一个典型的 web 应用程序来理解两种类型的事务之间的差异。对需要从数据库读取数据、将数据显示给用户然后把数据提交给数据库的应用程序来说，我们查看有可能冗长的事务时间（这对于 web 应用程序是很典型的）。但不能在数据库中无限地保持写锁。为了解决这一问题，castor 利用了两个短事务。例如，第一个短事务使用只读查询来具体化对象，这让您可以在不打开事务就显示对象。如果用户做了更改，则启动第二短个事务，update() 方法将更改过的对象带入事务的上下文。清单 5 是一个长事务的示例。

清单 5. 长事务示例
public lineitem getlineitem()
{
db.begin();
lineitem lineitem = ( lineitem ) db.load( lineitem.class,
lineitemnum, database.readonly );
db.commit();
return lineitem;
}

public void updateorder( lineitem li )
{
db.begin();
db.update( li );
db.commit();
}



因为第一个短事务和第二个短事务之间的时间间隔是任意的，所以您将不得不执行一个脏检查（dirty check）来确定是否在数据库中更改了对象。脏检查用于验证对象在长事务期间没有被修改。您可以通过指定映射描述符的 <sql> 元素中的 dirty 属性来启用脏检查。为了使脏检查正确工作，每个对象都必须保持一个时间戳记。如果您实现了 timestampable 回调接口，castor 将在第一个短事务中设置时间戳记并在第二个短事务期间检查该时间戳记。

database 支持
castor jdo 的主要特性是：它提供了将 java 对象绑定到关系数据库的 api。castor jdo 支持下列数据库：
db2
hypersonicsql
informix
instantdb
interbase
mysql
oracle
postgresql
sap db
sql server
sybase
generic（用于一般 jdbc 支持）
添加对其它数据库的支持十分容易。参阅参考资料以获取进一步的信息。

结束语
在本文中，我们讨论了使用 castor 将关系数据模型映射到 java 对象模型的基础知识。本文中所使用的示例与 castor 源代码中当前所提供的示例非常相近。这些简单的示例肯定不能涵盖 castor 的全部能力。实际上，castor 支持许多其它特性，包括键生成、延迟装入、lru 高速缓存、不同的锁定／访问方式以及更多。如果您想了解关于这些特性以及许多其它特性的更多信息，请参考参考资料一节。

castor jdo 只不过是当今开放源码世界中许多可用数据绑定解决方案中的一种。如本文所显示的那样，castor 为内部解决方案提供了完善的替代方案，内部解决方案通常需要您为您支持的每个数据库维护不同的 sql 和 jdbc 代码。而且，因为 castor 是开放源码的、基于社区的项目，所以 castor 得到了不断的改进。我鼓励您研究这一技术，甚至可能成为 castor 社区的一员。