XML的几种解析器

前端之家收集整理的这篇文章主要介绍了XML的几种解析器前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

XML优点:平台无关性,语言无关性,系统无关性

XML在不同的语言里解析方式都是一样的,只不过实现的语法不同而已。基本的解析方式有两种,一种叫SAX,另一种叫DOM。SAX是基于事件流的解析,DOM是基于XML文档树结构的解析.假设我们XML的内容和结构如下:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <employees>
  3. <employee>
  4. <name>Darren</name>
  5. <sex>man</sex>
  6. <age>25</age>
  7. </employee>
  8. </employees>
下面是解析XMl常用的Dom和Sex方法
  1. package com.darren.test.xml;
  2.  
  3.  
  4. public interface XmlParse {
  5.  
  6. void createXml(String path);
  7.  
  8. void parseXml(String path);
  9. }

1、DOM生成和解析XML文档

为 XML 文档的已解析版本定义了一组接口。解析器读入整个文档,然后构建一个驻留内存的树结构,然后代码就可以使用 DOM 接口来操作这个树结构。

优点:整个文档树在内存中,便于操作;支持删除修改、重新排列等多种功能

缺点:将整个文档调入内存(包括无用的节点),浪费时间和空间;使用场合:一旦解析了文档还需多次访问这些数据;硬件资源充足(内存、cpu)。

  1. package com.darren.test.xml;
  2.  
  3. import java.io.FileOutputStream;
  4. import java.io.PrintWriter;
  5.  
  6. import javax.xml.parsers.DocumentBuilder;
  7. import javax.xml.parsers.DocumentBuilderFactory;
  8. import javax.xml.transform.OutputKeys;
  9. import javax.xml.transform.Transformer;
  10. import javax.xml.transform.TransformerFactory;
  11. import javax.xml.transform.dom.DOMSource;
  12. import javax.xml.transform.stream.StreamResult;
  13.  
  14. import org.w3c.dom.Document;
  15. import org.w3c.dom.Element;
  16. import org.w3c.dom.Node;
  17. import org.w3c.dom.NodeList;
  18.  
  19. public class DomParse implements XmlParse {
  20. private static DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  21.  
  22. @Override
  23. public void createXml(String path) {
  24. try {
  25. DocumentBuilder builder = factory.newDocumentBuilder();
  26. Document document = builder.newDocument();
  27. // 创建根节点
  28. Element root = document.createElement("employees");
  29. // 添加根节点
  30. document.appendChild(root);
  31.  
  32. // 创建一级子节点
  33. Element employee = document.createElement("employee");
  34.  
  35. // 操作一
  36. // 创建二级子节点
  37. Element name = document.createElement("name");
  38. // 为二级子节点添加
  39. name.appendChild(document.createTextNode("Darren"));
  40. // 把二级子节点放到一级子节点下
  41. employee.appendChild(name);
  42.  
  43. // 同操作一
  44. Element sex = document.createElement("sex");
  45. sex.appendChild(document.createTextNode("man"));
  46. employee.appendChild(sex);
  47.  
  48. // 同操作一
  49. Element age = document.createElement("age");
  50. age.appendChild(document.createTextNode("25"));
  51. employee.appendChild(age);
  52.  
  53. // 把一级子节点添加到根节点下
  54. root.appendChild(employee);
  55.  
  56. TransformerFactory transformerFactory = TransformerFactory.newInstance();
  57. Transformer transformer = transformerFactory.newTransformer();
  58. DOMSource source = new DOMSource(document);
  59. transformer.setOutputProperty(OutputKeys.ENCODING,"UTF-8");
  60. transformer.setOutputProperty(OutputKeys.INDENT,"yes");
  61. PrintWriter pw = new PrintWriter(new FileOutputStream(path));
  62. StreamResult result = new StreamResult(pw);
  63. transformer.transform(source,result);
  64. System.out.println("生成XML文件成功!");
  65. } catch (Exception e) {
  66. e.printStackTrace();
  67. }
  68. }
  69.  
  70. @Override
  71. public void parseXml(String path) {
  72. try {
  73. DocumentBuilder builder = factory.newDocumentBuilder();
  74. Document document = builder.parse(path);
  75. Element root = document.getDocumentElement();
  76. NodeList employee = root.getChildNodes();
  77. outPut(employee);
  78. System.out.println("解析XML文件成功!");
  79. } catch (Exception e) {
  80. e.printStackTrace();
  81. }
  82.  
  83. }
  84.  
  85. private void outPut(NodeList nodeList) {
  86. int length = nodeList.getLength();
  87. for (int i = 0; i < length; i++) {
  88. Node node = nodeList.item(i);
  89. // 叶子节点
  90. if (node.getChildNodes().getLength() == 1) {
  91. String nodeName = node.getNodeName();
  92. String nodeValue = node.getTextContent();
  93. System.out.println(nodeName + ":" + nodeValue);
  94. }
  95. // 非叶子节点
  96. if (node.getChildNodes().getLength() > 1) {
  97. NodeList subList = node.getChildNodes();
  98. outPut(subList);
  99. }
  100. }
  101. }
  102. }

