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");
}
}