翻译:linqingfeng
英语原文: http://www.w3schools.com/schema/default.asp

XML Schema is an XML based alternative to DTD.
[XML Schema是一种XML文件类型定义的基本方法]

An XML schema describes the structure of an XML document.
[每个XML Schema描述XML文档的结构]

The XML Schema language is also referred to as XML Schema Definition (XSD).
[XML Schema也称为XML模式定义(XSD)]

What You Should Already Know
[在学习之前你应该知道什么]

Before you study the XML Schema Language, you should have a basic understanding of XML and XML Namespaces. It will also help to have some basic understanding of DTD.
[在你开始学习XML Schema语言之前，你应该对XML和XML的命名空间有基本的了解。那样会帮助你了解DTD（Document Type Definition文件类型定义）].

What is an XML Schema?
[XML Schema是什么？]

The purpose of an XML Schema is to define the legal building blocks of an XML document, just like a DTD.
[XML Schema目标是定义合法的XML文档，就像DTD那样]

An XML Schema:
[任一个XML Schema：]

• defines elements that can appear in a document
  [定义在文档中的元素]
• defines attributes that can appear in a document
  [定义在文档中的属性]
• defines which elements are child elements
  [定义哪些元素为子元素]
• defines the order of child elements
  [定义子元素的阶]
• defines the number of child elements
  [定义子元素的数]
• defines whether an element is empty or can include text
  [定义元素是否为空]
• defines data types for elements and attributes
  [定义元素和属性的数据类型]
• defines default and fixed values for elements and attributes
  [定义元素和属性的默认值和固定值]

XML Schemas are the Successors of DTDs
[XML Schemas是DTD的替代者]

We think that very soon XML Schemas will be used in most Web applications as a replacement for DTDs. Here are some reasons:
[我们认为很快XML Schemas就会替代DTD而大量应用于Web应用。原因有如下几个：]

• XML Schemas are extensible to future additions
  [XML Schemas易于未来的扩展]
• XML Schemas are richer and more useful than DTDs
  [XML Schemas比DTD更有用处]
• XML Schemas are written in XML
  [XML Schemas本身就是XML]
• XML Schemas support data types
  [XML Schemas支持数据类型]
• XML Schemas support namespaces
  [XML Schemas支持命名空间]

XML Schema is a W3C Recommendation
[XML Schemas是W3C推荐使用的]

XML Schema was originally proposed by Microsoft, but became an official W3C recommendation in May 2001.
[XML Schemas最初由微软提出，并在2001年五月成为W3C的官方指定标准]

The specification is now stable and has been reviewed by the W3C Membership.
[其规格文档现已稳定并加入到W3C标准中]

XML Schemas - Why?
[为什么选用XML Schemas？]

There are a number of reasons why XML Schema is better than DTD.
[XML Schemas有趣多方面优于DTD]

XML Schema has Support for Data Types
[XML Schemas支持数据类型]

One of the greatest strengths of XML Schemas is the support for data types.
[XML Schemas其中最好的方面之一就是支持数据类型]

With the support for data types:
[对数据类型提供的支持有：]

• It is easier to describe permissible document content
  [易于描述文档内容是否允许]
• It is easier to validate the correctness of data
  [易于验证数据的正确性]
• It is easier to work with data from a database
  [易于复合数据库操作数据]
• It is easier to define data facets (restrictions on data)
  [易于定义数据约束]
• It is easier to define data patterns (data formats)
  [易于格式化数据]
• It is easier to convert data between different data types
  [易于数据在不同的数据类型中转换]

XML Schemas use XML Syntax
[XML Schemas是用XML的语法]

Another great strength about XML Schemas is that they are written in XML.
[另一个最大的优点是XML Schemas是用XML书写的]

Because XML Schemas are written in XML:
[XML Schemas用XML书写的好处有：]

• You don't have to learn another language
  [不用学习另一种新的语言]
• You can use your XML editor to edit your Schema files
  [能在XML的编辑器中编写XML Schemas文件]
• You can use your XML parser to parse your Schema files
  [能用XML解释器去解释XML Schemas文件]
• You can manipulate your Schema with the XML DOM
  [能用XML DOM(Document Object Model,文档物件模型)操作XML Schemas文件]
• You can transform your Schema with XSLT
  [能用XSLT来转换XML Schemas文件]

XML Schemas Secure Data Communication
[XML Schemas数据通信更安全]

When data is sent from a sender to a receiver it is essential that both parts have the same "expectations" about the content.
[当数据从发送方传递给接受方时, XML Schemas会让显示的内容达到你的”期望”]

With XML Schemas, the sender can describe the data in a way that the receiver will understand.
[XML Schemas文件能让发送方的数据被接受方所解释]

A date like this: "03-11-2004" will, in some countries, be interpreted as 3. November and in other countries as 11. March, but an XML element with a data type like this:
[例如一个日期的表述” 03-11-2004”,在某些国家会被解释为11月3日,而在另一些国家却被解释成3月11日],而相同的数据在XML上表述成:

<date type="date">2004-03-11</date>

ensures a mutual understanding of the content because the XML data type date requires the format YYYY-MM-DD.
[由于XML数据类型定义了他的格式是YYYY-MM-DD,从而使能正确的表述其内容的含义]

XML Schemas are Extensible
[XML Schemas是可扩展的]

XML Schemas are extensible, just like XML, because they are written in XML.
[XML Schemas是可扩展的,就像普通的XML一样,因为他本身就是一个XML]

