SAX和DOM解析的比较

SAX和DOM解析的比较

在针对XML文档的应用编程接口中，最主要的有W3C制定的DOM(DocumentObjectMethod，文档对象模型)和由DavidMegginson领导的SAX(SimpleAPIforXML，用于XML的简单API)。

SAX和DOM在实现过程中，分别侧重于不同的方面以满足不同的应用需求。DOM为开发基于XML的应用系统提供了便利。它通过一种随机访问机制，使得应用程序利用该接口可以在任何时候访问XML文档中的任何一部分数据，也可以对XML文档中的数据进行插入、删除、修改、移动等操作。在DOM中，文档的逻辑结构类似一棵树。文档、文档中的根、元素、元素内容、属性、属性值等都是以对象模型的形式表示的。DOM的优点在于它在内存中保存文档的整个模型。这使得能以任何顺序访问XML元素。然而，对于大型文档来说，这样做可能不方便。因为它可能会用尽内存，或者当系统达到了它的极限时，机器的性能将

会慢下来。

SAX提供了一种对XML文档进行顺序访问的模式，这是一种快速读XML数据的方式。SAX接口是事件驱动的，当使用SAX分析器对XML文档进行分析时，就会触发一系列事件，并激活相应的事件处理函数，从而完成对XML文档的访问。SAX处理XML的方式与DOM不同。SAX解析器不是将DOM树解析和表现为输出，它是基于事件的，所以在XML被解析时，事件被发送给引擎。SAX可以在文档的开始接收事件，也可以接收文档中的元素。使用这些事件可以构建一种结构。因为SAX没有把XML文档完全地加载到内存中，所以需要的系统资源较少，是一个分析大型XML文档的高效API。缺点是编写SAX比编写DOM复杂，这因为首先必须实现通知接口并维护状态，其次SAX不允许对文档进行随机访问，也没有提供像DOM那样的修改功能。

比较而言，DOM和SAX各有自己的应用场合。DOM适用于处理下面的问题：解析比较小的XML文件；需要对文档进行修改；需要随机对文档进行访问。SAX适于处理下面的问题：对大型文档进行处理；只需要文档的部分内容；只需要从文档中得到特定信息。

DOM:

DocumentObjectModel文档对象模型，由W3C制定标准规范与具体语言无关随机访问XML文档重复读

DOM的编程API：

Node:节点

Document:根节点表示整个文档

NodeList:节点的集合

NamedNodeMap:一般用于存储属性

Element:

编程思路:

1.获得DocumentBuilderFactory的实例

2.通过工厂获得DocumentBuilder的解析器

3.parse(File)======>Document

------------MyDom.xml-----------

importjavax.xml.parsers.DocumentBuilder;

importjavax.xml.parsers.DocumentBuilderFactory;

importjava.io.*;

importorg.w3c.dom.Document;

importorg.w3c.dom.NodeList;

importorg.w3c.dom.Node;

importorg.w3c.dom.Element;

importorg.w3c.dom.Attr;

importorg.w3c.dom.NamedNodeMap;

//通过DOM方式解析XML文档

publicclassMyDom{

publicstaticvoidmain(Stringargs[])throwsException{

//1.得到工厂类（DocumentBuilderFactory）的实例

DocumentBuilderFactoryfactory=DocumentBuilderFactory.newInstance();

//2.得到解析器实例

DocumentBuilderbuilder=factory.newDocumentBuilder();

//3.使用parse（）解析文件返回文档的根节点Document

Documentdoc=builder.parse(newFile("student.xml"));

Elementroot=doc.getDocumentElement();

System.out.println("根元素是："+root.getTagName());

NodeListnl=doc.getElementsByTagName("student");

//NodeListnl=root.getChildNodes();

//遍历NodeList

for(inti=0;i<nl.getLength();i++){

Nodenode=nl.item(i); //得到Node集合中的每一个

NamedNodeMapnnm=node.getAttributes();

for(intj=0;j<nnm.getLength();j++){

Nodeatt_node=nnm.item(j);

Attrattr=(Attr)att_node;

Stringatt_name=attr.getName();

Stringatt_value=attr.getValue();

System.out.println(att_name+"="+att_value);

}

Elementfirst=(Element)node;

System.out.println(first.getTagName());

//得到每个student元素的子节点

NodeListsecs=node.getChildNodes();

System.out.println(secs.getLength());

for(intk=0;k<secs.getLength();k++){

//得到二级子节点

Nodesec_node=secs.item(k);

//过滤空白

if(sec_node.getNodeType()==Node.ELEMENT_NODE){

Elementsec=(Element)sec_node;

System.out.println(sec.getTagName());

System.out.println(sec.getTextContent());

}

}

}

}

}

