DIV CSS 佈局教程網

您现在的位置: DIV+CSS佈局教程網 >> 網頁腳本 >  >> XML學習教程 >> XML詳解
把 XML 節點轉成 JavaBean 再入庫:半自動框架設計
編輯:XML詳解     

一、問題背景

要處理的是外部系統給來的 XML 檔,解析後存進資料庫。聽起來是標準流程,實際上卻有兩個麻煩:

第一,沒有 DTD 也沒有 Schema,只有一份 Word 寫的口頭說明文件。第二,XML 節點樹的結構與業務 Bean 的結構並不一致。舉例說,從業務角度看,一隻豬有個豬頭,是 pig 與 pighead 的父子關係;但 XML 裡卻寫成 pig → content → pighead 三層,中間莫名多出一個 content 節點。

沒有結構描述、結構又不規範,自動化的第三方 Java 轉換 API 就用不上,只能一支一支手動解析。但在手動的過程中會發現:各節點的解析與入庫其實有大量共同規律。把這些共同點抽成一個基底框架,再把節點間的差異開放給具體實作,就能得到一個半自動的解析/入庫框架。

為什麼是「半」自動

自動的部分:不必為每個節點撰寫 XML 解析程式碼與入庫程式碼。
半自動的部分:仍需手寫每個 JavaBean,並手動為每個 Bean 建表。

這個框架有三個前提限制,全都源自「要用 Java 反射機制做自動操作」:

  • 所有業務欄位的型別只能是 String/VARCHAR;非業務欄位在 Bean 中則不能是 String(否則無法區分)。
  • Bean 名與表名必須相同,或至少能一對一映射。
  • Bean 的成員變數名必須與 XML 節點的屬性名/元素名相同,或能一對一映射。

二、基本思路

所謂 XML 解析,就是把 XML 節點轉成 JavaBean 實例,節點的屬性值與元素值就是實例的成員變數值。所謂持久化,就是把 JavaBean 實例變成資料庫對應表中的一筆記錄。

關鍵觀察是:XML 節點之間、JavaBean 之間、資料表關聯之間,全都是樹形結構。所以整體的解析與入庫,本質上就是「遍歷樹時執行轉換動作」。而樹的遍歷可以用遞迴實作——遞迴正是程式自動化的主要途徑之一。

假設業務實體 A 與 B 之間存在聚合(父子)關係,可分三種情況:

情況 a:B 是原子欄位,且是 A 的屬性。XML 中 B 是 A 的屬性或不可再分的子元素;Bean 中 B 是 A 的成員變數且為 Java 內建型別;資料庫中 B 是 A 表的一個欄位。

情況 b:B 是複合欄位,與 A 是 1:1。XML 中 B 是 A 的子元素且 B 自己還有子元素或屬性;Bean 中 B 是 A 的成員變數且有對應的類別;資料庫中 B 表是 A 的子表(B 以外部索引參考 A)。

情況 c:B 是複合欄位,與 A 是 N:1。XML 結構同情況 b;Bean 中 B 組成某個集合(List、Set)作為 A 的成員變數;資料庫中 B 表同樣是 A 的子表。

釐清這三種情況後,程式每抓到一个節點就遞迴處理三件事:先處理原子屬性(a),再處理單一子節點(b),最後處理集合子節點(c)。

三、實作上的兩個重點

重點 a:如何讓業務實體在三棵樹之間對齊?答案是讓三棵樹裡相同的業務實體取相同的名字。

解析 XML 時發現節點 X 的屬性 Y 等於值 Z,就執行 PropertyUtils.setProperty(X, Y, Z)。X、Y、Z 都是變數,程式不必知道具體是哪個節點哪個屬性。注意:若 Y 是原子欄位,Y 必須是 String 型別,否則程式無從得知該把 Z 轉成哪種型別。(PropertyUtils 出自 Apache Commons BeanUtils。)

入庫時發現 x.getY() = z,若 y 是原子欄位,就執行 insert into X(..., y, ...) values (..., z, ...);y 欄位必須是 varchar/char,以免型別轉換出錯。

重點 b:如何發現樹形關係?分三個層面:

XML 樹:JDOM、dom4j 都能直接取得父子關係。

Bean 體系:

  • 原子屬性——限定所有具業務意義的原子欄位一律為 String,於是「所有 String 型別的欄位」就是業務欄位。
  • 單一子節點——讓所有具業務意義的非原子欄位都實作一個共同介面 BusiNode,於是「所有 BusiNode 型別的成員」就是子節點。
  • 集合子節點——限定只有集合子節點可以使用 List 或 Set,即可過濾出來。但 Java 1.4 以前沒有泛型,程式無法得知集合中的元素是哪個 Class,也就無法實例化,因此仍需手動註冊集合子節點的屬性名與 Class。

資料表關聯:靠外部索引。每類節點對應的表都必須有個外鍵參考前代節點,還要有個主鍵供後代參考。所有表的外鍵名必須一致且為固定常數,這樣程式產生 INSERT 敘述時就不必理會各表實際的外鍵名稱。

