解析Xml四种方法

关键字：Java解析xml、解析xml四种方法、DOM、SAX、JDOM、DOM4j、XPath

【引言】

目前在Java中用于解析XML的技术很多，主流的有DOM、SAX、JDOM、DOM4j，下文主要介绍这4种解析XML文档技术的使用、优缺点及性能测试。

一、【基础知识——扫盲】

sax、dom是两种对xml文档进行解析的方法(没有具体实现，只是接口)，所以只有它们是无法解析xml文档的；jaxp只是api，它进一步封装了sax、dom两种接口，并且提供了DomcumentBuilderFactory/DomcumentBuilder和SAXParserFactory/SAXParser（默认使用xerces解释器）。

二、【DOM、SAX、JDOM、DOM4j简单使用介绍】

1、【DOM(Document Object Model) 】
由W3C提供的接口，它将整个XML文档读入内存，构建一个DOM树来对各个节点(Node)进行操作。
示例代码：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <university name="pku">
  3. <college name="c1">
  4. <class name="class1">
  5. <student name="stu1" sex=‘male‘ age="21" />
  6. <student name="stu2" sex=‘female‘ age="20" />
  7. <student name="stu3" sex=‘female‘ age="20" />
  8. </class>
  9. <class name="class2">
  10. <student name="stu4" sex=‘male‘ age="19" />
  11. <student name="stu5" sex=‘female‘ age="20" />
  12. <student name="stu6" sex=‘female‘ age="21" />
  13. </class>
  14. </college>
  15. <college name="c2">
  16. <class name="class3">
  17. <student name="stu7" sex=‘male‘ age="20" />
  18. </class>
  19. </college>
  20. <college name="c3">
  21. </college>
  22. </university>

