跟踪数据的变化在很多软件、应用程序和商业场景中是一个基本的要求。如果要严格地实现这个需求是非常困难的，这主要是因为对文件的不同变化建模，并监视这些变化一般很难做到。从另一方面讲，在所有的程序中反复地实现这种功能要比将一个单独的模块应用到不同的应用程序中更经济实用。而服务数据对象（SDO），这个由BEA和IBM定义的异构数据访问解决方案，为开发人员提供了更容易实现的机制来从系统层跟踪数据的变化。

　　本文给出了一个使用Apache SDO处理XML数据的例子。由于SDO现在还不是处理XML的标准的解决方案，因此，本文还讨论了SDO中的基本的操作XML数据的方法。

　　一、处理XML数据的三个阶段

　　在本文给出的处理XML的例子分为三个不同的阶段，这些阶段如下：

　　1. 建立

　　2. 处理

　　3. 浏览

　　XML数据可以通过一个文件系统在这三个阶段之间进行传输。在本例的中心场景如下：第二步需要记录XML文件在第一阶段被建立的记录，当第三步浏览XML数据时，人们总希望知道这个文件有哪些变化。如果我们使用Word的跟踪特性，我们将会立即获得这些变化的值。

　　许多应用程序都有这些需求，包括实现并发控制、离线应用程序的同步，商业进程管理（BPM）系统。这部分将演示SDO如何帮助我们更容易地实现这些需求。

　　本文提供的XML数据是一个订购数据，代码如下：

<?xml version=”1.0″ encoding=”UTF-8″?>
<xsd:schema
   
targetNamespace=”http://www.example.com/PO”>

<xsd:import namespace=”commonj.sdo/xml” schemaLocation=”sdo.xsd”/>
    <xsd:element name=”purchaseOrder” type=”PurchaseOrderType”/>
    <xsd:element name=”comment” type=”xsd:string”/>

<xsd:complexType name=”PurchaseOrderType”>
        <xsd:sequence>
            <xsd:element name=”shipTo” type=”USAddress”/>
            <xsd:element name=”billTo” type=”USAddress”/>
            <xsd:element ref=”comment” minOccurs=”0″/>
            <xsd:element name=”items”  type=”Items”/>
        </xsd:sequence>
        <xsd:attribute name=”orderDate” type=”xsd:date”/>
    </xsd:complexType>
    <xsd:complexType name=”StatusType”>
        <xsd:sequence>
            <xsd:element name=”status”   type=”xsd:string”/>
            <xsd:element name=”contact”   type=”xsd:string”/>
            <xsd:element name=”changeDate” type=”xsd:date”/>
        </xsd:sequence>
    </xsd:complexType>

<xsd:complexType name=”USAddress”>
        <xsd:sequence>
            <xsd:element name=”name”   type=”xsd:string”/>
            <xsd:element name=”street” type=”xsd:string”/>
            <xsd:element name=”city”   type=”xsd:string”/>
            <xsd:element name=”state”  type=”xsd:string”/>
            <xsd:element name=”zip”    type=”xsd:decimal”/>
        </xsd:sequence>
        <xsd:attribute name=”country” type=”xsd:NMTOKEN” fixed=”US”/>
    </xsd:complexType>
    <xsd:complexType name=”Items”>
        <xsd:sequence>
            <xsd:element name=”item” minOccurs=”0″ maxOccurs=”unbounded”>
                <xsd:complexType>
                    <xsd:sequence>
                        <xsd:element name=”productName” type=”xsd:string”/>
                        <xsd:element name=”price”  type=”xsd:decimal”/>
                        <xsd:element name=”quantity”>
                            <xsd:simpleType>
                                <xsd:restriction base=”xsd:positiveInteger”>
                                    <xsd:maxExclusive value=”100″/>
                                </xsd:restriction>
                            </xsd:simpleType>
                        </xsd:element>
                        <xsd:element ref=”comment”   minOccurs=”0″/>
                        <xsd:element name=”shipDate” type=”xsd:date” minOccurs=”0″/>
                    </xsd:sequence>
                    <xsd:attribute name=”partNum” type=”SKU” use=”required”/>
                </xsd:complexType>
            </xsd:element>
        </xsd:sequence>
    </xsd:complexType>