With an extensible Schema definition you can:
[可扩展性的定义带来的好处有：]

• Reuse your Schema in other Schemas
  [可从用你的规则与其他规则]
• Create your own data types derived from standard types
  [从其他的标准的数据类型中创建自定义的数据类型]
• Reference multiple schemas from the same document
  [同一个文档可以引用多个规则]

Well-Formed is not Enough
[良好格式还并不足够]

A well-formed XML document is a document that conforms to the XML syntax rules:
[一个具有良好格式的XML文档是完全符合XML的语法规则的：]

• must begin with the XML declaration
  [必须由XML声明开始]
• must have one unique root element
  [必须有且仅有一个根节点]
• all start tags must match end-tags
  [所有标签都必须有相对的结束标签]
• XML tags are case sensitive
  [XML的标签是区分大小写的]
• all elements must be closed
  [所有的元素都必须是闭合的]
• all elements must be properly nested
  [所有元素都必须合理的嵌套(元素不可以交叉)]
• all attribute values must be quoted
  [所有的属性都必须被引用]
• XML entities must be used for special characters
  [所有的XML实体都必须用特殊的字符来做]

Even if documents are Well-Formed they can still contain errors, and those errors can have serious consequences. Think of this situation: you order 5 gross of laser printers, instead of 5 laser printers. With XML Schemas, most of these errors can be caught by your validating software.
[即使文档完全符合格式也会包含错误,而且有些错误会有严重的逻辑问题.想一想这样的情况:你订购五台激光打印机是为了来替代五台激光打印机.配合XML Schemas,大部分的错误都可以由你的软件校验出来的.]

XSD How To
[XSD如何]

XML documents can have a reference to a DTD or an XML Schema.
[XML文档能和一个DTD或者一个XML Schema相关]

A Simple XML Document
[一个简单的XML文档]

Look at this simple XML document called "note.xml":
[看看这个名为"note.xml"的XML文档]

A Simple DTD
[一个简单的DTD]

This is a simple DTD file called "note.dtd" that defines the elements of the XML document above ("note.xml"):
[这个简单的DTD"note.dtd"定义了"note.xml"中的元素:]

Line 1 defines the note element to have four elements: "to, from, heading, body". Line 2-5 defines the to element to be of the type "#PCDATA", the from element to be of the type "#PCDATA", and so on...
[第一行定义了note元素有四个子元素: "to, from, heading, body".而第二行到第五行分别定义了to和from等元素为"#PCDATA"]

A Simple XML Schema
[一个简单的XML Schema]

This is a simple XML Schema file called "note.xsd" that defines the elements of the XML document above ("note.xml"):
[这个简单的XML Schema文件"note.xsd"同样定义了"note.xml"中的元素：]

The note element is said to be of a complex type because it contains other elements. The other elements (to, from, heading, body) are said to be simple types because they do not contain other elements. You will learn more about simple and complex types in the following chapters.
[那个note元素由于包含有其他的子元素而被定义为complex type(复合类型). 其他包含在它里面的元素(to, from, heading, body)都被定义为simple types(简单类型). 你将会在以后的章节里面学到更多关于复合类型和简单类型的知识.]

A Reference to a DTD
[DTD的引用]

This XML document has a reference to a DTD:
[这个XML文档引用自一个DTD:]

A Reference to an XML Schema
[XML Schema的引用]

This XML document has a reference to an XML Schema:
[这个XML文档引用自一个XML Schema文档:]

XSD - The <schema> Element
[XSD中的<schema>元素]

The <schema> element is the root element of every XML Schema!
[<schema>元素是每一个XML Schema文件的根元素!]

The <schema> Element
[<schema>元素]

