JAVA_PARSEXML_DEMO

DOM解析：

package com.parsexml;

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

import org.w3c.dom.Document;
import org.w3c.dom.NodeList;

/**
 * 可读写
 * 解析器读入整个文档，然后构建一个驻留内存的树结构，然后代码就可以使用 DOM 接口来操作这个树结构
 * 可以在任何时候在树中上下导航
 * 
 * @优点：整个文档树在内存中，便于操作；支持删除、修改、重新排列等多种功能
 * @缺点：将整个文档调入内存（包括无用的节点），浪费时间和空间
 * @使用场合：需要修改XML文档。一旦解析了文档还需多次访问这些数据；硬件资源充足（内存、CPU）。 
 * 
 * @notice DOM解析时会将所有回车都视为 节点的子节点
 * @author lj.tang
 *
 */
public class TestDOM {
	/*<?xml version="1.0" encoding="ISO-8859-1"?>
	<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
	    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
	    version="2.4">

	    <servlet>
	        <servlet-name>
	        	test ---- 文字节点
	        </servlet-name>
	        <servlet-class>cn.com.tnjun.test.TestServlet</servlet-class>
	    </servlet>
	    

	    <servlet-mapping>
	        <servlet-name>test</servlet-name>
	        <url-pattern>/testTT</url-pattern>
	    </servlet-mapping>
	    

	</web-app>*/
	public void parseXmlForDom() {
		// 实例化一个文档构建器工厂
		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		try {
			// 通过文档构建器工厂获取一个文档构建器
			DocumentBuilder builder = factory.newDocumentBuilder();
			// 通过文档通过文档构建器构建一个文档实例
			Document doc = builder.parse(TestDOM.class.getResource("parsexml.xml").toString());
			// 获取所有名为 “servlet” 的节点
			NodeList nls = doc.getElementsByTagName("servlet");
			// 获取所有名为 “servlet-mapping” 的节点
			NodeList nlMaps = doc.getElementsByTagName("servlet-mapping");
			
			for (int i = 0; i < nls.getLength(); i++) {
				// cnServlets.getLength() = 5
				NodeList cnServlets = nls.item(i).getChildNodes();
				for (int j = 0; j < cnServlets.getLength(); j++) {
					if(cnServlets.item(j).hasChildNodes()){// 证明是否是回车
						System.out.println(cnServlets.item(j).getNodeName() + " = " + cnServlets.item(j).getFirstChild().getNodeValue());
					}
				}
				for (int j = 0; j < nlMaps.getLength(); j++) {
					// cnMaps.getLength() = 5
					NodeList cnMaps = nlMaps.item(j).getChildNodes();
					for (int m = 0; m < cnMaps.getLength(); m++) {
						if(cnMaps.item(m).hasChildNodes()){// 证明是否是回车
							// cnMaps.item(m).getFirstChild().getNodeValue()
							System.out.println(cnMaps.item(m).getNodeName() + " = " + cnMaps.item(m).getFirstChild().getNodeValue());
						}
					}
				}
			}
		}catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		TestDOM test = new TestDOM();
		test.parseXmlForDom();
	}
}

SAX解析：

package com.parsexml;

import java.io.File;
import java.io.IOException;

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

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

/**
 * 事件驱动。当解析器发现元素开始、元素结束、文本、文档的开始或结束等时，发送事件，程序员编写响应这些事件的代码，保存数据
 * @优点：不用事先调入整个文档，占用资源少；SAX解析器代码比DOM解析器代码小，适于Applet，下载
 * @缺点：不是持久的；事件过后，若没保存数据，那么数据就丢了；无状态性；从事件中只能得到文本，但不知该文本属于哪个元素,不能够随机访问XML文档 
 * @使用场合：Applet;只需XML文档的少量内容，很少回头访问；机器内存少。只从XML读取数据的应用程（不用于操作或修改XML文档）
 * @author lj.tang
 *
 */
public class TestSAX extends DefaultHandler {
	
	@Override
	public void startDocument() throws SAXException {
		System.out.println("xml解析开始....");
		System.out.println("------------------");
		System.out.println("<?xml version=\"1.0\" encoding=\"GBK\">");
	}