<xsd:simpleType name=”SKU”>
        <xsd:restriction base=”xsd:string”>
            <xsd:pattern value=”d{3}-[A-Z]{2}”/>
        </xsd:restriction>
    </xsd:simpleType>
</xsd:schema>
CreatePO.java类完成了建立XML的工作。代码如下：

package com.company.sdo.po;
import commonj.sdo.DataObject;
import commonj.sdo.helper.DataFactory;
public class CreatePO {
public static void main(String[] args) throws Exception {
//1.  使用XSD定义类型和属性
     Util.definePOTypes();
//2.  建立根DataObject
     DataObject purchaseOrder =
DataFactory.INSTANCE.create(Constants.PO_NAMESPACE, “PurchaseOrderType”);
//3.  设置根DataObject的数据类型属性
     purchaseOrder.setString(“orderDate”, “1999-10-20”);
//4.  建立子DataObject
     DataObject shipTo = purchaseOrder.createDataObject(“shipTo”);
//5.  设置子DataObject的数据类型属性
     shipTo.set(“country”, “US”);
shipTo.set(“name”, “Alice Smith”);
shipTo.set(“street”, “123 Maple Street”);
shipTo.set(“city”, “Mill Valley”);
shipTo.set(“state”, “CA”);
shipTo.setString(“zip”, “90952”);
DataObject billTo = purchaseOrder.createDataObject(“billTo”);
billTo.set(“country”, “US”);
billTo.set(“name”, “Robert Smith”);
billTo.set(“street”, “8 Oak Avenue”);
billTo.set(“city”, “Mill Valley”);
billTo.set(“state”, “PA”);
billTo.setString(“zip”, “95819”);
purchaseOrder.set(“comment”, “Hurry, my lawn is going wild!”);
DataObject items = purchaseOrder.createDataObject(“items”);
//6.  为子DataObject “item”建立一个子DataObject
     DataObject item1 = items.createDataObject(“item”);
item1.set(“partNum”, “872-AA”);
item1.set(“productName”, “Lawnmower”);
item1.setInt(“quantity”, 1);
item1.setString(“price”, “148.95”);
item1.set(“comment”, “Confirm this is electric”);
DataObject item2 = items.createDataObject(“item”);
item2.set(“partNum”, “926-AA”);
item2.set(“productName”, “Baby Monitor”);
item2.setInt(“quantity”, 1);
item2.setString(“price”, “39.98”);
item2.setString(“shipDate”, “2007-11-21”);
DataObject item3 = items.createDataObject(“item”);
item3.set(“partNum”, “998-AA”);
item3.set(“productName”, “Carpet”);
item3.setInt(“quantity”, 1);
item3.setString(“price”, “439.98”);
item3.setString(“shipDate”, “2007-12-01”);
//7.  将XML数据保存在一个XML文件中
     Util.storeXML(purchaseOrder,”purchaseOrder”, Constants.PO_XML);
}
}

　　1. 使用XSD定义类型和属性；由于我们的数据是基于XML格式的，因此，我们首先需要在运行时定义SDO类型的属性。这个功能由Util类的definePOTypes()方法完成。在definePOTypes方法内部调用了XSDHelper类。definePOTypes()方法的代码如下：

public static void definePOTypes() throws Exception {
FileInputStream fis = new FileInputStream(PO_MODEL_ORIGINAL);
XSDHelper.INSTANCE.define(fis, null);
fis.close();
}

　　2. 建立根数据对象：SDO的动态API可以通过数据对象的层次和属性或是一个DataGraph（包含了数据对象元数据的一个图）来描述结构化数据。SDO提供了用于建立一个未连接的数据对象的DataFactory接口。

　　3. 设置根数据对象的数据类型属性：订购单在SDO中是一个类型，并且根据schema，它有一个叫orderDate的数据类型属性，这是一个日期类型。