后文代码中有使用到text.xml（该文档放在src路径下，既编译后在classes路径下），都是指该xml文档。

  1. package test.xml;
  2. import java.io.File;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. import javax.xml.parsers.DocumentBuilder;
  8. import javax.xml.parsers.DocumentBuilderFactory;
  9. import javax.xml.parsers.ParserConfigurationException;
  10. import javax.xml.transform.Transformer;
  11. import javax.xml.transform.TransformerConfigurationException;
  12. import javax.xml.transform.TransformerException;
  13. import javax.xml.transform.TransformerFactory;
  14. import javax.xml.transform.dom.DOMSource;
  15. import javax.xml.transform.stream.StreamResult;
  16. import org.w3c.dom.Document;
  17. import org.w3c.dom.Element;
  18. import org.w3c.dom.Node;
  19. import org.w3c.dom.NodeList;
  20. import org.w3c.dom.Text;
  21. import org.xml.sax.SAXException;
  22. /**
  23. * dom读写xml
  24. * @author whwang
  25. */
  26. public class TestDom {
  27. public static void main(String[] args) {
  28. read();
  29. //write();
  30. }
  31. public static void read() {
  32. DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
  33. try {
  34. DocumentBuilder builder = dbf.newDocumentBuilder();
  35. InputStream in = TestDom.class.getClassLoader().getResourceAsStream("test.xml");
  36. Document doc = builder.parse(in);
  37. // root <university>
  38. Element root = doc.getDocumentElement();
  39. if (root == null) return;
  40. System.err.println(root.getAttribute("name"));
  41. // all college node
  42. NodeList collegeNodes = root.getChildNodes();
  43. if (collegeNodes == null) return;
  44. for(int i = 0; i < collegeNodes.getLength(); i++) {
  45. Node college = collegeNodes.item(i);
  46. if (college != null && college.getNodeType() == Node.ELEMENT_NODE) {
  47. System.err.println("\t" + college.getAttributes().getNamedItem("name").getNodeValue());
  48. // all class node
  49. NodeList classNodes = college.getChildNodes();
  50. if (classNodes == null) continue;
  51. for (int j = 0; j < classNodes.getLength(); j++) {
  52. Node clazz = classNodes.item(j);
  53. if (clazz != null && clazz.getNodeType() == Node.ELEMENT_NODE) {
  54. System.err.println("\t\t" + clazz.getAttributes().getNamedItem("name").getNodeValue());
  55. // all student node
  56. NodeList studentNodes = clazz.getChildNodes();
  57. if (studentNodes == null) continue;
  58. for (int k = 0; k < studentNodes.getLength(); k++) {
  59. Node student = studentNodes.item(k);
  60. if (student != null && student.getNodeType() == Node.ELEMENT_NODE) {
  61. System.err.print("\t\t\t" + student.getAttributes().getNamedItem("name").getNodeValue());
  62. System.err.print(" " + student.getAttributes().getNamedItem("sex").getNodeValue());
  63. System.err.println(" " + student.getAttributes().getNamedItem("age").getNodeValue());
  64. }
  65. }
  66. }
  67. }
  68. }
  69. }
  70. } catch (ParserConfigurationException e) {
  71. e.printStackTrace();
  72. } catch (FileNotFoundException e) {
  73. e.printStackTrace();
  74. } catch (SAXException e) {
  75. e.printStackTrace();
  76. } catch (IOException e) {
  77. e.printStackTrace();
  78. }
  79. }
  80. public static void write() {
  81. DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
  82. try {
  83. DocumentBuilder builder = dbf.newDocumentBuilder();
  84. InputStream in = TestDom.class.getClassLoader().getResourceAsStream("test.xml");
  85. Document doc = builder.parse(in);
  86. // root <university>
  87. Element root = doc.getDocumentElement();
  88. if (root == null) return;
  89. // 修改属性
  90. root.setAttribute("name", "tsu");
  91. NodeList collegeNodes = root.getChildNodes();
  92. if (collegeNodes != null) {
  93. for (int i = 0; i <collegeNodes.getLength() - 1; i++) {
  94. // 删除节点
  95. Node college = collegeNodes.item(i);
  96. if (college.getNodeType() == Node.ELEMENT_NODE) {
  97. String collegeName = college.getAttributes().getNamedItem("name").getNodeValue();
  98. if ("c1".equals(collegeName) || "c2".equals(collegeName)) {
  99. root.removeChild(college);
  100. } else if ("c3".equals(collegeName)) {
  101. Element newChild = doc.createElement("class");
  102. newChild.setAttribute("name", "c4");
  103. college.appendChild(newChild);
  104. }
  105. }
  106. }
  107. }
  108. // 新增节点
  109. Element addCollege = doc.createElement("college");
  110. addCollege.setAttribute("name", "c5");
  111. root.appendChild(addCollege);
  112. Text text = doc.createTextNode("text");
  113. addCollege.appendChild(text);
  114. // 将修改后的文档保存到文件
  115. TransformerFactory transFactory = TransformerFactory.newInstance();
  116. Transformer transFormer = transFactory.newTransformer();
  117. DOMSource domSource = new DOMSource(doc);
  118. File file = new File("src/dom-modify.xml");
  119. if (file.exists()) {
  120. file.delete();
  121. }
  122. file.createNewFile();
  123. FileOutputStream out = new FileOutputStream(file);
  124. StreamResult xmlResult = new StreamResult(out);
  125. transFormer.transform(domSource, xmlResult);
  126. System.out.println(file.getAbsolutePath());
  127. } catch (ParserConfigurationException e) {
  128. e.printStackTrace();
  129. } catch (SAXException e) {
  130. e.printStackTrace();
  131. } catch (IOException e) {
  132. e.printStackTrace();
  133. } catch (TransformerConfigurationException e) {
  134. e.printStackTrace();
  135. } catch (TransformerException e) {
  136. e.printStackTrace();
  137. }
  138. }
  139. }

该代码只要稍做修改，即可变得更加简洁，无需一直写if来判断是否有子节点。

