jdo基本思想及特点

    企业信息系统的一个重要问题是解决数据的存储，即持久化。在软件开发过程中，分析员分析领域业务，提取出领域业务模型，并对应设计出数据库中需要进行存储业务数据的数据库表及相应字段。

   并根据业务流程，设计业务处理逻辑单元，进行数据的加工、处理及存储、查询等业务。其中一个较为繁烦、枯燥的工作，就是处理大量的数据持久化代码。为了解决数据从业务对象层向数据存储层之间的转换工作，jdo提供了相应的开发规范及api，解决了由java对象直接存储为数据库相应表的底层处理过程，有助于设计人员更加专注于面向业务流程、面向业务对象等较高层次的应用。

   由于采用jdo的映射机制，能降低了业务系统与数据存储系统的耦合，使得业务系统相对于关系数据库或对象型数据库，具有可移植性，同时，由于采用面向对象（而非传统的面向记录）的持久化技术，系统更为轻便、简洁，增强了可维护性。

jdo应用示例及分析

  以下将通过一些示例，由浅及深地讲解jdo技术。

临时对象与持久对象

这是一个普通的业务对象的代码。

package business.model;
public class book {
  private string isbn;
  private string name;
  private date publishdate;
  public void setisbn(string isbn){
    this.isbn = isbn;
  }
  public string getisbn(){
    return this.isbn;
  }
  public void setname(string name){
    this.name = name;
  }
  public string getname(){
    return this.name;
  }
  public void setpublishdate(date pubdate){
    this.publishdate = pubdate;
  }
  public date getpublishdate(){
    return this.publishdate;
  }
}

现在将它作为一个jdo中对象保存到数据库中。代码如下：

book book = new book();
book.setisbn(“isbn-1234567”);
book.setname(“java设计模式”);

persistencemanager manager = persistencemanagerfactory.getpersistencemanager();
manager.currenttransaction().begin();
manager.makepersistence(book);
manager.currenttransaction().commit();

   book类的实例book对jdo的api而言，就是一个持久对象。类book是可持久类。那任何一个普通java类都是jdo的可持久类吗？不是的。只有具备以下的条件，一个对象才可以被jdo持久到数据库中。

它所属类应标记为可持久的类，有以下两种方法：
显式：实现接口，javax.jdo.persistencecapable即可；

隐式：以sun的jdo参考实现为例，book.java类的相同路径下还须有book.jdo文件。

< ?xml version=“1.0” encoding = “utf-8”?>
< !doctype jdo system “jdo.dtd”>
< jdo>
  < package name = “business.model”>
     < class name = “book”/>
  < /package>
< /jdo>

并通过字节码增强工具（本例采用sun的字节码增强工具）处理，

javac book.java
java com.sun.jdori.enhancer.main book.class book.jdo。

通过上述两种方法，获得的book.class才是一个可持久的类。

字节码增强的有如下功能：当应用程序通过set方法修改某个字段1时，由于通过增强过程，在其内部插入了某些代码，jdo会获得数据状态变化的信息，从而在持久过程中，进行有选择性的处理。

按照jdo规范，增强后的类可以在不同的jdo实现上使用，而无需重新编译或增强。

   并不是所有book对象都是持久对象，只有当makepersistence后，该对象才是持久对象，并会通过jdo实现存储到数据库中。通过jdo的供应商扩展标记符（vendor-extension），可详细描述book类的存储特性，如为该可持久类指定数据库表和对应字段。

持久对象查询

jdo查询主要有以下两种方式。

使用extend查询

extend可以查询指定类及子类的持久对象。

persistencemanager manager = persistencemanagerfactory.getpersistencemanager();
manager.currenttransaction().begin();
extend extend = manager.getextend(book.class,true);//true表明同时查询子类
iterator it = extend.iterator();
while(it.hasnext()){
  book book = (book)it.next();
  system.out.println(book.getisbn());
}
extend.closeall();
manager.currenttransaction().commit();

extend查询方法，提供了一种基于类的查询途径，它可以与下面的query构成更为强大的查询。

使用query查询

query可以指定过滤条件，是一种常用的查询方式。