　　4. 建立子数据对象：数据对象订购单有一些子数据对象。例如，上面代码中的注释4在purchaseOrder中建立shipTo子结点。除了这种方法，我们还可以使用DataFactory来建立一个未连接的shipTo数据对象，并使用setDataObject方法将他设置成purchaseOrder的一个子结点。代码如下：
 
DataObject shipTo = DataFactory.INSTANCE.create(CONSTANTS.PO_NAMESPACE, “USAddress”);
           ……
PurchaseOrder.setDataObject(“shipTo”, shipTo);

　　5. 设置子对象结点的数据类型属性：基于USAddress类型的定义，shipTo数据对象有不同的数据类型属性。上面注释5建立了这些属性。

　　6. 为子数据对象“item”建立一个子数据对象：这部分显示了建立XML时SDO数据模型。

　　在下一部分将讨论如何使用SDO的动态API，我们可以编辑订购单，并且在同时跟踪他们的变化。

　　三、记录处理XML数据的变化

　　我们可以利用在SDO中定义的ChangeSummary机制来跟踪订购单的变化。为了实现我们的第二个目的，我们先来编辑一个这个XML的schema文件po_orginal.xsd。代码如下：

　　<xsd:schema
   
   
   
targetNamespace=”http://www.example.com/PO”>

<xsd:import namespace=”commonj.sdo/xml”
schemaLocation=”C:\eclipse\workspace\SDO\src\main\resources\sdo.xsd” />
    <xsd:element name=”purchaseOrder” type=”PurchaseOrderType”/>
    <xsd:element name=”comment” type=”xsd:string”/>
    <xsd:element name=”status” type=”StatusType”/>

<xsd:complexType name=”PurchaseOrderType”>
        <xsd:sequence>
            <xsd:element name=”shipTo” type=”USAddress”/>
            <xsd:element name=”billTo” type=”USAddress”/>
            <xsd:element ref=”comment” minOccurs=”0″/>
            <xsd:element name=”items”  type=”Items”/>
            <xsd:element ref=”status” minOccurs=”1″ maxOccurs=”1″/>
        <xsd:element name=”changes” type=”sdo:ChangeSummaryType”/>
        </xsd:sequence>
        <xsd:attribute name=”orderDate” type=”xsd:date”/>
    </xsd:complexType>
   ……
</xsd:schema>

　　这个被导入的sdo.xsd定义了ChangeSummaryType。我们在PurchaseOrderType中加一个ChangeSummaryType的元素。我们可以将这个元素命名为任何东西，当然，除了使用“changes”。

　　为了使用新的schema，我们需要使用Util类的definePOTypes()方法来装载它。我们将要保存被CreatePO.java产生的XML文件为po.xml。这个文件和po_original.xml比较得知，po.xml在<po:purchaseOrder>: <changes logging=”false” />中有一个新的子元素。ProcessPO.java类处理订购单。当运行时，程序保存了这个处理过程，并在po_processed.xml中产生了一条变化记录。po_processed.xml的代码如下：