2、【SAX (Simple API for XML) 】
SAX不用将整个文档加载到内存，基于事件驱动的API(Observer模式)，用户只需要注册自己感兴趣的事件即可。SAX提供EntityResolver, DTDHandler, ContentHandler, ErrorHandler接口，分别用于监听解析实体事件、DTD处理事件、正文处理事件和处理出错事件，与AWT类似，SAX还提供了一个对这4个接口默认的类DefaultHandler（这里的默认实现，其实就是一个空方法），一般只要继承DefaultHandler，重写自己感兴趣的事件即可。
示例代码：

  1. package test.xml;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import javax.xml.parsers.ParserConfigurationException;
  5. import javax.xml.parsers.SAXParser;
  6. import javax.xml.parsers.SAXParserFactory;
  7. import org.xml.sax.Attributes;
  8. import org.xml.sax.InputSource;
  9. import org.xml.sax.Locator;
  10. import org.xml.sax.SAXException;
  11. import org.xml.sax.SAXParseException;
  12. import org.xml.sax.helpers.DefaultHandler;
  13. /**
  14. *
  15. * @author whwang
  16. */
  17. public class TestSAX {
  18. public static void main(String[] args) {
  19. read();
  20. write();
  21. }
  22. public static void read() {
  23. try {
  24. SAXParserFactory factory = SAXParserFactory.newInstance();
  25. SAXParser parser = factory.newSAXParser();
  26. InputStream in = TestSAX.class.getClassLoader().getResourceAsStream("test.xml");
  27. parser.parse(in, new MyHandler());
  28. } catch (ParserConfigurationException e) {
  29. e.printStackTrace();
  30. } catch (SAXException e) {
  31. e.printStackTrace();
  32. } catch (IOException e) {
  33. e.printStackTrace();
  34. }
  35. }
  36. public static void write() {
  37. System.err.println("纯SAX对于写操作无能为力");
  38. }
  39. }
  40. // 重写对自己感兴趣的事件处理方法
  41. class MyHandler extends DefaultHandler {
  42. @Override
  43. public InputSource resolveEntity(String publicId, String systemId)
  44. throws IOException, SAXException {
  45. return super.resolveEntity(publicId, systemId);
  46. }
  47. @Override
  48. public void notationDecl(String name, String publicId, String systemId)
  49. throws SAXException {
  50. super.notationDecl(name, publicId, systemId);
  51. }
  52. @Override
  53. public void unparsedEntityDecl(String name, String publicId,
  54. String systemId, String notationName) throws SAXException {
  55. super.unparsedEntityDecl(name, publicId, systemId, notationName);
  56. }
  57. @Override
  58. public void setDocumentLocator(Locator locator) {
  59. super.setDocumentLocator(locator);
  60. }
  61. @Override
  62. public void startDocument() throws SAXException {
  63. System.err.println("开始解析文档");
  64. }
  65. @Override
  66. public void endDocument() throws SAXException {
  67. System.err.println("解析结束");
  68. }
  69. @Override
  70. public void startPrefixMapping(String prefix, String uri)
  71. throws SAXException {
  72. super.startPrefixMapping(prefix, uri);
  73. }
  74. @Override
  75. public void endPrefixMapping(String prefix) throws SAXException {
  76. super.endPrefixMapping(prefix);
  77. }
  78. @Override
  79. public void startElement(String uri, String localName, String qName,
  80. Attributes attributes) throws SAXException {
  81. System.err.print("Element: " + qName + ", attr: ");
  82. print(attributes);
  83. }
  84. @Override
  85. public void endElement(String uri, String localName, String qName)
  86. throws SAXException {
  87. super.endElement(uri, localName, qName);
  88. }
  89. @Override
  90. public void characters(char[] ch, int start, int length)
  91. throws SAXException {
  92. super.characters(ch, start, length);
  93. }
  94. @Override
  95. public void ignorableWhitespace(char[] ch, int start, int length)
  96. throws SAXException {
  97. super.ignorableWhitespace(ch, start, length);
  98. }
  99. @Override
  100. public void processingInstruction(String target, String data)
  101. throws SAXException {
  102. super.processingInstruction(target, data);
  103. }
  104. @Override
  105. public void skippedEntity(String name) throws SAXException {
  106. super.skippedEntity(name);
  107. }
  108. @Override
  109. public void warning(SAXParseException e) throws SAXException {
  110. super.warning(e);
  111. }
  112. @Override
  113. public void error(SAXParseException e) throws SAXException {
  114. super.error(e);
  115. }
  116. @Override
  117. public void fatalError(SAXParseException e) throws SAXException {
  118. super.fatalError(e);
  119. }
  120. private void print(Attributes attrs) {
  121. if (attrs == null) return;
  122. System.err.print("[");
  123. for (int i = 0; i < attrs.getLength(); i++) {
  124. System.err.print(attrs.getQName(i) + " = " + attrs.getValue(i));
  125. if (i != attrs.getLength() - 1) {
  126. System.err.print(", ");
  127. }
  128. }
  129. System.err.println("]");
  130. }
  131. }