下例是查找条件为“书名以‘java设计模式’开头且出版日期小于今天”的书籍。

string filter = “((string)name).startswith(\”java设计模式\”) && publishdate <  today”;
query query = pm.getquery(book.class,filter);
query.declareimports(“import java.util.date”);
query.declareparameters(“date today);

date today = new date();
results = (collection)query.execute(today);//传入参数值today
if (results.isempty()){
  system.out.println(“no data!”);
}else{
  iterator it = results.iterator();
  while(it.hasnext()){
    book book = (book)it.next();
    system.out.println(“book name:” + book.getname() + “, isbn:” + book.getisbn());
  }
}

注：该条件使用了一个变元‘today’，通过“declareparameters”来声明该变量，并在“execute”方法中传入该变量的实例。

这种带参数的查询，很类似于我们以前采用jdbc的带?的查询方式。

其中startswith(string s)是jdo提供的标准字符方法，类似的方法还有endswith(string s)。

jdoql：上述使用的就是一个jdoql样例，jdoql是jdo规范一个组成部分。使用jdoql可以使用应用在不同的jdo实现上运行。为了解决jdoql的某些不足，jdo规范提供了支持特定jdo供应商查询语句接口。

查询排序

下例是将查询结果按“出版日期降序、书名升序”进行排序。

query query = pm.newquery(book.class, filter);

string orderstr = “publishdate decending, name ascending”;
query.setordering(orderstr);

results = query.execute(today);

对象更新

   当客户端对业务数据进行了更新后，需要通过业务过程将其更新到持久层中。

这有两个过程，首先根据主键找到该实例，接着更新字段及提交。

如下例，将指定书目编号的书本的出版日期进行更改。

public void updatebookpublishdate(string isbn, date newdate){
  persistencemanager pm = null;
  try{
pm = pmf.getpersistencemanager();
object obj = pm.newobjectidinstance(book.class,isbn);
book book = (book)pm.getobjectbyid(obj,true);
book.setpublishdate(newdate);
  }catch(exception e){
xxxcontext.setrollbackonly();
throw new exception(e);
  }finally{
    try{
if (pm != null && !pm.isclosed()){
    pm.close();
}
}catch(exception ex){
  system.out.println(ex);
  }
}

注，在persistencemanager使用newobjectidinstance（）方法时，jdo是如何知道通过书目编号isbn来找到该对象呢？

其实在本可持久类book的jdo描述文件中，还需提供如下信息：

< ?xml version=“1.0” encoding = “utf-8”?>
< !doctype jdo system “jdo.dtd”>
< jdo>
  < package name = “business.model”>
     < class name = “book” identity-type=“application” objectid-class=“bookkey” >
          < field name=“isbn” primary-key=“true”/>
     < /class>
  < /package>
< /jdo>

   其中“identity-type=“application””声明可持久类book采用程序标识方式，即应用程序传入id（字段isbn为“primary-key”）信息，jdo实现构造出指定的“objectid-class”的实例（即newobjectidinstance过程），并由jdo来检索出指定的持久化对象（即getobjectbyid）。

bookkey类源码如下：

package businesss.model;
public class bookkey implements java.io.serializable{
      public string isbn;
      public bookkey(){
      }
      public bookkey(string oid){
    isbn = oid;
    }
    public string tostring(){
          return isbn;
    }
    public boolean equals(object obj){
      return isbn.equals((bookkey)obj).isbn);
    }
    public int hashcode(){
          return isbn.hashcode();
    }
}

符合 jdo 的“objectid-class”类，如“bookkey”，须具备以下条件：

类声明为 public，并实现 java.io.serializable；
 

带有一个公有且不带参数的构造方法；
 

当字段作为主键时，须有公有的，且名称和类型与持久类的字段一致，如：public string isbn；

