作者:臧圩人(zangweiren)
网址:http://zangweiren.iteye.com
Java 6.0对XML支持的新特性有许多方面。比如StAX、针对XML-Web服务的Java架构(JAX-WS)2.0、针对XML绑定的API(JAXB)2.0、XML数字签名API,甚至还支持sql:2003 'XML'数据类型。在这一篇文章中我们将要介绍的是StAX技术,因为它在我们的开发中将被使用地更加频繁。
StAX是Streaming API for XML的缩写,是一种针对XML的流式拉分析API。关于对XML进行分析(或解析)的技术,大家一定都不陌生了。在Java 6.0之前,就已经有四种:
关于它们的解析原理,以及性能和优缺点,我会在本文的结尾做一个简要的介绍。这篇文章中,我们主要说说StAX这种新的解析方式。
首先我们来搞清楚两个概念: 推分析和 拉分析。
在程序中访问和操作XML文件一般有两种模型:DOM(文档对象模型)和流模型。它们的优缺点如下:
关于什么是DOM,文章结尾处会有介绍。这里我们简单说一下流:它是一个连续的字节序列,可以理解为不停地从源头向目标搬运着字节的特殊对象。
让我们回到主题。流模型每次迭代XML文档中的一个节点,适合于处理较大的文档,所耗内存空间小。它有两种变体--“推”模型和“拉”模型。
到此,我们就弄明白了“推分析”和“拉分析”的概念:
StAX就是一种拉分析式的XML解析技术。它也支持对XML文件的生成操作,但是这篇文章里我们只介绍有关解析的知识。
从一开始,JAXP(Java API for XML Processing)就提供了两种方法来处理XML:DOM和SAX。StAX是一种面向流的新方法,最终版本于2004年3月发布,并成为JAXP 1.4(包含在Java 6.0中)的一部分。StAX的实现使用了JWSDP(Java Web Services Development Pack)1.6,并结合了SJSXP(Sun Java System XML Streaming Parser,位于javax.xml.stream.*包中)。
JWSDP是用来开发Web Services、Web应用程序以及Java应用(主要是XML处理)的开发包。它包含的Java API有:
JWSDP的早期版本中还包括:
现在,JWSDP已经被GlassFish所替代。
StAX包括两套处理XML的API,分别提供了不同程度的抽象。它们是:基于指针的API和基于迭代器的API。
我们先来了解基于指针的API。它把XML作为一个标记(或事件)流来处理,应用程序可以检查解析器的状态,获得解析的上一个标记的信息,然后再处理下一个标记,依次类推。
在开始API探索之前,我们首先创建一个名为users.xml的XML文档用于测试,它的内容如下:
可以让我们使用基于指针的API的接口是javax.xml.stream.XMLStreamReader(很遗憾,你不能直接实例化它),要得到它的实例,我们需要借助于javax.xml.stream.XMLInputFactory类。根据JAXP的传统风格,这里使用了抽象工厂(Abstract Factory)模式。如果你对这个模式很熟悉的话,就能够在脑海中想象出我们将要编写的代码的大致框架了。
首先,获得一个XMLInputFactory的实例。方法是:
或者:
这两个方法是等价的,它们都是创建了一个新的实例,甚至实例的类型都是完全一致的。因为它们的内部实现都是:
接下来我们就可以创建XMLStreamReader实例了。我们有这样一组方法可以选择:
这些方法都会根据给定的流创建一个XMLStreamReader实例,大家可以依据流的类型、是否需要指定解析XML的编码或者systemId来选择相应的方法。
在这里,我们对systemId稍作说明,并简单解释一下它与publicId的区别。
systemId和publicId是XML文档里DOCTYPE元素中经常出现的两个属性。它们都是对外部资源的引用,用以指明引用资源的地址。systemId是直接引用资源,publicId是间接定位外部资源。具体一点说是这样:
好了,我们接着用以上列出的第一个接口来创建一个XMLStreamReader实例:
要遍历XML文档,需要用到XMLStreamReader的下面几个方法:
getEventtype()方法返回XMLStreamConstants接口中定义的一个标记常量,表示当前指针所指向标记(或事件)的类型。根据当前事件类型的不同,应用程序可以做出不同的处理。标记常量的类型和含义如下:
next()方法将指针移动到下一个标记,它同时返回这个标记(或事件)的类型。此时若接着调用getEventtype()方法则返回相同的值。
hasNext()用于判断是否还有下一个标记。只有当它返回true时才可以调用next()以及其它移动指针的方法。
看了上面几个方法的介绍,大家就会发现使用XMLStreamReader遍历XML文档是非常容易的,因为它的用法和每个人都熟悉的Java迭代器(Iterator)是一样的。下面我们就用已经掌握的这几个方法对上文中给出的XML文档做一个测试。希望你还记得它的内容,如果忘记了,请翻回去重新浏览一下。
我们的测试代码如下:
运行结果:
在上面的示例代码中,我们用到了XMLStreamReader的两个新方法:
与此相关的还有一个方法:
这三个方法牵扯到XML的namespace(命名空间)、localName(本地名称)、QName(Qualified Name,限定名称)三个概念,我们顺便解释一下:
命名空间是为了支持相同名称不同含义的XML标签而产生的,它可以这么定义:
其中,com是命名空间的前缀,company是命名空间的标签,http://www.zangweiren.com/company是命名空间的标识,相同的标识被认为是同一个命名空间。标识又叫URI,是唯一的,有URL(统一资源定位器)和URN(统一资源名称)两种。前缀是命名空间的简写,目的是为了使用方便。命名空间被声明后就可以被使用:
在上例的<com:depart />标签中,前缀com是命名空间,depart是localName,这两个合起来就是QName。
在明白了这三个XML基本概念之后,也就明白了getLocalName()和getAttributeValue(String namespaceURI,String localName)方法的含义。
现在,我们已经学会了使用XMLStreamReader遍历XML文档,并对特定标签进行解析了。
我们再来看看下面两个方法:
getElementText()方法返回元素的开始标签(START_ELEMENT)和关闭标签(END_ELEMENT)之间的所有文本内容,若遇到嵌套的元素就会抛出异常。
nextTag()方法将跳过所有空白、注释或处理指令,直到遇到START_ELEMENT或END_ELEMENT。它在解析只含元素内容的XML文档时很有用。否则,在发现标记之前遇到非空白文本(不包括注释和处理指令),就会抛出异常。
比如我们修改上一个测试程序,增加一个新方法:
然后把它添加到主方法中:
运行它试试看,在解析到<user name="Tom" age="28" gender="male" >Manager</user>的时候会报错,因此你会得到一个类似这样的错误信息:
javax.xml.stream.XMLStreamException: ParseError at [row,col]:[4,53]
Message: found: CHARACTERS,expected START_ELEMENT or END_ELEMENT
对于基于指针的XMLStreamReader来说,虽然API文档说的是“事件”,但是我们把它看成“标记”更易于理解,而且不会与另一套基于事件的API相混淆。
XMLStreamReader的某些方法,无论当前标记(或事件)是什么类型的,都可以被调用。它们的定义和作用如下:
对于以上方法都很容易理解和记忆,我们不再编写代码展示它们的效果。
让我们看看有关属性操作方法。还是首先熟悉一下它们的定义:
这些方法都十分容易理解,基本上看方法的名称和参数就知道它的用途了。而且最后一个方法在上面的示例中我们已经用过了。让我们再用一个简单的示例程序进一步加深对这些方法的认识。
把它加入到主方法中:
运行结果:
相信你看到这里,已经可以顺利地使用XMLStreamReader来完成XML文档的解析了。
上面我们介绍了基于指针的StAX API。这种方式尽管效率高,但是没有提供XML结构的抽象,因此是一种低层API。
较为高级的基于迭代器的API允许应用程序把XML作为一系列事件对象来处理,每个对象和应用程序交换XML结构的一部分。应用程序只需要确定解析事件的类型,将其转换成对应的具体类型,然后利用其方法获得属于该事件对象的信息。
StAX中基于迭代器的API是一种面向对象的方式,这也是它与基于指针的API的最大区别。它通过将事件转变为对象,让应用程序可以用面向对象的方式处理它们,这有利于模块化和不同组件之间的代码重用。
事件迭代器API的主要接口是javax.xml.stream.XMLEventReader和javax.xml.stream.events.XMLEvent。XMLEventReader和XMLStreamReader相比要简单的多,这是因为关于解析事件的所有信息都封装在了事件对象(XMLEvent)中。
创建XMLEvent对象前同样需要一个XMLInputFactory实例。它有如下这些创建XMLEvent实例的方法:
最后一个方法不同与其它的,它是将一个XMLStreamReader对象转换成一个XMLEventReader对象。值得注意的是,XMLInputFactory没有提供将XMLEventreader对象转换成XMLStreamreader对象的方法。我想,在我们的开发过程中,应该不会出现这种需要将高层API转换成低层API来使用的情况。
XMLEventReader接口扩展了java.util.Iterator接口,它定义了以下几个方法:
其中,getElementText()、hasNext()、nextTag()三个方法的含义及用法类似于XMLStreamReader,而nextEvent()方法类似于XMLStreamReader的next()方法。所以,这里只对peed()方法做一下说明。
调用peek()方法,你将得到下一个事件对象。它与nextEvent()方法的不同是,当你连续两次或两次以上调用它时,你得到的都是同一个事件对象。
我们再看看XMLEvent接口中定义的方法。这些方法大体可以分为三种类别。第一类是用于事件类型判断的:
第二类是将XMLEvent转换为具体的子类对象的:
第三类是获取事件对象通用信息的:
其中,getEventtype()方法的返回值也是XMLStreamConstants中定义的常量,其类型和含义与XMLStreamReader的getEventtype()方法的返回值完全相同。
下面让我们用一段示例代码来熟悉基于迭代器的StAX API的使用方法,进而引出XMLEvent接口的子接口类型。我们仍然使用users.xml作为测试文件:
把它加到主程序中:
运行后得到如下结果:
这个例子中,我们利用基于迭代器的StAX API打印出了所有元素的本地名称以及它们的全部属性信息。大家可以看到,它的用法与基于指针的StAX API的用法十分相似。但是由于使用了面向对象的思想,更加容易理解。
我们用到了两个新的接口:StartElement和Attribute。它们都是XMLEvent接口的子接口,且都在javax.xml.stream.events.*包中。它们是更具体的事件对象类型。实际上在javax.xml.stream.events中,除了XMLEvent接口自身外,其余接口都是它的子接口。它们的名称和代表的具体事件对象类型如下:
你可能觉得这些类看着很眼熟,因为它们在XMLStreamReader的getEventtype()方法的返回值,也就是XMLStreamConstants中定义的常量中,都能找到一一的对应。唯独缺少了SAPCE(可忽略的空白)和CDATA(CDATA块)。也就是说,在基于指针的StAX API中定义事件类型,在基于迭代器的StAX API中都是以对象的形式提供给应用程序的,这就是为什么说后者是一种更具有面向对象思想的高层API的原因。
这些事件对象接口不仅代表了一种事件类型,还包含对应事件对象的信息。至于它们所具有的方法大多是获取事件对象信息的访问器,其含义及具体用法,都很容易理解和使用,因此不再详细介绍。
大家可能注意到,XMLEvent只提供了三个asXXX()形式的方法将它转换到具体的子类型,如果你想要处理的事件对象类型在这三种类型之外,直接使用强制类型转换就可以了。
现在我们掌握了StAX的基于指针的拉分析API和基于迭代器的拉分析API的基本应用。我们再来看一种稍微高级的用法,它可以帮助我们更好地完成XML文档的解析工作。
XMLInputFactory还有两个创建流读取器的方法:
它们分别为XMLStreamReader和XMLEventReader增加一个过滤器,过滤掉不需要解析的内容,只留下应用程序关心的信息用于解析。虽然我们可以在应用程序中做同样的过滤工作,就像之前示例程序中所写的那样,但是把过滤工作交给过滤器的好处是,让应用程序可以更加专注于解析工作,并且对于通用的过滤(比如注释),将它放到过滤器中可以实现过滤逻辑部分代码的重用。这符合软件设计原则。
如果你编写过文件过滤器java.io.FileFilter的话,那么编写StreamFilter和EventFilter就更加容易。我们先来看看这两个接口的定义:
我们就以StreamFilter为例来演示过滤器的用法。为此,我们使用users.xml为测试文档编写一段新的程序:
测试结果:
大家可能已经发现,这里有一个与之前处理不同的地方,就是我们先打印了用户的信息,再调用next()方法;这与java.util.Iterator的先调用next()方法,再获取对象信息不同。而之前我们一直采用的是与Iterator一样的处理代码。这里,就有一个问题需要说明。
对于XMLStreamReader的next()方法来说,第一次被调用的时候返回的是第二个标记(或事件)。要获得第一个标记,就需要在调用next()方法之前调用getEventtype()方法。这是需要注意的地方。我们以上的代码之所以采用Java迭代器一样的处理方式,是因为第一个标记总是START_DOCUMENT,而我们不需要对它进行操作,因此就采用了一种熟悉的编码方式,方便大家理解。XMLEventReader的nextEvent()方法就不存在这样的问题。
EventFilter的用法与StreamFilter相同,不再举例说明。
StAX还为我们提供了另外一种隔离标记或事件对象过滤逻辑的方法,那就是StreamReaderDelegate和EventReaderDelegate这两个类,它们都位于javax.xml.stream.util.*包中。StAX API中大部分都是接口,这两个是确确实实的类。它们都做了同样的工作,就是分别包装了XMLStreamReader和XMLEventReader,并把所有的方法都委托(Delegate)给它们处理,既没有增加任何的方法或逻辑,也没有改变或删除任何方法,因此这里使用的是策略(Strategy)模式。我们可以采用装饰(Decorator)模式,给StreamReaderDelegate或EventReaderDelegate增加新的功能。请看下面的例子:
测试结果:
EventReaderDelegate的用法与StreamReaderDelegate相同。
现在我们介绍完了StAX的两种解析XML文档的方式,大家也可能对它的使用有了自己的认识。我们最后总结一下:XMLStreamReader和XMLEventReader都允许应用程序迭代底层的XML流,区别在于它们如何对外提供解析后的XML信息片段。前者像个指针,指在刚刚解析过的XML标记的后面,并提供获得关于该标记更多信息的方法。因为不用创建新的对象,所以更节约内存。后者具有更多的面向对象特征,就是个标准的Java迭代器,解析器的当前状态反映在事件对象中,应用程序在处理事件对象的时候不需要访问解析器/读取器。
关于各种XML解析技术的优劣
除了我们刚刚介绍过的StAX这种Java 6.0新支持的XML文档解析技术之外,还有四种广为应用的解析方式,我们将对它们做一个简要介绍,并比较五种技术的优缺点以及性能表现,以供大家在开发中选择何种解析技术做参考。
网址:http://zangweiren.iteye.com
Java 6.0对XML支持的新特性有许多方面。比如StAX、针对XML-Web服务的Java架构(JAX-WS)2.0、针对XML绑定的API(JAXB)2.0、XML数字签名API,甚至还支持sql:2003 'XML'数据类型。在这一篇文章中我们将要介绍的是StAX技术,因为它在我们的开发中将被使用地更加频繁。
StAX是Streaming API for XML的缩写,是一种针对XML的流式拉分析API。关于对XML进行分析(或解析)的技术,大家一定都不陌生了。在Java 6.0之前,就已经有四种:
- DOM:Document Object Model
- SAX:Simple API for XML
- JDOM:Java-based Document Object Model
- DOM4J:Document Object Model for Java
关于它们的解析原理,以及性能和优缺点,我会在本文的结尾做一个简要的介绍。这篇文章中,我们主要说说StAX这种新的解析方式。
首先我们来搞清楚两个概念: 推分析和 拉分析。
在程序中访问和操作XML文件一般有两种模型:DOM(文档对象模型)和流模型。它们的优缺点如下:
引用
DOM优点:允许编辑和更新XML文档,可以随机访问文档中的数据,可以使用XPath(XML Path Language,是一种从XML文档中搜索节点的查询语言)查询。
DOM缺点:需要一次性加载整个文档到内存中,对于大型文档,会造成性能问题。
DOM缺点:需要一次性加载整个文档到内存中,对于大型文档,会造成性能问题。
引用
关于什么是DOM,文章结尾处会有介绍。这里我们简单说一下流:它是一个连续的字节序列,可以理解为不停地从源头向目标搬运着字节的特殊对象。
让我们回到主题。流模型每次迭代XML文档中的一个节点,适合于处理较大的文档,所耗内存空间小。它有两种变体--“推”模型和“拉”模型。
引用
推模型:就是我们常说的SAX,它是一种靠事件驱动的模型。当它每发现一个节点就引发一个事件,而我们需要编写这些事件的处理程序。这样的做法很麻烦,且不灵活。
引用
拉模型:在遍历文档时,会把感兴趣的部分从读取器中拉出,不需要引发事件,允许我们选择性地处理节点。这大大提高了灵活性,以及整体效率。
到此,我们就弄明白了“推分析”和“拉分析”的概念:
引用
基于流模型中推模型的分析方式称为推分析;基于流模型中拉模型的分析方式就称为拉分析。
StAX就是一种拉分析式的XML解析技术。它也支持对XML文件的生成操作,但是这篇文章里我们只介绍有关解析的知识。
从一开始,JAXP(Java API for XML Processing)就提供了两种方法来处理XML:DOM和SAX。StAX是一种面向流的新方法,最终版本于2004年3月发布,并成为JAXP 1.4(包含在Java 6.0中)的一部分。StAX的实现使用了JWSDP(Java Web Services Development Pack)1.6,并结合了SJSXP(Sun Java System XML Streaming Parser,位于javax.xml.stream.*包中)。
JWSDP是用来开发Web Services、Web应用程序以及Java应用(主要是XML处理)的开发包。它包含的Java API有:
- JAXP:Java API for XML Processing
- JAXB:Java Architecture for XML Binding
- JAX-RPC:Java API for XML-based Remote Procedure Calls
- JAX-WS:Java API for XML Web Services
- SAAJ:SOAP with Attachments API for Java
- JAXR:Java API for XML Registries
- Web Services Registry
JWSDP的早期版本中还包括:
- Java Servlet
- JSP:JavaServer Pages
- JSF:JavaServer Faces
现在,JWSDP已经被GlassFish所替代。
StAX包括两套处理XML的API,分别提供了不同程度的抽象。它们是:基于指针的API和基于迭代器的API。
我们先来了解基于指针的API。它把XML作为一个标记(或事件)流来处理,应用程序可以检查解析器的状态,获得解析的上一个标记的信息,然后再处理下一个标记,依次类推。
在开始API探索之前,我们首先创建一个名为users.xml的XML文档用于测试,它的内容如下:
- <?xmlversion="1.0"encoding="UTF-8"?>
- <company>
- <departtitle="DevelopGroup">
- <username="Tom"age="28"gender="male">Manager</user>
- <username="Lily"age="26"gender="female"/>
- </depart>
- <departtitle="TestGroup">
- <username="Frank"age="32"gender="male">TeamLeader</user>
- <username="Bob"age="45"gender="male"/>
- <username="Kate"age="25"gender="female"/>
- </depart>
- </company>
可以让我们使用基于指针的API的接口是javax.xml.stream.XMLStreamReader(很遗憾,你不能直接实例化它),要得到它的实例,我们需要借助于javax.xml.stream.XMLInputFactory类。根据JAXP的传统风格,这里使用了抽象工厂(Abstract Factory)模式。如果你对这个模式很熟悉的话,就能够在脑海中想象出我们将要编写的代码的大致框架了。
首先,获得一个XMLInputFactory的实例。方法是:
- XMLInputFactoryfactory=XMLInputFactory.newInstance();
或者:
- XMLInputFactoryfactory=XMLInputFactory.newFactory();
这两个方法是等价的,它们都是创建了一个新的实例,甚至实例的类型都是完全一致的。因为它们的内部实现都是:
- {
- return(XMLInputFactory)FactoryFinder.find("javax.xml.stream.XMLInputFactory","com.sun.xml.internal.stream.XMLInputFactoryImpl");
- }
接下来我们就可以创建XMLStreamReader实例了。我们有这样一组方法可以选择:
- XMLStreamReadercreateXMLStreamReader(java.io.Readerreader)throwsXMLStreamException;
- XMLStreamReadercreateXMLStreamReader(javax.xml.tranform.Sourcesource)throwsXMLStreamException;
- XMLStreamReadercreateXMLStreamReader(java.io.InputStreamstream)throwsXMLStreamException;
- XMLStreamReadercreateXMLStreamReader(java.io.InputStreamstream,Stringencoding)throwsXMLStreamException;
- XMLStreamReadercreateXMLStreamReader(StringsystemId,java.io.InputStreamstream)throwsXMLStreamException;
- XMLStreamReadercreateXMLStreamReader(StringsystemId,java.io.Readerreader)throwsXMLStreamException;
这些方法都会根据给定的流创建一个XMLStreamReader实例,大家可以依据流的类型、是否需要指定解析XML的编码或者systemId来选择相应的方法。
在这里,我们对systemId稍作说明,并简单解释一下它与publicId的区别。
systemId和publicId是XML文档里DOCTYPE元素中经常出现的两个属性。它们都是对外部资源的引用,用以指明引用资源的地址。systemId是直接引用资源,publicId是间接定位外部资源。具体一点说是这样:
引用
systemId:外部资源(大多是DTD文件)的URI。比如本地文件file:///user/dtd/users.dtd或者网络某个地址的文件http://www.w3.org/dtd/users.dtd。
引用
publicId:相当于一个名字,这个名字代表了一个外部资源。比如,我们规定"W3C HTML 4.0.1"这个字符串对应"http://www.w3.org/dtd/users.dtd"这个资源。那么,publicId="W3C HTML 4.0.1"和systemId="http://www.w3.org/dtd/users.dtd"的作用就是一样的。
好了,我们接着用以上列出的第一个接口来创建一个XMLStreamReader实例:
- try{
- XMLStreamReaderreader=factory.createXMLStreamReader(newFileReader("users.xml"));
- }catch(FileNotFoundExceptione){
- e.printStackTrace();
- }catch(XMLStreamExceptione){
- e.printStackTrace();
- }
要遍历XML文档,需要用到XMLStreamReader的下面几个方法:
- intgetEventType();
- booleanhasNext()throwsXMLStreamException;
- intnext()throwsXMLStreamException;
getEventtype()方法返回XMLStreamConstants接口中定义的一个标记常量,表示当前指针所指向标记(或事件)的类型。根据当前事件类型的不同,应用程序可以做出不同的处理。标记常量的类型和含义如下:
- START_DOCUMENT:文档的开始
- END_DOCUMENT:文档的结尾
- START_ELEMENT:元素的开始
- END_ELEMENT:元素的结尾
- PROCESSING_INSTRUCTION:处理指令
- CHARACTERS:字符(文本或空格)
- COMMENT:注释
- SPACE:可忽略的空格
- ENTITY_REFERENCE:实体的引用
- ATTRIBUTE:元素的属性
- DTD:DTD
- CDATA:CDATA块
- NAMESPACE:命名空间的声明
- NOTATION_DECLARATION:标记的声明
- ENTITY_DECLARATION:实体的声明
next()方法将指针移动到下一个标记,它同时返回这个标记(或事件)的类型。此时若接着调用getEventtype()方法则返回相同的值。
hasNext()用于判断是否还有下一个标记。只有当它返回true时才可以调用next()以及其它移动指针的方法。
看了上面几个方法的介绍,大家就会发现使用XMLStreamReader遍历XML文档是非常容易的,因为它的用法和每个人都熟悉的Java迭代器(Iterator)是一样的。下面我们就用已经掌握的这几个方法对上文中给出的XML文档做一个测试。希望你还记得它的内容,如果忘记了,请翻回去重新浏览一下。
我们的测试代码如下:
- /**
- *列出所有用户
- *
- *@authorzangweiren2010-4-17
- *
- */
- publicclassListUsers{
- //获得解析器
- publicstaticXMLStreamReadergetStreamReader(){
- StringxmlFile=ListUsers.class.getResource("/").getFile()
- +"users.xml";
- XMLInputFactoryfactory=XMLInputFactory.newFactory();
- try{
- XMLStreamReaderreader=factory
- .createXMLStreamReader(newFileReader(xmlFile));
- returnreader;
- }catch(FileNotFoundExceptione){
- e.printStackTrace();
- }catch(XMLStreamExceptione){
- e.printStackTrace();
- }
- returnnull;
- }
- //列出所有用户名称
- publicstaticvoidlistNames(){
- XMLStreamReaderreader=ListUsers.getStreamReader();
- //遍历XML文档
- try{
- while(reader.hasNext()){
- intevent=reader.next();
- //如果是元素的开始
- if(event==XMLStreamConstants.START_ELEMENT){
- //列出所有用户名称
- if("user".equalsIgnoreCase(reader.getLocalName())){
- System.out.println("Name:"
- +reader.getAttributeValue(null,"name"));
- }
- }
- }
- reader.close();
- }catch(XMLStreamExceptione){
- e.printStackTrace();
- }
- }
- publicstaticvoidmain(String[]args){
- ListUsers.listNames();
- }
- }
运行结果:
引用
Name:Tom
Name:Lily
Name:Frank
Name:Bob
Name:Kate
Name:Lily
Name:Frank
Name:Bob
Name:Kate
在上面的示例代码中,我们用到了XMLStreamReader的两个新方法:
- StringgetLocalName();
- StringgetAttributeValue(StringnamespaceURI,StringlocalName);
与此相关的还有一个方法:
- QNamegetName();
这三个方法牵扯到XML的namespace(命名空间)、localName(本地名称)、QName(Qualified Name,限定名称)三个概念,我们顺便解释一下:
命名空间是为了支持相同名称不同含义的XML标签而产生的,它可以这么定义:
- <com:companyxmlns:com="http://www.zangweiren.com/company">
- <!--hereisothertags-->
- </com:company>
其中,com是命名空间的前缀,company是命名空间的标签,http://www.zangweiren.com/company是命名空间的标识,相同的标识被认为是同一个命名空间。标识又叫URI,是唯一的,有URL(统一资源定位器)和URN(统一资源名称)两种。前缀是命名空间的简写,目的是为了使用方便。命名空间被声明后就可以被使用:
- <com:companyxmlns:com="http://www.zangweiren.com/company">
- <com:departname="DevelopGroup"/>
- </com:company>
在上例的<com:depart />标签中,前缀com是命名空间,depart是localName,这两个合起来就是QName。
在明白了这三个XML基本概念之后,也就明白了getLocalName()和getAttributeValue(String namespaceURI,String localName)方法的含义。
现在,我们已经学会了使用XMLStreamReader遍历XML文档,并对特定标签进行解析了。
我们再来看看下面两个方法:
- StringgetElementText()throwsXMLStreamException;
- intnextTag()throwsXMLStreamException;
getElementText()方法返回元素的开始标签(START_ELEMENT)和关闭标签(END_ELEMENT)之间的所有文本内容,若遇到嵌套的元素就会抛出异常。
nextTag()方法将跳过所有空白、注释或处理指令,直到遇到START_ELEMENT或END_ELEMENT。它在解析只含元素内容的XML文档时很有用。否则,在发现标记之前遇到非空白文本(不包括注释和处理指令),就会抛出异常。
比如我们修改上一个测试程序,增加一个新方法:
- //列出所有用户的名称和年龄
- publicstaticvoidlistNamesAndAges(){
- XMLStreamReaderreader=ListUsers.getStreamReader();
- try{
- while(reader.hasNext()){
- //跳过所有空白、注释或处理指令,到下一个START_ELEMENT
- intevent=reader.nextTag();
- if(event==XMLStreamConstants.START_ELEMENT){
- if("user".equalsIgnoreCase(reader.getLocalName())){
- System.out.println("Name:"
- +reader.getAttributeValue(null,"name")
- +";Age:"
- +reader.getAttributeValue(null,"age"));
- }
- }
- }
- reader.close();
- }catch(XMLStreamExceptione){
- e.printStackTrace();
- }
- }
然后把它添加到主方法中:
- publicstaticvoidmain(String[]args){
- ListUsers.listNames();
- ListUsers.listNamesAndAges();
- }
运行它试试看,在解析到<user name="Tom" age="28" gender="male" >Manager</user>的时候会报错,因此你会得到一个类似这样的错误信息:
javax.xml.stream.XMLStreamException: ParseError at [row,col]:[4,53]
Message: found: CHARACTERS,expected START_ELEMENT or END_ELEMENT
对于基于指针的XMLStreamReader来说,虽然API文档说的是“事件”,但是我们把它看成“标记”更易于理解,而且不会与另一套基于事件的API相混淆。
XMLStreamReader的某些方法,无论当前标记(或事件)是什么类型的,都可以被调用。它们的定义和作用如下:
- String getVersion();//获得XML文档中的版本信息
- String getEncoding();//获得XML文档中的指定编码
- javax.xml.namespace.NamespaceContext getNamespaceContext();//获得当前有效的命名空间上下文,包含前缀、URI等信息
- String getNamespaceURI();//获得当前有效的命名空间的URI
- javax.xml.stream.Location getLocation();//获得当前标记的位置信息,包含行号、列号等
- boolean hasName();//判断当前标记是否有名称,比如元素或属性
- boolean hasText();//判断当前标记是否有文本,比如注释、字符或CDATA
- boolean isStartElement();//判断当前标记是否是标签开始
- boolean isEndElement();//判断当前标记是否是标签结尾
- boolean isCharacters();//判断当前标记是否是字符
- boolean isWhiteSpace();//判断当前标记是否是空白
对于以上方法都很容易理解和记忆,我们不再编写代码展示它们的效果。
让我们看看有关属性操作方法。还是首先熟悉一下它们的定义:
- intgetAttributeCount();
- StringgetAttributeLocalName(intindex);
- QNamegetAttributeName(intindex);
- StringgetAttributeNamespace(intindex);
- StringgetAttributePrefix(intindex);
- StringgetAttributeType(intindex);
- StringgetAttributeValue(intindex);
- StringgetAttributeValue(StringnamespaceURI,StringlocalName);
这些方法都十分容易理解,基本上看方法的名称和参数就知道它的用途了。而且最后一个方法在上面的示例中我们已经用过了。让我们再用一个简单的示例程序进一步加深对这些方法的认识。
- //列出所有用户的名称和年龄
- publicstaticvoidlistNamesAndAges(){
- XMLStreamReaderreader=ListUsers.getStreamReader();
- try{
- while(reader.hasNext()){
- //跳过所有空白、注释或处理指令,到下一个START_ELEMENT
- intevent=reader.nextTag();
- if(event==XMLStreamConstants.START_ELEMENT){
- if("user".equalsIgnoreCase(reader.getLocalName())){
- System.out.println("Name:"
- +reader.getAttributeValue(null,"age"));
- }
- }
- }
- reader.close();
- }catch(XMLStreamExceptione){
- e.printStackTrace();
- }
- }
把它加入到主方法中:
- publicstaticvoidmain(String[]args){
- ListUsers.listNames();
- //ListUsers.listNamesAndAges();
- ListUsers.listAllAttrs();
- }
运行结果:
引用
1.name=Tom;age=28;gender=male;
2.name=Lily;age=26;gender=female;
3.name=Frank;age=32;gender=male;
4.name=Bob;age=45;gender=male;
5.name=Kate;age=25;gender=female;
2.name=Lily;age=26;gender=female;
3.name=Frank;age=32;gender=male;
4.name=Bob;age=45;gender=male;
5.name=Kate;age=25;gender=female;
相信你看到这里,已经可以顺利地使用XMLStreamReader来完成XML文档的解析了。
上面我们介绍了基于指针的StAX API。这种方式尽管效率高,但是没有提供XML结构的抽象,因此是一种低层API。
较为高级的基于迭代器的API允许应用程序把XML作为一系列事件对象来处理,每个对象和应用程序交换XML结构的一部分。应用程序只需要确定解析事件的类型,将其转换成对应的具体类型,然后利用其方法获得属于该事件对象的信息。
StAX中基于迭代器的API是一种面向对象的方式,这也是它与基于指针的API的最大区别。它通过将事件转变为对象,让应用程序可以用面向对象的方式处理它们,这有利于模块化和不同组件之间的代码重用。
事件迭代器API的主要接口是javax.xml.stream.XMLEventReader和javax.xml.stream.events.XMLEvent。XMLEventReader和XMLStreamReader相比要简单的多,这是因为关于解析事件的所有信息都封装在了事件对象(XMLEvent)中。
创建XMLEvent对象前同样需要一个XMLInputFactory实例。它有如下这些创建XMLEvent实例的方法:
- XMLEventReadercreateXMLEventReader(java.io.InputStreamstream)throwsXMLStreamException;
- XMLEventReadercreateXMLEventReader(java.io.InputStreamstream,Stringencoding)throwsXMLStreamException;
- XMLEventReadercreateXMLEventReader(java.io.Readerreader)throwsXMLStreamException;
- XMLEventReadercreateXMLEventReader(StringsystemId,java.io.InputStreamstream)throwsXMLStreamException;
- XMLEventReadercreateXMLEventReader(StringsystemId,java.io.Readerreader)throwsXMLStreamException;
- XMLEventReadercreateXMLEventReader(Sourcesource)throwsXMLStreamException;
- XMLEventReadercreateXMLEventReader(XMLStreamReaderreader)throwsXMLStreamException;
最后一个方法不同与其它的,它是将一个XMLStreamReader对象转换成一个XMLEventReader对象。值得注意的是,XMLInputFactory没有提供将XMLEventreader对象转换成XMLStreamreader对象的方法。我想,在我们的开发过程中,应该不会出现这种需要将高层API转换成低层API来使用的情况。
XMLEventReader接口扩展了java.util.Iterator接口,它定义了以下几个方法:
- StringgetElementText()throwsXMLStreamException;
- booleanhasNext();
- XMLEventnextEvent()throwsXMLStreamException;
- XMLEventnextTag()throwsXMLStreamException;
- XMLEventpeek()throwsXMLStreamException;
其中,getElementText()、hasNext()、nextTag()三个方法的含义及用法类似于XMLStreamReader,而nextEvent()方法类似于XMLStreamReader的next()方法。所以,这里只对peed()方法做一下说明。
调用peek()方法,你将得到下一个事件对象。它与nextEvent()方法的不同是,当你连续两次或两次以上调用它时,你得到的都是同一个事件对象。
我们再看看XMLEvent接口中定义的方法。这些方法大体可以分为三种类别。第一类是用于事件类型判断的:
- boolean isAttribute();//判断该事件对象是否是元素的属性
- boolean isCharacters();//判断该事件对象是否是字符
- boolean isStartDocument();//判断该事件对象是否是文档开始
- boolean isEndDocument();//判断该事件对象是否是文档结尾
- boolean isStartElement();//判断该事件对象是否是元素开始
- boolean isEndElement();//判断该事件对象是否是元素结尾
- boolean isEntityReference();//判断该事件对象是否是实体的引用
- boolean isNamespace();//判断该事件对象是否是命名空间
- boolean isProcessingInstruction();//判断该事件对象是否是处理指令
第二类是将XMLEvent转换为具体的子类对象的:
- Characters asCharacters();//转换为字符事件对象
- StartElement asStartElement();//转换为标签开始事件对象
- EndElement asEndElement();//转换为标签结尾事件对象
第三类是获取事件对象通用信息的:
- javax.xml.stream.Location getLocation();//获得事件对象的位置信息,类似于XMLStreamReader的getLocation()方法
- int getEventType();//获得事件对象的类型,类似于XMLStreamReader的getEventtype()方法
其中,getEventtype()方法的返回值也是XMLStreamConstants中定义的常量,其类型和含义与XMLStreamReader的getEventtype()方法的返回值完全相同。
下面让我们用一段示例代码来熟悉基于迭代器的StAX API的使用方法,进而引出XMLEvent接口的子接口类型。我们仍然使用users.xml作为测试文件:
- //列出所有信息
- @SuppressWarnings("unchecked")
- publicstaticvoidlistAllByXMLEventReader(){
- StringxmlFile=ListUsers.class.getResource("/").getFile()
- +"users.xml";
- XMLInputFactoryfactory=XMLInputFactory.newInstance();
- try{
- //创建基于迭代器的事件读取器对象
- XMLEventReaderreader=factory
- .createXMLEventReader(newFileReader(xmlFile));
- //遍历XML文档
- while(reader.hasNext()){
- XMLEventevent=reader.nextEvent();
- //如果事件对象是元素的开始
- if(event.isStartElement()){
- //转换成开始元素事件对象
- StartElementstart=event.asStartElement();
- //打印元素标签的本地名称
- System.out.print(start.getName().getLocalPart());
- //取得所有属性
- Iteratorattrs=start.getAttributes();
- while(attrs.hasNext()){
- //打印所有属性信息
- Attributeattr=(Attribute)attrs.next();
- System.out.print(":"+attr.getName().getLocalPart()
- +"="+attr.getValue());
- }
- System.out.println();
- }
- }
- reader.close();
- }catch(FileNotFoundExceptione){
- e.printStackTrace();
- }catch(XMLStreamExceptione){
- e.printStackTrace();
- }
- }
把它加到主程序中:
- publicstaticvoidmain(String[]args){
- ListUsers.listNames();
- //ListUsers.listNamesAndAges();
- ListUsers.listAllAttrs();
- ListUsers.listAllByXMLEventReader();
- }
运行后得到如下结果:
引用
company
depart:title=Develop Group
user:age=28:name=Tom:gender=male
user:age=26:name=Lily:gender=female
depart:title=Test Group
user:age=32:name=Frank:gender=male
user:age=45:name=Bob:gender=male
user:age=25:name=Kate:gender=female
depart:title=Develop Group
user:age=28:name=Tom:gender=male
user:age=26:name=Lily:gender=female
depart:title=Test Group
user:age=32:name=Frank:gender=male
user:age=45:name=Bob:gender=male
user:age=25:name=Kate:gender=female
这个例子中,我们利用基于迭代器的StAX API打印出了所有元素的本地名称以及它们的全部属性信息。大家可以看到,它的用法与基于指针的StAX API的用法十分相似。但是由于使用了面向对象的思想,更加容易理解。
我们用到了两个新的接口:StartElement和Attribute。它们都是XMLEvent接口的子接口,且都在javax.xml.stream.events.*包中。它们是更具体的事件对象类型。实际上在javax.xml.stream.events中,除了XMLEvent接口自身外,其余接口都是它的子接口。它们的名称和代表的具体事件对象类型如下:
- Attribute:元素的属性
- Characters:字符
- Comment:注释
- DTD:DTD
- StartDocument:文档的开始
- EndDocument:文档的结束
- StartElement:元素的开始
- EndElement:元素的结束
- EntityDeclaration:实体声明
- EntityReference:实体的引用
- Namespace:命名空间声明
- NotationDeclaration:标记的声明
- ProcessingInstruction:处理指令
你可能觉得这些类看着很眼熟,因为它们在XMLStreamReader的getEventtype()方法的返回值,也就是XMLStreamConstants中定义的常量中,都能找到一一的对应。唯独缺少了SAPCE(可忽略的空白)和CDATA(CDATA块)。也就是说,在基于指针的StAX API中定义事件类型,在基于迭代器的StAX API中都是以对象的形式提供给应用程序的,这就是为什么说后者是一种更具有面向对象思想的高层API的原因。
这些事件对象接口不仅代表了一种事件类型,还包含对应事件对象的信息。至于它们所具有的方法大多是获取事件对象信息的访问器,其含义及具体用法,都很容易理解和使用,因此不再详细介绍。
大家可能注意到,XMLEvent只提供了三个asXXX()形式的方法将它转换到具体的子类型,如果你想要处理的事件对象类型在这三种类型之外,直接使用强制类型转换就可以了。
现在我们掌握了StAX的基于指针的拉分析API和基于迭代器的拉分析API的基本应用。我们再来看一种稍微高级的用法,它可以帮助我们更好地完成XML文档的解析工作。
XMLInputFactory还有两个创建流读取器的方法:
- XMLStreamReadercreateFilteredReader(XMLStreamReaderreader,StreamFilterfilter)throwsXMLStreamException;
- XMLEventReadercreateFilteredReader(XMLEventReaderreader,EventFilterfilter)throwsXMLStreamException;
它们分别为XMLStreamReader和XMLEventReader增加一个过滤器,过滤掉不需要解析的内容,只留下应用程序关心的信息用于解析。虽然我们可以在应用程序中做同样的过滤工作,就像之前示例程序中所写的那样,但是把过滤工作交给过滤器的好处是,让应用程序可以更加专注于解析工作,并且对于通用的过滤(比如注释),将它放到过滤器中可以实现过滤逻辑部分代码的重用。这符合软件设计原则。
如果你编写过文件过滤器java.io.FileFilter的话,那么编写StreamFilter和EventFilter就更加容易。我们先来看看这两个接口的定义:
- publicinterfaceStreamFilter{
- publicbooleanaccept(XMLStreamReaderreader);
- }
- publicinterfaceEventFilter{
- publicbooleanaccept(XMLEventevent);
- }
我们就以StreamFilter为例来演示过滤器的用法。为此,我们使用users.xml为测试文档编写一段新的程序:
- /**
- *StreamFilter示例程序
- *
- *@authorzangweiren2010-4-19
- *
- */
- publicclassTestStreamFilterimplementsStreamFilter{
- publicstaticvoidmain(String[]args){
- TestStreamFiltert=newTestStreamFilter();
- t.listUsers();
- }
- @Override
- publicbooleanaccept(XMLStreamReaderreader){
- try{
- while(reader.hasNext()){
- intevent=reader.next();
- //只接受元素的开始
- if(event==XMLStreamConstants.START_ELEMENT){
- //只保留user元素
- if("user".equalsIgnoreCase(reader.getLocalName())){
- returntrue;
- }
- }
- if(event==XMLStreamConstants.END_DOCUMENT){
- returntrue;
- }
- }
- }catch(XMLStreamExceptione){
- e.printStackTrace();
- }
- returnfalse;
- }
- publicXMLStreamReadergetFilteredReader(){
- StringxmlFile=TestStreamFilter.class.getResource("/").getFile()
- +"users.xml";
- XMLInputFactoryfactory=XMLInputFactory.newFactory();
- XMLStreamReaderreader;
- try{
- reader=factory.createXMLStreamReader(newFileReader(xmlFile));
- //创建带有过滤器的读取器实例
- XMLStreamReaderfreader=factory
- .createFilteredReader(reader,this);
- returnfreader;
- }catch(FileNotFoundExceptione){
- e.printStackTrace();
- }catch(XMLStreamExceptione){
- e.printStackTrace();
- }
- returnnull;
- }
- publicvoidlistUsers(){
- XMLStreamReaderreader=getFilteredReader();
- try{
- //列出所有用户的名称
- while(reader.hasNext()){
- //过滤工作已交由过滤器完成,这里不需要再做
- System.out.println("Name="
- +reader.getAttributeValue(null,"name"));
- if(reader.getEventType()!=XMLStreamConstants.END_DOCUMENT){
- reader.next();
- }
- }
- reader.close();
- }catch(XMLStreamExceptione){
- e.printStackTrace();
- }
- }
- }
测试结果:
引用
Name=Tom
Name=Lily
Name=Frank
Name=Bob
Name=Kate
Name=Lily
Name=Frank
Name=Bob
Name=Kate
大家可能已经发现,这里有一个与之前处理不同的地方,就是我们先打印了用户的信息,再调用next()方法;这与java.util.Iterator的先调用next()方法,再获取对象信息不同。而之前我们一直采用的是与Iterator一样的处理代码。这里,就有一个问题需要说明。
对于XMLStreamReader的next()方法来说,第一次被调用的时候返回的是第二个标记(或事件)。要获得第一个标记,就需要在调用next()方法之前调用getEventtype()方法。这是需要注意的地方。我们以上的代码之所以采用Java迭代器一样的处理方式,是因为第一个标记总是START_DOCUMENT,而我们不需要对它进行操作,因此就采用了一种熟悉的编码方式,方便大家理解。XMLEventReader的nextEvent()方法就不存在这样的问题。
EventFilter的用法与StreamFilter相同,不再举例说明。
StAX还为我们提供了另外一种隔离标记或事件对象过滤逻辑的方法,那就是StreamReaderDelegate和EventReaderDelegate这两个类,它们都位于javax.xml.stream.util.*包中。StAX API中大部分都是接口,这两个是确确实实的类。它们都做了同样的工作,就是分别包装了XMLStreamReader和XMLEventReader,并把所有的方法都委托(Delegate)给它们处理,既没有增加任何的方法或逻辑,也没有改变或删除任何方法,因此这里使用的是策略(Strategy)模式。我们可以采用装饰(Decorator)模式,给StreamReaderDelegate或EventReaderDelegate增加新的功能。请看下面的例子:
- /**
- *测试StreamReaderDelegate
- *
- *@authorzangweiren2010-4-19
- *
- */
- publicclassTestStreamDelegate{
- publicstaticvoidmain(String[]args){
- TestStreamDelegatet=newTestStreamDelegate();
- t.listUsers();
- }
- publicXMLStreamReadergetDelegateReader(){
- StringxmlFile=TestStreamFilter.class.getResource("/").getFile()
- +"users.xml";
- XMLInputFactoryfactory=XMLInputFactory.newFactory();
- XMLStreamReaderreader;
- try{
- reader=newStreamReaderDelegate(factory
- .createXMLStreamReader(newFileReader(xmlFile))){
- //重写(Override)next()方法,增加过滤逻辑
- @Override
- publicintnext()throwsXMLStreamException{
- while(true){
- intevent=super.next();
- //保留用户元素的开始
- if(event==XMLStreamConstants.START_ELEMENT
- &&"user".equalsIgnoreCase(getLocalName())){
- returnevent;
- }elseif(event==XMLStreamConstants.END_DOCUMENT){
- returnevent;
- }else{
- continue;
- }
- }
- }
- };
- returnreader;
- }catch(FileNotFoundExceptione){
- e.printStackTrace();
- }catch(XMLStreamExceptione){
- e.printStackTrace();
- }
- returnnull;
- }
- publicvoidlistUsers(){
- XMLStreamReaderreader=this.getDelegateReader();
- try{
- while(reader.hasNext()){
- reader.next();
- if(reader.getEventType()!=XMLStreamConstants.END_DOCUMENT){
- //列出用户的名称和年龄
- System.out.println("Name="
- +reader.getAttributeValue(null,"name")+";age="
- +reader.getAttributeValue(null,"age"));
- }
- }
- reader.close();
- }catch(XMLStreamExceptione){
- e.printStackTrace();
- }
- }
- }
测试结果:
引用
Name=Tom;age=28
Name=Lily;age=26
Name=Frank;age=32
Name=Bob;age=45
Name=Kate;age=25
Name=Lily;age=26
Name=Frank;age=32
Name=Bob;age=45
Name=Kate;age=25
EventReaderDelegate的用法与StreamReaderDelegate相同。
现在我们介绍完了StAX的两种解析XML文档的方式,大家也可能对它的使用有了自己的认识。我们最后总结一下:XMLStreamReader和XMLEventReader都允许应用程序迭代底层的XML流,区别在于它们如何对外提供解析后的XML信息片段。前者像个指针,指在刚刚解析过的XML标记的后面,并提供获得关于该标记更多信息的方法。因为不用创建新的对象,所以更节约内存。后者具有更多的面向对象特征,就是个标准的Java迭代器,解析器的当前状态反映在事件对象中,应用程序在处理事件对象的时候不需要访问解析器/读取器。
关于各种XML解析技术的优劣
除了我们刚刚介绍过的StAX这种Java 6.0新支持的XML文档解析技术之外,还有四种广为应用的解析方式,我们将对它们做一个简要介绍,并比较五种技术的优缺点以及性能表现,以供大家在开发中选择何种解析技术做参考。