The <schema> element is the root element of every XML Schema:
[[<schema>元素是每一个XML Schema文件的根元素:]

The <schema> element may contain some attributes. A schema declaration often looks something like this:
[[<schema>元素包含一些属性.一般声明如下:]

The following fragment:
[以下片段:]

indicates that the elements and data types used in the schema (schema, element, complexType, sequence, string, boolean, etc.) come from the "http://www.w3.org/2001/XMLSchema" namespace. It also specifies that the elements and data types that come from the "http://www.w3.org/2001/XMLSchema" namespace should be prefixed with xs:
[说明元素和数据类型的使用模式(schema, element, complexType, sequence, string, Boolean等等)来自于"http://www.w3.org/2001/XMLSchema"命名空间.同时也可用xs:作为前缀]

This fragment:
[如下片段:]

indicates that the elements defined by this schema (note, to, from, heading, body.) come from the "http://www.w3schools.com" namespace.
[说明元素(note, to, from, heading, body.)的使用模式来自于命名空间"http://www.w3schools.com"]

This fragment:
[如下片段:]

indicates that the default namespace is "http://www.w3schools.com".
[说明默认的命名空间是"http://www.w3schools.com".]

This fragment:
[如下片段:]

indicates that any elements used by the XML instance document which were declared in this schema must be namespace qualified.
[说明所有全局元素的子元素将被以缺省方式放到目标命名空间，连同全局元素或者类型一起]

Referencing a Schema in an XML Document
[在XML文件中引用Schema]

This XML document has a reference to an XML Schema:
[如下XML文档有一个XML Schema的引用:]

The following fragment:
[下面片段:]

specifies the default namespace declaration. This declaration tells the schema-validator that all the elements used in this XML document are declared in the "http://www.w3schools.com" namespace.
[声明默认的命名空间.此声明告知模式校验器让所有XML元素都在命名空间"http://www.w3schools.com"下]

Once you have the XML Schema Instance namespace available:
[有时你可以用到XML模式实例命名空间:]

you can use the schemaLocation attribute. This attribute has two values. The first value is the namespace to use. The second value is the location of the XML schema to use for that namespace:
[你能用上schemaLocation这个属性.这个属性有两个含义.第一个含义是这个命名空间被使用.第二个含义是定位XML schema用到的命名空间:]

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=705007

RSS Introduction [RSS介绍]
An introduction to what RSS is and how it can be used.
介绍什么是RSS，它的应用。

RSS History [RSS历史]
How RSS started and how it has been developed and changed
RSS是怎么诞生的，它是怎样发展和变化的.

RSS Syntax [RSS语法]
A brief introduction how to make RSS.
制作RSS的简单介绍

RSS Channel [RSS频道]
How to make and what can be included in the <channel> element.
怎么完成<channel>元素里的内容

RSS Item [RSS内容]- How to make and what can be included in the <item> element.
怎样的<item>元素才算合理的

RSS Publishing [RSS 发布]- How to publish your RSS.
怎样发布的你的RSS

RSS Readers [RSS阅读器]- How to read other site's RSS.
怎样阅读其他网站的RSS

<?xml version="1.0" encoding="ISO-8859-1" ?>

<rss version="2.0">

<channel>

<title>W3Schools</title>
<link>http://www.w3schools.com</link>
<description>W3Schools Web Tutorials </description>

<item>
<title>RSS Tutorial</title>

<link>http://www.w3schools.com/rss</link>
<description>Check out the RSS tutorial
on W3Schools.com</description>
</item>

</channel>
</rss>

<rss version="2.0">

<channel>

<title>W3Schools</title>
<link>http://www.w3schools.com</link>

<description>W3Schools Web Tutorials</description>

<item>
<title>RSS Tutorial</title>
<link>http://www.w3schools.com/rss</link>
<description>Check out the RSS tutorial
on W3Schools.com</description>
</item>

</channel>
</rss>

<!-- This is a comment -->

<title>W3Schools News Update</title>

<link>http://www.w3schools.com</link>

<description>W3Schools Web Tutorials</description>

<title>W3Schools New RSS Tutorial</title>

<link>http://www.w3schools.com/rss</link>

<description>W3Schools RSS Tutorial</description>

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=704849

这是篇细探 JAXP，Sun 的 Java API for XML 的文章，帮助解除了有关 JAXP 本质和服务目的的疑惑。本文讲解了 JAXP 的基本概念，演示 XML 语法分析为什么需要 JAXP，并显示如何轻易更改 JAXP 使用的语法分析器。本文还进一步讲述了 SAX 和 DOM 这两个流行的与 JAXP 相关的 Java 和 XML API。

Java 和 XML 在每一个技术领域都制造了新闻，并且对于软件开发人员来说，似乎是 1999 年和 2000 年最重要的发展。结果，Java 和 XML API 的数量激增。其中两个最流行的 DOM 和 SAX 还引起极大兴趣，而 JDOM 和数据绑定 API 也接踵而来。只透彻理解这些技术中的一个或两个就是一项艰巨任务，而正确使用所有这些技术就会使您成为专家。但在去年，另一个 API 给人留下了深刻印象，它就是 Sun 的 Java API for XML，通常称为 JAXP。如果考虑到 Sun 在其平台上还没有任何特定于 XML 的产品，那么这个进展就不足为奇。而令人惊奇的是人们对 JAXP 了解的缺乏。多数使用它的开发人员在他们所用的这个 API 的概念理解上都有错误。

什么是 JAXP？

本文假设您有 SAX 和 DOM 的基本知识。这里实在没有足够篇幅来解释 SAX、DOM 和 JAXP。如果您是 XML 语法分析的新手，那么可能要通过联机资源阅读 SAX 和 DOM，或者浏览我的书。（ 参考资源 一节中有至 API 和我的书的链接。）获得基本知识后再看本文会比较好。

回页首

API 还是抽象？

在讲解代码之前，介绍一些基本概念很重要。严格地说，JAXP 是 API，但是将其称为抽象层更准确。它不提供处理 XML 的新方式，不补充 SAX 或 DOM，也不向 Java 和 XML 处理提供新功能。（如果在这点上理解有误，则本文正好适合您！）它只是使通过 DOM 和 SAX 处理一些困难任务更容易。如果在使用 DOM 和 SAX API 时遇到特定于供应商的任务，它还使通过独立于供应商的方式处理这些任务成为可能。

虽然要分别讲述所有这些特性，但是真正需要掌握的是：JAXP 不提供语法分析功能 ！没有 SAX、DOM 或另一个 XML 语法分析 API，就 无法分析 XML 语法 。有很多人曾让我将 DOM、SAX 或 JDOM 与 JAXP 进行对比。但进行这些对比是不可能的，因为前三个 API 与 JAXP 的目的完全不同。SAX、DOM 和 JDOM 都分析 XML 语法。而 JAXP 却提供到达这些语法分析器和结果的方式。它自身不提供分析文档语法的新方法。如果要正确使用 JAXP，则一定要弄清这点。这将使您比其它 XML 开发人员领先一大截。

如果仍然怀疑（或认为我故弄玄虚），请从 Sun 的 Web 站点下载 JAXP 分发（请参阅 参考资料 一节），然后就会知道基本 JAXP 是什么。在包括的 jar ( jaxp.jar ) 中 只有六个类 ！这个 API 会有多难哪？所有这些类（ javax.xml.parsers 包的一部分）都位于现有语法分析器之上。这些类中的两个还用于错误处理。JAXP 比人们想象的要简单得多。那么，为什么还感到困惑哪？

回页首

Sun 的 JAXP 和 Sun 的语法分析器

JAXP 下载时包括 Sun 的语法分析器。所有 parser 器类作为 com.sun.xml.parser 包和相关子包的一部分位于 parser.jar 档案中。应该知道，该语法分析器（代码名为 Crimson） 不 是 JAXP 自身的一部分。它是 JAXP 版本的一部分，但不是 JAXP API 的一部分。令人困惑吗？有一点。换这种方式想想：JDOM 与 Apache Xerces 语法分析器一起提供。该语法分析器不是 JDOM 的一部分，但由 JDOM 使用，所以包括它，以确保 JDOM 可以单独使用。JAXP 也是如此，但不象 JDOM 那样好表达：JAXP 与 Sun 的语法分析器一起提供，以便可以立即使用。但是，很多人将 Sun 的语法分析器中包括的类当成 JAXP API 的一部分。例如，新闻组中一个常见的问题是：“怎样使用 JAXP 中的 XMLDocument 类？其目的是什么？”这个答案可有些复杂。

首先， com.sun.xml.tree.XMLDocument 类不是 JAXP 的一部分。它是 Sun 语法分析器的一部分。所以，这个问题从一开始就给人以误导。其次，JAXP 的整个意义在于在处理语法分析器时提供供应商独立性。使用 JAXP 的同一代码可以与 Sun 的 XML 语法分析器、Apache 的 Xerces XML 语法分析器和 Oracle 的 XML 语法分析器一起使用。而使用特定于 Sun 的类是个坏主意。这与 JAXP 的整个意义相背离。现在看出来这个问题怎样混淆概念了吗？语法分析器和 JAXP 发行版本（至少是 Sun 的版本）中的 API 被混为一谈，开发人员将其中一个的类和特性当成是另一个的了，反之亦然。

回页首

旧和新

关于 JAXP，最后需要指出的是：使用 JAXP 有一些缺陷。例如，JAXP 只支持 SAX 1.0 和 DOM 第一层规范。SAX 2.0 从 2000 年 5 月起就完成，DOM 第二层规范支持甚至在大多数语法分析器中存在更长时间。DOM 第二层规范还没有完成，但确实足够稳定以用于生产。这两个 API 的新版本都有重大改进，最明显的是对 XML 名称空间的支持。该支持还允许“XML Schema 确认”，这个与 XML 相关的另一热门技术。公平地说，当 JAXP 发布 1.0 最终发行版时，SAX 2.0 和 DOM 第一层规范都还没有完成。但是，由于没有包括这些新版本，确实为开发人员带来很大不便。

还可以使用 JAXP，但是也可以等待 JAXP 1.1，它支持 SAX 2.0 和 DOM第二层规范 。否则，将发现，JAXP 提供的优点以 SAX 和 DOM 最新版本中的功能为代价，并使应用程序更加难以编码。无论是否等待下一个 JAXP 发行版，都要留意这个问题。如果将 JAXP 与语法分析器一起使用，而语法分析器支持的 DOM 和 SAX 版本比 JAXP 支持的要高，则可能会有类路径问题。所以，事先留意一下，并且，一旦有 JAXP 1.1，马上升级。基本理解 JAXP 之后，让我们看一下 JAXP 依赖的 API：SAX 和 DOM。

回页首

从 SAX 开始

SAX （Simple API for XML）是用于处理 XML 的事件驱动方法。它基本由许多回调函数组成。例如，每当 SAX 语法分析器遇到元素的开始标记时就调用 startElement() 。对于字符串，将调用 characters() 回调函数，然后在元素结束标记处调用 endElement() 。还有很多回调函数用于文档处理、错误和其它词汇结构。现在知道这是怎么回事了。SAX 程序员实现一个定义这些回调函数的 SAX 接口。SAX 还实现一个名为 HandlerBase 的类，该类实现所有这些回调函数，并提供所有这些回调方法的缺省空实现。（提到这一点是因为它在后面讲到的 DOM 中很重要。）SAX 开发人员只需扩展这个类，然后实现需要插入特定逻辑的方法。所以，SAX 的关键在于为这些不同的回调函数提供代码，然后允许语法分析器在适当的时候触发这些回调函数中的每一个。

因此，典型的 SAX 过程如下：

• 用特定供应商的语法分析器实现创建一个 SAXParser 实例
• 注册回调实现（例如，通过使用扩展 HandlerBase 的类）
• 开始进行语法分析，然后在触发回调实现时等待

JAXP 的 SAX 组件提供执行所有这些步骤的简单方式。如果没有 JAXP，SAX 语法分析器要直接从供应商类（如 org.apache.xerces.parsers.SAXParser ）进行实例化，或者必须使用名为 ParserFactory 的帮助类。第一个方法的问题很明显：不独立于供应商。第二个方法的问题在于类厂需要一个自变量，即要使用的语法分析器类的字符串名称（还是那个 Apache 类 org.apache.xerces.parsers.SAXParser ）。可以通过将不同语法分析器作为 String 传递来更改语法分析器。使用这种方法不必更改任何 import 语句，但是还是要重新编译类。这显然不是最佳解决方案。如果能够不重新编译类而更改语法分析器，可能会简单得多，是不是这样呢？

JAXP 提供了更好的替代方法：它允许将语法分析器作为 Java 系统属性来提供。当然，当从 Sun 下载版本时，将得到使用 Sun 语法分析器的 JAXP 实现。可以从 Apache XML Web 站点下载在 Apache Xerces 上构建其实现的相同 JAXP 接口。因此（无论哪一种情况），更改正在使用的语法分析器需要更改类路径设置，即从一种语法分析器实现更改到另一个，但是 不要求重新编译代码。这就是 JAXP 的魔力，或抽象性。

SAX 语法分析器一瞥

JAXP SAXParserFactory 类是能够轻易更改语法分析器实现的关键所在。必须创建这个类的新实例（等一会将讲到）。创建新实例之后，类厂提供一个方法来获得支持 SAX 的语法分析器。在内部，JAXP 实现处理依赖于供应商的代码，使您的代码不受影响。这个类厂还提供其它一些优秀特性。

除创建 SAX 语法分析器实例的基本工作之外，类厂还允许设置配置选项。这些选项影响所有通过类厂获得的语法分析器实例。JAXP 1.0 中两个可用的功能是设置名称空间敏感性 ( setNamespaceAware (boolean awareness))，和打开确认 ( setValidating (boolean validating))。请记住，一旦设置了这些选项，在调用该方法之后，它们将影响 所有从 类厂获得的实例。

设置了类厂之后，调用 newSAXParser() 将返回一个随时可用的 JAXP SAXParser 类实例。这个类封装了一个下层的 SAX 语法分析器（SAX 类 org.xml.sax.Parser 的实例）。它还防止向语法分析器类添加任何特定于供应商的附加功能。（还记得以前对 XmlDocument 的讨论吗？）这个类可以开始进行实际的语法分析。以下清单显示如何创建、配置和使用 SAX 类厂。

import java.io.File;
            import java.io.IOException;
            import java.io.OutputStreamWriter;
            import java.io.Writer;
            // JAXP
            import javax.xml.parsers.FactoryConfigurationError;
            import javax.xml.parsers.ParserConfigurationException;
            import javax.xml.parsers.SAXParserFactory;
            import javax.xml.parsers.SAXParser;
            // SAX
            import org.xml.sax.AttributeList;
            import org.xml.sax.HandlerBase;
            import org.xml.sax.SAXException;
            public class TestSAXParsing {
            public static void main(String[] args) {
            try {
            if (args.length != 1) {
            System.err.println ("Usage: java TestSAXParsing [filename]");
            System.exit (1);
            }
            // 获得SAX 语法分析器类厂
            SAXParserFactory factory = SAXParserFactory.newInstance();
            //设置设置名称空间敏感性选项，关掉确认选项
            factory.setValidating(true);
            factory.setNamespaceAware(false);
            SAXParser parser = factory.newSAXParser();
            parser.parse(new File(args[0]), new MyHandler());
            } catch (ParserConfigurationException e) {
            System.out.println("The underlying parser does not support " +
            " the requested features.");
            } catch (FactoryConfigurationError e) {
            System.out.println("Error occurred obtaining SAX Parser Factory.");
            } catch (Exception e) {
            e.printStackTrace();
            }
            }
            }
            class MyHandler extends HandlerBase {
            //通过 DocumentHandler, ErrorHandler等实现的SAX回调函数
            }
            

请注意，在这段代码中，在使用类厂时可能发生两个特定于 JAXP 的问题：无法获得或配置 SAX 类厂，以及无法配置 SAX 语法分析器。当无法获得 JAXP 实现中指定的语法分析器或系统属性时，通常会发生第一个问题 FactoryConfigurationError 。当正在使用的语法分析器中的特性不可用时，会发生第二个问题 ParserConfigurationException 。这两个问题都容易处理，应该不会对 JAXP 的使用造成任何困难。

在获得类厂、关闭名称空间并打开“确认”之后，将获得 SAXParser ，然后开始语法分析。请注意， SAX 语法分析器的 parse() 方法取得前面提到的 SAX HandlerBase 类的一个实例。（可以通过完整的 Java 清单 查看该类的实现 。）还要传递要进行语法分析的文件。但是， SAXParser 所包含的远不止这一个方法。

使用 SAX 语法分析器

获得 SAXParser 类的实例之后，除了向语法分析器传递 File 进行语法分析之外，还可以用它做更多的事。由于如今大型应用中的应用程序组件之间通信方式，“对象实例创建者就是其使用者”这样的假定并不总是安全的。换句话说，一个组件可能创建 SAXParser 实例，而另一组件（可能由另一开发人员编码）可能需要使用那个实例。由于这个原因，提供了一些方法来确定语法分析器的设置。执行此任务的两个方法是 isValidating() ，它通知调用程序：语法分析器将要、或不要执行“确认”，以及 isNamespaceAware() ，它返回一个指示，说明语法分析器可以或不可以处理 XML 文档中的名称空间。虽然这些方法能提供有关语法分析器可以执行功能的信息，但是无法更改这些特性。必须在语法分析器类厂级别执行该操作。

另外，有多种方法来请求对文档进行语法分析。除了只接受 File 和 SAX HandlerBase 实例，SAXParser 的 parse() 方法还能以 String 形式接受 SAX InputSource 、Java InputStream 或 URL，所有这些都要与 HandlerBase 实例一起提供。所以，不同类型的输入文档可以用不同方式的语法分析来处理。

最后，可以直接通过 SAXParser 的 getParser() 方法获得和使用下层的 SAX 语法分析器（ org.xml.sax.Parser 的实例）。获得这个下层实例之后，就可以获得通常的 SAX 方法。下一个清单显示 SAXParser 类（这个 JAXP 中 SAX 语法分析的核心类）的各种使用示例。

 //获得SAXP的一个实例
            SAXParser saxParser = saxFactory.newSAXParser();
            //查看是否支持 Validate 选项
            boolean isValidating = saxParser.isValidating();
            //查看是否支持 namespace 选项
            boolean isNamespaceAware = saxParser.isNamespaceAware();
            // 运用一个File 和一个SAX HandlerBase 的实例进行多种形式的语法分析
            saxParser.parse(new File(args[0]), myHandlerBaseInstance);
            // 运用一个 SAX InputSource实例 和一个 SAX HandlerBase 实例
            saxParser.parse(mySaxInputSource, myHandlerBaseInstance);
            //运用一个 InputStream 实例和一个SAX HandlerBase 实例
            saxParser.parse(myInputStream, myHandlerBaseInstance);
            // 运用一个 URI 和一个SAX HandlerBase 实例
            saxParser.parse("http://www.newInstance.com/xml/doc.xml", myHandlerBaseInstance);
            //获得底层的（封装）SAX 语法分析器
            org.xml.sax.Parser parser = saxParser.getParser();
            //利用底层的语法分析器
            parser.setContentHandler(myContentHandlerInstance);
            parser.setErrorHandler(myErrorHandlerInstance);
            parser.parse(new org.xml.sax.InputSource(args[0]));
            

目前为止，关于 SAX 已经讲了很多，但是还没有揭示任何不寻常或令人惊奇的东西。事实上，JAXP 的功能很少，特别是当 SAX 也牵涉进来时。这很好，因为有最少的功能性意味着代码可移植性更强，并可以由其他开发人员与任何与 SAX 兼容的 XML 语法分析器一起使用，无论是免费（通过开放源码，希望如此）还是通过商业途径。就是这样。在 JAXP 中使用 SAX 没有更多的东西。如果已经知道 SAX，那么现在已经掌握大约 98% 的内容。只需学习两个新类和两个 Java 异常，您就可以开始了。如果从没使用过 SAX，那也很简单，现在就可以开始。

回页首

处理 DOM

如果要休息以迎接 DOM 挑战，那么先别休息。在 JAXP 中使用 DOM 的过程与 SAX 几乎相同，所要做的全部只是更改两个类名和一个返回类型，这样就差不多了。如果理解 SAX 的工作原理和 DOM 是什么，则不会有任何问题。

DOM 和 SAX 的主要差异是它们的 API 结构。SAX 包含一个基于事件的回调函数集，而 DOM 有一个内存中的树状结构。换句话说，在 SAX 中，从不需要操作数据结构（除非开发人员手工创建）。因此，SAX 不提供修改 XML 文档的功能。而 DOM 正好提供这种类型的功能。 org.w3c.dom.Document 类表示 XML 文档，它由表示元素、属性和其它 XML 结构的 DOM 节点 组成。所以，JAXP 无需触发 SAX 回调，它只负责从语法分析返回一个 DOM Document 对象。

DOM 语法分析器类厂一瞥

基本理解 DOM 以及 DOM 和 SAX 的差异之后，就没什么好说的了。以下代码看起来与 SAX 代码类似。首先，获得 DocumentBuilderFactory （与 SAX 中的方式相同)。然后，配置类厂来处理确认和名称空间（与 SAX 中的方式相同)。下一步，从类厂中检索 DocumentBuilder （它与 SAXParser 类似）（与 SAX 中的方式相同. . . 啊，您都知道了）。然后，就可以进行语法分析了，产生的 DOM Document 对象传递给打印 DOM 树的方法。