<?xml version=”1.0″ encoding=”ASCII”?>
<po:purchaseOrder orderDate=”1999-10-20″>
  <shipTo country=”US”>
    <name>Alice Smith</name>
    <street>123 Maple Street</street>
    <city>Mill Valley</city>
    <state>CA</state>
    <zip>90952</zip>
  </shipTo>
  <billTo country=”US”>
    <name>Alice Smith</name>
    <street>8 Oak Avenue</street>
    <city>Mill Valley</city>
    <state>PA</state>
    <zip>95819</zip>
  </billTo>
  <po:comment>Hurry, my lawn is going wild!</po:comment>
  <items>
    <item partNum=”872-AA”>
      <productName>Lawnmower</productName>
      <price>148.95</price>
      <quantity>1</quantity>
      <po:comment>Confirm this is electric</po:comment>
    </item>
    <item partNum=”926-AA”>
      <productName>Baby Monitor</productName>
      <price>39.98</price>
      <quantity>2</quantity>
      <shipDate>2007-11-21</shipDate>
    </item>
    <item partNum=”999-AA”>
      <productName>Armed Chair</productName>
      <price>299.95</price>
      <quantity>1</quantity>
      <po:comment>Make sure the cover is leather.</po:comment>
    </item>
  </items>
  <changes create=”     ##//items/item[3]” delete=”     ##//changes/items[1]/item[3]” logging=”false” >
    <billTo sdo_ref=”     ##//billTo”>
      <name>Robert Smith</name>
    </billTo>
    <item sdo_ref=”     ##//items/item[2]”>
      <quantity>1</quantity>
    </item>
    <items sdo_ref=”     ##//items”>
      <item sdo_ref=”     ##//items/item[1]” />
      <item sdo_ref=”     ##//items/item[2]” />
      <item partNum=”998-AA”><productName>Carpet</productName><price>439.98</price><quantity>1</quantity><shipDate>2007-12-01</shipDate></item>
    </items>
  </changes>
</po:purchaseOrder>

　　上面的代码显示了XML文件的变化记录，但是我们更感兴趣的是<changes>元素，这个元素现在变得更复杂了。这个元素捕捉了订购单的所有的变化。基本这些变化，应用程序可以恢复以前的未变化的数据。

　　现在让我我们看一下ProcessPO.java类，并分析一个SDO如何允许我们获得这样详细的变化数据。

　　1. 注释1中在运行时转载了po.xml。

　　2. 注释2建立了和purchaseOrder数据对象相关的ChangeSummary对象。

　　3. 为了跟踪变化，注释3打开了ChangeSummary对象的日志功能。

　　4. 在注释4中，日志是关闭的，purchaseOrder的所有变化和它的子数据对象在ChangeSummary对象中被捕捉。

　　5. 在注释5中输出了结果，我们可以看看Util类中的printChangeSummary方法，代码如下：

public static void printChangeSummary(ChangeSummary chngSum) {
if (chngSum == null) {
System.out.println(“ChangeSummary is not in existence!”);
return;
}
for (Iterator it = chngSum.getChangedDataObjects().iterator(); it.hasNext();) {
DataObject changedObject = (DataObject) it.next();
System.out.println();
if (chngSum.isCreated(changedObject)) {//is the changed object newly created
                System.out.println(“Created: ” + changedObject);
if (changedObject.getContainer()!=null){
System.out.println(“t— to be contained in : “
                        + changedObject.getContainer().getType().getName()
+ ” —“);
}else{
System.out.println(“t— created object has no container — “);
}
printAnnotatedDataObject(“newly created”,changedObject, 2);
} else if (chngSum.isDeleted(changedObject)) {
System.out.println(“Deleted: ” + changedObject);
if (chngSum.getOldContainer(changedObject) != null){
System.out.println(“t— originally contained in : ” + chngSum.getOldContainer(changedObject).getType().getName() + ” —“);
}else{
System.out.println(“t— deleted object has no container —“);
}
// a potential bug in Tuscany SDO, this shows nothing in ProcessPO.java
                printAnnotatedDataObject(“deleted”,changedObject, 2);
// drill down to deleted property
                System.out.println(“t— deleted property information — “);
// a potential bug in Tuscany SDO, this section shows nothing in ReviewPO.java
                for (Iterator settingIt = chngSum.getOldValues(changedObject).iterator(); settingIt.hasNext();) {
printDeletedProperty((ChangeSummary.Setting) settingIt.next());
}
System.out.println(“t— deleted property information — “);
} else if (chngSum.isModified(changedObject)) {
System.out.println(“Updated:  ” + changedObject);
// print out the updated object
                printAnnotatedDataObject(“after update”, changedObject, 2);
// drill down to changed property
                System.out.println(“t— property update information — “);
for (Iterator settingIt = chngSum.getOldValues(changedObject).iterator(); settingIt.hasNext();) {
ChangeSummary.Setting changeSetting = (ChangeSummary.Setting) settingIt.next();
printUpdatedProperty(changeSetting, changedObject,chngSum);
}
System.out.println(“t— property update information — “);
} else
                System.out.println(“Should never come here!”);
}
}

