文件物件模型 (DOM) 是一個文件標準，對於完備的文件和複雜的應用程式，DOM 提供了大量靈活性。DOM標準是標準的。它很強壯且完整，並且有許多實現。這是許多大型安裝的決定因素--特別是對產品應用程式，以避免在API發生改變時進行大量的改寫。
以上是我在選擇處理XML資料時之所以沒有選擇JDOM或者dom4j等其它面向物件的標準的原因，不過也由於DOM從一開始就是一種與語言無關的模型，而且它更趨向用於像C或Perl這類語言，沒有利用Java的面向物件的效能，所以在使用的過程中也遇到了不少的麻煩，今天這裡做一個小結。另外，我目前使用XML主要是作為資料傳輸的統一格式，並統一使用者介面展示的介面，應用的面並不是很廣，所以使用到的DOM的內容其實不多。

在準備使用它的時候，是做了充足的準備的，也有遇到困難的準備，所以一開始就有了一個簡單的工具類來封裝DOM物件使用時必要的公共方法，實際證明這樣做是很明智的，一個簡單的建立Document物件的操作，要是每次都需要寫上5行以上程式碼，並且還要處理那些煩人的Exception，實在是會打擊大家的積極性，所以在最初，做了一個XMLTool類，專門封裝瞭如下的公共方法：
1、Document物件建立（包括空的Document物件建立，以一個給定Node節點作為根節點建立。
2、將一個規範的XML字串轉換成一個Document物件。
3、從物理硬碟讀取一個XML檔案並返回一個Document物件。
4、將一個Node物件轉換成字串。

其中每個方法都截獲相關的DOM操作所丟擲的異常，轉換成一個RuntimeException丟擲，這些異常在實際使用過程中，一般狀況下其實都不會丟擲，特別是象生成一個Document物件時的ParserConfigurationException、轉換Node節點成字串時要生成一個Transformer物件時的TransformerConfigurationException等等，沒有必要在它們身上花時間精力。而且真就出了相關的異常的話，其實根本沒有辦法處理，這樣的狀況通常是系統環境配置有問題（比如必要的DOM實現解析器等包沒有加入環境），所以包裝該異常時只是很簡要的獲取其Message丟擲。

程式碼如下：

 1 /**
 2   * 初始化一個空Document物件返回。
 3   * @return a Document
 4   */
 5  public static Document newXMLDocument() {
 6   try {
 7    return newDocumentBuilder().newDocument();
 8   } catch (ParserConfigurationException e) {
 9    throw new RuntimeException(e.getMessage());
10   }
11  }

1  /**
2   * 初始化一個DocumentBuilder
3   * @return a DocumentBuilder
4   * @throws ParserConfigurationException
5   */
6  public static DocumentBuilder newDocumentBuilder()
7   throws ParserConfigurationException {
8   return newDocumentBuilderFactory().newDocumentBuilder();
9  }