import java.io.File;
            import java.io.IOException;
            import java.io.OutputStreamWriter;
            import java.io.Writer;
            // JAXP
            import javax.xml.parsers.FactoryConfigurationError;
            import javax.xml.parsers.ParserConfigurationException;
            import javax.xml.parsers.DocumentBuilderFactory;
            import javax.xml.parsers.DocumentBuilder;
            // DOM
            import org.w3c.dom.Document;
            import org.w3c.dom.DocumentType;
            import org.w3c.dom.NamedNodeMap;
            import org.w3c.dom.Node;
            import org.w3c.dom.NodeList;
            public class TestDOMParsing {
            public static void main(String[] args) {
            try {
            if (args.length != 1) {
            System.err.println ("Usage: java TestDOMParsing [filename]");
            System.exit (1);
            }
            // 获得 Document Builder Factory
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            //打开确认选项，关掉名称空间敏感性选项。
            factory.setValidating(true);
            factory.setNamespaceAware(false);
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document doc = builder.parse(new File(args[0]));
            // 从DOM 数中打印文档，并加一初始空格
            printNode(doc, "");
            // 在这里也可以对 DOM 文档进行修改
            } catch (ParserConfigurationException e) {
            System.out.println("The underlying parser does not support the requested features.");
            } catch (FactoryConfigurationError e) {
            System.out.println("Error occurred obtaining Document Builder Factory.");
            } catch (Exception e) {
            e.printStackTrace();
            }
            }
            private static void printNode(Node node, String indent) {
            // 打印 DOM 树
            }
            

此代码中可能会出现两个不同的问题（与 JAXP 中的 SAX 类似）： FactoryConfigurationError 和 ParserConfigurationException 。每一个的原因与 SAX 中的相同。不是实现类 ( FactoryConfigurationError ) 中有问题，就是语法分析器不支持请求的特性 ( ParserConfigurationException )。DOM 和 SAX 的唯一差异是：在 DOM 中，用 DocumentBuilderFactory 替代 SAXParserFactory ，用 DocumentBuilder 替代 SAXParser 。就这么简单！（可以 查看完整代码清单 ，该清单包括用于打印 DOM 树的方法。）

使用 DOM 语法分析器

有了 DOM 类厂之后，就可以获得 DocumentBuilder 实例。 DocumentBuilder 实例可以使用的方法与 SAX 的非常类似。主要差异是 parse() 的变种不需要 HandlerBase 类的实例。它们返回表示语法分析之后的 XML 文档的 DOM Document 实例。另一唯一不同之处是：为类似于 SAX 的功能提供了两个方法：用 SAX ErrorHandler 实现来处理语法分析时可能出现的问题的 setErrorHandler() ，和用 SAX EntityResolver 实现来处理实体解析的 setEntityResolver() 。如果不熟悉这些概念，则需要通过联机或在我的书中学习 SAX。以下清单显示使用这些方法的示例。

    //获得一个 DocumentBuilder 实例
            DocumentBuilder builder = builderFactory.newDocumentBuilder();
            //查看是否支持 Validate 选项
            boolean isValidating = builder.isValidating();
            //查看是否支持 namespace 选项
            boolean isNamespaceAware = builder.isNamespaceAware();
            // 设置一个 SAX ErrorHandler
            builder.setErrorHandler(myErrorHandlerImpl);
            // 设置一个 SAX EntityResolver
            builder.setEntityResolver(myEntityResolverImpl);
            // 运用多种方法对 file 进行语法分析
            Document doc = builder.parse(new File(args[0]));
            // 运用 SAX InputSource
            Document doc = builder.parse(mySaxInputSource);
            // 运用 InputStream
            Document doc = builder.parse(myInputStream, myHandlerBaseInstance);
            // 运用 URI
            Document doc = builder.parse("http://www.newInstance.com/xml/doc.xml");
            

是不是感到 DOM 这一节有些令人厌烦？有这种想法的不止您一个，写 DOM 代码有些令人厌烦是因为它是直接取得所学的 SAX 知识，然后将其用于 DOM。因此，和朋友、同事打赌吧，说使用 JAXP 只是小菜一碟。

回页首

更改语法分析器

最后要探讨的主题是 JAXP 轻易更改类厂类使用的语法分析器的能力。更改 JAXP 使用的语法分析器实际意味着更改 类厂，因为所有 SAXParser 和 DocumentBuilder 实例都来自这些类厂。既然确定装入哪个语法分析器的是类厂，因此，必须更改类厂。可以通过设置 Java 系统属性 javax.xml.parsers.SAXParserFactory 来更改要使用的 SAXParserFactory 接口实现。如果没有定义该属性，则返回缺省实现（供应商指定的任何语法分析器)。相同原理适用于 DocumentBuilderFactory 实现。在这种情况下，将查询 javax.xml.parsers.DocumentBuilderFactory 系统属性。就这么简单，我们已经学完了！这就是 SAXP 的全部：提供到 SAX 的挂钩，提供到 DOM 的挂钩，并允许轻易更改语法分析器。

