要處理的是外部系統給來的 XML 檔,解析後存進資料庫。聽起來是標準流程,實際上卻有兩個麻煩:
第一,沒有 DTD 也沒有 Schema,只有一份 Word 寫的口頭說明文件。第二,XML 節點樹的結構與業務 Bean 的結構並不一致。舉例說,從業務角度看,一隻豬有個豬頭,是 pig 與 pighead 的父子關係;但 XML 裡卻寫成 pig → content → pighead 三層,中間莫名多出一個 content 節點。
沒有結構描述、結構又不規範,自動化的第三方 Java 轉換 API 就用不上,只能一支一支手動解析。但在手動的過程中會發現:各節點的解析與入庫其實有大量共同規律。把這些共同點抽成一個基底框架,再把節點間的差異開放給具體實作,就能得到一個半自動的解析/入庫框架。
自動的部分:不必為每個節點撰寫 XML 解析程式碼與入庫程式碼。
半自動的部分:仍需手寫每個 JavaBean,並手動為每個 Bean 建表。
這個框架有三個前提限制,全都源自「要用 Java 反射機制做自動操作」:
所謂 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 體系:
資料表關聯:靠外部索引。每類節點對應的表都必須有個外鍵參考前代節點,還要有個主鍵供後代參考。所有表的外鍵名必須一致且為固定常數,這樣程式產生 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, ...。必須讓程式知道某個具體節點用的是哪一種模式。
整個框架的核心只有兩個字:多型 + 遞迴。
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);
}
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);
}
}
/** 入庫;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 換成具語意的自訂例外,方便定位是哪個節點出了問題。