3、【JDOM】
JDOM与DOM非常类似，它是处理XML的纯JAVA API，API大量使用了Collections类，且JDOM仅使用具体类而不使用接口。　JDOM 它自身不包含解析器。它通常使用 SAX2 解析器来解析和验证输入 XML 文档（尽管它还可以将以前构造的 DOM 表示作为输入）。它包含一些转换器以将 JDOM 表示输出成 SAX2 事件流、DOM 模型或 XML 文本文档
示例代码：

  1. package test.xml;
  2. import java.io.File;
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.util.List;
  7. import org.jdom.Attribute;
  8. import org.jdom.Document;
  9. import org.jdom.Element;
  10. import org.jdom.JDOMException;
  11. import org.jdom.input.SAXBuilder;
  12. import org.jdom.output.XMLOutputter;
  13. /**
  14. * JDom读写xml
  15. * @author whwang
  16. */
  17. public class TestJDom {
  18. public static void main(String[] args) {
  19. //read();
  20. write();
  21. }
  22. public static void read() {
  23. try {
  24. boolean validate = false;
  25. SAXBuilder builder = new SAXBuilder(validate);
  26. InputStream in = TestJDom.class.getClassLoader().getResourceAsStream("test.xml");
  27. Document doc = builder.build(in);
  28. // 获取根节点 <university>
  29. Element root = doc.getRootElement();
  30. readNode(root, "");
  31. } catch (JDOMException e) {
  32. e.printStackTrace();
  33. } catch (IOException e) {
  34. e.printStackTrace();
  35. }
  36. }
  37. @SuppressWarnings("unchecked")
  38. public static void readNode(Element root, String prefix) {
  39. if (root == null) return;
  40. // 获取属性
  41. List<Attribute> attrs = root.getAttributes();
  42. if (attrs != null && attrs.size() > 0) {
  43. System.err.print(prefix);
  44. for (Attribute attr : attrs) {
  45. System.err.print(attr.getValue() + " ");
  46. }
  47. System.err.println();
  48. }
  49. // 获取他的子节点
  50. List<Element> childNodes = root.getChildren();
  51. prefix += "\t";
  52. for (Element e : childNodes) {
  53. readNode(e, prefix);
  54. }
  55. }
  56. public static void write() {
  57. boolean validate = false;
  58. try {
  59. SAXBuilder builder = new SAXBuilder(validate);
  60. InputStream in = TestJDom.class.getClassLoader().getResourceAsStream("test.xml");
  61. Document doc = builder.build(in);
  62. // 获取根节点 <university>
  63. Element root = doc.getRootElement();
  64. // 修改属性
  65. root.setAttribute("name", "tsu");
  66. // 删除
  67. boolean isRemoved = root.removeChildren("college");
  68. System.err.println(isRemoved);
  69. // 新增
  70. Element newCollege = new Element("college");
  71. newCollege.setAttribute("name", "new_college");
  72. Element newClass = new Element("class");
  73. newClass.setAttribute("name", "ccccc");
  74. newCollege.addContent(newClass);
  75. root.addContent(newCollege);
  76. XMLOutputter out = new XMLOutputter();
  77. File file = new File("src/jdom-modify.xml");
  78. if (file.exists()) {
  79. file.delete();
  80. }
  81. file.createNewFile();
  82. FileOutputStream fos = new FileOutputStream(file);
  83. out.output(doc, fos);
  84. } catch (JDOMException e) {
  85. e.printStackTrace();
  86. } catch (IOException e) {
  87. e.printStackTrace();
  88. }
  89. }
  90. }