回页首

结束语

如您所见，没多少复杂的东西。更改系统属性，通过类厂、而不是语法分析器或构建器来设置“确认”，以及弄清楚JAXP实际上不是人们通常所认为的那样，这些是使用 JAXP 的最困难部分。除了没有 SAX 2.0 和 DOM第二层规范支持之外，JAXP 在两个流行的 Java 和 XML API 之上提供一个有帮助的可插入层。它使代码独立于供应商，并允许不编译语法分析代码而更改语法分析器。那么，从 Sun、Apache XML 或其它方便之处下载 JAXP，并使用它吧！继续关注 JAXP 1.1，并增加对 SAX 2 和 DOM 2、XSLT 及更多内容的支持。您将在这里获得第一手新闻，所以，请关注 developerWorks。

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文.
  
  
• 阅读 JAXP 1.0 规范(英)，以获得详细信息。
  
  
• 在 Sun 的 Java and XML 总部(英)查看 Sun 的所有关于 XML 的动向。
  
  
• 在 Apache XML 获得 Apache JAXP 实现。
  
  
• 查找更多 API 内幕。在 SAX Web 站点(英) 从 SAX 2 for Java 开始。
  
  
• 要查看 SAX 支持的另一个 XML，在 W3C Web 站点看一下 DOM。
  
  
• 要得到 490 多个页面的 XML 专家建议，请查看 O'Reilly 出版的 Java 与 XML(英)，和 Brett 关于最热门技术的书籍。
  
  
• 加入 developerWorks的 Java 语言开发人员 XML 工具和 API 新闻组
  
  
• 需要更基本的 XML 介绍吗？尝试 developerWorks的 XML 教程介绍(英)和 其它教育文章，它们包括最基本的主题。
  

