慕课学习笔记之DOM,SAX,JDOM,DOM4J解析XML文件

DOM,SAX,JDOM,DOM4J四种解析XML文件的方式，下面将使用这四种方式一一实践。

1.准备工作

自己先写一个test.xml,内容如下：

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
</dependencies>

2.下面开始解析

2.1  DOM解析

DOM是平台无关的官方解析方式，它一次性将整个XML文件读入内存，形成DOM树。优点：解析过程中树结构驻留内存，修改方便。缺点：XML较大时，消耗内存，影响性能，也可能导致内存溢出。  

注：import org.w3c.dom.Document;

以下是DomTest.java代码部分(节点属性并未解析，方法类似，不再赘述)：

package com.company.domTest;

import java.io.IOException;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class DomTest {
	public static void main(String[] args) {
		//实例化一个DocumentBuilderFactory对象
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		DocumentBuilder docBuilder;
		Document docment;
		try {
			//通过DocumentBuilderFactory实例获得DocumentBuilder实例
			docBuilder = dbf.newDocumentBuilder();
			//传入xml进行解析
			docment = docBuilder.parse("test.xml");
			NodeList dependencyList = docment.getElementsByTagName("dependency");
			for(int i=0;i<dependencyList.getLength();i++){
				Node dependency = dependencyList.item(i);
				System.out.println("属性名为:" + dependency.getNodeName());
				System.out.println();
				NodeList childList = dependency.getChildNodes();
				for(int j=0;j<childList.getLength();j++){
					if(childList.item(j).getNodeType()== Node.ELEMENT_NODE){
						System.out.println("    第"+(j+1)+"个子属性的名为:" + childList.item(j).getNodeName());
						System.out.println("    第"+(j+1)+"个子属性的值为:" + childList.item(j).getTextContent());
						System.out.println();
					}
				}
			}
		} catch (ParserConfigurationException e) {
			e.printStackTrace();
		} catch (SAXException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}
}

SAX是基于事件驱动的解析方式，平台自带，无需导包。它是一条语句一条语句进行判断。优点：消耗内存小，速度快。缺点：编码较其他方式比较困难，也较难同时访问不同位置的数据。需要自己写一个类来继承DefaultHandler类，重写其中一些必要方法：

TestHandler.java代码如下：

package com.company.saxTest;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class TestHandler extends DefaultHandler{

	@Override
	public void endDocument() throws SAXException {
//		System.out.println("SAX解析结束");
		super.endDocument();
	}

	@Override
	public void endElement(String uri, String localName, String qName)
			throws SAXException {
//		System.out.println(qName+"  element结束");
		super.endElement(uri, localName, qName);
	}

	@Override
	public void startDocument() throws SAXException {
//		System.out.println("SAX解析开始");
		super.startDocument();
	}

	@Override
	public void startElement(String uri, String localName, String qName,
			Attributes attributes) throws SAXException {
		super.startElement(uri, localName, qName, attributes);
		if(qName.equals("dependency")){
			System.out.println("节点名为："+ qName);
		}
		if(!qName.equals("dependency")&&!qName.equals("dependencies")){
			System.out.println("节点名："+qName);
		}
	}

	@Override
	public void characters(char[] ch, int start, int length)
			throws SAXException {
		super.characters(ch, start, length);
		String value = new String(ch,start,length);
		if(!value.trim().equals("")){
			System.out.println("value:" + value);
		}
	}
}

SaxTest.java代码如下:

package com.company.saxTest;

import java.io.IOException;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.SAXException;

public class SaxTest {

	public static void main(String[] args) {
		SAXParserFactory spf = SAXParserFactory.newInstance();
		try {
			SAXParser sp = spf.newSAXParser();
			sp.parse("test.xml",new TestHandler());
		} catch (ParserConfigurationException e) {
			e.printStackTrace();
		} catch (SAXException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}

JDOM解析主要是通过SAXBuilder的build()方法，得到一个Document对象，再通过该Document对象获取根节点，之后的遍历即根据根节点往下遍历。 它需要导入相应jar包，JdomTest.java代码如下：

 

package com.company.jdomtest;
import java.io.IOException;
import java.util.List;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;


public class JdomTest {
	public static void main(String[] args) {
		SAXBuilder sb = new SAXBuilder();
		try {
			Document document = sb.build("test.xml");
			Element rootElement = document.getRootElement();
			List<Element> elementList = rootElement.getChildren();
			for (Element element : elementList) {
				System.out.println();
				System.out.println(element.getName());
				List<Element> chileList = element.getChildren();
				for (Element child : chileList) {
					System.out.println("元素名:"+child.getName());
					System.out.println("元素值:"+child.getValue());
				}
			}
		} catch (JDOMException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

          

DOM4J解析则是通过SAXReader的read方法得到Document对象，再通过该Document对象获取根节点，之后便可依据该根节点进一步往下遍历。

Dom4JTest.java代码如下:

package com.company.dom4jtest;

import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

public class Dom4JTest {
	public static void main(String[] args) {
		SAXReader sr= new SAXReader();
		try {
			Document document = sr.read("test.xml");
			//获取根节点
			Element rootElement = document.getRootElement();
			List<Element> elementList = rootElement.elements();
			for (Element element : elementList) {
				System.out.println();
				System.out.println(element.getName());
				List<Element> childList = element.elements();
				for (Element element2 : childList) {
					System.out.print("元素名:"+element2.getName());
					System.out.println(" 元素值:"+element2.getText());
				}
			}
		} catch (DocumentException e) {
			e.printStackTrace();
		}
	}
}

四种方式性能比较

     1. DOM4J性能最好，连Sun的JAXM也在用DOM4J。目前许多开源项目中大量采用DOM4J，例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文件。如果不考虑可移植性，那就采用DOM4J.

     2. JDOM和DOM在性能测试时表现不佳，在测试10M文档时内存溢出，但可移植。在小文档情况下还值得考虑使用DOM和JDOM.虽然JDOM的开发者已经说明他们期望在正式发行版前专注性能问题，但是从性能观点来看，它确实没有值得推荐之处。另外，DOM仍是一个非常好的选择。DOM实现广泛应用于多种编程语言。它还是许多其它与XML相关的标准的基础，因为它正式获得W3C推荐（与基于非标准的Java模型相对），所以在某些类型的项目中可能也需要它（如在JavaScript中使用DOM）。

     3. SAX表现较好，这要依赖于它特定的解析方式－事件驱动。一个SAX检测即将到来的XML流，但并没有载入到内存（当然当XML流被读入时，会有部分文档暂时隐藏在内存中）。