4、【DOM4j】
dom4j是目前在xml解析方面是最优秀的(Hibernate、Sun的JAXM也都使用dom4j来解析XML)，它合并了许多超出基本 XML 文档表示的功能，包括集成的 XPath 支持、XML Schema 支持以及用于大文档或流化文档的基于事件的处理
示例代码：

  1. package test.xml;
  2. import java.io.File;
  3. import java.io.FileWriter;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.util.List;
  7. import org.dom4j.Attribute;
  8. import org.dom4j.Document;
  9. import org.dom4j.DocumentException;
  10. import org.dom4j.DocumentHelper;
  11. import org.dom4j.Element;
  12. import org.dom4j.ProcessingInstruction;
  13. import org.dom4j.VisitorSupport;
  14. import org.dom4j.io.SAXReader;
  15. import org.dom4j.io.XMLWriter;
  16. /**
  17. * Dom4j读写xml
  18. * @author whwang
  19. */
  20. public class TestDom4j {
  21. public static void main(String[] args) {
  22. read1();
  23. //read2();
  24. //write();
  25. }
  26. public static void read1() {
  27. try {
  28. SAXReader reader = new SAXReader();
  29. InputStream in = TestDom4j.class.getClassLoader().getResourceAsStream("test.xml");
  30. Document doc = reader.read(in);
  31. Element root = doc.getRootElement();
  32. readNode(root, "");
  33. } catch (DocumentException e) {
  34. e.printStackTrace();
  35. }
  36. }
  37. @SuppressWarnings("unchecked")
  38. public static void readNode(Element root, String prefix) {
  39. if (root == null) return;
  40. // 获取属性
  41. List<Attribute> attrs = root.attributes();
  42. if (attrs != null && attrs.size() > 0) {
  43. System.err.print(prefix);
  44. for (Attribute attr : attrs) {
  45. System.err.print(attr.getValue() + " ");
  46. }
  47. System.err.println();
  48. }
  49. // 获取他的子节点
  50. List<Element> childNodes = root.elements();
  51. prefix += "\t";
  52. for (Element e : childNodes) {
  53. readNode(e, prefix);
  54. }
  55. }
  56. public static void read2() {
  57. try {
  58. SAXReader reader = new SAXReader();
  59. InputStream in = TestDom4j.class.getClassLoader().getResourceAsStream("test.xml");
  60. Document doc = reader.read(in);
  61. doc.accept(new MyVistor());
  62. } catch (DocumentException e) {
  63. e.printStackTrace();
  64. }
  65. }
  66. public static void write() {
  67. try {
  68. // 创建一个xml文档
  69. Document doc = DocumentHelper.createDocument();
  70. Element university = doc.addElement("university");
  71. university.addAttribute("name", "tsu");
  72. // 注释
  73. university.addComment("这个是根节点");
  74. Element college = university.addElement("college");
  75. college.addAttribute("name", "cccccc");
  76. college.setText("text");
  77. File file = new File("src/dom4j-modify.xml");
  78. if (file.exists()) {
  79. file.delete();
  80. }
  81. file.createNewFile();
  82. XMLWriter out = new XMLWriter(new FileWriter(file));
  83. out.write(doc);
  84. out.flush();
  85. out.close();
  86. } catch (IOException e) {
  87. e.printStackTrace();
  88. }
  89. }
  90. }
  91. class MyVistor extends VisitorSupport {
  92. public void visit(Attribute node) {
  93. System.out.println("Attibute: " + node.getName() + "="
  94. + node.getValue());
  95. }
  96. public void visit(Element node) {
  97. if (node.isTextOnly()) {
  98. System.out.println("Element: " + node.getName() + "="
  99. + node.getText());
  100. } else {
  101. System.out.println(node.getName());
  102. }
  103. }
  104. @Override
  105. public void visit(ProcessingInstruction node) {
  106. System.out.println("PI:" + node.getTarget() + " " + node.getText());
  107. }
  108. }

三、【性能测试】

环境：AMD4400+ 2.0+GHz主频 JDK6.0
运行参数：-Xms400m -Xmx400m
xml文件大小：10.7M
结果：
DOM: >581297ms
SAX: 8829ms
JDOM: 581297ms
DOM4j: 5309ms
时间包括IO的，只是进行了简单的测试，仅供参考！！！！

