使用 StAX 解析 XML，第 2 部分: 拉式解析和事件

最新推荐文章于 2019-01-18 10:35:36 发布

最新推荐文章于 2019-01-18 10:35:36 发布 · 211 阅读

文章标签：

本文深入探讨了StreamingAPIforXML(StAX)的基于事件迭代器API，对比了基于指针的API，阐述了其在性能和可用性上的独特优势，并详细介绍了如何使用XMLEventReader接口来迭代XML事件，处理各种事件类型，以及如何筛选和操纵事件流。

http://www.ibm.com/developerworks/cn/xml/x-stax2.html

探讨 StAX 基于事件迭代器的 API

Peter Nehrer( pnehrer@ecliptical.ca), 自由撰稿人, 独立咨询顾问

简介：Streaming API for XML (StAX) 的基于事件迭代器 API 无论在性能还是在可用性上都有其他 XML 处理方法所不及的独到之处。第 1 部分介绍了 StAX 并详细讨论了它的基于指针的 API。本文进一步讨论基于事件迭代器 API 及其为 Java™ 开发人员带来的好处。

查看本系列更多内容

标记本文！

发布日期：2007 年 7 月 05 日
级别：中级
访问情况：2850 次浏览
评论：0(查看|添加评论- 登录)

平均分 (2个评分)
为本文评分

使用 StAX 解析 XML

第 1 部分（请参阅参考资料）提到，StAX 提供了两种风格的处理 XML 的 API。基于指针的 API 是解析 XML 的低层方法。使用这种方法，应用程序沿着 XML 标记流移动指针，在每一步中检查解析器的状态来了解解析内容的更多信息。这种方法效率很高，特别适用于资源受限的环境。但是，基于指针的 API 不是面向对象的，因而不适合 Java 应用程序，尤其是在代码的可扩展性和可维护性与性能同样重要的企业领域中就更是如此。比方说，多层 Web 服务使用一般组件处理消息信封，而把特定于消息的内容处理（如参数绑定）委托给其他组件完成，这种情况下就能从面向对象的方法中获益。

StAX 提供的另一种风格的 API 以事件对象为中心。和基于指针的 API 一样，这也是一种基于拉的 XML 解析方法：应用程序使用提供的方法从解析器中拉出每个事件，按照需要处理该事件，依此类推，直到流解析完成（或者应用程序决定停止解析）。

XMLEventReader接口简介

事件迭代器 API 的主要接口是XMLEventReader。和XMLStreamReader相比它的方法要少很多。这是因为XMLEventReader用于迭代事件对象流（事实上XMLEventReader扩展了java.util.Iterator）。关于解析事件的所有信息都封装在事件对象而不是读取器中。

要使用基于事件迭代器的 API，应用程序首先必须从XMLInputFactory获得XMLEventReader的实例。工厂本身可用标准 JAXP 方法获得，它依靠抽象工厂模式支持可插入的服务提供者。这就使得获取默认的XMLInputFactory实现的实例和调用XMLInputFactory.getInstance()一样简单，如清单 1 所示。

清单 1. 使用默认的 XMLInputFactory 实现创建XMLEventReader

                
String uri = "http://www.atomenabled.org/atom.xml";
URL url = new URL(uri);
InputStream input = url.openStream();
XMLInputFactory factory = XMLInputFactory.newInstance();
XMLEventReader reader = factory.createXMLEventReader(uri, input);
...

XMLInputFactory支持各种可用于创建XMLEventReader的输入源。除了 Java I/O 包中的InputStream和Reader之外，还支持 JAXP Source（来自 TrAX），后者有助于集成 StAX 和 JAXP 的转换 API（TrAX）。最后，还可以从XMLStreamReader创建XMLEventReader。这种用法可以很好地说明基于事件迭代器的 API 如何堆叠于基于指针的 API 之上。事实上，实现通常要使用其他输入源创建一个XMLStreamReader，然后再用它创建XMLEventReader。

