java解析XML的四种方法的学习与比较

 

四种XML解析方法：

   (1)Dom生成和解析XML文档

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

   (2)SAX生成和解析XML文档

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

   (3)DOM4J生成和解析XML文档

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

   (4)JDOM生成和解析XML

       *为减少DOM、SAX的编码量，出现了JDOM；
     *优点：20-80原则，极大减少了代码量。
     *使用场合：要实现的功能简单，如解析、创建等，
     *但在底层，JDOM还是使用SAX（最常用）、DOM、Xanan文档。

 

 

首先编写一个要解析的test.xml文件

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<employees>
<employee>
<name>wxyfree</name>
<age>30</age>
</employee>
<employee>
<name>freewxy</name>
<age>22</age>
</employee>
</employees>

 

然后，编写一个XMLDocument接口

/**
 * 定义XML文档建立与解析的接口
 * @author wxy
 *
 */
public interface XMLDocument {
	/**
	 *建立XML文档 
	 * @param fileName 文件全路径名
	 */
	public void createXML(String fileName);
	/**
	 * 解析XML文档
	 * @param fileName 文件全路径名
	 */
	public void parseXML(String fileName);
}

 

一、

package review.testXML;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;


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;



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

	private Document document;
	private String fileName;
	
	public void init(){
		try{
			DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
			DocumentBuilder builder=factory.newDocumentBuilder();
			this.document=builder.newDocument();
		}catch(ParserConfigurationException e){
			System.out.println(e.getMessage());
		}
	}
	@Override
	public void createXML(String fileName) {
		Element root=this.document.createElement("employees");//创建根元素
		this.document.appendChild(root);
		Element employee=this.document.createElement("employee");//创建子元素
        Element name=this.document.createElement("name");//添加元素的属性
        name.appendChild(this.document.createTextNode("wxyfree"));
        employee.appendChild(name);//将元素添加到子元素中
        Element sex=this.document.createElement("sex");
        sex.appendChild(this.document.createTextNode("m"));
        Element age=this.document.createElement("age");
        age.appendChild(this.document.createTextNode("30"));
        employee.appendChild(age);
        root.appendChild(employee);//将子元素添加到根元素中
        TransformerFactory tf=TransformerFactory.newInstance();//此抽象类的实例能够将源树转为结果树
        try{
        	Transformer transformer=tf.newTransformer();
        	DOMSource source=new DOMSource(document);//创建带有DOM节点的新输入源
        	transformer.setOutputProperty(OutputKeys.ENCODING,"UTF-8");//设置转换中世纪的输出属性
        	transformer.setOutputProperty(OutputKeys.INDENT, "yes");//
        	PrintWriter pw=new PrintWriter(new FileOutputStream(fileName));
        	StreamResult result=new StreamResult(pw);//充当转换结果的持有者，可以为xml、纯文本、HTML或某些其他格式的标记
        	transformer.transform(source, result);//将XML Source转换为Result
        	System.out.println("生成XML文件成功");
        }catch(TransformerConfigurationException e){
        	System.out.println(e.getMessage());
        } catch (TransformerException e) {
        	System.out.println(e.getMessage());
		} catch (FileNotFoundException e) {
			System.out.println(e.getMessage());
		}
	}

	@Override
	public void parseXML(String fileName) {
		DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
		DocumentBuilder db;
		try {
			db = dbf.newDocumentBuilder();
			Document document = db.parse(fileName);
			NodeList employees=document.getChildNodes();
			for(int i=0;i<employees.getLength();i++){
				Node employee=employees.item(i);
				NodeList employeeInfo=employee.getChildNodes();
				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++){
						System.out.println(employeeMeta.item(k).getNodeName()+":"+employeeMeta.item(k).getTextContent());
					}
				}
			}
		} catch (ParserConfigurationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SAXException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("解析完毕");
	}

	public static void main(String[] args){
		DomDemo d=new DomDemo();
		d.init();
		d.createXML("conf/test2.xml");
		d.parseXML("conf/test.xml");

	}

}

 

 

二、

package review.testXML;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

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

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

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

	@Override
	public void createXML(String fileName) {
		System.out.println("<<"+fileName+">>");
		
	}

	@Override
	public void parseXML(String fileName) {
		SAXParserFactory saxfac=SAXParserFactory.newInstance();
	    try {
			SAXParser saxParser=saxfac.newSAXParser();
			InputStream ins=new FileInputStream(fileName);
			saxParser.parse(ins,new MySAXHandler());
		} catch (ParserConfigurationException e) {
			System.out.println(e.getMessage());
		} catch (SAXException e) {
			System.out.println(e.getMessage());
		} catch (FileNotFoundException e) {
			System.out.println(e.getMessage());
		} catch (IOException e) {
			System.out.println(e.getMessage());
		}
	    
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
	 SaxDemo s=new SaxDemo();
	 s.parseXML("conf/test.xml");
	}
}
class MySAXHandler extends DefaultHandler{
	boolean hasAttribute=false;
	Attributes attributes=null;
	