四、【对比】

1、【DOM】
DOM是基于树的结构，通常需要加载整文档和构造DOM树，然后才能开始工作。
优点：
    a、由于整棵树在内存中，因此可以对xml文档随机访问
    b、可以对xml文档进行修改操作
    c、较sax，dom使用也更简单。
缺点：
    a、整个文档必须一次性解析完
    a、由于整个文档都需要载入内存，对于大文档成本高
2、【SAX】
SAX类似流媒体，它基于事件驱动的，因此无需将整个文档载入内存，使用者只需要监听自己感兴趣的事件即可。
优点：
    a、无需将整个xml文档载入内存，因此消耗内存少
    b、可以注册多个ContentHandler
缺点：
    a、不能随机的访问xml中的节点
    b、不能修改文档
3、【JDOM】
JDOM是纯Java的处理XML的API，其API中大量使用Collections类，
优点：
    a、DOM方式的优点
    b、具有SAX的Java规则
缺点
    a、DOM方式的缺点
4、【DOM4J】
这4中xml解析方式中，最优秀的一个，集易用和性能于一身。

五、【小插曲XPath】

XPath 是一门在 XML 文档中查找信息的语言， 可用来在 XML 文档中对元素和属性进行遍历。XPath 是 W3C XSLT 标准的主要元素，并且 XQuery 和 XPointer 同时被构建于 XPath 表达之上。因此，对 XPath 的理解是很多高级 XML 应用的基础。
XPath非常类似对数据库操作的SQL语言，或者说JQuery，它可以方便开发者抓起文档中需要的东西。（dom4j也支持xpath）
示例代码：

  1. package test.xml;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import javax.xml.parsers.DocumentBuilder;
  5. import javax.xml.parsers.DocumentBuilderFactory;
  6. import javax.xml.parsers.ParserConfigurationException;
  7. import javax.xml.xpath.XPath;
  8. import javax.xml.xpath.XPathConstants;
  9. import javax.xml.xpath.XPathExpression;
  10. import javax.xml.xpath.XPathExpressionException;
  11. import javax.xml.xpath.XPathFactory;
  12. import org.w3c.dom.Document;
  13. import org.w3c.dom.NodeList;
  14. import org.xml.sax.SAXException;
  15. public class TestXPath {
  16. public static void main(String[] args) {
  17. read();
  18. }
  19. public static void read() {
  20. try {
  21. DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
  22. DocumentBuilder builder = dbf.newDocumentBuilder();
  23. InputStream in = TestXPath.class.getClassLoader().getResourceAsStream("test.xml");
  24. Document doc = builder.parse(in);
  25. XPathFactory factory = XPathFactory.newInstance();
  26. XPath xpath = factory.newXPath();
  27. // 选取所有class元素的name属性
  28. // XPath语法介绍： http://w3school.com.cn/xpath/
  29. XPathExpression expr = xpath.compile("//class/@name");
  30. NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
  31. for (int i = 0; i < nodes.getLength(); i++) {
  32. System.out.println("name = " + nodes.item(i).getNodeValue());
  33. }
  34. } catch (XPathExpressionException e) {
  35. e.printStackTrace();
  36. } catch (ParserConfigurationException e) {
  37. e.printStackTrace();
  38. } catch (SAXException e) {
  39. e.printStackTrace();
  40. } catch (IOException e) {
  41. e.printStackTrace();
  42. }
  43. }
  44. }

六、【补充】

注意4种解析方法对TextNode（文本节点）的处理：