1  /**
2   * 初始化一個DocumentBuilderFactory
3   * @return a DocumentBuilderFactory
4   */
5  public static DocumentBuilderFactory newDocumentBuilderFactory() {
6   DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
7   dbf.setNamespaceAware(true);
8   return dbf;
9  }

 1  /**
 2   * 將傳入的一個XML String轉換成一個org.w3c.dom.Document物件返回。
 3   * @param xmlString 一個符合XML規範的字串表達。
 4   * @return a Document
 5   */
 6  public static Document parseXMLDocument(String xmlString) {
 7   if (xmlString == null) {
 8    throw new IllegalArgumentException();
 9   }
10   try {
11    return newDocumentBuilder().parse(
12     new InputSource(new StringReader(xmlString)));
13   } catch (Exception e) {
14    throw new RuntimeException(e.getMessage());
15   }
16  }

 1 /**
 2   * 給定一個輸入流，解析為一個org.w3c.dom.Document物件返回。
 3   * @param input
 4   * @return a org.w3c.dom.Document
 5   */
 6  public static Document parseXMLDocument(InputStream input) {
 7   if (input == null) {
 8    throw new IllegalArgumentException("引數為null！");
 9   }
10   try {
11    return newDocumentBuilder().parse(input);
12   } catch (Exception e) {
13    throw new RuntimeException(e.getMessage());
14   }
15  }

 1 /**
 2   * 給定一個檔名，獲取該檔案並解析為一個org.w3c.dom.Document物件返回。
 3   * @param fileName 待解析檔案的檔名
 4   * @return a org.w3c.dom.Document
 5   */
 6  public static Document loadXMLDocumentFromFile(String fileName) {
 7   if (fileName == null) {
 8    throw new IllegalArgumentException("未指定檔名及其物理路徑！");
 9   }
10   try {
11    return newDocumentBuilder().parse(new File(fileName));
12   } catch (SAXException e) {
13    throw new IllegalArgumentException(
14     "目標檔案（" + fileName + "）不能被正確解析為XML！\n" + e.getMessage());
15   } catch (IOException e) {
16    throw new IllegalArgumentException(
17     "不能獲取目標檔案（" + fileName + "）！\n" + e.getMessage());
18   } catch (ParserConfigurationException e) {
19    throw new RuntimeException(e.getMessage());
20   }
21  }

 1  /**
 2   * 給定一個節點，將該節點加入新構造的Document中。
 3   * @param node a Document node
 4   * @return a new Document
 5   */
 6  public static Document newXMLDocument(Node node) {
 7   Document doc = newXMLDocument();
 8   doc.appendChild(doc.importNode(node, true));
 9   return doc;
10  }

 1  /**
 2   * 將傳入的一個DOM Node物件輸出成字串。如果失敗則返回一個空字串""。
 3   * @param node DOM Node 物件。
 4   * @return a XML String from node
 5   */
 6  public static String toString(Node node) {
 7   if (node == null) {
 8    throw new IllegalArgumentException();
 9   }
10   Transformer transformer = newTransformer();
11   if (transformer != null) {
12    try {
13     StringWriter sw = new StringWriter();
14     transformer.transform(
15      new DOMSource(node),
16      new StreamResult(sw));
17     return sw.toString();
18    } catch (TransformerException te) {
19     throw new RuntimeException(te.getMessage());
20 
21    }
22   }
23   return errXMLString("不能生成XML資訊！");
24  }

 1  /**
 2   * 將傳入的一個DOM Node物件輸出成字串。如果失敗則返回一個空字串""。
 3   * @param node DOM Node 物件。
 4   * @return a XML String from node
 5   */
 6  public static String toString(Node node) {
 7   if (node == null) {
 8    throw new IllegalArgumentException();
 9   }
10   Transformer transformer = newTransformer();
11   if (transformer != null) {
12    try {
13     StringWriter sw = new StringWriter();
14     transformer.transform(
15      new DOMSource(node),
16      new StreamResult(sw));
17     return sw.toString();
18    } catch (TransformerException te) {
19     throw new RuntimeException(te.getMessage());
20 
21    }
22   }
23   return errXMLString("不能生成XML資訊！");
24  }

 1  /**
 2   * 獲取一個Transformer物件，由於使用時都做相同的初始化，所以提取出來作為公共方法。
 3   * @return a Transformer encoding gb2312
 4   */
 5  public static Transformer newTransformer() {
 6   try {
 7    Transformer transformer =
 8     TransformerFactory.newInstance().newTransformer();
 9    Properties properties = transformer.getOutputProperties();
10    properties.setProperty(OutputKeys.ENCODING, "gb2312");
11    properties.setProperty(OutputKeys.METHOD, "xml");
12    properties.setProperty(OutputKeys.VERSION, "1.0");
13    properties.setProperty(OutputKeys.INDENT, "no");
14    transformer.setOutputProperties(properties);
15    return transformer;
16   } catch (TransformerConfigurationException tce) {
17    throw new RuntimeException(tce.getMessage());
18   }
19  }

 1  /**
 2   * 返回一段XML表述的錯誤資訊。提示資訊的TITLE為：系統錯誤。之所以使用字串拼裝，主要是這樣做一般
 3   * 不會有異常出現。
 4   * @param errMsg 提示錯誤資訊
 5   * @return a XML String show err msg
 6   */
 7  public static String errXMLString(String errMsg) {
 8   StringBuffer msg = new StringBuffer(100);
 9   msg.append("<?xml version=\"1.0\" encoding=\"gb2312\" ?>");
10   msg.append("<errNode title=\"系統錯誤\" errMsg=\"" + errMsg + "\"/>");
11   return msg.toString();
12  }

 1 /**
 2   * 返回一段XML表述的錯誤資訊。提示資訊的TITLE為：系統錯誤
 3   * @param errMsg 提示錯誤資訊
 4   * @param errClass 丟擲該錯誤的類，用於提取錯誤來源資訊。
 5   * @return a XML String show err msg
 6   */
 7  public static String errXMLString(String errMsg, Class errClass) {
 8   StringBuffer msg = new StringBuffer(100);
 9   msg.append("<?xml version=\"1.0\" encoding=\"gb2312\" ?>");
10   msg.append(
11    "<errNode title=\"系統錯誤\" errMsg=\""
12     + errMsg
13     + "\" errSource=\""
14     + errClass.getName()
15     + "\"/>");
16   return msg.toString();
17  }

 1  /**
 2   * 返回一段XML表述的錯誤資訊。
 3   * @param title 提示的title
 4   * @param errMsg 提示錯誤資訊
 5   * @param errClass 丟擲該錯誤的類，用於提取錯誤來源資訊。
 6   * @return a XML String show err msg
 7   */
 8  public static String errXMLString(
 9   String title,
10   String errMsg,
11   Class errClass) {
12   StringBuffer msg = new StringBuffer(100);
13   msg.append("<?xml version=\"1.0\" encoding=\"gb2312\" ?>");
14   msg.append(
15    "<errNode title=\""
16     + title
17     + "\" errMsg=\""
18     + errMsg
19     + "\" errSource=\""
20     + errClass.getName()
21     + "\"/>");
22   return msg.toString();
23  }