----------MyDom2.xml--------------

importjavax.xml.parsers.DocumentBuilderFactory;

importjavax.xml.parsers.DocumentBuilder;

importjava.io.*;

importorg.w3c.dom.*;

publicclassMyDom2{

publicstaticvoidmain(Stringargs[])throwsException{

DocumentBuilderbuilder=DocumentBuilderFactory.newInstance().newDocumentBuilder();

Documentdoc=builder.parse(newFile("student.xml"));

NodeListfirsts=doc.getElementsByTagName("student");

//遍历一级子元素过程

for(inti=0;i<firsts.getLength();i++){

Elementfirst=(Element)firsts.item(i);//student

Stringid_value=first.getAttribute("id");

Stringname=first.getElementsByTagName("name").item(0).getFirstChild().getNodeValue();

Stringage=first.getElementsByTagName("age").item(0).getFirstChild().getNodeValue();

Stringaddress=first.getElementsByTagName("address").item(0).getFirstChild().getNodeValue();

System.out.println("idis:"+id_value+"\t"+name+"\t"+age+"\t"+address);

//getChildNodes()

//NodeListfirst.getChildNodes();

}

}

}

DOM创建文档

---------------Create.java---------

importjavax.xml.parsers.*;

importjava.io.*;

importorg.w3c.dom.*;

importjavax.xml.transform.*;

importjavax.xml.transform.dom.DOMSource;

importjavax.xml.transform.stream.StreamResult;

publicclassCreate{

publicstaticvoidmain(Stringargs[])throwsException{

//1.获得工厂实例

DocumentBuilderFactoryf=DocumentBuilderFactory.newInstance();

//2.得到解析器

DocumentBuilderbuilder=f.newDocumentBuilder();

//3.builder.newDocument();

Documentdoc=builder.newDocument();

//创建元素

Elementroot=doc.createElement("emps");

Elementemp1=doc.createElement("emp");

Elementname1=doc.createElement("name");

name1.setTextContent("etoak");

Elementemail1=doc.createElement("email");

email1.setTextContent("email1");

Elementemp2=doc.createElement("emp");

Elementname2=doc.createElement("name");

name2.setTextContent("etoak1");

Elementemail2=doc.createElement("email");

email2.setTextContent("email1");

//组装appendChild() Node

doc.appendChild(root);

root.appendChild(emp1);

root.appendChild(emp2);

emp1.appendChild(name1);

emp1.appendChild(email1);

emp2.appendChild(name2);

emp2.appendChild(email2);

//将DOcument实例持久化到磁盘上

//1.TransformerFactory实例newInstance();

TransformerFactoryfactory=TransformerFactory.newInstance();

//2.factory实例得到Transformer实例

Transformerformer=factory.newTransformer();

former.setOutputProperty(OutputKeys.INDENT,"yes");

//构造源

DOMSourcesource=newDOMSource(doc);

//构造结果类型stream

StreamResultresult=newStreamResult(newFile("emp.xml"));

former.transform(source,result);

}

}

SAX：

SimpleApiforXML（xml简单处理API),提供了一种基于事件的XML的解析方式

多用于快速读取XML文档

基于事件驱动，在内存中并不会加载整个文档，效率要高（解析大型XML文档）

不能重复读取顺序读取模式

1.得到工厂实例

SAXParserFactoryactory=SAXParserFactory.newInstance();

2.由工厂实例得到解析器

SAXParserparser=factory.newSAXParser();

3.解析器parse(Filef,MyHandlerextendsDefaultHandlerdh)

ClassMyHandlerextendsDefaultHandler{

publicvoid…

}

SAX应用程序构成图

SAX解析实例

测试流程

importjavax.xml.parsers.SAXParser;

importjavax.xml.parsers.SAXParserFactory;

importjava.io.*;