1、在使用DOM时，调用node.getChildNodes()获取该节点的子节点，文本节点也会被当作一个Node来返回，如：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <university name="pku">
  3. <college name="c1">
  4. <class name="class1">
  5. <student name="stu1" sex=‘male‘ age="21" />
  6. <student name="stu2" sex=‘female‘ age="20" />
  7. <student name="stu3" sex=‘female‘ age="20" />
  8. </class>
  9. </college>
  10. </university>
  1. package test.xml;
  2. import java.io.FileNotFoundException;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.util.Arrays;
  6. import javax.xml.parsers.DocumentBuilder;
  7. import javax.xml.parsers.DocumentBuilderFactory;
  8. import javax.xml.parsers.ParserConfigurationException;
  9. import org.w3c.dom.Document;
  10. import org.w3c.dom.Element;
  11. import org.w3c.dom.Node;
  12. import org.w3c.dom.NodeList;
  13. import org.xml.sax.SAXException;
  14. /**
  15. * dom读写xml
  16. * @author whwang
  17. */
  18. public class TestDom2 {
  19. public static void main(String[] args) {
  20. read();
  21. }
  22. public static void read() {
  23. DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
  24. try {
  25. DocumentBuilder builder = dbf.newDocumentBuilder();
  26. InputStream in = TestDom2.class.getClassLoader().getResourceAsStream("test.xml");
  27. Document doc = builder.parse(in);
  28. // root <university>
  29. Element root = doc.getDocumentElement();
  30. if (root == null) return;
  31. //          System.err.println(root.getAttribute("name"));
  32. // all college node
  33. NodeList collegeNodes = root.getChildNodes();
  34. if (collegeNodes == null) return;
  35. System.err.println("university子节点数：" + collegeNodes.getLength());
  36. System.err.println("子节点如下：");
  37. for(int i = 0; i < collegeNodes.getLength(); i++) {
  38. Node college = collegeNodes.item(i);
  39. if (college == null) continue;
  40. if (college.getNodeType() == Node.ELEMENT_NODE) {
  41. System.err.println("\t元素节点：" + college.getNodeName());
  42. } else if (college.getNodeType() == Node.TEXT_NODE) {
  43. System.err.println("\t文本节点：" + Arrays.toString(college.getTextContent().getBytes()));
  44. }
  45. }
  46. } catch (ParserConfigurationException e) {
  47. e.printStackTrace();
  48. } catch (FileNotFoundException e) {
  49. e.printStackTrace();
  50. } catch (SAXException e) {
  51. e.printStackTrace();
  52. } catch (IOException e) {
  53. e.printStackTrace();
  54. }
  55. }
  56. }

输出的结果是：

  1. university子节点数：3
  2. 子节点如下：
  3. 文本节点：[10, 9]
  4. 元素节点：college
  5. 文本节点：[10]

其中\n的ASCII码为10，\t的ASCII码为9。结果让人大吃一惊，university的子节点数不是1，也不是2，而是3，这3个子节点都是谁呢？为了看得更清楚点，把xml文档改为：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <university name="pku">11
  3. <college name="c1">
  4. <class name="class1">
  5. <student name="stu1" sex=‘male‘ age="21" />
  6. <student name="stu2" sex=‘female‘ age="20" />
  7. <student name="stu3" sex=‘female‘ age="20" />
  8. </class>
  9. </college>22
  10. </university>

还是上面的程序，输出结果为：

  1. university子节点数：3
  2. 子节点如下：
  3. 文本节点：[49, 49, 10, 9]
  4. 元素节点：college
  5. 文本节点：[50, 50, 10]

其中数字1的ASCII码为49，数字2的ASCII码为50。

2、使用SAX来解析同DOM，当你重写它的public void characters(char[] ch, int start, int length)方法时，你就能看到。

3、JDOM，调用node.getChildren()只返回子节点，不包括TextNode节点（不管该节点是否有Text信息）。如果要获取该节点的Text信息，可以调用node.getText()方法，该方法返回节点的Text信息，也包括\n\t等特殊字符。

4、DOM4j同JDOM

解析Xml四种方法

时间： 2024-10-01 23:22:20

解析Xml四种方法的相关文章

IOS中Json解析的四种方法

作为一种轻量级的数据交换格式,json正在逐步取代xml,成为网络数据的通用格式. 有的json代码格式比较混乱,可以使用此“http://www.bejson.com/”网站来进行JSON格式化校验(点击打开链接).此网站不仅可以检测Json代码中的错误,而且可以以视图形式显示json中的数据内容,很是方便. 从IOS5开始,APPLE提供了对json的原生支持(NSJSONSerialization),但是为了兼容以前的ios版本,可以使用第三方库来解析Json. 本文将介绍TouchJso

