IDC资讯中心
在本篇文章中，我们将详细地讨论sun公司的java数据对象（jdo）标准。jdo允许我们使用java对象，支持事务和多用户。与odbc不同的是，它使我们无需考虑sql和与数据库有关的其他东西。它与串行化也有所区别，因为它支持多个用户和事务。jdo允许java开发人员将他们的数据模型用作数据模型，无需在“数据端”、“对象端”之间的转移方面花费大量的时间。
包括cocobase、webgain toplink和castor jdo在内的多种产品都可以实现了jdo标准。既然有一种标准的方法，我们就可以只学习其中的一种，就象有了odbc，我们就可以使用任何提供了驱动程序的数据库那样。
在本篇文章中，我们将使用prism技术公司的openfusion jdo。读者在后面会发现，只有很小一部分代码使用了prismtech api，其他部分都使用了标准的jdo标准。
创建person对象
我们将首先创建一个person对象，该对象遵循了javabean的惯例，可以对其属性执行get和set操作。需要注意的是，尽管我们是在创建这个类，但它并没有什么特别的，它没有继承或实现任何基本类。对一个可保持类的要求是：
1、所有域必须能够被jdo类访问（public或set*方法）
2、域的数据类型必须符合jdo规格。
3、不能支持一些类型的字段（例如thread、file、socket等不能串行化的字段）。
下面是符合上述要求的person.java：
public class person {
private string name;
private string address;
private string ssn;
private string email;
private string homephone;
private string workphone;
// 允许我们使用构造器创建person对象
public person(string name, string address, string ssn,
string email, string homephone, string workphone) {
this.name = name;
this.address = address;
this.ssn = ssn;
this.email = email;
this.homephone = homephone;
this.workphone = workphone;
}
// 方法
public string getname() { return name; }
public string getaddress() { return address; }
public string getssn() { return ssn; }
public string getemail() { return email; }
public string gethomephone() { return homephone; }
public string getworkphone() { return workphone; }
public void setname(string name) { this.name = name; }
public void setaddress(string address) {
this.address = address;
}
public void setssn(string ssn) { this.ssn = ssn; }
public void setemail(string email) { this.email = email; }
public void sethomephone(string homephone) {
this.homephone = homephone;
}
public void setworkphone(string workphone) {
this.workphone = workphone;
}
}
创建personpersist对象管理可保持性
现在已经有了person对象，我们需要创建一些代码来管理这种可保持性。下面我们将详细讨论这些代码，并学习如何：
1、初始化jdo可保持性管理器。
2、向数据库中输入三个人的资料。
3、从数据库中显示人的资料。
4、修改其中一个人的名字。
5、从数据库中删除一个人的资料。
6、在main()方法中进行相关的处理。
第一步：初始化jdo可保持性管理器
我们从openfusion实现中导入了标准的jdo类和managedconnectionfactory，当然了我们也可以将它们抽象成一个独立的类。构造器使用javax.jdo.persistencemanagerfactoryclass属性设置连接代理，这一点与在jdbc中设置数据库驱动程序的属性很相似。
package addressbook;
import java.util.*;
import javax.jdo.*;
import
com.prismt.j2ee.connector.jdbc.managedconnectionfactoryimpl;
public class personpersist
{
private final static int size = 3;
private persistencemanagerfactory pmf = null;
private persistencemanager pm = null;
private transaction transaction = null;
// 需要保持的人的数组
private person[] people;
// 现有对象标识符的向量
private vector id = new vector(size);
public personpersist() {
try {
properties props = new properties();
props.setproperty("javax.jdo.persistencemanagerfactoryclass",
"com.prismt.j2ee.jdo.persistencemanagerfactoryimpl");
pmf = jdohelper.getpersistencemanagerfactory(props);
pmf.setconnectionfactory( createconnectionfactory() );
} catch(exception ex) {
ex.printstacktrace();
system.exit(1);
}
}
连接代理是在名字为createconnectionfactory()的静态方法中创建的，该代理需要jdbc url、jdbc驱动程序、用户名和口令。
public static object createconnectionfactory() {
managedconnectionfactoryimpl mcfi = new
managedconnectionfactoryimpl();
object connectionfactory = null;
try {
mcfi.setusername("scott");
mcfi.setpassword("tiger");
mcfi.setconnectionurl(
"jdbc:oracle:thin:@localhost:1521:thedb");
mcfi.setdbdriver("oracle.jdbc.driver.oracledriver");
connectionfactory = mcfi.createconnectionfactory();
} catch(exception e) {
e.printstacktrace();
system.exit(1);
}
return connectionfactory;
}
第二步：在数据库中输入三个人的资料
persistpeople()使用person.java文件中的构造器创建了3个人的资料。。我们要作的第一件事是通过
getpersistencemanager()获得一个可保持性管理器，然后创建一个执行我们的任务的事务。为了保持这一对象结构图，我们简单地调用makepersistentall( object[] )方法即可。代码底部的for()循环获得每个保持对象的唯一的id，并保存起来供以后使用。
public void persistpeople() {
// 创建人的资料的数组
people = new person[size];
// 创建3个人的资料
people[0] = new person("gary segal", "123 foobar lane",
"123-123-1234", "gary@segal.com",
"(608) 294-0192", "(608) 029-4059");
people[1] = new person("michael owen",
"222 bazza lane, liverpool, mn",
"111-222-3333", "michael@owen.com",
"(720) 111-2222", "(303) 222-3333");
people[2] = new person("roy keane",
"222 trafford ave, manchester, mn",
"234-235-3830", "roy@keane.com",
"(720) 940-9049", "(303) 309-7599)");
// 保持这3个人的资料
pm = pmf.getpersistencemanager();
transaction = pm.currenttransaction();
pm.makepersistentall(people);
transaction.commit();
// 获取被保持对象的对象id
for(int i = 0; i < people.length; i++) {
id.add(pm.getobjectid(people[i]));
}
// 关闭现有的保持性管理器，保证对象是从数据库而不是从保持性管理器的缓存中读取的
pm.close();
}
下面是一些可以针对保持性管理器的其他方法：
使实例成为可保持的：获得一个临时对象，并保持它。
删除可保持实例：从数据存储库中删除信息。
使实例临时化：使实例与可保持性管理器分离，而不删除在数据存储库中的信息。
使实例处于保持状态 删除保持的实例 使实例处于临时状态
makepersistent(object o) deletepersistent(object o) maketransient(object o)
makepersistentall(object[] os) deletepersistentall(object[] os) maketransientall(object[] os)
makepersistentall(collection os) deletepersistentall(collection os) maketransientall(collection os)
（这里是一个4×3的表格，可以参阅原稿中的英文表格）
第三步：显示数据库中人的信息
显示信息代码以获得可保持性管理器开始。我们使用上面代码中用persistpeople()方法保存的对象id获得对象，调用对象的方法━━在本例中是gets，来得到我们输入的信息。我们可以发现，要保持我们的对象，并不需要编写大量的代码。
public void display(int end) {
person person;
int max = end <= size ? end : size;
// 获得一个新的可保持性管理器
pm = pmf.getpersistencemanager();
// 从数据库中获取对象并进行显示
for(int i = 0; i < max; i++) {
person = (person) pm.getobjectbyid(id.elementat(i),
false);
system.out.println("name : " + person.getname());
system.out.println("address : " +
person.getaddress());
system.out.println("ssn : " + person.getssn());
system.out.println("email : " + person.getemail());
system.out.println("home phone: " +
person.gethomephone());
system.out.println("work phone: " +
person.getworkphone());
}
pm.close();
}
第四步：改变其中一个人的名字
改变存储在数据库中的一个人的信息的代码也十分简单，它与显示数据库中人的信息的代码非常类似。在这里，我们需要创建一个事务（因为要修改其中的记录），使用定义的setname()方法修改一个人的名字，最终提交该事务，保存所作的修改。这种操作与处理临时对象之间真正的差别是，我们考虑是事务。
public void change() {
person person;
// 从数据存储库中获取对象
pm = pmf.getpersistencemanager();
transaction = pm.currenttransaction();
// 修改第二个保持记录的datastring字段
person = (person) pm.getobjectbyid(id.elementat(1),
false);
person.setname("steve gerrard");
// 提交事务并关闭可保持性管理器
transaction.commit();
pm.close();
}
第五步：删除一个人的资料
你自己能够想象出从数据库中删除第二个人资料的代码吗？因为我们已经了解了所有编写这一代码所需要的知识。仔细地研究一下下面的代码就会发现，我们使用了第二步中的可保持性管理器方法中提到的deletepersistent()方法。
public void delete() {
// 从数据库中获取对象
pm = pmf.getpersistencemanager();
transaction = pm.currenttransaction();
// 从数据库中删除第二个人的信息，并从id向量中删除其id
pm.deletepersistent(pm.getobjectbyid(id.remove(1),
false));
// 提交事务并关闭可保持性管理器
transaction.commit();
pm.close();
}
第六步：在main()方法中运行上面的代码
最后，整个代码需要有一个main()串起来，在数据库中输入人的信息、改变其中一个人的名字，然后删除该人的资料。如果运行这一程序，就会看到程序运行到每一步时的地址簿。
public static void main(string[] args) {
system.out.println("create personpersist");
personpersist personpersist = new personpersist();
system.out.println("setup and persist a group of people");
personpersist.persistpeople();
system.out.println("display the persisted people");
personpersist.display(size);
system.out.println("change a name ");
personpersist.change();
personpersist.display(size);
system.out.println("delete a person ");
personpersist.delete();
personpersist.display(size – 1);
}
jdoenhancer：创建jdoenhancer的jdo描述符
现在，我们已经编写好了整个应用程序的源代码，下一步需要作的就是创建一个jdoenhancer将要使用的
jdo描述符。读者一定会问，jdoenhancer是什么？jdo架构是基于下面的理念的：一个jdo实现能够获取类的字节码，对它们进行处理，添加一些必要的功能。例如，jdoenhancer将使类实现persistancecapable接口（因此我们不用自己编程实现这一接口），而且能够实现该接口中的一些方法。因此在对代码编译后我们就会发现，我们必须运行jdoenhancer对字节码进行适当的处理。我们需要创建一个给出我们需要保持的类的信息的描述符文件，这一文件如下所示：
<?xml version="1.0" encoding="utf-8"?>
<!doctype jdo system
"file:/d:/apps/openfusionjdo/xml/schema/jdo.dtd">
<jdo>
<package name="addressbook">
<class name="person" identity-type="datastore">
</class>
</package>
</jdo>
这只是一个最基本的文件，但能够满足我们的要求。当然了，还有许多更复杂的映射。下面是openfusion例子中一个稍微复杂一些的映射：
<class name="department" identity-type="datastore">
<field name="name"/>
<field name="employees">
<collection element-
type="com.prismt.j2ee.jdo.examples.appkeydepartment.employee">
</collection>
</field>
<field name="manager"/>
</class>
</package>
</jdo>
现在我们已经编写好了代码和jdo描述符文件，我们将对它们进行整合，并讨论如何建立整个系统。要建立整个系统，我们只需要简单的几步工作即可：
1、编译代码。
2、运行jdoenhancer。
3、使用jdoenhancer的输出建立数据库。
4、运行应用程序。
第一步：编译代码
我想广大的读者想必已经知道如何运行javac了吧。在运行javac之前，我们只要保证正确地设置classpath就可以了。下面是一个在windows平台上运行javac的例子：
% set openfusion_dir=d:\apps\openfusionjdo
% set
classpath=%openfusion_dir%\lib\connector.jar;%openfusion_dir%\
lib\jndi.jar;%openfusion_dir%\lib\log4j.jar;%openfusion_dir%\l
ib\xerces.jar;%openfusion_dir%\lib\classes12.zip;%openfusion_d
ir%\lib\jdo.jar;%openfusion_dir%\lib\jta-
spec1_0_1.jar;%openfusion_dir%\lib\ofjdo.jar;.
% javac ?d . person*.java
第二步：运行jdoenhancer
jdoenhancer需要使用在上一步编译中得到的字节码和我们先前建立的jdo描述符文件。下面是openfusion jdoenhancer的完整语法：
java com.prismt.j2ee.jdo.enhancer.jdoenhancer
命令选项：
-cp 开始搜索需要强化的类的基本路径，与classpath不同，它是编译后的可保持类所在的目录
-oc 存储强化后的类的目录
-pd jdo描述符文件
可选项：
-db 指定目标数据库 [oracle、sybase等]
-od 生成sql脚本的目录
下面是为建立我们的应用程序而运行jdoenhancer的一个例子：
% java com.prismt.j2ee.jdo.enhancer.jdoenhancer -oc . -pd
person.jdo -db oracle -od db -cp .
第三步：使用jdoenhancer的输出建立数据库
，只要使用?db和-od可选项，jdoenhancer就能够创建建立数据库的数据库脚本。它能够创建许多脚本，但其中有一个的名字叫load_all.sql，打开该文件并将它加载到一个sql提示符中。（例如sqlplus for oracle）
create sequence instid_seq increment by 1
;
create table jdo_addressbook_person_sco
(
inst_id integer not null,
class integer not null,
jdo_address varchar2(255),
jdo_email varchar2(255),
jdo_homephone varchar2(255),
jdo_name varchar2(255),
jdo_ssn varchar2(255),
jdo_workphone varchar2(255)
)
;
create table jdo_addressbook_person
(
inst_id integer not null,
class integer not null,
jdo_address varchar2(255),
jdo_email varchar2(255),
jdo_homephone varchar2(255),
jdo_name varchar2(255),
jdo_ssn varchar2(255),
jdo_workphone varchar2(255)
)
;
create table prismjdoprop
(
name varchar2(255) primary key,
value varchar2(255)
)
;
create table prismjdoextents
(
class_id number(38,0) primary key,
class_name varchar2(255) unique,
app_key varchar2(255)
)
;
alter table jdo_addressbook_person_sco add primary key
(inst_id, class)
;
alter table jdo_addressbook_person add primary key (inst_id,
class)
;
insert into prismjdoextents values(0, addressbook.person,
com.prismt.j2ee.jdo.spi.dbkey)
;
commit work
;
insert into prismjdoprop values(use.rdbms.triggers, true)
;
commit work
;
第四步：运行应用程序
现在已经建立了数据库，我们就可以运行应用程序了。怎么样，分享一下自己的劳动成果吧！
% java addressbook.personpersist
结束语
我们已经讨论了如何使用openfusion jdo实现来处理jdo标准。这是一个全新的领域，开发人员可以集中精力处理业务需求和对象，而无需对sql十分精通。