　　在这个方法中，我们首先使用了getChangedDataObjects()来获得所有变化了的数据对象，然后按着他们的种类处理，即建立、删除或编辑。如果数据对象是新建的，我们会打印对象的信息和所有的属性。

　　在下一部分，我们来浏览被编辑的订购单。

　　四、通过一个不同的实体浏览数据的变化

　　XML数据处理的第三部分需要完成两个任务：

　　1. 程序需要按着编辑顺序打印出主要的信息。
　　2. 显示处理阶段所有的修改记录。

　　当我们可以更进一步根据着一个记录变化阶段编辑订购单时，这部分显示了如何使用ReviewPO.java调用所有的编辑记录。ReviewPO.java的代码如下：
package com.company.sdo.po;
import java.io.FileInputStream;
import java.util.List;
import commonj.sdo.ChangeSummary;
import commonj.sdo.DataObject;
import commonj.sdo.helper.XMLDocument;
import commonj.sdo.helper.XMLHelper;
public class ReviewPO {
public static void main(String[] args) throws Exception {
Util.definePOTypes();
FileInputStream fis = new FileInputStream(Constants.PO_PROCESSED_XML);
//1. 装载要处理的订购单
          XMLDocument xmlDoc = XMLHelper.INSTANCE.load(fis);
DataObject purchaseOrder = xmlDoc.getRootObject();
//2.  显示被编辑的订购单的信息
          System.out.println();
System.out.println(“—received purchase order information—“);
System.out.println(“Order date: ” + purchaseOrder.get(“orderDate”));
System.out.println(“Order comment: ” + purchaseOrder.get(“comment”));
DataObject shipTo = purchaseOrder.getDataObject(“shipTo”);
System.out.println(“Ship to name: “);
Util.printDataObject(shipTo,1);
DataObject billTo = purchaseOrder.getDataObject(“billTo”);
System.out.println(“Bill to name: “);
Util.printDataObject(billTo,1);
DataObject items = purchaseOrder.getDataObject(“items”);
List itemList = items.getList(“item”);
System.out.println(“Ordered items: “);
for (int i = 0; i < itemList.size(); i++) {
DataObject item = (DataObject) itemList.get(i);
System.out.println(“tItem ” + (i+1) + ” :” );
Util.printDataObject(item,2);
}
//3.  显示了第二阶段的数据变化
          System.out.println();
System.out.println(“—review changes in purchase order —“);
ChangeSummary chngSum = purchaseOrder.getChangeSummary();
Util.printChangeSummary(chngSum);
//4.  取消第二阶段的所有变化
          System.out.println();
System.out.println(“—action taken after reviewing the changes—“);
System.out.println(“t###undo all changes###”);
chngSum.undoChanges();
//5. 编辑订购单的原始版本
          System.out.println();
System.out.println(“—changes made in purchase order review—“);
chngSum.beginLogging();
billTo.set(“name”, “Alice Smith”);
chngSum.endLogging();
//6.  将新的变化输出到系统控制台
          Util.printChangeSummary(chngSum);
//7.  将改变记录保存到一个XML文件中
          Util.storeXML(purchaseOrder,”purchaseOrder”, Constants.PO_REVIEWED_XML);
}
}

　　要注意的是第二个任务不同于在前一部分打印ChangeSummary，在这里printout是直接基于ChangeSummary的。变化细节在运行时被重新装载。我们可以通过比较这两个printout来分辨它们的不同。在上一部分，printDataObject()在删除项时什么都没产生，而是调用了printDeletedProperty()来列出它们的属性和它们的值。在当前的printout中，恰恰相反。

　　在程序的其他部分，注释4通过调用undoChanges方法取消了在第二阶段的所有的变化，注释5对订购单做了一些小的变化。我们可以看看保存变化记录的文件（po_reviewed.xml）来验证这些操作结果。