打印结果:

  1. 生成XML文件成功!
  2. name:Darren
  3. sex:man
  4. age:25
  5. 解析XML文件成功!

2、SAX生成和解析XML文档

解决DOM的问题,出现了SAX。SAX ,事件驱动。当解析器发现元素开始、元素结束、文本、文档的开始或结束等时,发送事件,程序员编写响应这些事件的代码,保存数据。

优点:不用事先调入整个文档,占用资源少;SAX解析器代码比DOM解析器代码小,适于Applet,下载。

缺点:不是持久的;事件过后,若没保存数据,那么数据就丢了;无状态性;从事件中只能得到文本,但不知该文本属于哪个元素;使用场合:Applet;只需XML文档的少量内容,很少回头访问;机器内存少;

  1. package com.darren.test.xml;
  2.  
  3. import org.xml.sax.Attributes;
  4. import org.xml.sax.SAXException;
  5. import org.xml.sax.helpers.DefaultHandler;
  6.  
  7. public class MySAXHandler extends DefaultHandler {
  8.  
  9. // 一般将正式解析前的一些初始化工作放到这里面
  10. public void startDocument() throws SAXException {
  11. System.out.println("文档开始打印了");
  12. }
  13.  
  14. // 收尾工作放在endDocument中
  15. public void endDocument() throws SAXException {
  16. System.out.println("文档打印结束了");
  17. }
  18.  
  19. // XML解析器遇到XML里面的tag时就会调用这个函数。经常在这个函数内是通过qName俩进行判断而操作一些数据
  20. public void startElement(String uri,String localName,String qName,Attributes attributes) throws SAXException {
  21. if (qName.equals("employees")) {
  22. return;
  23. }
  24. if (qName.equals("employee")) {
  25. return;
  26. }
  27. System.out.print(qName + ":");
  28. }
  29.  
  30. // 这个方法与startElement()相对应,解析完一个tag节点后,执行这个方法
  31. public void endElement(String uri,String qName) throws SAXException {
  32.  
  33. }
  34.  
  35. // 回调方法。解析器执行完startElement()后,解析完节点的内容后就会执行这个方法,并且参数ch[]就是节点的内容
  36. public void characters(char[] ch,int start,int length) throws SAXException {
  37. String value = new String(ch,start,length);
  38. if (value.startsWith("\n")) {
  39. return;
  40. }
  41.  
  42. System.out.println(value);
  43. }
  44. }
  1. package com.darren.test.xml;
  2.  
  3. import java.io.FileInputStream;
  4. import java.io.FileOutputStream;
  5. import java.io.InputStream;
  6.  
  7. import javax.xml.parsers.SAXParser;
  8. import javax.xml.parsers.SAXParserFactory;
  9. import javax.xml.transform.OutputKeys;
  10. import javax.xml.transform.Result;
  11. import javax.xml.transform.Transformer;
  12. import javax.xml.transform.sax.SAXTransformerFactory;
  13. import javax.xml.transform.sax.TransformerHandler;
  14. import javax.xml.transform.stream.StreamResult;
  15.  
  16. import org.xml.sax.helpers.AttributesImpl;
  17.  
  18. public class SaxParse implements XmlParse {
  19.  
  20. @Override
  21. public void createXml(String path) {
  22. try {
  23. SAXTransformerFactory sff = (SAXTransformerFactory) SAXTransformerFactory.newInstance();
  24. TransformerHandler th = sff.newTransformerHandler();
  25. Result resultXml = new StreamResult(new FileOutputStream(path));
  26. th.setResult(resultXml);
  27.  
  28. Transformer transformer = th.getTransformer();
  29. transformer.setOutputProperty(OutputKeys.ENCODING,"UTF-8"); // 编码格式是UTF-8
  30. transformer.setOutputProperty(OutputKeys.INDENT,"yes"); // 换行
  31. th.startDocument(); // 开始xml文档
  32. AttributesImpl attr = new AttributesImpl();
  33. th.startElement("","","employees",attr); // 定义employees节点
  34. th.startElement("","employee",attr); // 定义employee节点
  35.  
  36. th.startElement("","name",attr); // 定义name节点
  37. th.characters("Darren".tocharArray(),"Darren".length());
  38. th.endElement("","name"); // 结束name节点
  39.  
  40. th.startElement("","sex",attr); // 定义sex节点
  41. th.characters("man".tocharArray(),"man".length());
  42. th.endElement("","sex"); // 结束gender节点
  43.  
  44. th.startElement("","age",attr); // 定义age节点
  45. th.characters("25".tocharArray(),"25".length());
  46. th.endElement("","age"); // 结束age节点
  47.  
  48. th.endElement("","employee"); // 结束employee节点
  49. th.endElement("","employees"); // 结束employees节点
  50. th.endDocument(); // 结束xml文档
  51.  
  52. } catch (Exception e) {
  53. e.printStackTrace();
  54. }
  55.  
  56. }
  57.  
  58. @Override
  59. public void parseXml(String path) {
  60. SAXParserFactory saxfac = SAXParserFactory.newInstance();
  61. try {
  62. SAXParser saxparser = saxfac.newSAXParser();
  63. InputStream is = new FileInputStream(path);
  64. saxparser.parse(is,new MySAXHandler());
  65. } catch (Exception e) {
  66. e.printStackTrace();
  67. }
  68. }
  69.  
  70. }