	/**
	 *  Receive notification of the beginning of the document.
	 */
	public void startDocument()throws SAXException{
		System.out.print("文档开始打印了");
	}
	/**
	 * Receive notification of the end of the document.
	 */
	public void endDocument()throws SAXException{
		System.out.print("文档开始结束了"); 
	}
	 /**
     * Receive notification of the start of an element.
     * @param uri The Namespace URI, or the empty string if the
     *        element has no Namespace URI or if Namespace
     *        processing is not being performed.
     * @param localName The local name (without prefix), or the
     *        empty string if Namespace processing is not being
     *        performed.
     * @param qName The qualified name (with prefix), or the
     *        empty string if qualified names are not available.
     * @param attributes The attributes attached to the element.  If
     *        there are no attributes, it shall be an empty
     *        Attributes object.
     * @exception org.xml.sax.SAXException Any SAX exception, possibly
     *            wrapping another exception.
     */
	public void startElement(String uri,String localName,String qName,Attributes attributes)throws SAXException{
		if(qName.equals("employees")){return;}
		if(qName.equals("employee")){
			System.out.print(qName);
		}
		if(attributes.getLength()>0){
			this.attributes=attributes;
			this.hasAttribute=true;
		}
	}
	/**
     * Receive notification of the end of an element.
     * @param uri The Namespace URI, or the empty string if the
     *        element has no Namespace URI or if Namespace
     *        processing is not being performed.
     * @param localName The local name (without prefix), or the
     *        empty string if Namespace processing is not being
     *        performed.
     * @param qName The qualified name (with prefix), or the
     *        empty string if qualified names are not available.
     * @exception org.xml.sax.SAXException Any SAX exception, possibly
     *            wrapping another exception.
     */
	public void endElement(String uri,String localName,String qNaqme)throws SAXException{
		if(hasAttribute&&(attributes!=null)){
			for(int i=0;i<attributes.getLength();i++){
				System.out.print(attributes.getQName(0)+attributes.getValue(0));
			}
		}
	}
    /**
     * Receive notification of character data inside an element.
     * @param ch The characters.
     * @param start The start position in the character array.
     * @param length The number of characters to use from the
     *               character array.
     */
	public void characters(char[] ch,int start,int length)throws SAXException{
		System.out.print(new String(ch,start,length));
	}
}

 

三、

package review.testXML;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.Iterator;

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

/**
 *  Dom4j 生成XML文档与解析XML文档
 * DOM4J 是一个非常非常优秀的Java XML API，
 * 具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。
 * 如今你可以看到越来越多的 Java 软件都在使用 DOM4J 来读写 XML，特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J。 
 * @author wxy
 *
 */
public class Dom4jDemo implements XMLDocument{

	@Override
	public void createXML(String fileName) {
		Document document = DocumentHelper.createDocument();
		Element employees=document.addElement("employees");
		Element employee=document.addElement("employee");
		Element name=employee.addElement("name");
		name.setText("wxy");
		Element sex=employee.addElement("sex");
		name.setText("f");
		Element age=employee.addElement("age");
		name.setText("29");
		try {
			Writer fileWriter=new FileWriter(fileName);
            XMLWriter xmlWriter=new XMLWriter(fileWriter);
            xmlWriter.write(document);
            xmlWriter.close();
		} catch (IOException e) {
			System.out.println(e.getMessage());
		}
	}

	@Override
	public void parseXML(String fileName) {
		File inputXML=new File(fileName);
		SAXReader saxReader=new SAXReader();
		try {
			Document document=saxReader.read(inputXML);
			Element employees=document.getRootElement();
			for(Iterator i=employees.elementIterator();i.hasNext();){
				Element employee=(Element)i.next();
				for(Iterator j=employee.elementIterator();j.hasNext();){
					Element node=(Element)j.next();
					System.out.println(node.getName()+":"+node.getText());	
				}
			}
		} catch (DocumentException e) {
			System.out.println(e.getMessage());
		}
		System.out.println("dom4j parserXML");
	}

	
	public static void main(String[] args) {
		Dom4jDemo d=new Dom4jDemo();
		d.parseXML("conf/test.xml");
	}

}

 

 

四、

package review.testXML;


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

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


/**
 * JDOM生成和解析XML   
 *为减少DOM、SAX的编码量，出现了JDOM；
 *优点：20-80原则，极大减少了代码量。
 *使用场合：要实现的功能简单，如解析、创建等，
 *但在底层，JDOM还是使用SAX（最常用）、DOM、Xanan文档。 
 * @author wxy
 *
 */
public class JDomDemo implements XMLDocument{
	

	@Override
	public void createXML(String fileName) {
		Document document;
		Element root;
		root=new Element("employees");
		document=new Document(root);
		Element employee=new Element("employee");
		root.addContent(employee);
		Element name=new Element("name");
		name.setText("wxywxy");
		employee.addContent(name);
		Element sex=new Element("sex");
		sex.setText("m");
		employee.addContent(sex);
		Element age=new Element("age");
		age.setText("25");
		employee.addContent(age);
		XMLOutputter XMLOut=new XMLOutputter();
		try {
			XMLOut.output(document, new FileOutputStream(fileName));
		} catch (FileNotFoundException e) {
			System.out.println(e.getMessage());
		} catch (IOException e) {
			System.out.println(e.getMessage());
		}
	}

	@Override
	public void parseXML(String fileName) {
		SAXBuilder builder=new SAXBuilder(false);
		try {
			Document document=builder.build(fileName);
			Element employees=document.getRootElement();
			List employeeList=employees.getChildren("employee");
			for(int i=0;i<employeeList.size();i++){
				Element employee=(Element)employeeList.get(i);
			    List employeeInfo=employee.getChildren();
			    for(int j=0;j<employeeInfo.size();j++){
			    	System.out.println(((Element)employeeInfo.get(j)).getName()+":"+((Element)employeeInfo.get(j)).getText());
			    }
			}
		} catch (JDOMException e) {
			System.out.println(e.getMessage());
		} catch (IOException e) {
			System.out.println(e.getMessage());
		}
	}

	
	public static void main(String[] args){
		JDomDemo jd=new JDomDemo();
		jd.parseXML("conf/test.xml");
	}
}