关于作者

		Brett McLaughlin 是 Lutris Technologies 的 Enhydra 策略顾问，他致力于研究分布式系统体系结构。他是 Java 和 XML (O'Reilly) 的作者。他还参与了诸如 Java Servlet、Enterprise JavaBeans 技术、XML 和B2B应用程序等技术的研究。最近，他与 Jason Hunter 一起创建了 JDOM 项目，该项目为在 Java 应用程序中使用 XML 提供了一个简单的 API。他还是 Apache Cocoon 项目、EJBoss EJB 服务器的主要开发人员，并且是 Apache Turbine 项目的共同创始人。Brett 目前在专家组从事 JAXP 1.1 的规范和发行。可以通过 brett@newInstance.com 与他联系。

    1）DOM（JAXP Crimson解析器）

    DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而DOM被认为是基于树或基于对象的。DOM以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航，而不是像SAX那样是一次性的处理。DOM使用起来也要简单得多。

    2）SAX

    SAX处理的优点非常类似于流媒体的优点。分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。一般来说，SAX还比它的替代者DOM快许多。

    选择DOM还是选择SAX？ 对于需要自己编写代码来处理XML文档的开发人员来说， 选择DOM还是SAX解析模型是一个非常重要的设计决策。 DOM采用建立树形结构的方式访问XML文档，而SAX采用的事件模型。

    DOM解析器把XML文档转化为一个包含其内容的树，并可以对树进行遍历。用DOM解析模型的优点是编程容易，开发人员只需要调用建树的指令，然后利用navigation APIs访问所需的树节点来完成任务。可以很容易的添加和修改树中的元素。然而由于使用DOM解析器的时候需要处理整个XML文档，所以对性能和内存的要求比较高，尤其是遇到很大的XML文件的时候。由于它的遍历能力，DOM解析器常用于XML文档需要频繁的改变的服务中。

    SAX解析器采用了基于事件的模型，它在解析XML文档的时候可以触发一系列的事件，当发现给定的tag的时候，它可以激活一个回调方法，告诉该方法制定的标签已经找到。SAX对内存的要求通常会比较低，因为它让开发人员自己来决定所要处理的tag.特别是当开发人员只需要处理文档中所包含的部分数据时，SAX这种扩展能力得到了更好的体现。但用SAX解析器的时候编码工作会比较困难，而且很难同时访问同一个文档中的多处不同数据。

    3）JDOM http://www.jdom.org

    JDOM的目的是成为Java特定文档模型，它简化与XML的交互并且比使用DOM实现更快。由于是第一个Java特定模型，JDOM一直得到大力推广和促进。正在考虑通过“Java规范请求JSR-102”将它最终用作“Java标准扩展”。从2000年初就已经开始了JDOM开发。

    JDOM与DOM主要有两方面不同。首先，JDOM仅使用具体类而不使用接口。这在某些方面简化了API，但是也限制了灵活性。第二，API大量使用了Collections类，简化了那些已经熟悉这些类的Java开发者的使用。

    JDOM文档声明其目的是“使用20%（或更少）的精力解决80%（或更多）Java/XML问题”（根据学习曲线假定为20%）。JDOM对于大多数Java/XML应用程序来说当然是有用的，并且大多数开发者发现API比DOM容易理解得多。JDOM还包括对程序行为的相当广泛检查以防止用户做任何在XML中无意义的事。然而，它仍需要您充分理解XML以便做一些超出基本的工作（或者甚至理解某些情况下的错误）。这也许是比学习DOM或JDOM接口都更有意义的工作。

    JDOM自身不包含解析器。它通常使用SAX2解析器来解析和验证输入XML文档（尽管它还可以将以前构造的DOM表示作为输入）。它包含一些转换器以将JDOM表示输出成SAX2事件流、DOM模型或XML文本文档。JDOM是在Apache许可证变体下发布的开放源码。

    4）DOM4J http://dom4j.sourceforge.net

    虽然DOM4J代表了完全独立的开发结果，但最初，它是JDOM的一种智能分支。它合并了许多超出基本XML文档表示的功能，包括集成的XPath支持、XML Schema支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项，它通过DOM4J API和标准DOM接口具有并行访问功能。从2000下半年开始，它就一直处于开发之中。

    为支持所有这些功能，DOM4J使用接口和抽象基本类方法。DOM4J大量使用了API中的Collections类，但是在许多情况下，它还提供一些替代方法以允许更好的性能或更直接的编码方法。直接好处是，虽然DOM4J付出了更复杂的API的代价，但是它提供了比JDOM大得多的灵活性。

    在添加灵活性、XPath集成和对大文档处理的目标时，DOM4J的目标与JDOM是一样的：针对Java开发者的易用性和直观操作。它还致力于成为比JDOM更完整的解决方案，实现在本质上处理所有Java/XML问题的目标。在完成该目标时，它比JDOM更少强调防止不正确的应用程序行为。

    DOM4J是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的Java软件都在使用DOM4J来读写XML，特别值得一提的是连Sun的JAXM也在用DOM4J.

    2…… 比较

    1）DOM4J性能最好，连Sun的JAXM也在用DOM4J.目前许多开源项目中大量采用DOM4J，例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文件。如果不考虑可移植性，那就采用DOM4J.

    2）JDOM和DOM在性能测试时表现不佳，在测试10M文档时内存溢出。在小文档情况下还值得考虑使用DOM和JDOM.虽然JDOM的开发者已经说明他们期望在正式发行版前专注性能问题，但是从性能观点来看，它确实没有值得推荐之处。另外，DOM仍是一个非常好的选择。DOM实现广泛应用于多种编程语言。它还是许多其它与XML相关的标准的基础，因为它正式获得W3C推荐（与基于非标准的Java模型相对），所以在某些类型的项目中可能也需要它（如在JavaScript中使用DOM）。

    3）SAX表现较好，这要依赖于它特定的解析方式－事件驱动。一个SAX检测即将到来的XML流，但并没有载入到内存（当然当XML流被读入时，会有部分文档暂时隐藏在内存中）。