以上都是DOM的基本應用，所以就不一一詳細說明了。
在實際使用過程中，有幾種狀況使用很頻繁，但是DOM的介面的設計卻使該操作很麻煩，所以分別添加了相應的處理方法。
其中最麻煩的要數獲取一個節點的Text子節點文字資訊了，如下的XML節點：
<element>
text
</element>
在擁有element節點物件時，要獲取其中的文字資訊"text"，首先要獲取element節點的子節點列表，要判斷其是否存在子節點，如果存在，那麼遍歷其子節點找到一個TextNode節點，通過getNodeValue()方法來獲取該文字資訊，由於這裡element節點沒有資訊時沒有子節點，所以必須判斷element節點是否存在子節點才能去訪問真正包含了文字資訊的TextNode節點，那麼如果要處理的資料都是以這種形式給出的，就會增加大量的開發程式碼同時讓開發工作枯燥無味，因此這裡使用了一個預設的約定實現，就是，給出了一個公共方法，該方法取給定Node下的直接子節點的Text節點文字資訊，如果不存在Text節點則返回null，這個約定雖然使該方法的使用有所限制，也可能導致錯誤使用該方法，但是，按實際使用的狀況來看，這樣的約定和使用方式是沒有問題的，因為實際用到的都是上面舉的例子的狀況，程式碼：

 1  /**
 2   * 這個方法獲取給定Node下的Text節點文字資訊，如果不存在Text節點則返回null。
 3   * 注意：是直接子節點，相差2層或2層以上不會被考慮。
 4   * @param node a Node 一個Node。
 5   * @return a String 如果給定節點存在Text子節點，則返回第一個訪問到的Text子節點文字資訊，如果不存在則返回null。
 6   */
 7  public static String getNodeValue(Node node) {
 8   if (node == null) {
 9    return null;
10   }
11 
12   Text text = getTextNode(node);
13 
14   if (text != null) {
15    return text.getNodeValue();
16   }
17 
18   return null;
19  }

 1  /**
 2   * 這個方法獲取給定Node下的Text節點，如果不存在Text節點則返回null。
 3   * 注意：是直接子節點，相差2層或2層以上不會被考慮。
 4   * @param node a Node 一個Node。
 5   * @return a Text 如果給定節點存在Text子節點，則返回第一個訪問到的Text子節點，如果不存在則返回null。
 6   */
 7  public static Text getTextNode(Node node) {
 8   if (node == null) {
 9    return null;
10   }
11   if (node.hasChildNodes()) {
12    NodeList list = node.getChildNodes();
13    for (int i = 0; i < list.getLength(); i++) {
14     if (list.item(i).getNodeType() == Node.TEXT_NODE) {
15      return (Text) list.item(i);
16     }
17    }
18   }
19   return null;
20  }

上面程式碼將獲取給定Node節點的直接Text子節點分開包裝。