equals 和 hashcode 须使用全部（特指多字段的联合主键）的主键字段值；
类必须有一个构造方法，与 tostring 方法的处理过程是逆向过程；即将 tostring 的输出值，作为该构造方法的输入值，又可以重新生成该实例（如构造方法“public bookkey(string oid)”）。

    综上所述，如果book由两个字段作为主键，如isbn和name，则可能的代码是pm.newobjectidinstance(book.class,isbn+“#”+name)，且bookkey的构造方法作相应更改，并有两个公有字段“isbn”和“name”。

对象删除

对象删除采用方法deletepersistence。示例如下：

pm.currenttransaction().begin();
object obj = pm.newobjectidinstance(book.class,isbn);
book book = (book)pm.getobjectbyid(obj,true);
pm.deletepersistence(book);
pm.currenttransaction().commit();

获得persistencemanager实例

上述的所有操作与需要persistencemanager实例，它可以在两种环境方法下获得：非受管环境和受管环境。

非受管环境

   非受管环境是多指两层开发模式，应用程序直接获得资源对象，进行业务操作。一般事务管理、安全管理或资源管理都需要应用程序自行维护。

properties properties = new properties();
properties.put(“javax.jdo.persistencemanagerfactoryclass”, “com.xxx.jdo.xxxpmfclass”);
properties.put(“javax.jdo.option.connectionurl”, “xxx”);
properties.put(“javax.jdo.option.connectionusername”, “xxx”);
properties.put(“javax.jdo.option.connectionpassword”, “xxx”);
persistencemanagerfactory pmf = jdohelper.getpersistencemanagerfactory(properties);
persistencemanager pm = pmf.getpersistencemanager();

与jdbc获取类似。

受管环境

   受管环境一般是多层开发模式，尤其是处于j2ee应用环境中，程序通过容器获得资源对象，进行业务操作，由于在容器环境下，事务、安全及资源管理都由容器进行统一集中管理，从而简化了代码结构。

以下是ejb（entitybean、sessionbean、messagedrivenbean）中的setxxxcontext中的代码示例。

private persistencemanagerfactory pmf;
public void setxxxcontext(xxxcontext context){
  try{
    initialcontext ctx = new initialcontext();
    object obj = ctx.lookup(“java:compenvjdofactory”);
    pmf = (persistencemanagerfactory)portableremoteobject.narrow(o,persistencemanagerfactory.class);
  }catch(namingexception e){
    throw new exception(e);
  }
}

pmf是如何绑定到j2ee环境下的jndi上，有兴趣可参考jca相关的技术文档。

事务管理

事务管理及使用，主要有以下三种情形。

使用jdo事务的bean管理情形

一般在非j2ee环境下，使用该事务管理模式。

persistencemanager pm = pmf.getpersistencemanager();
pm.currenttransaction().begin();
//do some business with jdo
pm.currenttransaction().commit();
pm.close();

使用jta事务的bean管理情形

一般在j2ee环境下，采用bean管理的事务情形下，使用以下方式。

该方式可用在ejb的事务环境下。

xxxcontext.getusertransaction().begin();
persistencemanager pm = pmf.getpersistencemanager();
//do some business with jdo
xxxcontext.getusertransaction().commit();
pm.close();

使用jta事务的容器管理情形

一般在j2ee环境下，采用容器管理的事务情形下，使用如下方式。

如下是某个会话bean的业务方法。

public void dobusiness(){
  persistencemanager pm ;
  try{
    pm = pmf.getpersistencemanager();
    //do some business with jdo
  }catch(exception e){
    xxxcontext.setrollbackonly();
    system.out.println(e);
  }finally{
    try{
      if (pm != null && !pm.isclosed())
        pm.close();
    }catch(exception ex){
      system.out.println(ex);
    }
  }
}

综上，可以得出结论，jdo的操作完全与jdbc的操作相差无几。

jdo高级应用

复杂对象的持久化

在实际的应用中，一个可持久化类要远比book类复杂很多。它可能会引用其它的java类型、类、集合或数组，及可能复杂的继承关系。

当这些对象的状态发生变化时，jdo是如何感知及跟踪状态变化？

jdo提供了相应的api及规范来实现该功能。

基本类型及引用

可持久化类的字段能被jdo实现进行持久化的原则。

原始类型、java.util.date等被支持（其它较为复杂或可选特性，详见jdo规范）；

如果引用是一个可持久类，则jdo进行持久化处理；

通过元数据(如jdo文件)声明的字段，一般是非可持久化类的引用，jdo进行持久化；

  前面两种情形，当状态发生变化时，jdo会自动感知，但如果引用是非可持久化类，则需要代码进行显式通知，否则jdo不会将变化进行存储。如下例：

public class book {
  ……
    private object picture;
    public void setpicture(object pic){
          picture = pic;
    }
    public object getpicture(){
          return picture;
    }
}

该类字段picture需要持久化，但java.lang.object不是一个可持久类，故声明如下：

< ?xml version=“1.0” encoding = “utf-8”?>
< !doctype jdo system “jdo.dtd”>
< jdo>
  < package name = “business.model”>
     < class name = “book” >
          < field name=“picture” persistence-modifier=“persistent”/>
     < /class>
  < /package>
< /jdo>
 

  如果其它模块通过getpicture获得对象，并在jdo不可感知的外部，修改对象，则变化不会存储，较好的办法是修改setpicture方法，如下：

public void setpicture(object pic){
  jdohelper.makedirty(this, “picture”);
  picture = pic;
}
 

并通过setpicture方法来更新数据。

jdo的“makedirty”方法，主要负责通知jdo实现，可持久化类book某个实例（this）的“picture”字段发生了变化。

集合

可持久类的字段引用为集合时，按照jdo规范，强制支持java.util.hashset，对hashmap、hashtable、treemap、treeset、linkedlist、arraylist及vector的支持对jdo实现而言是可选的，通过persistencemanagerfactory的supportedoptions方法获得实现特性。

数组

如果可持久类的引用是数组类型，当数组单元发生变化时，需要调用“makedirty”来通知jdo实现，该实例的数组引用内容发生了变化。

与引用是非可持久类实例不同，不需要进行jdo的元数据声明。

继承

如果使用可持久性，一般继承的子类与父类都为可持久类，以减少系统复杂性，这时需要在子类的元数据中指出其可持久超类，如下：

<
class name=“techbook” persistence-capable-superclass=“book”/>
 

可为非持久类扩展持久类，或可为持久类扩展非可持久类；这两种情形jdo实现都将忽略非可持久类的字段部分，而不保存到数据库。

jdo的一些不足之处

jdo对数据的持久化技术相比于成熟的sql，还有不足之处，这些不足在某些情况下将可能会影响数据处理部分的设计实现。

以下列举了常用数据访问的必要功能

查询增强

如字符串不支持通配符、大小写比较；

不支持聚合操作，无法实现min、max、sum和avg；

不支持投影操作，jdo查询返回为对象，而不像sql那样返回字段；

不支持联合、交叉（union/intersect）；

不支持join、in和exists；

企业应用探究

由于jdo采用面向对象的持久化处理技术，从而为解决企业业务系统的持久化问题提供了一个新技术解决方案。但是先进的未必就最适用。在某些应用场景下，需要结合各种因素，采取灵活的策略。

面向对象与面向记录

现在大多业务系统都采用面向对象分析设计，这就需要每个应用系统都自行实现将对象映射成记录，并存储到数据库中，而有jdo这样的面向对象的持久化技术，在某种程度上解放了这种转化设计的不规范性，进而获得相对更优的系统结构；另一方面，一个业务系统的数据持久化，一般都有这样的过程：对象层－＞记录层－＞物理层，jdo无疑使分析设计人员从记录层的苦海中解脱出来，从而更加专注于对象层，这对开发人员无疑是一个令人欢欣鼓舞的技术。

jdo并不能完全代替jdbc。

根据经典的“8-2原理”，如果用jdo来解决80%的问题，余下的20%由jdbc来实现，这种相互补充，各取所长的策略，是一个很有效的办法。

这样一方面可以获得较好的结构及提升开发质量，另一方面解决了jdo的某些技术不足，并可根据以后的技术变化，再做适当转化。

性能问题

jdo与jdbc究竟谁的性能更优，目前还没有一个权威、且令人满意的答案。但对于一些jdo实现而言，通过采用缓存机制，使得性能有了较大提高。