打印结果:

  1. 文档开始打印了
  2. name:Darren
  3. sex:man
  4. age:25
  5. 文档打印结束了

3、DOM4J生成和解析XML文档

DOM4J 是一个非常非常优秀的Java XML API,具有性能优异、功能强大和极端易用使用的特点,同时它也是一个开放源代码的软件。如今你可以看到越来越多的 Java 软件都在使用 DOM4J 来读写 XML,特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J

需要引入dom4j包

  1. package com.darren.test.xml;
  2.  
  3. import java.io.File;
  4. import java.io.FileWriter;
  5. import java.io.Writer;
  6. import java.util.Iterator;
  7.  
  8. import org.dom4j.Document;
  9. import org.dom4j.DocumentHelper;
  10. import org.dom4j.Element;
  11. import org.dom4j.io.SAXReader;
  12. import org.dom4j.io.XMLWriter;
  13.  
  14. public class Dom4jParse implements XmlParse {
  15.  
  16. @Override
  17. public void createXml(String path) {
  18. try {
  19. Document document = DocumentHelper.createDocument();
  20. Element employees = document.addElement("employees");
  21. Element employee = employees.addElement("employee");
  22. Element name = employee.addElement("name");
  23. name.setText("Darren");
  24. Element sex = employee.addElement("sex");
  25. sex.setText("man");
  26. Element age = employee.addElement("age");
  27. age.setText("25");
  28. Writer fileWriter = new FileWriter(path);
  29. XMLWriter xmlWriter = new XMLWriter(fileWriter);
  30. xmlWriter.write(document);
  31. xmlWriter.close();
  32. } catch (Exception e) {
  33. e.printStackTrace();
  34. }
  35.  
  36. }
  37.  
  38. @Override
  39. @SuppressWarnings("unchecked")
  40. public void parseXml(String path) {
  41. try {
  42. File inputXml = new File(path);
  43. SAXReader saxReader = new SAXReader();
  44.  
  45. Document document = saxReader.read(inputXml);
  46. Element employees = document.getRootElement();
  47. Iterator<Element> employeeElements = employees.elementIterator();
  48. while (employeeElements.hasNext()) {
  49. Element employee = (Element) employeeElements.next();
  50.  
  51. Iterator<Element> nodeElements = employee.elementIterator();
  52. while (nodeElements.hasNext()) {
  53. Element node = (Element) nodeElements.next();
  54. System.out.println(node.getName() + ":" + node.getText());
  55. }
  56. }
  57. } catch (Exception e) {
  58. e.printStackTrace();
  59. }
  60.  
  61. }
  62.  
  63. }