【转】IOS中Json解析的四种方法

原文网址:http://blog.csdn.net/enuola/article/details/7903632 作为一种轻量级的数据交换格式,json正在逐步取代xml,成为网络数据的通用格式. 有的json代码格式比较混乱,可以使用此“http://www.bejson.com/”网站来进行JSON格式化校验(点击打开链接).此网站不仅可以检测Json代码中的错误,而且可以以视图形式显示json中的数据内容,很是方便. 从IOS5开始,APPLE提供了对json的原生支持(NSJSONSer

收集json解析的四种方法

Json在Web开发的用处非常广泛,作为数据传递的载体,如何解析Json返回的数据是非常常用的.下面介绍下四种解析Json的方式: Part 1云鼎娱乐城 var list1 = [1,3,4]; alert(list1[1]); var list2 = [{"name":"leamiko","xing":"lin"}]; alert(list2[0]["xing"]) alert(list2[0].xin

XML解析的四种方法 建议使用demo4j解析 测试可以用

https://www.cnblogs.com/longqingyang/p/5577937.html 4.DOM4J解析  特征: 1.JDOM的一种智能分支,它合并了许多超出基本XML文档表示的功能. 2.它使用接口和抽象基本类方法. 3.具有性能优异.灵活性好.功能强大和极端易用的特点. 4.是一个开放源码的文件 以下是解析代码: public class DOM4JTest { private static ArrayList<Book> bookList = new ArrayLis

Java中Xml解析（四种方法）

1.DOM,Document Object Model,基于DOM的XML分析器将XML文档转换成一个对象模型的集合(DOC树),通过对此模型操作实现对XML文档数据的操作,可以在任何时候对XML文档的任何一部分数据进行访问. DOC强制使用树模型来访问XML文档中信息 很灵活,当XML文档较大时对内存需求比较高,而且对结构复杂的DOC树的遍历也很耗时,对机器要求比较高. // step 1: 获得dom解析器工厂(工作的作用是用于创建具体的解析器) DocumentBuilderFactory

详解Java解析XML的四种方法

(1)DOM解析 DOM是html和xml的应用程序接口(API),以层次结构(类似于树型)来组织节点和信息片段,映射XML文档的结构,允许获取 和操作文档的任意部分,是W3C的官方标准 [优点] ①允许应用程序对数据和结构做出更改. ②访问是双向的,可以在任何时候在树中上下导航,获取和操作任意部分的数据. [缺点] ①通常需要加载整个XML文档来构造层次结构,消耗资源大. [解析详解] ①构建Document对象: DocumentBuilderFactory dbf = DocumentBu

Java解析XML文件的四种方法

[摘要] 可扩展标志语言(XML)在实现信息标准化.信息的交流与共享上有其独特的技术优势,因此受到了广泛的重视.本文先简单的介绍了XML基本知识,然后从XML应用入手总结了四种现今最常见的XML的解析方法,介绍了这四种方法的特点,其中包括优点与不足之处.最后给出了一个简单的案例来对这四种解析进行代码介绍. [关键字] XML文件,DOM,SAX,JDOM,DOM4J [引言] XML即可扩展标记语言(EXtensible Markup Language),是标准通用标记语言的子集,是一种用于标记

详解Java解析XML的四种方法(转)

XML现在已经成为一种通用的数据交换格式,平台的无关性使得很多场合都需要用到XML.本文将详细介绍用Java解析XML的四种方法. XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便.对于XML本身的语法知识与技术细节,需要阅读相关的技术文献,这里面包括的内容有DOM(Document Object Model),DTD(Document Type Definition),SAX(Simple API for XML),XSD(Xm

Java学习之道：详解Java解析XML的四种方法

XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便.对于XML本身的语法知识与技术细节,需要阅读相关的技术文献,这里面包括的内容有DOM(Document Object Model),DTD(Document Type Definition),SAX(Simple API for XML),XSD(Xml Schema Definition),XSLT(Extensible Stylesheet Language Transform