importorg.xml.sax.helpers.DefaultHandler;

importorg.xml.sax.SAXException;

importorg.xml.sax.Attributes;

//使用SAX方式解析XML文档

publicclasss1{

publicstaticvoidmain(String[]agrs)throwsException{

//****使用SAXParser.parse()处理文件

//1、得到工厂的实例使用static方法newInstance();

SAXParserFactoryfactory=SAXParserFactory.newInstance();

//2、使用工厂实例得到解析器newSAXParser();

SAXParserparser=factory.newSAXParser();

//3、使用SAXParser.parse()处理文件

parser.parse(newFile("s1.xml"),newMyHandler());

}

}

//文档处理器其中定义了很多回调方法按照要求重写方法

classMyHandlerextendsDefaultHandler{

//文件开始的时候调用的方法

@Override

publicvoidstartDocument()throwsSAXException{

System.out.println("文档开始。。。");

}

//元素开始时调用的方法

@Override

publicvoidstartElement(Stringuri,StringlocalName,StringqName,Attributesattrs)throwsSAXException{

System.out.println("元素开始。。。");

}

@Override

publicvoidcharacters(char[]ch,intstart,intlength)throwsSAXException{

System.out.println("字符数据。。。");

}

publicvoidendElement(Stringuri,StringlocalName,StringqName,Attributesattrs)throwsSAXException{

System.out.println("元素结束。。。");

}

@Override

publicvoidendDocument()throwsSAXException{

System.out.println("文档结束。。。");

}

}

.遍历文档

----------Student.xml------------

<?xmlversion="1.0"encoding="GBK"?>

<students>

<studentid="1">

<name>zhangsan</name>

<age>12</age>

<address>jinan</address>

</student>

<studentid="2">

<name>lisi</name>

<age>23</age>

<address>shandong</address>

</student>

</students>

----------MySax.java:----------

importjavax.xml.parsers.SAXParser;

importjavax.xml.parsers.SAXParserFactory;

importjava.io.*;

importorg.xml.sax.helpers.DefaultHandler;

importorg.xml.sax.SAXException;

importorg.xml.sax.Attributes;

//使用SAX方式解析XML文档完整遍历过程

publicclassMySax{

publicstaticvoidmain(Stringargs[])throwsException{

//1.得到工厂的实例使用static方法newInstance();

SAXParserFactoryfactory=SAXParserFactory.newInstance();

//2.使用工厂实例得到解析器newSAXParser();

SAXParserparser=factory.newSAXParser();

//使用SAXParser.parse()处理文件

parser.parse(newFile("student.xml"),newMyHandler());

}

}

//文档处理器其中定义了很多回调方法按照需求重写方法

classMyHandlerextendsDefaultHandler{

StringBufferstr=newStringBuffer("");

//文档开始的时候调用的方法

@Override

publicvoidstartDocument()throwsSAXException{

str.append("<?xmlversion=\"1.0\"encoding=\"GBK\"?>\n");

}

//元素开始的时候调用的方法

@Override

publicvoidstartElement(Stringuri,StringlocalName,

StringqName,Attributesattrs)throwsSAXException{

str.append("<"+qName);//拼装元素的开始标记

//如果有属性则遍历得到

for(inti=0;i<attrs.getLength();i++){

//得到属性名字

Stringatt_name=attrs.getQName(i);

//属性值

Stringatt_value=attrs.getValue(i);

str.append(""+att_name+"=\""+att_value+"\"");

}

str.append(">");

}

@Override

publicvoidcharacters(char[]ch,intstart,intlength)

throwsSAXException{

str.append(newString(ch,start,length));

}

@Override

publicvoidendElement(Stringuri,StringlocalName,StringqName)

throwsSAXException{

str.append("</").append(qName).append(">");

}

@Override

publicvoidendDocument()throwsSAXException{

System.out.println(str.toString());

}

}

.在school.xml中查询指定老师所带的课程

result:

xx老师所带的课程是xxx

----------school.xml:---------

<?xmlversion="1.0"encoding="utf-8"?>

<school>

<teachers>

<teacherage="30"course="jdbc"gender="male"name="kk">

<phonetype="company"/>

<others><iphone/></others>

</teacher>

<teacherage="33"course="corejava"gender="male"name="David">

<phonetype="company"/>