使用XMLEventReader

创建XMLEventReader之后，应用程序可用它迭代表示底层 XML 流的InfoSet片段的事件。由于接口XMLEventReader扩展了java.util.Iterator，可以使用标准迭代器方法如hasNext()和next()。但是请注意，不支持remove()方法，如果调用该方法会抛出异常。

XMLEventReader还提供了一些方便的方法来简化 XML 处理：

nextEvent()本质上是一种等同于 Iterator 的next()方法的强类型方法，它返回一个XMLEvent，它是所有事件对象的基本接口。
nextTag()能够跳过所有无关紧要的空白直到下一个开始或结束标记。因此返回值将是StartElement或EndElement事件（参见后述）。该方法在处理纯元素（即文档类型声明 DTD 中声明为 EMPTY 的元素）内容时尤其有用。
getElementText()可以访问纯文本元素的文本内容（开始标签到结束标签之间）。从StartElement作为下一个预期事件开始，该方法在遇到EndElement之前将所有字符连接起来并返回结果字符串。
peek()可以得到迭代器将返回的下一个事件（如果有）但是不移动迭代器。

清单 2 示范了XMLEventReader方法如何用于迭代 Atom 提要。Atom 是用于 Web 发布的一种连锁格式。该例首先获得XMLInputFactory的默认实例然后用它创建XMLEventReader来解析给定 URL 的 Atom 提要。迭代事件的过程中，peek()方法判定下一个事件是否从 icon 元素开始，该元素包含提要的图标 URL。如果是，则用getElementText()方法获取元素的文本内容（即图标 URL），然后停止迭代。

清单 2. 使用peek()和getElementText()提取 Atom 提要的图标 URL

                
final QName ICON = new QName("http://www.w3.org/2005/Atom", "icon");
URL url = new URL(uri);
InputStream input = url.openStream();

XMLInputFactory factory = XMLInputFactory.newInstance();
XMLEventReader reader = factory.createXMLEventReader(uri, input);
try {
 while (reader.hasNext()) {
 XMLEvent event = reader.peek();
 if (event.isStartElement()) {
 StartElement start = event.asStartElement();
 if (ICON.equals(start.getName())) {
 System.out.println(reader.getElementText());
 break;
 }
 }

 reader.nextEvent();
 }
} finally {
 reader.close();
}

input.close();

返回的事件对象是不变的，应用程序可以保存到解析过程之后。但是应用程序也可定义不同的事件保留（或重用）策略，请参阅第 3 部分。

应用程序也可用getProperty(String)从底层实现中获得一个定制的或预先定义的属性值。完成之后，应用程序应该调用读取器的close()方法关闭它，以便释放处理所占用的资源。

使用XMLEventReader迭代事件流非常简单。处理这些事件需要知道和熟悉 StAXXMLEvent的层次结构，下面我们来讨论它。

回页首

事件以及如何在 XML 解析器中使用事件

前面已经强调过，XMLEventReader在解析过程的每一步之后通过事件对象和应用程序通信自己的状态。整个 API 中使用的事件对象的标准类型定义在javax.xml.stream.events包中。接口XMLEvent表示类型层次结构的根，所有类型的事件必须扩展该接口。表示各种指针层事件类型（在基于指针的 API 中）定义在接口XMLStreamConstants中。不过，在第 3 部分将看到也可使用定制的接口（只要扩展了XMLEvent）。

回页首

导航XMLEvent层次结构

从解析器中检索到事件之后，应用程序通常需要将其向下转换成 XMLEvent 的子类型以便访问该特定类型的信息。有多种方法，除了蛮力的 instanceof 检查（即通过一系列的 if/then 语句检查返回的事件是否实现了指定接口）以外，XMLEvent还提供了getEventType()方法返回XMLStreamConstants中定义的事件常量。可基于该信息对事件进行向下类型转换。比方说，如果事件的getEventType()返回START_ELEMENT，它就可以安全地转换成StartElement。