	@Override
	public void endDocument() throws SAXException {
		System.out.println("\n------------------");
		System.out.println("xml解析结束....");
	}

	@Override
	public void startElement(String uri, String localName, String qName,
			Attributes attributes) throws SAXException {
		System.out.print("<");
		System.out.print(qName);
		if(attributes != null){
			for (int i = 0; i < attributes.getLength(); i++) {
				System.out.println(" " + attributes.getQName(i) + "=" + attributes.getValue(i));
			}
		}
		System.out.print(">");
	}

	@Override
	public void endElement(String uri, String localName, String qName)
			throws SAXException {
		System.out.print("</");
		System.out.print(qName);
		System.out.print(">");
	}
	
	@Override
	public void characters(char[] ch, int start, int length)
			throws SAXException {
		System.out.print(new String(ch,start,length));
	}

	public static void main(String[] args) {
		SAXParserFactory saxFactory = SAXParserFactory.newInstance();
		try {
			SAXParser parse = saxFactory.newSAXParser();
			parse.parse(new File("src/com/parsexml/parsexml.xml"), new TestSAX());
		} catch (ParserConfigurationException e) {
			e.printStackTrace();
		} catch (SAXException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

JDOM：

package com.parsexml;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;

/**
 * 为减少DOM、SAX的编码量，出现了JDOM。是基于树的处理XML的Java API，把树加载在内存中
 * @优点：20-80原则，极大减少了代码量
 * @使用场合：JDOM具有树的便利，也有SAX的JAVA规则。在需要平衡时使用
 * 在底层，JDOM还是使用SAX（最常用）、DOM、Xanan文档。
 * @author lj.tang 
 *
 */
public class TestJdom {
	@SuppressWarnings("unchecked")
	public static void main(String[] args) {
		Map<String,String> map = new HashMap<String,String>();
		List<Element> list = null;
		List<Element> lists = null;
		// 创建一个解析对象
		SAXBuilder sb = new SAXBuilder();
		try {
			// 从提供的文件名构造一个文件对象
			Document doc = sb.build(new File("src/com/parsexml/parsexml.xml"));
			// 获取根节点对象
			Element root = doc.getRootElement();
			root = doc.getRootElement();
			//根据XML文档结构，解析出根节点下的所有符合要求的节点的集合
			list = root.getChildren("servlet-mapping",root.getNamespace());
			lists = root.getChildren("servlet",root.getNamespace());
			//循环遍历，找出对应的信息，放入Map中
			for(Element sm:list){
				Element sn = sm.getChild("servlet-name",root.getNamespace());
				Element up = sm.getChild("url-pattern",root.getNamespace());
				//循环遍历获得根节点下另一子节点下的元素的子节点信息并对比，符合条件则存入Map
				for(Element s:lists){
					Element snO = s.getChild("servlet-name",root.getNamespace());
					Element scO = s.getChild("servlet-class",root.getNamespace());
					if(sn.getText().equals(snO.getText())) {
						map.put(up.getText(), scO.getText());
						break;
					}
				}
			}
			System.out.println(map.size());
		} catch (JDOMException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

DOM4J解析：

package com.parsexml;

import java.io.File;
import java.util.Iterator;

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

/**
 * 性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件
 * 
 * @author lj.tang
 * 
 */
public class TestDom4j {
	public static void main(String[] args) {
		String filePath = "src/com/parsexml/parsexml.xml";
		parserXml(filePath);
	}

	public static void parserXml(String fileName) {
		File inputXml = new File(fileName);
		SAXReader saxReader = new SAXReader();
		try {
			Document document = saxReader.read(inputXml);
			Element elements = document.getRootElement();
			for (Iterator iterator1 = elements.elementIterator(); iterator1.hasNext();) {
				Element element = (Element) iterator1.next();
				for (Iterator iterator2 = element.elementIterator(); iterator2.hasNext();) {
					Element node = (Element) iterator2.next();
					System.out.println(node.getName() + ":" + node.getText());
				}

			}
		} catch (DocumentException e) {
			e.printStackTrace();
		}
		System.out.println("finish....");
	}
}