打印结果:
  1. name:Darren
  2. sex:man
  3. age:25

4、JDOM生成和解析XML

为减少DOM、SAX的编码量,出现了JDOM;

优点:20-80原则,极大减少了代码量。使用场合:要实现的功能简单,如解析、创建等,但在底层,JDOM还是使用SAX(最常用)、DOM、Xanan文档
需要引入jdom包

  1. package com.darren.test.xml;
  2.  
  3. import java.io.FileOutputStream;
  4. import java.util.List;
  5.  
  6. import org.jdom.Document;
  7. import org.jdom.Element;
  8. import org.jdom.input.SAXBuilder;
  9. import org.jdom.output.XMLOutputter;
  10.  
  11. public class JDomParse implements XmlParse {
  12.  
  13. @Override
  14. public void createXml(String path) {
  15. try {
  16. Element root = new Element("employees");
  17. Document document = new Document(root);
  18. Element employee = new Element("employee");
  19. root.addContent(employee);
  20. Element name = new Element("name");
  21. name.setText("Darren");
  22. employee.addContent(name);
  23. Element sex = new Element("sex");
  24. sex.setText("man");
  25. employee.addContent(sex);
  26. Element age = new Element("age");
  27. age.setText("25");
  28. employee.addContent(age);
  29. XMLOutputter XMLOut = new XMLOutputter();
  30. XMLOut.output(document,new FileOutputStream(path));
  31. } catch (Exception e) {
  32. e.printStackTrace();
  33. }
  34.  
  35. }
  36.  
  37. @Override
  38. @SuppressWarnings("unchecked")
  39. public void parseXml(String path) {
  40. try {
  41. SAXBuilder builder = new SAXBuilder(false);
  42. Document document = builder.build(path);
  43. Element root = document.getRootElement();
  44. List<Element> employeeList = root.getChildren("employee");
  45. for (Element employee : employeeList) {
  46. List<Element> employeeInfo = employee.getChildren();
  47. for (Element info : employeeInfo) {
  48. System.out.println(info.getName() + ":" + info.getValue());
  49. }
  50. }
  51. } catch (Exception e) {
  52. e.printStackTrace();
  53. }
  54.  
  55. }
  56. }
打印结果:
  1. name:Darren
  2. sex:man
  3. age:25
测试类:
  1. package com.darren.test.xml;
  2.  
  3. public class XmlParseTest {
  4.  
  5. public static void main(String[] args) {
  6. // DomParse domParse = new DomParse();
  7. // domParse.createXml("F:\\employee.xml");
  8. // domParse.parseXml("F:\\employee.xml");
  9.  
  10. // SaxParse saxParse = new SaxParse();
  11. // saxParse.createXml("F:\\employee.xml");
  12. // saxParse.parseXml("F:\\employee.xml");
  13.  
  14. // Dom4jParse dom4jParse = new Dom4jParse();
  15. // dom4jParse.createXml("F:\\employee.xml");
  16. // dom4jParse.parseXml("F:\\employee.xml");
  17.  
  18. JDomParse jdomParse = new JDomParse();
  19. jdomParse.createXml("F:\\employee.xml");
  20. jdomParse.parseXml("F:\\employee.xml");
  21. }
  22.  
  23. }

猜你在找的XML相关文章