DIV CSS 佈局教程網

您现在的位置: DIV+CSS佈局教程網 >> 網頁腳本 >  >> XML學習教程 >> XML詳解
使用 SDO 跟蹤 XML 數據的變化(上)
編輯:XML詳解     

本文以 Apache SDO 為例,示範如何用它處理 XML 數據並追蹤變化。由於 SDO 當時還不是處理 XML 的標準方案,文中也會說明 SDO 操作 XML 數據的基本方法。

需求從哪裡來

追蹤數據變化在許多軟體、應用程式與商業場景中都是基本要求。若要嚴格實現這個需求其實非常困難——對文件的不同變化建模並監視這些變化,本身就不好做。而從工程角度看,與其每個程式各自重複實作一遍,不如把這個能力抽成獨立模組供各處複用。

服務數據物件(SDO)正是這樣的方案。這個由 BEA 與 IBM 共同定義的異構數據訪問方案,為開發者提供了更容易實現的機制,能從系統層追蹤數據變化。

處理 XML 的三個階段

本文的 XML 處理分為三個階段:

  1. 建立
  2. 處理
  3. 瀏覽

XML 數據會透過文件系統在這三個階段之間傳遞。核心場景是:第二步要記下 XML 檔在第一步被建立時的樣子;到了第三步瀏覽數據時,人們希望能知道這份文件究竟被改動了哪些地方——就像在 Word 裡開啟修訂追蹤那樣,一眼看到所有變更。

其實很多應用都有類似需求,包括實作並發控制、離線應用程式的同步,以及商業流程管理(BPM)系統。以下示範 SDO 如何讓這些需求變得容易實現。

一、建立 XML 數據

本文使用的數據是一份訂購單。先定義對應的 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,正是典型的主子結構。

二、記錄 XML 數據的變化

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 裡。

ProcessPO.java 的關鍵步驟

  1. 在運行時載入 po.xml。
  2. 建立與 purchaseOrder 數據物件相關的 ChangeSummary 物件。
  3. 為追蹤變化,打開 ChangeSummary 物件的日誌功能(beginLogging())。
  4. 日誌關閉(endLogging())後,purchaseOrder 及其所有子數據物件的變化都會被 ChangeSummary 捕捉。
  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)) {
            // 新建的物件
            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() 逐一列出每個被改動的屬性及其舊值。

三、透過不同實體瀏覽變化

第三階段要完成兩件事:

  1. 依編輯後的順序印出主要資訊。
  2. 顯示處理階段的全部修改記錄。
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 跨系統傳遞。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved