XML 解析（一） 原始的DOM和SAX解析（用于理解解析原理）

我们今天的话题是XML的解析。现在做项目很多时候用到框架，就算不用到SSH这些通用框架，每个公司基本上也会用到自己的一些框架技术。而说到框架技术，很重要的一点就是可配置。而XML的使用则是实现可配置的重要条件。我们的配置文件无非是properties和xml，但是因为properties支持的仅仅是键值对的方式，不利于复杂的表述和扩展。所以很多框架上还是提倡使用XML来实现配置。闲话过后，让我们来看看方便的几种XML解析方式。

[b][color=red]在进入正题之前，首先提醒各位看客，这两种解析方式并不是最方便的解析方式，只是两种标准的XML解析的代码，用到的自然是JDK里面的方法，还有很多已经很完善的开源包支持更方便快捷效率快的XML解析方式，只想使用而不想深究原理的请跳过。[/color][/b]

讲到XML解析之前，让我们先了解一下XML的一些基本概念。XML现在已经成为一种通用的数据交换格式,它的[color=red][b]平台无关性,语言无关性,系统无关性,[/b][/color]给数据集成与交互带来了极大的方便。XML在不同的语言里解析方式都是一样的,只不过实现的语法不同而已。基本的解析方式有两种,一种叫[color=red][b]SAX[/b][/color]，另一种叫[color=red][b]DOM[/b][/color]。SAX是基于[color=red][b]事件流[/b][/color]的解析,DOM是基于[b][color=red]XML文档树结构[/color][/b]的解析。

今天我们需要解析到的XML文件的结构如下：
[quote]<?xml version="1.0" encoding="UTF-8"?>
<employees>
<employee>
<name>tangsir</name>
<sex>m</sex>
<age>31</age>
</employee>
<employee>
<name>jianqiangsir</name>
<sex>fm</sex>
<age>30</age>
</employee>
</employees>
[/quote]

因为我们要用到各种不同的解析方式来解析以上的XML文件，或者我们也可能讲讲用这些方法来创建一个XML结构的文件，所以我们就写一个java接口XMLExecutor，让所有实际解析XML的类实现该接口。接口代码如下：

public interface XMLExecutor {
	//该方法用于创建一个XML到指定文件路径上
	public void createXML(String fileName);
	//该方法用于解析指定文件路径下的XML文件
	public void parseXML(String fileName);
}

[b]1. 使用DOM解析以上XML文件方法：[/b]

public class ExecuteXMLwithDOM implements XMLExecutor {

	private Document document;
	private String fileName;

	// 使用init()方法获取document对象，用于之后的创建XML节点树。
	public void init() {
		try {
			DocumentBuilderFactory factory = DocumentBuilderFactory
					.newInstance();
			DocumentBuilder builder = factory.newDocumentBuilder();
			this.document = builder.newDocument();
		} catch (ParserConfigurationException e) {
			System.out.println(e.getMessage());
		}
	}

	public void createXML(String fileName) {
		// 利用document对象创建一个叫“employees”的根节点
		Element root = this.document.createElement("employees");
		// 将“employees”作为文档树的根节点
		this.document.appendChild(root);

		// 创建“employee”节点
		Element employee = this.document.createElement("employee");
		// 创建name节点，并为该节点添加Text内容“tangsir”
		Element name = this.document.createElement("name");
		name.appendChild(this.document.createTextNode("tangsir"));
		// 为“employee”节点中加入name节点
		employee.appendChild(name);
		// 同加入name节点一样的加入sex节点和age节点
		Element sex = this.document.createElement("sex");
		sex.appendChild(this.document.createTextNode("m"));
		employee.appendChild(sex);

		Element age = this.document.createElement("age");
		age.appendChild(this.document.createTextNode("31"));
		employee.appendChild(age);
		// 将employee节点加入到"employees"节点下
		root.appendChild(employee);

		// 相同方法创建和添加另一个"employee"节点到根节点下
		Element employee2 = this.document.createElement("employee");
		Element name2 = this.document.createElement("name");
		name2.appendChild(this.document.createTextNode("jianqiangsir"));
		employee2.appendChild(name2);

		Element sex2 = this.document.createElement("sex");
		sex2.appendChild(this.document.createTextNode("fm"));
		employee2.appendChild(sex2);

		Element age2 = this.document.createElement("age");
		age2.appendChild(this.document.createTextNode("30"));
		employee2.appendChild(age2);

		root.appendChild(employee2);

		// 我们的文档树在上面已经构建完成，以下代码是将文档树写入到XML文件中的过程。
		// 利用transformer对象将DOMSource转换为StreamResult的过程。
		TransformerFactory tf = TransformerFactory.newInstance();
		try {
			Transformer transformer = tf.newTransformer();
			// 通过Node(document)获得DOMSource
			DOMSource source = new DOMSource(document);
			// 设置transformer对象的输出参数
			transformer.setOutputProperty(OutputKeys.ENCODING, "utf-8");
			transformer.setOutputProperty(OutputKeys.INDENT, "yes");
			// 通过文件输出流获得文件打印流并用StreamResult封装打印流。
			PrintWriter pw = new PrintWriter(new FileOutputStream(fileName));
			StreamResult result = new StreamResult(pw);
			// 使用transformer对象将DOMSource转换为StreamResult
			transformer.transform(source, result);
			System.out.println("生成XML文件成功!");
		} catch (TransformerConfigurationException e) {
			System.out.println(e.getMessage());
		} catch (IllegalArgumentException e) {
			System.out.println(e.getMessage());
		} catch (FileNotFoundException e) {
			System.out.println(e.getMessage());
		} catch (TransformerException e) {
			System.out.println(e.getMessage());
		}
	}

	public void parseXML(String fileName) {
		try {
			// 通过DocumentBuilderFactory获取DocumentBuilder
			DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
			DocumentBuilder db = dbf.newDocumentBuilder();
			// 使用DocumentBuilder解析fileName的XML文件成Document节点。
			Document document = db.parse(fileName);
			//Document节点获取employees的NodeList(这里我们已知employees是根节点，所以使用他获得子节点列表)
			NodeList employees = document.getChildNodes();
			//遍历获得的employees子节点列表
			for (int i = 0; i < employees.getLength(); i++) {
				Node employee = employees.item(i);
				//从获得的子节点继续获得该节点的子节点列表
				NodeList employeeInfo = employee.getChildNodes();
				//遍历获得的employee子节点列表
				for (int j = 0; j < employeeInfo.getLength(); j++) {
					Node node = employeeInfo.item(j);
					//继续从获得的子节点获得他的子节点，并遍历子节点列表。
					NodeList employeeMeta = node.getChildNodes();
					for (int k = 0; k < employeeMeta.getLength(); k++) {
						//打印出每个item的名字和内容。(这里我们已知该节点下没有子节点了。)
						System.out.println(employeeMeta.item(k).getNodeName()
								+ ":" + employeeMeta.item(k).getTextContent());
					}
				}
			}
			System.out.println("解析完毕");
		} catch (FileNotFoundException e) {
			System.out.println(e.getMessage());
		} catch (ParserConfigurationException e) {
			System.out.println(e.getMessage());
		} catch (SAXException e) {
			System.out.println(e.getMessage());
		} catch (IOException e) {
			System.out.println(e.getMessage());
		}
	}
}

以上code中init()方法是为了获取一个空的Document节点，为创建一个XML文档树做准备，在创建XML文件的方法createXML()里面，我们首先shiyon个文档树Document来制作了我们需要的XML的主要内容（包括格式）。接下来，用Transformer将DOMSource转换成了输出的StreamResult。作者在此也不甚了解这一步的一一，不知道Transformer，DOMSource和StreamResult的用途和为何要这样转换，希望知道的大鸟能够指导一下。

相比之下，解析XML的方法parseXML()反而更简单明了。获取一个DocumentBuilder对象，利用DocumentBuilder对象的parse(fileName)方法，将要解析的XML文件全路径放入，就获取了该XML的一个Document对象。这下就getChildNodes()然后遍历继续getChildNodes()直到我们发现没有Child了，我们就.item(i).getNodeName()，.item(i).getTextContent()获得XML节点名称和节点内容就行了。

DOM解析XML的方式，是为XML文档的已解析版本定义了一组接口。解析器读入整个文档，然后构建一个驻留内存的树结构，然后代码就可以使用 DOM 接口来操作这个树结构。[b]优点：[/b]整个文档树在内存中，便于操作；支持删除、修改、重新排列等多种功能；[b]缺点：[/b]将整个文档调入内存（包括无用的节点），浪费时间和空间；使用场合：一旦解析了文档还需多次访问这些数据；硬件资源充足（内存、CPU）。

[b]2. 使用SAX解析以上XML文件方法：[/b]

首先我们来写一个自己的SAXHandler来继承SAX的DefaultHandler，在方法里面，我们重写了父类的几个方法，实现了我们自己对XML解析的要求。

public class MySAXHandler extends DefaultHandler {

	boolean hasAttribute = false;
	Attributes attributes = null;

	//在开始解析之前做的事情可以写在该方法内
	@Override
	public void startDocument() throws SAXException {
		System.out.println("文档开始打印了");
	}
	//在解析完毕之后做的事情可以写在该方法内
	@Override
	public void endDocument() throws SAXException {
		System.out.println("文档打印结束了");
	}
	@Override
	public void startElement(String uri, String localName, String qName,
	Attributes attributes) throws SAXException {

		if (qName.equals("employees")) {
			return;
		}
		if (qName.equals("employee")) {
			System.out.println(qName);
		}

		if (attributes.getLength() > 0) {
			this.attributes = attributes;
			this.hasAttribute = true;
		}
	}
	@Override
	public void endElement(String uri, String localName, String qName)
	throws SAXException {

		if (hasAttribute && (attributes != null)) {
			for (int i = 0; i < attributes.getLength(); i++) {
				System.out.println(attributes.getQName(0)
						+ attributes.getValue(0));
			}
		}
	}
	@Override
	public void characters(char[] ch, int start, int length)
	throws SAXException {
		System.out.println(new String(ch, start, length));
	}
}

接下来就是我们SAX解析的真正方法了，该方法使用到了我们自定义的MySAXHandler来对XML对象进行解析。

public class ExecuteXMLwithSAX implements XMLExecutor {

	public void createXML(String fileName) {
		//SAX不做createXML
	}

	public void parseXML(String fileName) {
		SAXParserFactory saxfac = SAXParserFactory.newInstance();
		try {
			SAXParser saxparser = saxfac.newSAXParser();
			InputStream is = new FileInputStream(fileName);
			saxparser.parse(is, new MySAXHandler());
		} catch (ParserConfigurationException e) {
			e.printStackTrace();
		} catch (SAXException e) {
			e.printStackTrace();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

SAX解析XML的处理思路是：
1: 创建SAXParserFactory对象
2: 根据SAXParserFactory.newSAXParser()方法返回一个SAXParser解析器
3: 获取需要parse的XML文件的InputStream对象
4: 实例化一个DefaultHandler对象或自定义Handler对象
5: 用saxparser连接获取到的InputSream对象到事件处理类DefaultHandler中进行XML解析。

为解决DOM的问题，SAX才出现的。SAX基于事件驱动。当解析器发现元素开始、元素结束、文本、文档的开始或结束等时，发送事件，程序员编写响应这些事件的代码，保存数据。[b]优点：[/b]不用事先调入整个文档，占用资源少；SAX解析器代码比DOM解析器代码小。[b]缺点：[/b]不是持久的；事件过后，若没保存数据，那么数据就丢了；无状态性；从事件中只能得到文本，但不知该文本属于哪个元素；使用场合：Applet;只需XML文档的少量内容，很少回头访问；机器内存少；

最后我们贴出测试代码，供大家参考，使用DOM解析XML我们首先还是用DOM创建了一个XML在C盘上。然后再解析的。使用SAX我们只用来解析。还有一种获得SaxReader的解析方式我也一并写在了测试代码里面。

	public static void main(String[] args) {
		//使用DOM方式解析XML测试代码
//		ExecuteXMLwithDOM exd = new ExecuteXMLwithDOM();
//		exd.init();
//		exd.createXML("C:\\temp.xml");
//		exd.parseXML("C:\\temp.xml");

		//使用SAX解析XML测试代码
//		ExecuteXMLwithSAX exs = new ExecuteXMLwithSAX();
//		exs.parseXML("C:\\temp.xml");

		//SAX解析的另一种方式
		SAXParserFactory saxfac = SAXParserFactory.newInstance();
		try {
			SAXParser saxparser = saxfac.newSAXParser();
			XMLReader reader = saxparser.getXMLReader();
			reader.setContentHandler(new MySAXHandler());
			InputStream is = new FileInputStream("C:\\temp.xml");
			InputSource source = new InputSource(is);
			reader.parse(source);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}