無論解析或持久化,遍歷的都是 Bean 樹:比起 XML 樹,Bean 樹代表真正的業務結構;比起資料表關聯樹,只有 Bean 樹能由父至子做先序遍歷。

四、幾個必須開放給子類的決定

a. 哪些是屬性、哪些是原子元素。XML 節點的屬性與不可再分的子元素在 XML 裡是兩種不同位置,程式無法自動分辨。做法是在程式碼中定義兩個抽象方法,交由具體節點類別實作。

b. 子節點的父節點是誰。回到前面 pig → content → pighead 的例子:程式必須知道 pighead、pigfoot 的子節點究竟掛在 pig 底下,還是掛在 pig 底下的 content 裡。這也是一個抽象方法。

c. 集合節點的不規範問題。更棘手的是集合。假設一隻豬有多個豬頭,結構可能是 pig → pighead, pighead, ...,也可能是 pig → pigheads → content, content, ...。必須讓程式知道某個具體節點用的是哪一種模式。

五、核心程式碼

整個框架的核心只有兩個字:多型 + 遞迴。

介面 BusiNode

import java.util.*;
import org.dom4j.Element;

/**
 * 每個節點都要實作的介面,提供遞迴解析與持久化所需的方法
 */
public interface BusiNode {

    /** 所有不可分型別的屬性名稱 */
    public List getAtomicPropNames();

    /** 對應 XML 節點屬性的成員變數名稱 */
    public List getXmlAttributes();

    /** 對應 XML 子元素、且型別不可分的成員變數名稱 */
    public List getXmlAtomicElements();

    /**
     * 所有集合型別的屬性,集合中每個元素的型別都是 BusiNode
     * @return key = 屬性名, value = 該屬性元素類別的 Class 物件;為空時回傳空 Map 而非 null
     */
    public Map getCollectionPropsMap();

    /** 所有 BusiNode 型別的屬性名稱 */
    public List getBusiNodePropNames();

    /** 從 XML 節點解析出資料 */
    public void parseFromXML(Element element);
}

抽象基底類別 DefaultBusiNode

import java.lang.reflect.Field;
import java.util.*;
import org.apache.commons.beanutils.PropertyUtils;
import org.dom4j.Attribute;
import org.dom4j.Element;

/**
 * 預設實作。繼承此類別的 BusiNode 需滿足:
 * 所有不可分屬性 = String 型別的屬性
 */
public abstract class DefaultBusiNode implements BusiNode {

    public List getAtomicPropNames() {
        return MyUtils.getFieldNamesOfClass(this.getClass(), String.class);
    }

    public List getBusiNodePropNames() {
        return MyUtils.getFieldNamesOfClass(this.getClass(), BusiNode.class);
    }

    /** 子元素的父元素。有時是本節點,有時是本節點下的某個元素 */
    public abstract Element getXmlElementParent(Element rootElement);

    /**
     * 集合子節點根元素的 Iterator。
     * 若為空請回傳空集合的 Iterator,不要回傳 null
     */
    public abstract Iterator getCollectionElementIterator(Element xmlElementParent, String attName);