<others><iphone/></others>

</teacher>

<teacherage="30"course="hibernatestruts"gender="male"name="adam">

<phonetype="home"/>

<others>

<iphone>13944456789</iphone>

<iphone>13934567889</iphone>

</others>

</teacher>

</teachers>

<courses>

<coursename="corejava"></course>

<coursename="hibernate">持久层框架</course>

<coursename="struts">视图层框架</course>

<coursename="ajax"></course>

<coursename="jdbc"></course>

</courses>

<students>

<studentage="23"gender="male"name="tom">

<subjectsname="corejava"><score>80</score></subject>

<subjectsname="hibernate"/>

<subjectsname="struts"><score>88</score></subject>

<birthplacename="天津"/>

</student>

<studentgender="male"name="Jimmy">

<subjectsname="corejava"><score>82</score></subject>

<subjectsname="hibernate"></subject>

<subjectsname="struts"><score>83</score></subject>

<subjectsname="ajax"><score>78</score></subject>

</student>

</students>

</school>

--------------Execl.java:-------------

importjavax.xml.parsers.SAXParserFactory;

importjavax.xml.parsers.SAXParser;

importjava.io.*;

importorg.xml.sax.helpers.DefaultHandler;

importorg.xml.sax.Attributes;

importorg.xml.sax.SAXException;

publicclassExec1{

publicstaticvoidmain(Stringargs[])throwsException{

SAXParserparser=SAXParserFactory.newInstance().newSAXParser();

parser.parse(newFile("school.xml"),newMyHandler("David"));

}

}

classMyHandlerextendsDefaultHandler{

StringteaName;

publicMyHandler(StringteaName){

this.teaName=teaName;

}

@Override

publicvoidstartElement(Stringuri,StringlocalName,StringqName,Attributesattrs)throwsSAXException{

//首先,判读当前读到的标签是不是teacher

if(qName.equals("teacher")){

//如果是则读取里面的name属性值

Stringtea=attrs.getValue("name");

//如果name属性的值与传入的teaName相等则表示该老师就是所找的那一个

if(tea.equals(teaName)){

Stringcourse=attrs.getValue("course");

//打印输出

System.out.println(teaName+"老师所在的课程是:"+course);

}

}

}

} //打印：David老师所在的课程是:corejava

.在school..xml中查询选修了指定课程的学生以及分数只查有分数的

result：xx学生选修的xx课程是xx分

param:course

studentName有可能

sname.value===courseflag1

scoreflag2

(flag1&&flag2)charachers

----------Exec2.java:-------------

importjavax.xml.parsers.SAXParserFactory;

importjavax.xml.parsers.SAXParser;

importjava.io.*;

importorg.xml.sax.helpers.DefaultHandler;

importorg.xml.sax.Attributes;

importorg.xml.sax.SAXException;

publicclassExec2{

publicstaticvoidmain(Stringargs[])throwsException{

SAXParserparser=SAXParserFactory.newInstance().newSAXParser();

parser.parse(newFile("school.xml"),newMyHandler("corejava"));

}

}

classMyHandlerextendsDefaultHandler{

Stringcourse;

StringstuName;//预存学生名字

booleanflag1;//判断课程是否是传入的课程

booleanflag2;//判断是否有分数

publicMyHandler(Stringcourse){

this.course=course;

}

@Override

publicvoidstartElement(Stringuri,StringlocalName,StringqName,Attributesattrs)throwsSAXException{

//判断是否是学生如果是学生则取名字

if("student".equals(qName)){

stuName=attrs.getValue("name");

}

//判断课程是否与传入的一致

if("subject".equals(qName)){//判断开始标签是否是subject

StringcourseName=attrs.getValue("sname");

if("corejava".equals(courseName))

flag1=true;

}

if("score".equals(qName))flag2=true;

}

publicvoidcharacters(charch[],intstart,intlength)throwsSAXException{

if(flag1&&flag2)

System.out.println(stuName+"选修的"+course+"分数是："+newString(ch,start,length));

}

publicvoidendElement(Stringuri,StringlocalName,StringqName)throwsSAXException{

//把标记还原

if(qName.equals("student"))stuName="";

if(qName.equals("subject"))flag1=false;

if(qName.equals("score"))flag2=false;

}

}