本文以 Apache SDO 為例,示範如何用它處理 XML 數據並追蹤變化。由於 SDO 當時還不是處理 XML 的標準方案,文中也會說明 SDO 操作 XML 數據的基本方法。
追蹤數據變化在許多軟體、應用程式與商業場景中都是基本要求。若要嚴格實現這個需求其實非常困難——對文件的不同變化建模並監視這些變化,本身就不好做。而從工程角度看,與其每個程式各自重複實作一遍,不如把這個能力抽成獨立模組供各處複用。
服務數據物件(SDO)正是這樣的方案。這個由 BEA 與 IBM 共同定義的異構數據訪問方案,為開發者提供了更容易實現的機制,能從系統層追蹤數據變化。
本文的 XML 處理分為三個階段:
XML 數據會透過文件系統在這三個階段之間傳遞。核心場景是:第二步要記下 XML 檔在第一步被建立時的樣子;到了第三步瀏覽數據時,人們希望能知道這份文件究竟被改動了哪些地方——就像在 Word 裡開啟修訂追蹤那樣,一眼看到所有變更。
其實很多應用都有類似需求,包括實作並發控制、離線應用程式的同步,以及商業流程管理(BPM)系統。以下示範 SDO 如何讓這些需求變得容易實現。
本文使用的數據是一份訂購單。先定義對應的 XSD 類別與屬性,再用 CreatePO.java 完成建立工作。
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() 完成,其內部呼叫了 XSDHelper 類:
public static void definePOTypes() throws Exception {
FileInputStream fis = new FileInputStream(PO_MODEL_ORIGINAL);
XSDHelper.INSTANCE.define(fis, null);
fis.close();
}
2. 建立根數據物件。SDO 的動態 API 可以用數據物件的層次與屬性,或是一個 DataGraph(含數據物件元數據的圖)來描述結構化數據。建立未連接的數據物件則由 DataFactory 介面負責。
3. 設定根物件的屬性。訂購單在 SDO 中是一個類型,依 schema 有一個名為 orderDate 的日期型屬性。
4. 建立子物件。訂購單下掛著若干子物件。除了範例中直接呼叫 createDataObject 建立 shipTo 節點,也可以先用 DataFactory 建一個未連接的物件,再用 setDataObject 掛上去:
DataObject shipTo = DataFactory.INSTANCE.create(CONSTANTS.PO_NAMESPACE, "USAddress");
......
PurchaseOrder.setDataObject("shipTo", shipTo);
5. 設定子物件的屬性。依 USAddress 類型的定義,shipTo 擁有不同的數據型屬性。
6. 為子物件 item 再建子物件。這段展示了建立 XML 時 SDO 數據模型的嵌套方式——items 之下再掛多個 item,正是典型的主子結構。
SDO 提供了 ChangeSummary 機制來追蹤訂購單的變化。要啟用它,得先改寫 XML schema 檔 po_original.xsd:
<xsd:schema xmlns:xsd="https://www.w3.org/2001/XMLSchema"
xmlns="https://www.example.com/PO"
xmlns:sdo="commonj.sdo"
xmlns:sdoxml="commonj.sdo/XML"
targetNamespace="https://www.example.com/PO">
<xsd:import namespace="commonj.sdo/xml"
schemaLocation="sdo.xsd" />
<xsd:element name="purchaseOrder" type="PurchaseOrderType" />
</xsd:schema>
被導入的 sdo.xsd 定義了 ChangeSummaryType。我們在 PurchaseOrderType 中加一個該類型的元素——名稱可以自取,但不能用「changes」。
換用新 schema 後,用 Util.definePOTypes() 重新載入即可。此時由 CreatePO.java 產生的 XML(存為 po.xml)與 po_original.xml 相比,會在 <purchaseOrder> 下多出一個子元素:
<CHANGES logging="false" />
ProcessPO.java 負責處理訂購單。運行時它會保存處理過程,並在 po_processed.xml 中產生一條變化記錄。這份輸出的關鍵在於 <CHANGES> 元素,它變得相當複雜,捕捉了訂購單的所有變更:
<CHANGES logging="false"
create=" ##//items/item[3]"
delete=" ##//changes/items[1]/item[3]"
xmlns:sdo="commonj.sdo">
<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.xml 與 po_processed.xml 可以看到:第二個 item 的數量從 1 改成 2、第三個 item 被替換、billTo 的 name 被改動——這些都精確地留在了 CHANGES 裡。
beginLogging())。endLogging())後,purchaseOrder 及其所有子數據物件的變化都會被 ChangeSummary 捕捉。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)) {
// 新建的物件
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 ---");
}
printAnnotatedDataObject("deleted", changedObject, 2);
System.out.println("\t--- deleted property information --- ");
for (Iterator settingIt = chngSum.getOldValues(changedObject).iterator();
settingIt.hasNext();) {
printDeletedProperty((ChangeSummary.Setting) settingIt.next());
}
} else if (chngSum.isModified(changedObject)) {
// 修改的物件
System.out.println("Updated: " + changedObject);
printAnnotatedDataObject("after update", changedObject, 2);
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);
}
}
}
}
這個方法先用 getChangedDataObjects() 取得所有變動過的數據物件,再依種類分別處理:新建、刪除或修改。若是新建的物件,就印出物件本身與它的全部屬性;若是修改,除了印出修改後的內容,還會用 getOldValues() 逐一列出每個被改動的屬性及其舊值。
第三階段要完成兩件事:
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("---received purchase order information---");
System.out.println("Order date: " + purchaSEOrder.get("orderDate"));
System.out.println("Order comment: " + purchaSEOrder.get("comment"));
Util.printDataObject(purchaSEOrder.getDataObject("shipTo"), 1);
Util.printDataObject(purchaSEOrder.getDataObject("billTo"), 1);
List itemList = purchaSEOrder.getDataObject("items").getList("item");
for (int i = 0; i < itemList.size(); i++) {
System.out.println("\tItem " + (i + 1) + " :");
Util.printDataObject((DataObject) itemList.get(i), 2);
}
// 3. 顯示第二階段的數據變化
System.out.println("---review changes in purchase order ---");
ChangeSummary chngSum = purchaSEOrder.getChangeSummary();
Util.printChangeSummary(chngSum);
// 4. 取消第二階段的所有變化
System.out.println("---action taken after reviewing the changes---");
System.out.println("\t###undo all changes###");
chngSum.undoChanges();
// 5. 編輯訂購單的原始版本
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);
}
}
值得注意的是,這裡的 printout 直接基於 ChangeSummary,而變化細節是在運行時重新載入的——所以它與上一階段的輸出呈現方式恰好相反:上一階段遇到刪除項時 printDataObject() 什麼都不印,改由 printDeletedProperty() 列出屬性與舊值;而在這一階段,變更資訊本身已經內嵌在文檔中。
程式其他部分:第 4 步透過 undoChanges() 撤銷第二階段的所有變化,第 5 步對訂購單做一處小改動。想看結果,直接檢查輸出的 po_reviewed.xml 即可。
把「變化」當作一等公民來建模,解決的是一類很常見的痛點:離線編輯後如何同步、並發修改如何偵測衝突、流程審批如何留痕。傳統做法要在應用層自己比對前後快照,而 SDO 把這件事下沉到了數據層——只要打開日誌、做完操作、關閉日誌,一份結構化的變更記錄就在手上,而且能序列化成 XML 跨系統傳遞。