    /** 解析 XML 屬性 */
    protected void parseAttributesFromXml(Element rootElement) {
        List xmlAttributes = this.getXmlAttributes();
        for (int i = 0; i < xmlAttributes.size(); i++) {
            String attName = (String) xmlAttributes.get(i);
            Attribute att = rootElement.attribute(attName);
            if (att != null) {
                try {
                    PropertyUtils.setProperty(this, attName, att.getValue());
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

    /** 解析不可分的 Element */
    protected void parseAtomicElementFromXml(Element rootElement) {
        Element xmlElementParent = getXmlElementParent(rootElement);
        if (xmlElementParent == null) return;

        List xmlElements = this.getXmlAtomicElements();
        for (int i = 0; i < xmlElements.size(); i++) {
            String attName = (String) xmlElements.get(i);
            Element elmt = xmlElementParent.element(attName);
            if (elmt != null) {
                try {
                    PropertyUtils.setProperty(this, attName, elmt.getText());
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

    /** 解析 BusiNode 型別的屬性(情況 b) */
    protected void parseBusiNodeElementFromXml(Element rootElement) {
        Element xmlElementParent = getXmlElementParent(rootElement);
        if (xmlElementParent == null) return;

        List busiNodePropNames = this.getBusiNodePropNames();
        for (int i = 0; i < busiNodePropNames.size(); i++) {
            try {
                String attName = (String) busiNodePropNames.get(i);
                Element elmt = xmlElementParent.element(attName);
                if (elmt != null) {
                    Field field = this.getClass().getDeclaredField(attName);
                    BusiNode att = (BusiNode) field.getType().newInstance();
                    att.parseFromXML(elmt);
                    PropertyUtils.setProperty(this, attName, att);
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }

    /** 解析集合屬性(情況 c) */
    protected void parseCollectionPropsFromXml(Element rootElement) {
        Element xmlElementParent = getXmlElementParent(rootElement);
        if (xmlElementParent == null) return;

        Map collectionPropsMap = this.getCollectionPropsMap();
        for (Iterator it = collectionPropsMap.keySet().iterator(); it.hasNext();) {
            try {
                String attName = (String) it.next();
                Collection coll = (Collection) PropertyUtils.getProperty(this, attName);
                Class attType = (Class) collectionPropsMap.get(attName);
                Iterator collElementsIt = this.getCollectionElementIterator(xmlElementParent, attName);

                while (collElementsIt.hasNext()) {
                    Element collElmt = (Element) collElementsIt.next();
                    BusiNode singleAtt = (BusiNode) attType.newInstance();
                    singleAtt.parseFromXML(collElmt);
                    coll.add(singleAtt);
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }

    /** 從 XML 解析出節點,可能丟出 RuntimeException */
    public void parseFromXML(Element rootElement) {
        this.parseAttributesFromXml(rootElement);
        this.parseAtomicElementFromXml(rootElement);
        this.parseBusiNodeElementFromXml(rootElement);
        this.parseCollectionPropsFromXml(rootElement);
    }
}

入庫用的 BusiNodeDAO

/** 入庫;JdbcUtil 與 MyUtils 的程式碼此處從略 */
public class BusiNodeDAO {

    /** 遞迴儲存:先存自己,再存子節點,回傳自己的主鍵 */
    private Long saveBusiNode(BusiNode node, Long parentNodeId) {
        // 先存原子屬性,取得主鍵
        Long id = saveBareBusiNode(node, parentNodeId);

        // 再存集合屬性
        Map collectionPropsMap = node.getCollectionPropsMap();
        for (Iterator it = collectionPropsMap.keySet().iterator(); it.hasNext();) {
            String attName = (String) it.next();
            Collection coll;
            try {
                coll = (Collection) PropertyUtils.getProperty(node, attName);
            } catch (Exception e) {
                throw new RuntimeException("編碼錯誤");
            }
            for (Iterator iitt = coll.iterator(); iitt.hasNext();) {
                BusiNode subNode = (BusiNode) iitt.next();
                saveBusiNode(subNode, id);
            }
        }

        // 最後存單一 BusiNode 屬性
        Iterator iitt = node.getBusiNodePropNames().iterator();
        while (iitt.hasNext()) {
            BusiNode subNode;
            try {
                subNode = (BusiNode) PropertyUtils.getProperty(node, (String) iitt.next());
            } catch (Exception e) {
                throw new RuntimeException("編碼錯誤");
            }
            if (subNode != null) saveBusiNode(subNode, id);
        }
        return id;
    }

    /** 插入某個 BusiNode 的根節點,可能丟出 RuntimeException */
    private Long saveBareBusiNode(BusiNode node, Long parentNodeId) {
        StringBuffer sbForSql = new StringBuffer();
        List paramValues = new ArrayList();
        genInsertSqlAndParam(node, parentNodeId, node.getAtomicPropNames(), sbForSql, paramValues);
        return new Long(JdbcUtil.queryForLong(sbForSql.toString(), paramValues.toArray()));
    }

    /** 產生插入敘述與參數陣列 */
    private void genInsertSqlAndParam(BusiNode node, Long parentNodeId, List columnNames,
                                      StringBuffer sbForSql, List paramValues) {
        sbForSql.append(" insert into ");
        sbForSql.append(MyUtils.getClassBareName(node.getClass()));

        List cns = new ArrayList();
        cns.addAll(columnNames);
        cns.add("parentNodeId");           //外鍵名固定,程式不必理會各表差異
        sbForSql.append(MyUtils.encloseWithCurve(MyUtils.joinCollectionStrings(cns, ",")));

        sbForSql.append(" values ");

        List qms = new ArrayList();
        for (Iterator it = columnNames.iterator(); it.hasNext();) {
            qms.add("?");
            String cn = (String) it.next();
            try {
                paramValues.add(PropertyUtils.getProperty(node, cn));
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        qms.add("?");                      //parentNodeId 的佔位符
        paramValues.add(parentNodeId);

        sbForSql.append(MyUtils.encloseWithCurve(MyUtils.joinCollectionStrings(qms, ",")));
        sbForSql.append(";select @@identity");   //取回自增主鍵,供子節點參考
    }
}

六、這套設計的取捨

它換到的好處很明確:新增一類節點時,只要寫一個繼承 DefaultBusiNode 的 Bean、實作三個抽象方法(父元素定位、集合元素迭代、以及屬性/原子元素的區分),解析與入庫就不用再動。代價則是型別被壓成 String、命名必須對齊、集合子節點在泛型之前仍需手動註冊。

如果今天重做,有兩點值得調整。第一,型別限制源自「用反射自動化」的取捨;若改用 JAXB 或 XMLBeans 這類具備映射能力的工具,即使缺少正式 Schema,也能先由一組樣本 XML 反推 Schema 再產生類別,通常比自製框架更省力。第二,程式碼用字串拼接 SQL,應改用 PreparedStatement 全程參數化(範例中已對值使用 ?,但表名與欄位名仍是拼接而來,需自行確保來源可信),並把 RuntimeException 換成具語意的自訂例外,方便定位是哪個節點出了問題。

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