xml文档解析之DOM、SAX、JDOM、Dom4J总结

DOM解析：

优点：常驻内存，对于频繁访问的应用程序提高效率

缺点：当xml文件非常复杂的时候，占用太多的内存空间

解析的xml文件，文件存放在src下：

<?xml version="1.0" encoding="UTF-8"?>
<students>
<student id="stu001">
<name>张小三</name>
<age>21</age>
<sex>男</sex>
</student>
<student id="stu002">
<name>张小</name>
<age>23</age>
<sex>女</sex>
</student>
</students>

DOM解析的处理java类：

步骤：

1.创建一个解析器DocumentBuilderFactory工厂对象

2.创建一个DocumentBuilder解析器对象

3.使用解析器对象使用parse方法创建一个XML文件在内存的树形节点模型：就是加载xml文件

4.获取所有student结点的集合

import java.util.ArrayList;
import java.util.List;

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

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

public class ReaderXMLToList {

public static void main(String[] args) throws Exception {
//创建一个解析器工厂对象
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
//创建一个解析器对象
DocumentBuilder  builder = factory.newDocumentBuilder();
//创建一个XML文件在内存的树形节点模型
Document document = builder.parse(DomReaderXML.class.getClassLoader()
.getResourceAsStream("students.xml"));
//获取所有student节点集合
NodeList studentList = document.getElementsByTagName("student");

List<Student> stus = new ArrayList<Student>();

for(int i=0;i<studentList.getLength();i++){
Student stu = new Student();
//获取第一个student的结点
Element elt = (Element)studentList.item(i);
//获取student结点的ID属性
String id=elt.getAttribute("id");

stu.setId(id);
//第一种获取子结点文本的方式
//			String name=document.getElementsByTagName("name").item(i)
//										.getFirstChild().getNodeValue();
//			stu.setName(name);
//			String sex=document.getElementsByTagName("sex").item(i)
//										.getFirstChild().getNodeValue();
//			stu.setSex(sex);
//
//			String strAge=document.getElementsByTagName("age").item(i)
//									.getFirstChild().getNodeValue();
//			stu.setAge(Integer.parseInt(strAge));
//

//第二种获取子节点的方法(注意：对于结点来说，它的第一个孩子往往是文本类型，
//所以才用childElt.getFirstChild().getNodeValue())获取子节点内容)
NodeList childs=elt.getChildNodes();

for(int j=0;j<childs.getLength();j++){

if(childs.item(j).getNodeType()==Node.ELEMENT_NODE){
Element childElt = (Element)childs.item(j);
//System.out.println(childElt.getNodeName());

//System.out.println(childElt.getFirstChild().getNodeValue());

if("name".equals(childElt.getNodeName())){
stu.setName(childElt.getFirstChild().getNodeValue());
}else  if("age".equals(childElt.getNodeName())){
stu.setAge(Integer.parseInt(childElt.getFirstChild().getNodeValue()));
}else{
stu.setSex(childElt.getFirstChild().getNodeValue());
}

}

}
stus.add(stu);

}

for(Student s:stus){
System.out.println(s);
}

}
}

SAX解析：

优点：“读一句，解析一句”，不占用太多内存，适合较大的文件的解析

缺点：需应用程序频繁访问文件

解析的文件还是student.xml文件，所以不再赘述。

主要步骤：

1.创建解析器工厂

2.通过工厂创建解析器

3.设置具体的解析器对象，参数是一个ContentHandler类型的对象，所以我们写了一个类实现了ContentHandler接口

4.在我们创建的类中进行xml文件解析

解析的主函数：

import org.xml.sax.InputSource;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.XMLReaderFactory;

public class SAXReaderXML {
public static void main(String[] args) throws Exception {
//解析器工厂
XMLReader reader = XMLReaderFactory.createXMLReader();
//创建解析器
MyContentHandler myhandler = new MyContentHandler();
//设置具体使用的解析器对象
reader.setContentHandler(myhandler);

InputSource is = new InputSource(SAXReaderXML.class.getClassLoader()
.getResourceAsStream("students.xml"));
reader.parse(is);

}
}

创建的myHandler类，即解析核心类：

import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;

public class MyContentHandler implements ContentHandler {

private String data;
@Override
public void characters(char[] ch, int start, int length)
throws SAXException {
data=new String(ch,start,length);

}

@Override
public void endDocument() throws SAXException {
//文档解析结束就执行的方法
System.out.println("文档解析结束");

}

@Override
public void endElement(String uri, String localName, String qName)
throws SAXException {
//元素解析结束就执行的方法
if(localName.equals("name")||localName.equals("age")
||localName.equals("sex")){
System.out.println(localName+"元素:"+data);
}

}

@Override
public void endPrefixMapping(String prefix) throws SAXException {
// TODO Auto-generated method stub

}

@Override
public void ignorableWhitespace(char[] ch, int start, int length)
throws SAXException {
// TODO Auto-generated method stub

}

@Override
public void processingInstruction(String target, String data)
throws SAXException {
// TODO Auto-generated method stub

}

@Override
public void setDocumentLocator(Locator locator) {
// TODO Auto-generated method stub

}

@Override
public void skippedEntity(String name) throws SAXException {
// TODO Auto-generated method stub

}

@Override
public void startDocument() throws SAXException {
//开始解析文档就执行的方法
System.out.println("文档开始解析");

}

@Override
public void startElement(String uri, String localName, String qName,
Attributes atts) throws SAXException {
//开始解析元素就执行的方法
//System.out.println(localName+"元素开始解析");
for(int i=0;i<atts.getLength();i++){
System.out.println(atts.getLocalName(i)+"="+atts.getValue(i));
}

}

@Override
public void startPrefixMapping(String prefix, String uri)
throws SAXException {
// TODO Auto-generated method stub

}

}

JDOM读取xml文件的方法：

步骤：

1.创建一个解析器对象

    SAXBuilder builder=new SAXBuilder();

2.得到文档对象

    Document doc=builder.build(“pathname");

3.得到文档对象的跟节点

     Element root=doc.getRootElement();

4.得到某个节点下的所有子节点

    List<Element> list=root.getChildren();

DOM4J解析：

1.得到Document对象的三种方式

    1）读取xml文件得到Document

            SAXReader reader=new SAXReader();

          Document document=reader.read("books.xml”);

    2）解析文本，得到Document对象

       String s="<books><book><bid>B0003</bid><bname>新加的</bname><author>临时的</author></book></books>";
Document document=DocumentHelper.parseText(s);

    3）创建一个空的Document对象 

       Document document = DocumentHelper.createDocument();

        Element root = document.addElement("members");// 创建根节点

2.得到根节点

    Element root=document.getRootElement();

3.得到某个节点的子节点

    Element  ele=bookEle.element("name");

4.根节点下的所有book节点

    List nodes=root.elements("book");

5.得到节点文本，通过Element的方法：

     getData()  ，getText()

    得到某个节点子节点的文本：

     bookEle. elementText (“name");