另一個很經常碰到的狀況是，我希望直接定位到目標節點，獲取該節點物件，而不需要通過一層一層的節點遍歷來找到目標節點，DOM2介面中至少提供瞭如下的方式來定位節點：
1、對於Document物件：
1）getDocumentElement()――獲取根節點物件，實際很少使用的，因為根節點基本也就只是根節點而已，實際的資料節點都是根節點下的直接子節點開始的。
2）getElementById(String elementId)――這個方法本來應該是一個最佳的定位方法，但是在實際使用過程中沒有被我使用，其主要原因就是，這裡的"ID"不同於一個節點的屬性"ID"，這在org.w3c.dom.Document的API說明中是明確指出，而我找了不少的資料也沒有看到有關的使用方式，所以只好放棄了。
3）getElementsByTagName(String tagname)――這個方法其實是沒有辦法的選擇，只好用它了，不過實際倒也很合用，雖然該方法返回的是一個NodeList，但是實際使用時，將節點的tagName設計成特殊字串，那麼就可以直接獲取了，而實際使用時，其實也差不多，很多時候會直接拿資料庫中的欄位名來作為tagName，以方便得獲取該欄位得值，在一個簡單得約定下，使用瞭如下方法：

 1  /**
 2   * 這個方法檢索引數element下所有TagName為：tagName的節點，並返回節點列表的第一個節點。
 3   * 如果不存在該tagName的節點，則返回null。
 4   * @param element 待搜尋節點
 5   * @param tagName 待搜尋標籤名
 6   * @return a Element 獲得以tagName為標籤名的節點列表的第一個節點。
 7   */
 8  public static Element getFirstElementByName(
 9   Element element,
10   String tagName) {
11   return (Element) getFirstElement(element.getElementsByTagName(tagName));
12  }

 1  /**
 2   * 從給定節點列表中獲取第一個節點返回，如果節點集合為null/空，則返回null。
 3   * @param nodeList a NodeList
 4   * @return a Node
 5   */
 6  private static Node getFirstElement(NodeList nodeList) {
 7   if (nodeList == null || nodeList.getLength() == 0) {
 8    return null;
 9   }
10   return nodeList.item(0);
11  }

這個約定看似限制很大，其實實際使用時基本都是這樣的，只要獲取第一個給定tagName的Element節點就可以了的。
4）getElementsByTagNameNS(String namespaceURI, String localName)――這個方法基本沒有使用，因為還沒有碰到需要使用名稱空間的狀況。
2、對於Element物件――――Element物件和Document物件雷同，少了getDocumentElement()方法，不過和Document一樣也都是主要使用getElementsByTagName()方法。
3、其它的節點物件基本沒有直接定位的訪問方法

還有一種，是由於DOM2的限制導致的，DOM2規範中，不能將一個Document docA的節點直接加入到另一個Document docB物件的節點的子節點列表中，要這麼做必須首先將docA的節點通過docB的importNode方法轉換後在新增到目標節點的子節點列表中，所以也有一個方法來統一處理：

 1  /**
 2   * 這個方法將引數appendedDoc的根節點及其以下節點附加到doc的跟節點下面。
 3   * 作為doc的跟節點的作後一個子節點。
 4   * 相當於：doc.appendDoc(appendedDoc);
 5   * @param doc a Document
 6   * @param appendedDoc a Document
 7   */
 8  public static void appendXMLDocument(Document doc, Document appendedDoc) {
 9   if (appendedDoc != null) {
10    doc.getFirstChild().appendChild(
11     doc.importNode(appendedDoc.getFirstChild(), true));
12   }
13  }

 1  /**
 2   * 這個方法將引數appendedDoc的根節點及其以下節點附加到node節點下面。
 3   * 作為node節點的作後一個子節點。
 4   * 相當於：node.appendDoc(appendedNode);
 5   * @param node 待新增的節點將被新增到該節點的最後。
 6   * @param appendedNode a Node 這個節點將被新增作為node節點的最後一個子節點。
 7   */
 8  public static void appendXMLDocument(Node node, Node appendedNode) {
 9   if (appendedNode == null) {
10    return;
11   }
12   if (appendedNode instanceof Document) {
13    appendedNode = ((Document) appendedNode).getDocumentElement();
14   }
15   node.appendChild(
16    node.getOwnerDocument().importNode(appendedNode, true));
17  }

基本上就這些常用的了，其它還有一些零碎的方法，不過都不常用到，就不作介紹了。