确定事件具体类型的另一种方法是使用为此提供的布尔查询方法。比如，如果事件是一个 Attribute 则isAttribute()返回 true，如果是StartElement则isStartElement()返回 true，等等。此外还有几种方便的方法可用于向下类型转换。asStartElement()、asEndElement()和asCharacters()分别将相应的事件转换成StartElement、EndElement和Characters。

清单 3 中首先使用isStartElement()和asStartElement()方法确定检索的事件是否是StartElement，然后将其向下转换成StartElement类型，从而访问元素名。

清单 3. 确定事件类型并向下转换成对应的接口

                
// get an event from the reader
...
if (event.isStartElement()) {
 StartElement start = event.asStartElement();
 // use methods provided by StartElement
...

除了和类型层次结构有关的方法外，XMLEventType还提供了getLocation()、getSchemaType()和writeAsEncodedUnicode(Writer)方法。getLocation()返回的Location对象提供了关于事件在底层输入源中的位置（比如该事件结束的行列号）的可选信息。getSchemaType()用于检索和给定事件有关的 XML Schema 信息（如果实现支持该功能）。writeAsEncodedUnicode(Writer)方法以标准的方式定义了将事件对象写入java.io.Writer的契约。这些方法对于定义定制的事件（将在下一期讨论）特别有用，因为可以让序列化器委托XMLEvent派生类的序列化而不需要应用程序使用定制的序列化器。

回页首

处理 XML 文档

解析表示完整 XML 文档的流时，XMLEventReader返回的第一个事件是StartDocument。该接口提供了获得文档本身信息的方法。比如，getSystemId()方法可以返回文档的系统 ID（如果知道的话）。getVersion()返回该文档使用的 XML 版本。默认的版本是 1.0，除非在文档的 XML 声明中指定了其他值。

getCharacterEncodingScheme()返回文档的字符编码，不论在 XML 声明中显式指定还是解析器自动检测。默认值为 UTF-8，除非给出了外部标记声明或者在文档 XML 声明中显式指定了该值，否则isStandalone()返回 true。

访问 DTD

如果XMLEventReader遇到 DTD 则返回 DTD 事件。如果应用程序不关心 DTD，可以通过将解析器的javax.xml.stream.supportDTD属性设置为 false 来关闭该特性。事件的getDocumentTypeDeclaration()方法可以将整个 DTD 作为一个字符串检索，包括内部子集。这个实现实际上可将 DTD 处理成更加结构化的形式（特定于提供的）并通过调用getProcessedDTD()方法使其可用。getEntities()方法返回EntityDeclaration事件列表（参见后述），这些事件表示一般外部实体声明，包括内部和外部实体。此外，getNotations()方法返回NotationDeclaration事件列表（同样将在后面说明），用于表示声明的符号。

EntityDeclaration事件表示在文档的 DTD 中声明的非解析的一般实体。该事件不被单独报告，而是作为 DTD 事件的一部分。它提供了用于获取实体的名称、公共和系统 ID 以及相关的符号名的方法（分别使用getName()、getPublicId()、getSystemId()和getNotationName()）。如果是内部实体，getReplacementText()方法可检索其替换文本。

类似的，NotationDeclaration事件也只能通过 DTD 事件访问。它表示符号声明。除了名称以外（getName()方法），该接口还提供了检索符号的公共和系统 ID 的方法（分别是getPublicId()和getSystemId()）。两者至少要有一个可用。

清单 4示范了如何处理非解析外部实体引用。该例中，虚构的 catalog 文档包含了对内容放在 PDF 或 HTML 文件（两者都不是有效的 XML）的出版物的引用。迭代这些事件的过程中，从 DTD 事件中提取符号声明并按照名字缓存。遇到实体引用时，取得实体声明并根据名称检索缓存的符号声明。实际的应用程序可能会使用符号标识符来定位适当的内容处理程序并使用实体的系统标识符作为其输入。

清单 4. 获取非解析实体和符号信息的例子

                
final String xml = "<?xml version=\"1.0\" standalone=\"no\" ?>" +
 "<!DOCTYPE catalog [" +
 "<!ELEMENT catalog (publication+) >" +
 "<!ELEMENT publication (#PCDATA) >" +
 "<!ATTLIST publication title CDATA #REQUIRED >" +
 "<!NOTATION pdf SYSTEM \"application/pdf\" >" +
 "<!NOTATION html SYSTEM \"text/html\" >" +
 "<!ENTITY overview SYSTEM \"resources/overview.pdf\" NDATA pdf 
>" +
 "<!ENTITY chapter1 SYSTEM \"resources/chapter_1.html\" NDATA html 
>" +
 "]>" +
 "<catalog>" +
 "<ext title=\"Overview\">&overview;</ext>" +
 "<ext title=\"Chapter 1\">&chapter1;</ext>" +
 "</catalog>";
Map notations = new HashMap();
StringReader input = new StringReader(xml);
XMLInputFactory f = XMLInputFactory.newInstance();
XMLEventReader r = f.createXMLEventReader("http://example.com/catalog.xml", 
input);
PrintWriter out = new PrintWriter(System.out);
try {
 while (r.hasNext()) {
 XMLEvent event = r.nextEvent();
 switch (event.getEventType()) {
 case XMLStreamConstants.ENTITY_REFERENCE:
 EntityReference ref = (EntityReference) event;
 EntityDeclaration decl = ref.getDeclaration();
 NotationDeclaration n = (NotationDeclaration) 
 notations.get(decl.getNotationName());

 out.print("Object of type ");
 out.print(n.getSystemId());
 out.print(" located at ");
 out.print(decl.getSystemId());
 out.print(" would be placed here.");
 break;
 case XMLStreamConstants.DTD:
 DTD dtd = (DTD) event;
 for (Iterator i = dtd.getNotations().iterator(); i.hasNext();) 
{
 n = (NotationDeclaration) i.next();
 notations.put(n.getName(), n);
 }
 default:
 event.writeAsEncodedUnicode(out);
 out.println();
 }
 }
} finally {
 r.close();
}

input.close();
out.flush();

回页首

处理元素、属性和名称空间声明

对每个元素，XMLEventReader都返回StartElement事件表示其开始标记，最后还有对应的EndElement事件表示结束标记。即使没有单独的开始和结束标记的空元素（比如 <empty-element/>），读取器也会在StartElement之后接着返回EndElement事件。

和其他事件相比可能会经常处理StartElement，因为它通常用于表示 XML 文档的大部分信息。检索元素的限定名可调用getName()。类 QName 表示 XML 限定名，它将限定名中的所有成分（如名称空间 URI、前缀和本地名）封装起来。getNamespaceContext()方法可以检索当前的名称空间上下文，包括当前所有名称空间的信息。检索元素的属性使用 getAttributes() 或者用 getAttributeByName(QName) 按属性名逐个检索（如果事先知道的话）。类似的，可以调用getNamespaces()获得元素上声明的任何名称空间。getNamespaceURI(String)返回捆绑到当前上下文中特定前缀的名称空间。

虽然被建模为事件并用接口 Attribute 表示，但元素的属性一般不作为单独的事件报告。而是通过 StartElement 事件访问。getName() 方法返回属性的限定名，getValue() 用字符串返回属性值。调用 isSpecified() 确定元素中是否指定了该属性，或者文档模式提供了默认值。方法 getDTDType() 返回属性的声明类型（如 CDATA、IDREF 或 NMTOKEN）。

类似的，元素中声明的所有名称空间都可通过StartElement事件访问而不需要单独报告。接口 Namespace 实际上是扩展了 Attribute，因为名称空间事实上被指定为元素的属性（包括特定的前缀）。方法getPrefix()是获得名称空间属性的本地名的快捷方式（除非是默认名称空间声明，这种情况下前缀是一个空字符串而非 “xmlns”）。与此类似，getNamespaceURI()方法返回属性值（即名称空间 URI）。为了判断该名称空间是否是默认名称空间（具有空前缀），可调用isDefaultNamespaceDeclaration()。

EndElement表示元素的结束标记（或元素标记的结束，如果是空元素的话）。可使用getName()方法获取元素的限定名，使用getNamespaces()确定那些名称空间超出了作用域。

清单 5 报告所有的 Atom 扩展元素和属性（即不属于 Atom 名称空间或 XML 名称空间的元素和属性）。对每个StartElement事件都检查其名称空间 URI 是否是 Atom 名称空间 URI。然后迭代所有的属性，使用Attribute接口获得属性名。最后报告不属于 Atom 或 XML 名称空间的属性。

清单 5. 从StartElement事件检索元素属性

                
final String ATOM_NS = "http://www.w3.org/2005/Atom";

URL url = new URL(uri);
InputStream input = url.openStream();
XMLInputFactory f = XMLInputFactory.newInstance();
XMLEventReader r = f.createXMLEventReader(uri, input);
try {
 while (r.hasNext()) {
 XMLEvent event = r.nextEvent();
 if (event.isStartElement()) {
 StartElement start = event.asStartElement();
 boolean isExtension = false;
 boolean elementPrinted = false;
 if (!ATOM_NS.equals(start.getName().getNamespaceURI())) {
 System.out.println(start.getName());
 isExtension = true;
 elementPrinted = true;
 }

 for (Iterator i = start.getAttributes(); i.hasNext();) {
 Attribute attr = (Attribute) i.next();
 String ns = attr.getName().getNamespaceURI();
 if (ATOM_NS.equals(ns))
 continue;

 if ("".equals(ns) && !isExtension)
 continue;

 if ("xml".equals(attr.getName().getPrefix()))
 continue;

 if (!elementPrinted) {
 elementPrinted = true;
 System.out.println(start.getName());
 }

 System.out.print("\t");
 System.out.println(attr);
 }
 }
 }
} finally {
 r.close();
}

input.close();

表示文本内容

Characters事件实际上用于表示三类文本事件：实际内容的文本（CHARACTERS）、CDATA部分以及可忽略的空白（SPACE）。它提供了区分这三种文本类型的方法，如果是 CDATA 事件则isCData()返回 true，如果是 SAPCE 事件则isIgnorableWhitespace()返回 true。getData()方法返回该事件的文本。此外，isWhiteSpace()说明文本是否全部由空白字符组成（不一定是可忽略的空白）。

未解析的一般实体引用由EntityReference事件报告。只有当读取器的javax.xml.stream.isReplacingEntityReferences属性设为 false 时才会报告解析实体。否则，就要求解析器用替换文本（在声明中做了指定）代替内部实体引用并作为一般字符事件报告，如果是解析的外部实体则作为正常标记报告。接口EntityReference提供了获取实体名及其声明的方法（作为EntityDeclaration事件），即通过分别调用getName()和getDeclaration()。

事件PROCESSING_INSTRUCTION和COMMENTS分别用ProcessingInstruction和Comment表示。ProcessingInstruction提供了getTarget()和getData()方法，用来检索指令的目标和数据。接口Comment定义的getText()方法可以检索注释文本。

清单 6 中的例子说明了如何使用 Characters 事件报告各种类型的文本内容。同时也说明了接口 Comment 和 ProcessingInstruction 的用法。

清单 6. 报告字符和处理指令事件

                
final String ATOM_NS = "http://www.w3.org/2005/Atom";

URL url = new URL(uri);
InputStream input = url.openStream();

XMLInputFactory f = XMLInputFactory.newInstance();
XMLEventReader r = f.createXMLEventReader(uri, input);
try {
 while (r.hasNext()) {
 XMLEvent event = r.nextEvent();
 if (event.isCharacters()) {
 Characters c = event.asCharacters();
 System.out.print("Characters");
 if (c.isCData()) {
 System.out.print(" (CDATA):");
 System.out.println(c.getData());
 } else if (c.isIgnorableWhiteSpace()) {
 System.out.println(" (IGNORABLE SPACE)");
 } else if (c.isWhiteSpace()) {
 System.out.println(" (EMPTY SPACE)");
 } else {
 System.out.print(": ");
 System.out.println(c.getData());
 }
 } else if (event.isProcessingInstruction()) {
 ProcessingInstruction pi = (ProcessingInstruction) event;
 System.out.print("PI(");
 System.out.print(pi.getTarget());
 System.out.print(", ");
 System.out.print(pi.getData());
 System.out.println(")");
 } else if (event.getEventType() == XMLStreamConstants.COMMENT) {
 System.out.print("Comment: ");
 System.out.println(((Comment) event).getText());
 }
 }
} finally {
 r.close();
}

input.close();

XMLEventReader提交的最后一个事件是EndDocument，它没有定义新方法。

回页首

筛选事件和操纵事件流

可以看到，使用XMLEventReader与XMLEvent及其子类型解析 XML 非常简单。通过控制解析过程，应用程序可以决定对每个事件做什么。但是如果应用程序（或某个组件）需要特定内容类型的事件流，也可以创建专门的事件读取器。比方说，很容易创建筛选过的XMLEventStream只允许特定的事件传递给调用者。只需要对XMLInputFactory实例调用createXMLEventReader(XMLEventReader, EventFilter)方法，并传递基本事件读取器和接受/拒绝从基本读取器获得的事件的简单筛选器。清单 7 给出了一个筛选器的例子（只接受处理指令事件，应用程序可以定义任何接受条件）。

清单 7. 使用EventFilter发现文档中的处理指令

                
URL url = new URL(uri);
InputStream input = url.openStream();

XMLInputFactory factory = XMLInputFactory.newInstance();
XMLEventReader r = factory.createXMLEventReader(uri, input);
XMLEventReader fr = factory.createFilteredReader(r, new EventFilter() {
 public boolean accept(XMLEvent e) {
 return e.getEventType() == PROCESSING_INSTRUCTION;
 }
});

try {
 while (fr.hasNext()) {
 XMLEvent e = fr.nextEvent();
 if (e.getEventType() == PROCESSING_INSTRUCTION) {
 ProcessingInstruction pi = (ProcessingInstruction) e;
 System.out.println(pi.getTarget() + ": " + pi.getData());
 }
 }
} finally {
 fr.close();
 r.close();
}

input.close();

要执行更复杂的流操作，可扩展EventReaderDelegate，这是javax.xml.stream.util包中定义的一个工具类。该类允许开发人员包装已有的XMLEventStream，把所有调用都默认委托给它。然后让子类改写某些特殊的方法从而改变基本读取器的行为。比如，可通过该方法在事件流中插入合成事件或者转换它。迭代修改过的流的应用程序不需要知道它处理的是什么。清单 8 给出了使用这种技术的一个例子。

清单 8. 使用EventReaderDelegate向流中插入注释

                
URL url = new URL(uri);
InputStream input = url.openStream();

XMLInputFactory factory = XMLInputFactory.newInstance();
XMLEventReader r = factory.createXMLEventReader(uri, input);

XMLEventReader fr = new EventReaderDelegate(r) {

 private Comment comment;

 public XMLEvent nextEvent() throws XMLStreamException {
 XMLEvent event = null;
 if (comment != null) {
 event = comment;
 comment = null;
 return event;
 }

 event = super.nextEvent();
 if (event.isStartDocument()) {
 XMLEventFactory ef = XMLEventFactory.newInstance();
 comment = ef.createComment("Generated " + new Date());
 }

 return event;
 }
};

OutputStreamWriter writer = new OutputStreamWriter(System.out);
try {
 while (fr.hasNext()) {
 XMLEvent event = fr.nextEvent();
 event.writeAsEncodedUnicode(writer);
 }
} finally {
 fr.close();
 r.close();
}

input.close();
writer.flush();

请注意，要实现该例应用程序必须能够创建标准事件的实例（这里是 Comment）。这种功能要用到类XMLEventFactory，它定义了各种标准事件类型的创建方法（事实上每个方法都有数个重载版本，根据事件的类型具有不同的参数设置）。和XMLInputFactory类似，该类也实现了抽象工厂模式：调用getInstance()获得它的具体实例。

回页首

结束语

本文仅介绍了用 StAX 基于事件迭代器的 API 所能完成的一部分功能，见证了它的灵活性以及易用性。第 3 部分中将介绍如何创建和使用定制事件。还将探究 StAX 序列化器 API。

参考资料

学习

您可以参阅本文在 developerWorks 全球网站上的英文原文。
使用 StAX 解析 XML，第 1 部分: Streaming API for XML (StAX) 简介（Peter Nehrer，developerWorks，2007 年 3 月）：从 StAX 及其用于处理 XML 的基于指针的 API 的概述开始学习本系列（共分 3 部分）。
使用 StAX 解析 XML，第 3 部分: 使用定制事件和编写 XML（Peter Nehrer，developerWorks，2007 年 7 月）：将介绍定制化技术，该技术使用由应用程序定义的事件，您还将看到如何创建定制事件类并使用它们结合基于事件迭代器的 API 来处理 XML。最后（同样也是重要的一点），将回顾由 StAX 提供的可将 XML 编写为标记流和事件对象的序列化器 API。
JSR 173: Streaming API for XML：阅读这份 Java Specification Request，它提出了可拉式解析 XML 的基于 Java 的 API。
XML Pull Parsing：这个站点致力于推广和培训拉式 XML 解析。
BEA Dev2Dev Online: StAX：BEA 关于 StAX 的网页，包括 WebLogic StAX 实现的链接。
利用 Java 技术进行 XML 编程，第 1 部分（Doug Tidwell，developerWorks，2004 年 2 月）：获得关于使用 Java 进行 XML 编程的教程，内容包括 XML 的通用 API，以及如何解析、创建、操作和转换 XML 文档。
JAXP 全面介绍，第 1 部分（Brett McLaughlin，developerWorks，2005 年 6 月）：了解如何使用 JAXP API 的解析和验证特性。
技巧: 使用 XML 流解析器（Berthold Daum，developerWorks，2003 年 11 月）：这篇技巧介绍了如何利用 StAX 提供的流解析器高效解析 XML。
技巧: 使用 StAX 编写 XML 文档（Berthold Daum，developerWorks，2004 年 1 月）：使用 StAX 序列化器 XML —— 解析 XML 文档并将 XML 文档写入一个输出流。
An XSLT style sheet and an XML dictionary approach to internationalization（Laura Menke，developerWorks，2001 年 4 月）：阅读 XSLT 用于解决实际问题的例子：通过词典驱动的方法对网页实现动态国际化，更新站点内容时减少需要编辑的文件。
XSLT 处理程序是如何工作的（Benoît Marchal，developerWorks，2004 年 4 月）：了解 XSLT 处理程序的有关理论，提高 XSLT 编程效率。
准备从 XSLT 1.0 升级到 2.0，第 1 部分: XSLT 的改进（David Marston 和 Joanne Tong，developerWorks，2006 年 11 月）：对 XSLT 2.0 的主要特性和 XSLT 1.0 （目前使用的版本）的不足之处进行了介绍。
IBM XML 认证：了解如何才能成为一名 IBM 认证的 XML 及相关技术的开发人员。
XML 技术库：developerWorks 中国网站 XML 专区提供了大量技术文章、技巧、教程、标准以及 IBM 红皮书。
developerWorks 技术活动和网络广播：随时关注技术的最新进展。
通过developerWorks 中国网站 XML 专区了解 XML 的方方面面。