Dom方式解析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文档。
首先定义了一个接口类
package com.java.xmlstudy;
/**
* 定义XML文档建立与解析的接口
* @author Administrator
*
*/
public interface IXMLDocument {
/**
*建立XML文档
* @param fileName 文件全路径名
*/
public void createXML(String fileName);
/**
* 解析XML文档
* @param fileName 文件全路径名
*/
public void parseXML(String fileName);
}
- 使用Dom方式生成和解析Xml
package com.java.xmlstudy.impl;
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;
import com.java.xmlstudy.IXMLDocument;
/**
* Dom生成和解析XML文档
* 为 XML 文档的已解析版本定义了一组接口。
* 解析器读入整个文档，然后构建一个驻留内存的树结构，然后代码就可以使用 DOM 接口来操作这个树结构。
* 优点：整个文档树在内存中，便于操作；支持删除、修改、重新排列等多种功能；
* 缺点：将整个文档调入内存（包括无用的节点），浪费时间和空间；
* 使用场合：一旦解析了文档还需多次访问这些数据；硬件资源充足（内存、CPU）。
* @param args
*/
public class DomDemo implements IXMLDocument {
private Document document;
private String fileName;
public void init(){
try{
//获得Dom解析工厂
DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
//获得Dom解析器
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("teachers");//创建根元素
this.document.appendChild(root);
Element employee=this.document.createElement("teacher");//创建子元素
Element name=this.document.createElement("name");//添加元素的属性
name.appendChild(this.document.createTextNode("Lisa"));
employee.appendChild(name);//将元素添加到子元素中
Element sex=this.document.createElement("sex");
sex.appendChild(this.document.createTextNode("Femail"));
employee.appendChild(sex);
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.STANDALONE, "yes");
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
//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++){
Node node2 = employeeMeta.item(k);
if(node2 instanceof Element){
String string = node2.getNodeName();
String ste = node2.getTextContent();
System.out.println(string+" "+ste);
}
//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("src/com/resources/dd.xml");
d.parseXML("src/com/resources/dd.xml");
}
}
2.使用SAX方式生成和解析XML
package com.java.xmlstudy.impl;
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.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import com.java.xmlstudy.IXMLDocument;
/**
* SAX ，事件驱动。
* 当解析器发现元素开始、元素结束、文本、文档的开始或结束等时，发送事件，程序员编写响应这些事件的代码，保存数据。
* 优点：不用事先调入整个文档，占用资源少；SAX解析器代码比DOM解析器代码小，适于Applet，下载。
* 缺点：不是持久的；事件过后，若没保存数据，那么数据就丢了；
* 无状态性；从事件中只能得到文本，但不知该文本属于哪个元素；
* 使用场合：Applet;只需XML文档的少量内容，很少回头访问；机器内存少；
* @author wxy
*
*/
public class SaxDemo implements IXMLDocument{
@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("src/com/resources/person.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("persons")){return;}
if(qName.equals("person")){
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));
System.out.println("***"+attributes.getQName(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));
}
}
3.使用Dom4J方式生成并解析xml文件
package com.java.xmlstudy.impl;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.util.Iterator;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import com.java.xmlstudy.IXMLDocument;
/**
* Dom4j 生成XML文档与解析XML文档
* DOM4J 是一个非常非常优秀的Java XML API，
* 具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。
* 如今你可以看到越来越多的 Java 软件都在使用 DOM4J 来读写 XML，特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J。
* @author wxy
*
*/
public class Dom4jDemo implements IXMLDocument{
@Override
public void createXML(String fileName) {
//建立document对象
try {
Document document = DocumentHelper.createDocument();
Element root = document.addElement("root");//添加文档根
root.addComment("这个一个注释");//加入一行注释
Element request = root.addElement("request"); //添加root的子节点
request.addAttribute("type", "cat");
request.addAttribute("flow", "tong");
request.addAttribute("time", "2009");
Element pro = request.addElement("pro");
pro.addAttribute("type", "att");
pro.addAttribute("name", "附件");
pro.addText("测试哈子");
Element cd = request.addElement("pro");
cd.addAttribute("type", "cd");
cd.addAttribute("name", "特殊字符过滤");
cd.addCDATA("特殊字符");
//输出全部原始数据，在编译器中显示
OutputFormat format = OutputFormat.createPrettyPrint();
format.setEncoding("GB2312");//根据需要设置编码
XMLWriter writer = new XMLWriter(System.out, format);
document.normalize();
writer.write(document);
writer.close();
// 输出全部原始数据，并用它生成新的我们需要的XML文件
XMLWriter writer2 = new XMLWriter(new FileWriter(new File(fileName)), format);
writer2.write(document); //输出到文件
writer2.close();
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Override
public void parseXML(String fileName) {
try {
SAXReader sax = new SAXReader();
Document xmlDoc = sax.read(new File(fileName));
Element root = xmlDoc.getRootElement();//根节点
Iterator it = root.elementIterator("request");
while(it.hasNext()){
Element request = (Element)it.next();
System.out.print(request.getName());
System.out.print(" type:"+request.attributeValue("type"));
System.out.print(" flow:"+request.attributeValue("flow"));
System.out.println(" time:"+request.attributeValue("time"));
List list = request.elements("pro");
for(int i = 0; i < list.size(); i++){
Element pro = (Element)list.get(i);
System.out.print(" "+pro.getName());
System.out.print(" type："+pro.attributeValue("type"));
System.out.print(" name："+pro.attributeValue("name"));
System.out.println(" 内容："+pro.getText());
System.out.println("+++++++++++++++++++++++++++++++++");
}
}
System.out.println("-------------------------------------------");
} catch (DocumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("dom4j parserXML");
}
public static void main(String[] args) {
Dom4jDemo d=new Dom4jDemo();
d.createXML("src/com/resources/Demo4j.xml");
d.parseXML("src/com/resources/Demo4j.xml");
}
}
结果：
request type:cat flow:tong time:2009
pro type：att name：附件 内容：测试哈子
+++++++++++++++++++++++++++++++++
pro type：cd name：特殊字符过滤 内容：特殊字符
+++++++++++++++++++++++++++++++++
-------------------------------------------
dom4j parserXML
4.使用JDOM方式生成并解析XML文件
package com.java.xmlstudy.impl;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
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;
import org.jdom2.output.XMLOutputter;
import com.java.xmlstudy.IXMLDocument;
/**
* JDOM生成和解析XML
*为减少DOM、SAX的编码量，出现了JDOM；
*优点：20-80原则，极大减少了代码量。
*使用场合：要实现的功能简单，如解析、创建等，
*但在底层，JDOM还是使用SAX（最常用）、DOM、Xanan文档。
* @author wxy
*
*/
public class JDomDemo implements IXMLDocument{
@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();
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.createXML("src/jdom.xml");
jd.parseXML("src/jdom.xml");
}
}
将一个xml使用Dom方式解析完毕后输出到控制台
package com.xmlStudy;
import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Attr;
import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
/**
* 使用递归解析给定的任意一个xml文档并且将其内容输出到命令行上
*
*/
public class DomTest3 {
public static void main(String[] args) throws Exception {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(new File("src/com/resources/person.xml"));
// 获得根元素结点
Element root = doc.getDocumentElement();
parseElement(root);
}
private static void parseElement(Element element) {
String tagName = element.getNodeName();
NodeList children = element.getChildNodes();
System.out.print("<" + tagName);
// element元素的所有属性所构成的NamedNodeMap对象，需要对其进行判断
NamedNodeMap map = element.getAttributes();
// 如果该元素存在属性
if (null != map) {
for (int i = 0; i < map.getLength(); i++) {
// 获得该元素的每一个属性
Attr attr = (Attr) map.item(i);
String attrName = attr.getName();
String attrValue = attr.getValue();
System.out.print(" " + attrName + "=\"" + attrValue + "\"");
}
}
System.out.print(">");
for (int i = 0; i < children.getLength(); i++) {
Node node = children.item(i);
// 获得结点的类型
short nodeType = node.getNodeType();
if (nodeType == Node.ELEMENT_NODE) {
// 是元素，继续递归
parseElement((Element) node);
} else if (nodeType == Node.TEXT_NODE) {
// 递归出口
System.out.print(node.getNodeValue());
} else if (nodeType == Node.COMMENT_NODE) {
System.out.print("<!--");
Comment comment = (Comment) node;
// 注释内容
String data = comment.getData();
System.out.print(data);
System.out.print("-->");
}
}
System.out.print("</" + tagName + ">");
}
}
原文地址：http://freewxy.iteye.com/blog/981000
也可参考：http://www.tuicool.com/articles/mU7ZZz
356
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
