整合Java与XML的新应用(zz)
来源：互联网 发布：淘宝导航条全屏 编辑：程序博客网 时间：2024/05/16 04:43
作者：谷和启 如果一个XML文档符合上述文档所表现出来的一些特征，即可称之为良构的XML文档。这些特征如下：
XML(eXtensible Markup Language，可扩展的标记语言)是万维网联盟（W3C）创建的一组规范，用于在Web上组织、发布各种信息。它不仅可以满足迅速增长的网络应用的需求，还能够确保网络进行交互操作时具有良好的可靠性与互操作性。
XML的语法类似HTML，都是用标签来描述数据的。HTML的标签是固定的，我们只能使用，不能修改。XML则不同，它没有预先定义好的标签可以使用，而是依据设计上的需要自行定义标签。XML是一个元语言，根据不同的行业和语义，可以派生出许许多多的协议和规范。目前的基本协议有XSL、XLink/Xpointer、Xpath、XHTML、Schema等。不同的行业和领域都可以制定自己的XML规范，用于横向和纵向的信息交流和数据传输。XML规范有大有小，大的可以为全世界范围内的商务数据制定格式，像ebXML、Biztalk、eCo；小的有专门用于电子钱包的ECML，有为数学制定的MathML；还有为多媒体数据同步的SMIL，像XSL是专门用于显示的，它制定了许多有显示语义的标签；而XLink是描述文档之间关系的语言。像Micrsoft 的CDF(Channel Definition Format)推送频道“PUSH”技术应用、WML(Wireless Market Language)无线商务应用等等都是XML技术的具体应用。XML给基于Web的应用软件赋予了强大的功能和灵活性，因此它给开发者和用户带来了许多好处。利用XML用户可以方便地进行本地计算和处理。XML格式的数据发送给客户后，客户可以用应用软件解析数据并对数据进行编辑和处理。使用者可以用不同的方法处理数据，而不仅仅是显示它。XML文档对象模式(DOM)允许用脚本或其它编程语言处理数据，数据计算不需要回到服务器就能进行。XML可以被利用来分离使用者观看数据的界面，使用简单灵活开放的格式，可以给Web创建功能强大的应用软件。
XML核心功能的有关特性和规范如下：
1. 格式良好的(Well-Formed)XML文档；
2. 文档类型定义(DTD)；
3. XML使用样式—CSS(Cascading Style Sheet，层叠样式表单)和XSL(eXtensible Style Language，可扩展样式语言)；
4. 文档对象模型(DOM)—XML编程接口；
5. XML 简单API(SAX)—XML编程接口；
6. XML 命名空间(Namespace)和模式(Schema)；
7. 链接(XLink)和查询；
8. XPath(XML Path Language) 和 XPointer(XML Pointer Language)；
9. 转换XML—XSL和XSLT(XSL Transformation)；
10. XML 和数据库；
11. 用于服务器协议— XML-RPC、SOAP(Simple Object Access Protocol，简单对象访问协议)和WDDX(Web Distributed Data Exchange，分布式Web 数据交换)。
XML 是一种具有描述数据功能的语言，它十分适合作为知识表示语言或作为组件及文件格式的表示方法。它还可以让数据在不同的来源中，根据通用的语法规则来处理。而Java则是用于Internet、适合于分布式环境、提供了一个跨平台的语言。XML和Java相结合主要原因是基于XML的语法提供了一种灵活的、标准的、健壮的Java编程方案，同时，Java也将一种普遍的语义集合应用于XML数据。既然Java和XML都是可移植的标准，这两种技术结合的结果也是可移植的，可以重用数据和移植行为。单独使用XML或Java所能获得的所有潜力还没有被完全掌握，将它们结合就走进了一个巨大的、新的国度。将XML应用于Java的两个主要的应用是面向表示的出版业和企业中面向消息的中间件技术。
Java和XML是在为不同客户开发Web程序时形成得自然的匹配。从传统的电话到最新的智能冰箱，利用和产生的信息都是在不同的系统平台的服务器上交换。XML和Java的方便性和可延展性使它们在新的Web上具有更多的功能：
1. 结构化—建立有任何复杂层次的数据模型；
2. 可扩展性—根据需要定义新的标志；
3. 验证—检查数据在结构上的正确性；
4. 独立与媒介—以多种方式发布内容；
5. 独立于供应商和平台—使用标准的商业软件，甚至文本工具处理任何符合(XML标准)的文档。
上述这些功能使得XML技术被期望给面向网络的应用，特别是在数据交换领域带来革命性的影响。Java 与XML一起使得新一代Web应用成为可能。
因为XML的信息编码容易阅读、处理和产生，所以在许多信息交换中XML是一种首选的技术。Java可以认为是XML的“同事”，因为这两种语言都有相同的历史背景(C++、 SGML)，都具有简单性、方便性和可移植性，并且都继续在工业上、学术上开发(W3C、JCP)。 理所当然Java在服务器和客户端的XML程序开发上成为一种首选语言。
Java 软件平台为了建立基于XML的程序已经全面地收集了API核心规范，具体有6个(JDK1.4)。它们分别是JAXP (Java API for XML Processing) 、JAXB (Java Architecture for XML Binding) 、JAXM (Java API for XML Messaging)、JAX-RPC (Java API for XML-based RPC)、JAXR (Java API for XML Registries)、JDOM (Java DOM)。简介如下：
1．JAXP支持使用 DOM、 SAX和XSLT处理XML文档。JAXP允许程序分析和转换XML 文档独立于一个特殊的 XML 处理进程。根据程序的需要，开发者们可以机动地与XML处理机间交换而不用改变程序代码。这样，程序和工具开发者们能够快速和容易地写出可以支持XML的Java应用程序。
JAXP参数的实现包括一个支持SAX和DOM的、高质量的解析器和一个支持XSLT的转换引擎。最新的版本JAXP 1.1允许使用最近的 SAX-2和 DOM level 2， 同样它也包括一个基于TrAX框架 (为XML转换API)的XSLT。 而最初的版本JAXP 1.0支持 SAX-1 和 DOM level 1。JAXP 1.1将来可当作一个用于JDK 1.1.8和更高平台的、可选择的包，也许将来还会包括在 J2SE（Java 2 Platform Standard Edition） 1.4和J2EE（Java 2 Platform Enterprise Edition）1.3 中。
2．JAXB 提供了一个API工具，它可以自动地在XML文档和Java对象间建立映射。JAXB可以使XML方便使用编译进一个XML计划的一个或多个类。已经产生的类提供所有的有关XML解析和格式的细节，它们能保证在计划中的强制约束有效。在许多事件里，使用一个SAX(Simple API for XML)解析器或执行一个DOM(Document Object Model) API是非常有效的。JAXB 1.0 将会成为一个Java 2平台的可选择性的包。
3．JAXM 的可选择包允许程序发送和接收用纯Java API导向XML的文档。 JAXM工具的SOAP（Simple Object Access Protocol） 1.1及其附件可使开发者能集中于为它们的程序建立、发送、接收和分解信息包，这样就代替了低层次的XML通信程序。
这个版本的JAXM规范包括Messaging Profiles概念。它的目的就是为了建立一个基础，使之可支持一类高层次基于标准的信息协议。 一个Profile的例子就是执行ebXML 的传输、路由和打包的信息处理服务，或者基于JAXM 的W3C 的XMLP。因此，Java技术开发者们在使用JAXM 时，将有挂接XML信息的能力。
这些高层次的协议常常在基本的基于SOAP信息之外，实现一些额外的功能。这个额外的功能对信息的安全性、可升级性及完整性经常是有用的。
JAXM 1.0 将可当作一个可选择的包用于J2SE。
4.JAX-RPC为基于RPC协议的标准XML提供了一个独立传输的API。JAX-RPC 1.0 将可当作一个可选择的包用于J2SE。JAX-RPC 将来也许会包括J2SE发行版或者J2EE。JAX-RPC 最近被 Executive Committee of the Java Community ProcessSM 认可，并且已经建立起专家组。 JAX-RPC 规范将作为 JSR-101被用于开发 JCP 进程。
5.JAXR提供一个统一和标准的 Java API 来传递不同种类的XML Registries。 XML Registries 能够建立、配置和发现Web服务器。
现在的XML Registries规范有ISO 11179、OASIS、 eCo Framework、 ebXML 和 UDDI。 JAXR API 允许 Java 程序员通过不同的XML Registries使用一个简单、容易使用的抽象API。JAXR API的JAXR 信息模式使它方便在XML registries中记录内容和数据。
JDK1.4的JAXR API规范包括在JAXR信息模式同ebXML Registry 和 UDDI Registry规范间建立的细节。
JAXR API 工作在与Java APIs for XML相关的核心规范上，比如说 JAXP、JAXB、 JAX-RPC 和 JAXM, 以允许 Web 服务器包含J2EE平台。
JAXR 1.0 将当作一个可选择的包用于J2SE，将来也许会包括在J2EE中。
6.JDOM是一种面向Java 的读、写和操作XML 文档的API。JDOM 与现行的SAX 和DOM标准兼容，为Java 程序员提供了一个简单、轻量的XML 文档操作方法。需要指出的是JDOM是专门为Java 程序员开发的，所以采用许多Java 语言的优秀特性，比如方法重载、集合(Collections，这是在Java2中出现的数据操作类型)和类映射(Reflection)。
JDOM 是一种使用XML 的独特Java 工具包，用于快速开发XML应用程序。它能够替换org.w3c.dom 软件包来有计划地操作XML 文档。实际上JDOM 和DOM 能够并存。
标准的 DOM 文件是由文字结点、元素结点、处理命令结点和其它许多的结点组成的。不过这些结点造成了一个松散的DOM 对象，也造成了应用上的困难。由于JDOM具有没有层次性的特点，所以它将XML 文件建立成一个Java 对象，这种方法让在Java 中使用XML 变得非常的容易，同时解决了DOM 应用上的困难。其次，JDOM 采用类驱动，不需要像DOM 那样进行工厂化接口配置，所以JDOM 的使用是直截了当的。由于使用JDOM对象就像使用Document、Element 和 Attribute 这些类的直接实例，所以创建一个新JDOM 对象在Java 语言中就像使用new 操作符一样容易。
建立一个良构(Well-Formed)的XML 文档及验证的实例
对于一个XML文件是否符合Well-Formed 所规定的各项XML 基本语法，必须借助XML 分析器来加以检查。比较常见的XML 分析器有Xerces、JAXP 和MSXML。
一个XML 文档是有明显特征的。下面是一个XML 文档的实例People.xml，代码如下：
1. 每个元素必须有起始和结束标记；
2. 文档只有一个根元素；
3. 正确地对空元素进行格式化；
4. 开始和结束标注必须匹配(区分大小写)；
5. 元素必须正确地嵌套；
6. 属性值必须用引号括起来。
IsXMLAvailable.java 是用于进行XML文档良构检验的Java程序，代码如下：
运行“java IsXMLAvailable People.xml”命令，如程序出错，则显示第几行有错，并给出可能的错误提示；如程序正确，则显示 “XML 文件结构正确!”
建立一个有效的XML 文档(DTD)及验证的实例
良好的XML 文档只说明了其语法正确，并没有解决语义问题。XML 描述了有一定含义的数据，其中可以指定包含数据的规则。通过这种指定的规则，可以验证已声明符合规则的XML 文档的有效性，即DTD——文档类型定义。
DTD 可以确保应用程序接收到一个有效的XML 文档，然后可以针对某一类XML 设计出应用程序接口。这样符合某种DTD 的XML 文档都可以被应用程序解析，也可以用DTD 制定自己的文档规则，而这个规则可被其它应用程序利用。DTD 有两种方法声明XML文件：
(1) 外部 DTD 声明如下：
(2) 内部 DTD 声明(PeopleDTD.xml)如下：
<? xml version="1.0" encoding="GB2312"?><! DOCTYPE PeopleInfo[<! ELEMENT PeopleInfo(People+)> <!ELEMENT People(Peoplename, PeopleSex,PeopleAge)> <! ELEMENT PeopleName(#PCDATA)> <! ELEMENT PeopleSex(#PCDATA)> <! ELEMENT PeopleAge(#PCDATA)> <! ATTLIST People PeopleId CDATA #REQUIRED> ]><PeopleInfo><People PeopleId="YOUR"> <PeopleName> 古董 </PeopleName> <PeopleSex> 男 </PeopleSex> <PeopleAge> 23 </PeopleAge></People><People PeopleId="SHEN"> <PeopleName> 王冠 </PeopleName> <PeopleSex> 女 </PeopleSex> <PeopleAge> 25 </PeopleAge> </People> </PeopleInfo>
从上面的文件可以看到内嵌的DTD 在
要检验一个XML 文件是否有效需要在解析XML 文件时检验其是否有效。首先在创建DocumentBuilder 对象之前，利用语句设置有效性检验，语句如下：
dbf.setValidating(true);//设置对XML 文件进行有效验证
因为SAX 在解析XML 文件时，遇到不符合DTD规定的地方要触发相应的事件，所以还要在程序中定义实现了事件接口的类。在这里用的是常用的处理事件的静态内部类，在此类中必须实现的方法语句如下：
public void warning(SAXParseException spe) throws SAXExceptonpublic void error(SAXParseException spe) throws SAXExceptonpublic void fatalError(SAXParseException spe) throws SAXExcepton
不同级别的错误事件将分别触发这3个方法中的一个。
在IsXMLAvailableDTD.java 中，提供了对XML 文档进行有效性检验的源程序。从中可以看到SAX事件驱动的解析XML程序的编写方式http:。
运行“java IsXML AvailableDTD PeopleDTD.xml”命令，如果XML文件有效符合DTD的定义，程序则会提示“XML文件有效!”。
显示XML 数据的两种方法和XSLT
1．调用CSS 文件
（1） 编写一个hell.css 的样式单；
编写语句为“hello{display:block;font-size:48pt;font-weight:bold;font-style:italic;}”，其中的hello 是样式单的名称，随后定义的属性display、font-size、font-weight 和font-style 分别表示文字采用块(block)显示、文字的大小为48磅、文字是粗体、字体是斜体。
（2） 编写XML 文件。
在XML 文件中，如1.xml，加入一行代码为，1.xml 源程序代码如下：
2．调用XSL 文件
通过语句“
<xsl:for-each select="hello"> <h1> <xsl:value-of/> </h1></xsl:for-each>
其中“
<?xml version="1.0" standalone="yes"?><?xml-stylesheet type="text/xsl" href="2.xsl"?><hello>Hello,the world!</hello>
2.xsl 文件的源代码如下：
<?xml version="1.0" ?><xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl"> <xsl:template match="/"> <html> <body> <xsl:for-each select="hello"> <h1> <xsl:value-of/> </h1> </xsl:for-each> </body> </html> </xsl:template></xsl:stylesheet>
3．XSLT
XSLT(XSL Transformations) 主要用于处理和输出XML 文档。处理功能指的是对XML 文档进行转换，对XML 文档中的元素进行提取、排序等操作。输出功能则是指用某种方式表现XML 文档。通过使用XSLT开发者可以描述一种从现有的XML 文档建立新的结构化文档的方法，而这种方法由XSLT引擎来实现。XSLT并不是一种编程语言。它的实现方法是给出实例，而不是描述执行过程。
XSLT是将模式(Pattern)与模板(Template)相结合实现的。模式与源树中的元素相匹配。模板被实例化产生部分结果树,结果树与源树是分离的，并且结果树的结构可以和源树截然不同。在结果树的构造中源树可以被过滤和重新排序，还可以增加任意的结构。
下面我们建立自己的XSLT，先将所需要用到的包加载到程序中。MyTransformer 的结构和DOM 及 SAX 很像，都有一个XXXFactory 和相对应的错误。除了基本的对象外MyTransformer 还需要加载DOMSource 和 StreamResult两个对象，分别作为Transformer 的输入和输出。
MyTransformer 的源代码如下：
//MyTransformer.javaimport javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.parsers.FactoryConfigurationError;import javax.xml.parsers.Parser ConfigurationException;import javax.xml.transform.Transformer;import javax.xml.transform.TransformerFactory;import javax.xml.transform.TransformerException;import javax.xml.transform.TransformerFactory ConfigurationError;import javax.xml.transform.dom.DOMSource;import javax.xml.transform.stream.StreamResult;import java.io.File;import org.w3c.dom.Document;public class MyTransformer { public static void main(String[] args) { if(args.length != 1){ System.out.println("java MyTransformer [目的文件]"); return; } DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance(); domFactory.setNamespaceAware(true); domFactory.setValidating(true); try { DocumentBuilder domParser = domFactory. newDocumentBuilder(); Document doc = domParser.parse(args[0]); TransformerFactory factory = TransformerFactory.newInstance(); Transformer transformer = factory.newTransformer(); DOMSource source = new DOMSource(doc); StreamResult target = new StreamResult(System.out); transformer.transform(source, target); }catch ( FactoryConfigurationError fce ) { System.err.println("domFactory设置错误" + fce.getMessage() ); }catch ( ParserConfigurationException pce ) { System.err.println("domBuilder设置错误" + pce.getMessage() ); }catch ( Exception e ) { System.err.println("其他错误" + e.getMessage() ); e.printStackTrace(); } }}
XML 编程接口—DOM 和 SAX
1． DOM 编程
DOM 是一套为合法的Well-Formed 文件设计的API(应用程序接口)，它同时定义了这些文件的逻辑结构、访问及操作方法。在DOM 的规范里，文件的定义很广泛，其中包括了HTML 和XML。所以，DOM 也可以用来操作XML 及 HTML 文件，也可以用DOM 建立文件、浏览文件结构以及增加或删除文件的某些内容。
DOM 由W3C 制定，目标是提供一个可以通用于各种程序语言、操作系统和应用程序的API，所以DOM 具有极高的兼容性，不论CORBA、COM、Java、C++等都可以使用同样的DOM 接口。也因为这种跨平台的需求，DOM 在定义时就采用了CORBA 标准，因此它可以为各个语言提供完全相同的接口。
DOM 是文档对象模型。XML 将数据组织为一棵树，DOM 就是对这棵树的一个对象描述。通俗地说，就是通过解析XML 文档，为XML 文档在逻辑上建立一个树模型，树的节点是一个个对象。我们通过存取这些对象就能够存取XML 文档的内容。
DOM 的基本对象有5个，分别是Document、Node、NodeList、Element 和 Attr。
下面举一个通过一个图形界面观察DOM 对象的例子。在Java 的标准包里有JTree 可以来表达树的概念，结合Java 的窗口JFrame ，完成一个类似于IE浏览器功能的DOM 对象查看器。
DOMTreeView.java 的源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
2．SAX 编程
SAX(Simple Application interface for XML)是一个为基于事件XML解析器定义的、可以免费获得的、与平台和语言无关的API，它允许程序和脚本动态的访问和更新文档内容、结构和风格。所以，它作为一个中间件层用来把XML文档中的数据解释成相应的Java事件。SAX这个接口规范是XML分析器和处理器提供的、较XML更底层的接口，它能提供应用以较大的灵活性。SAX是一种事件驱动的接口。它的基本原理是，由接口的用户提供符合定义的处理器，XML分析时遇到特定的事件，就去调用处理器中特定事件的处理函数。一般SAX都是Java的接口，但C++也可以用SAX接口，只是C++的分析器比较少。SAX需要用户提供以下三个处理器类的实现：
（1）DocumentHandlerXML：文件事件的处理器；
（2）DTDHandler：DTD中事件的处理器；
（3）ErrorHandler：出错处理器。
下面举一个例子，它实现了许多处理XML 文件时重要事件的ContentHandler 接口，并且说明SAX 是如何分析XML 数据的。
Java 与 XML ——JAXP编程应用
在许多方面，Java 语言已变成供XML 选择的一种非常适合的编程语言。在JAXP(用于XML语法分析的Java API)中包含3个软件包：
1. org.w3c.dom —W3C 推荐的用于XML 标准规划文档对象模型的Java 工具;
2. org.xml.sax—用于对XML 进行语法分析的事件驱动的简单API;
3. Javax.xml.parsers —工厂化工具，允许应用程序开发人员获得并配置特殊的语法分析器工具。
JAXP 作为Java 应用软件和XML 的公共接口，用来保证Sun 、IBM 和 Micrsoft 等公司的XML 分析程序的完全兼容性。
JAXP 是由Sun 提供的Java 的标准XML 语言开发接口，目前最高版本为1.1 。JAXP1.1包含两个部分：一个是parser 部分，位于Javax.xml.parsers 包中，负责解析XML 文档；另一个是transform(TrAX)部分，位于Java.xml.transform 包中，负责进行xslt 转换工作。
JAXP1.1 中包含3个jar 文件，分别是JAXP.jar、crimson.jar 和 xalan.jar 。JAXP.jar 提供了一系列的界面和抽象类，是开发时使用的接口；crimson.jar 中定义了实际上使用的解析器；xalan.jar 中定义了transform 处理器。
JAXP1.1 的解析器提供了SAX2 和 DOM2 支持，同时支持XML1.0 第二版，也支持名空间。JAXP1.1 的TrAX 部分提供了对Xslt 推荐标准1.0 版本的支持。
下面的例子分别是使用JAXP获得 Document Builder 建立一个DOM 对象套式文件，以及使用JAXP获得一个 SAX 语法分析器剖析一个XML 文件。
(1)DOMDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
(2)SAXDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
有关JAXB 和 JDOM 的编程，由于篇幅有限，在此就不多说了。
1．Java 与 XML 结合从用户使用的应用界面来说，XML 可以用来自定义用户界面。如果将Java 的图形界面Swing 技术应用以XML 的形式来设置，就可以同时发挥Java 的“write one, use many”特性。
2．Java 提供了Servlet 和 JSP （JavaServer Page） 。实际上 XML 和 Servlet、JSP 的相互结合，XML 可以成为Servlet或JSP的输出输入语言。XML 不仅提供具有意义的数据，也提供了验证的方式(DTD)，使得程序能轻易地获得内容，并能够彻底地完成内容数据和表达方式的分离。
3．XML 通过Java 的JDBC与Web 数据库相结合。以XML为基础的新一代环境是直接面对Web数据的，不仅可以很好地兼容原有的Web应用，而且可以更好地实现Web中的信息共享与交换。XML可看作为一种半结构化的数据模型，很容易地将其文档描述与关系数据库中的属性一一对应起来，实施精确地查询与模型抽取。XML能增加结构和语义信息，使计算机和服务器即时处理多种形式的信息。因此，运用XML的扩展功能不仅能从Web服务器下载大量的信息，还能大大减少网络业务量。
4．XML 与 Java 的 EJB（Enterprise Java Bean） 结合。XML 在EJB 上应用，对于数据的沟通和EJB 的参数设置，使得EJB可以将自己所包含的数据依照JSP 和 Servlet 要求，以 XML 的形式返回，让JSP 和 Servlet 自行去处理和显示这些数据有关的工作。一个EJB 可能用到的参数会很多，并且很复杂，如果可以用XML 来定义一个清楚的参数表，这样就可以依据不同的需求来修改EJB 操作的方式，让工作更有效率。
5．Java 的JMS、Java/IDL(CORBA)、Java RMI 及SOAP 等各种分布式的处理，与XML 的XML-RPC 和 SOAP 都具有相似的功能。XML-RPC 和 SOAP 都是将原本是以二进制形式传递的消息，用XML 来表达，这样确保了所有的应用程序都可以读取这些消息，整个分布式的环境更加开放。
MySAXParser.java 的源程序代码如下(节选部分)：//MySAXParser.javaimport java.io.IOException;import java.io.FileInputStream;import java.util.Properties;import org.xml.sax.Attributes;import org.xml.sax.ContentHandler;import org.xml.sax.ErrorHandler;import org.xml.sax.Locator;import org.xml.sax.SAXException;import org.xml.sax.SAXParseException;import org.xml.sax.XMLReader;import org.xml.sax.helpers.XMLReaderFactory;/** * <code>SAXParser</code>可以从命令行下读入一个XML文件并且使用SAX标准的机制来分析该文件。 */public class MySAXParser{/** *<p> *我们将在这里使用标准的SAX的处理机制(handler)来处理XML文件 *</p> * @param uri 欲分析的XML文件的URI */public void parseXML(String uri) {try{System.out.println("正在分析中的XML文件: " + uri + "/n");XMLReader parser = XMLReaderFactory.createXMLReader( "org.apache.xerces.parsers.SAXParser");//XMLReader parser = new SAXParser();//注册所设计的内容处理器parser.setContentHandler(new MyContentHandler());//注册错误处理器parser.setErrorHandler(new MyErrorHandler());//分析文件parser.parse(uri);} catch(IOException ioe){System.out.println("文件读取错误："+ioe.getMessage());} catch(SAXException saxe){System.out.println("XML分析错误： "+saxe.getMessage());}}/** *<p> *主程序使用命令列的参数来指定所要分析的XML文件 *</p> */public static void main(String[] args) {//如果参数数目不对，则输出使用说明，并结束程序if( args.length != 1 ){System.out.println("请输入欲分析的文件名: " +"java example3_1 [XML URI]");System.exit(-1);}String uri = args[0];MySAXParser myParser = new MySAXParser();myParser.parseXML(uri);}}/** *<code>ContentHandler</code>实做<code>org.xml.sax. *ContentHandler</code>界面，并且提供提供相关的回调方法。 *所有和XML文件内容有关的分析处理都是在这里解决。 */class MyContentHandler implements ContentHandler {....................
Java 与 XML ——JAXP编程应用
在许多方面，Java 语言已变成供XML 选择的一种非常适合的编程语言。在JAXP(用于XML语法分析的Java API)中包含3个软件包：
1. org.w3c.dom —W3C 推荐的用于XML 标准规划文档对象模型的Java 工具;
2. org.xml.sax—用于对XML 进行语法分析的事件驱动的简单API;
3. Javax.xml.parsers —工厂化工具，允许应用程序开发人员获得并配置特殊的语法分析器工具。
JAXP 作为Java 应用软件和XML 的公共接口，用来保证Sun 、IBM 和 Micrsoft 等公司的XML 分析程序的完全兼容性。
JAXP 是由Sun 提供的Java 的标准XML 语言开发接口，目前最高版本为1.1 。JAXP1.1包含两个部分：一个是parser 部分，位于Javax.xml.parsers 包中，负责解析XML 文档；另一个是transform(TrAX)部分，位于Java.xml.transform 包中，负责进行xslt 转换工作。
JAXP1.1 中包含3个jar 文件，分别是JAXP.jar、crimson.jar 和 xalan.jar 。JAXP.jar 提供了一系列的界面和抽象类，是开发时使用的接口；crimson.jar 中定义了实际上使用的解析器；xalan.jar 中定义了transform 处理器。
JAXP1.1 的解析器提供了SAX2 和 DOM2 支持，同时支持XML1.0 第二版，也支持名空间。JAXP1.1 的TrAX 部分提供了对Xslt 推荐标准1.0 版本的支持。
下面的例子分别是使用JAXP获得 Document Builder 建立一个DOM 对象套式文件，以及使用JAXP获得一个 SAX 语法分析器剖析一个XML 文件。
(1)DOMDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
(2)SAXDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
有关JAXB 和 JDOM 的编程，由于篇幅有限，在此就不多说了。
1．Java 与 XML 结合从用户使用的应用界面来说，XML 可以用来自定义用户界面。如果将Java 的图形界面Swing 技术应用以XML 的形式来设置，就可以同时发挥Java 的“write one, use many”特性。
2．Java 提供了Servlet 和 JSP （JavaServer Page） 。实际上 XML 和 Servlet、JSP 的相互结合，XML 可以成为Servlet或JSP的输出输入语言。XML 不仅提供具有意义的数据，也提供了验证的方式(DTD)，使得程序能轻易地获得内容，并能够彻底地完成内容数据和表达方式的分离。
3．XML 通过Java 的JDBC与Web 数据库相结合。以XML为基础的新一代环境是直接面对Web数据的，不仅可以很好地兼容原有的Web应用，而且可以更好地实现Web中的信息共享与交换。XML可看作为一种半结构化的数据模型，很容易地将其文档描述与关系数据库中的属性一一对应起来，实施精确地查询与模型抽取。XML能增加结构和语义信息，使计算机和服务器即时处理多种形式的信息。因此，运用XML的扩展功能不仅能从Web服务器下载大量的信息，还能大大减少网络业务量。
4．XML 与 Java 的 EJB（Enterprise Java Bean） 结合。XML 在EJB 上应用，对于数据的沟通和EJB 的参数设置，使得EJB可以将自己所包含的数据依照JSP 和 Servlet 要求，以 XML 的形式返回，让JSP 和 Servlet 自行去处理和显示这些数据有关的工作。一个EJB 可能用到的参数会很多，并且很复杂，如果可以用XML 来定义一个清楚的参数表，这样就可以依据不同的需求来修改EJB 操作的方式，让工作更有效率。
5．Java 的JMS、Java/IDL(CORBA)、Java RMI 及SOAP 等各种分布式的处理，与XML 的XML-RPC 和 SOAP 都具有相似的功能。XML-RPC 和 SOAP 都是将原本是以二进制形式传递的消息，用XML 来表达，这样确保了所有的应用程序都可以读取这些消息，整个分布式的环境更加开放。
//IsXMLAvailable.javaimport java.io.File;import javax.xml.parsers.*;import org.w3c.dom.*;import org.xml.sax.*;public class IsXMLAvailable{ public static void main(String argv[]){ if (argv.length!=1){ System.out.println("参数错误!"); System.exit(1); } try{ //取得工厂类的一个新实例 DocumentBuilderFactory dbf= DocumentBuilderFactory.newInstance(); //通过静态方法创建DocumentBuilder 实例 //准备建立Document 对象 DocumentBuilder db=dbf.newDocumentBuilder(); //建立XML 文档对象 Document doc=db.parse(new File(argv[0])); //格式化文档 doc.getDocumentElement().normalize(); System.out.println("XML 文件结构正确!"); } catch(SAXParseException e){ //错误提示，SystemID 为全路径的文件名 System.out.println("XML 在第" + e.getLineNumber()+"行出错异常，文件信息:"+e.getSystemId()); System.out.println("/n"+e.getMessage()); } catch(SAXException ex){ ex.printStackTrace(); } catch(Throwable th){ th.printStackTrace(); } }}
运行“java IsXMLAvailable People.xml”命令，如程序出错，则显示第几行有错，并给出可能的错误提示；如程序正确，则显示 “XML 文件结构正确!”
建立一个有效的XML 文档(DTD)及验证的实例
良好的XML 文档只说明了其语法正确，并没有解决语义问题。XML 描述了有一定含义的数据，其中可以指定包含数据的规则。通过这种指定的规则，可以验证已声明符合规则的XML 文档的有效性，即DTD——文档类型定义。
DTD 可以确保应用程序接收到一个有效的XML 文档，然后可以针对某一类XML 设计出应用程序接口。这样符合某种DTD 的XML 文档都可以被应用程序解析，也可以用DTD 制定自己的文档规则，而这个规则可被其它应用程序利用。DTD 有两种方法声明XML文件：
(1) 外部 DTD 声明如下：
<!DOCTYPE peopleinfo SYSTEM "People.dtd">
(2) 内部 DTD 声明(PeopleDTD.xml)如下：
<? xml version="1.0" encoding="GB2312"?><! DOCTYPE PeopleInfo[<! ELEMENT PeopleInfo(People+)> <!ELEMENT People(Peoplename, PeopleSex,PeopleAge)> <! ELEMENT PeopleName(#PCDATA)> <! ELEMENT PeopleSex(#PCDATA)> <! ELEMENT PeopleAge(#PCDATA)> <! ATTLIST People PeopleId CDATA #REQUIRED> ]><PeopleInfo><People PeopleId="YOUR"> <PeopleName> 古董 </PeopleName> <PeopleSex> 男 </PeopleSex> <PeopleAge> 23 </PeopleAge></People><People PeopleId="SHEN"> <PeopleName> 王冠 </PeopleName> <PeopleSex> 女 </PeopleSex> <PeopleAge> 25 </PeopleAge> </People> </PeopleInfo>
从上面的文件可以看到内嵌的DTD 在
要检验一个XML 文件是否有效需要在解析XML 文件时检验其是否有效。首先在创建DocumentBuilder 对象之前，利用语句设置有效性检验，语句如下：
dbf.setValidating(true);//设置对XML 文件进行有效验证
因为SAX 在解析XML 文件时，遇到不符合DTD规定的地方要触发相应的事件，所以还要在程序中定义实现了事件接口的类。在这里用的是常用的处理事件的静态内部类，在此类中必须实现的方法语句如下：
public void warning(SAXParseException spe) throws SAXExceptonpublic void error(SAXParseException spe) throws SAXExceptonpublic void fatalError(SAXParseException spe) throws SAXExcepton
不同级别的错误事件将分别触发这3个方法中的一个。
在IsXMLAvailableDTD.java 中，提供了对XML 文档进行有效性检验的源程序。从中可以看到SAX事件驱动的解析XML程序的编写方式http:。
运行“java IsXML AvailableDTD PeopleDTD.xml”命令，如果XML文件有效符合DTD的定义，程序则会提示“XML文件有效!”。
显示XML 数据的两种方法和XSLT
1．调用CSS 文件
（1） 编写一个hell.css 的样式单；
编写语句为“hello{display:block;font-size:48pt;font-weight:bold;font-style:italic;}”，其中的hello 是样式单的名称，随后定义的属性display、font-size、font-weight 和font-style 分别表示文字采用块(block)显示、文字的大小为48磅、文字是粗体、字体是斜体。
（2） 编写XML 文件。
在XML 文件中，如1.xml，加入一行代码为，1.xml 源程序代码如下：
2．调用XSL 文件
通过语句“
<xsl:for-each select="hello"> <h1> <xsl:value-of/> </h1></xsl:for-each>
其中“
<?xml version="1.0" standalone="yes"?><?xml-stylesheet type="text/xsl" href="2.xsl"?><hello>Hello,the world!</hello>
2.xsl 文件的源代码如下：
<?xml version="1.0" ?><xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl"> <xsl:template match="/"> <html> <body> <xsl:for-each select="hello"> <h1> <xsl:value-of/> </h1> </xsl:for-each> </body> </html> </xsl:template></xsl:stylesheet>
3．XSLT
XSLT(XSL Transformations) 主要用于处理和输出XML 文档。处理功能指的是对XML 文档进行转换，对XML 文档中的元素进行提取、排序等操作。输出功能则是指用某种方式表现XML 文档。通过使用XSLT开发者可以描述一种从现有的XML 文档建立新的结构化文档的方法，而这种方法由XSLT引擎来实现。XSLT并不是一种编程语言。它的实现方法是给出实例，而不是描述执行过程。
XSLT是将模式(Pattern)与模板(Template)相结合实现的。模式与源树中的元素相匹配。模板被实例化产生部分结果树,结果树与源树是分离的，并且结果树的结构可以和源树截然不同。在结果树的构造中源树可以被过滤和重新排序，还可以增加任意的结构。
下面我们建立自己的XSLT，先将所需要用到的包加载到程序中。MyTransformer 的结构和DOM 及 SAX 很像，都有一个XXXFactory 和相对应的错误。除了基本的对象外MyTransformer 还需要加载DOMSource 和 StreamResult两个对象，分别作为Transformer 的输入和输出。
MyTransformer 的源代码如下：
//MyTransformer.javaimport javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.parsers.FactoryConfigurationError;import javax.xml.parsers.Parser ConfigurationException;import javax.xml.transform.Transformer;import javax.xml.transform.TransformerFactory;import javax.xml.transform.TransformerException;import javax.xml.transform.TransformerFactory ConfigurationError;import javax.xml.transform.dom.DOMSource;import javax.xml.transform.stream.StreamResult;import java.io.File;import org.w3c.dom.Document;public class MyTransformer { public static void main(String[] args) { if(args.length != 1){ System.out.println("java MyTransformer [目的文件]"); return; } DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance(); domFactory.setNamespaceAware(true); domFactory.setValidating(true); try { DocumentBuilder domParser = domFactory. newDocumentBuilder(); Document doc = domParser.parse(args[0]); TransformerFactory factory = TransformerFactory.newInstance(); Transformer transformer = factory.newTransformer(); DOMSource source = new DOMSource(doc); StreamResult target = new StreamResult(System.out); transformer.transform(source, target); }catch ( FactoryConfigurationError fce ) { System.err.println("domFactory设置错误" + fce.getMessage() ); }catch ( ParserConfigurationException pce ) { System.err.println("domBuilder设置错误" + pce.getMessage() ); }catch ( Exception e ) { System.err.println("其他错误" + e.getMessage() ); e.printStackTrace(); } }}
XML 编程接口—DOM 和 SAX
1． DOM 编程
DOM 是一套为合法的Well-Formed 文件设计的API(应用程序接口)，它同时定义了这些文件的逻辑结构、访问及操作方法。在DOM 的规范里，文件的定义很广泛，其中包括了HTML 和XML。所以，DOM 也可以用来操作XML 及 HTML 文件，也可以用DOM 建立文件、浏览文件结构以及增加或删除文件的某些内容。
DOM 由W3C 制定，目标是提供一个可以通用于各种程序语言、操作系统和应用程序的API，所以DOM 具有极高的兼容性，不论CORBA、COM、Java、C++等都可以使用同样的DOM 接口。也因为这种跨平台的需求，DOM 在定义时就采用了CORBA 标准，因此它可以为各个语言提供完全相同的接口。
DOM 是文档对象模型。XML 将数据组织为一棵树，DOM 就是对这棵树的一个对象描述。通俗地说，就是通过解析XML 文档，为XML 文档在逻辑上建立一个树模型，树的节点是一个个对象。我们通过存取这些对象就能够存取XML 文档的内容。
DOM 的基本对象有5个，分别是Document、Node、NodeList、Element 和 Attr。
下面举一个通过一个图形界面观察DOM 对象的例子。在Java 的标准包里有JTree 可以来表达树的概念，结合Java 的窗口JFrame ，完成一个类似于IE浏览器功能的DOM 对象查看器。
DOMTreeView.java 的源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
2．SAX 编程
SAX(Simple Application interface for XML)是一个为基于事件XML解析器定义的、可以免费获得的、与平台和语言无关的API，它允许程序和脚本动态的访问和更新文档内容、结构和风格。所以，它作为一个中间件层用来把XML文档中的数据解释成相应的Java事件。SAX这个接口规范是XML分析器和处理器提供的、较XML更底层的接口，它能提供应用以较大的灵活性。SAX是一种事件驱动的接口。它的基本原理是，由接口的用户提供符合定义的处理器，XML分析时遇到特定的事件，就去调用处理器中特定事件的处理函数。一般SAX都是Java的接口，但C++也可以用SAX接口，只是C++的分析器比较少。SAX需要用户提供以下三个处理器类的实现：
（1）DocumentHandlerXML：文件事件的处理器；
（2）DTDHandler：DTD中事件的处理器；
（3）ErrorHandler：出错处理器。
下面举一个例子，它实现了许多处理XML 文件时重要事件的ContentHandler 接口，并且说明SAX 是如何分析XML 数据的。
Java 与 XML ——JAXP编程应用
在许多方面，Java 语言已变成供XML 选择的一种非常适合的编程语言。在JAXP(用于XML语法分析的Java API)中包含3个软件包：
1. org.w3c.dom —W3C 推荐的用于XML 标准规划文档对象模型的Java 工具;
2. org.xml.sax—用于对XML 进行语法分析的事件驱动的简单API;
3. Javax.xml.parsers —工厂化工具，允许应用程序开发人员获得并配置特殊的语法分析器工具。
JAXP 作为Java 应用软件和XML 的公共接口，用来保证Sun 、IBM 和 Micrsoft 等公司的XML 分析程序的完全兼容性。
JAXP 是由Sun 提供的Java 的标准XML 语言开发接口，目前最高版本为1.1 。JAXP1.1包含两个部分：一个是parser 部分，位于Javax.xml.parsers 包中，负责解析XML 文档；另一个是transform(TrAX)部分，位于Java.xml.transform 包中，负责进行xslt 转换工作。
JAXP1.1 中包含3个jar 文件，分别是JAXP.jar、crimson.jar 和 xalan.jar 。JAXP.jar 提供了一系列的界面和抽象类，是开发时使用的接口；crimson.jar 中定义了实际上使用的解析器；xalan.jar 中定义了transform 处理器。
JAXP1.1 的解析器提供了SAX2 和 DOM2 支持，同时支持XML1.0 第二版，也支持名空间。JAXP1.1 的TrAX 部分提供了对Xslt 推荐标准1.0 版本的支持。
下面的例子分别是使用JAXP获得 Document Builder 建立一个DOM 对象套式文件，以及使用JAXP获得一个 SAX 语法分析器剖析一个XML 文件。
(1)DOMDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
(2)SAXDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
有关JAXB 和 JDOM 的编程，由于篇幅有限，在此就不多说了。
1．Java 与 XML 结合从用户使用的应用界面来说，XML 可以用来自定义用户界面。如果将Java 的图形界面Swing 技术应用以XML 的形式来设置，就可以同时发挥Java 的“write one, use many”特性。
2．Java 提供了Servlet 和 JSP （JavaServer Page） 。实际上 XML 和 Servlet、JSP 的相互结合，XML 可以成为Servlet或JSP的输出输入语言。XML 不仅提供具有意义的数据，也提供了验证的方式(DTD)，使得程序能轻易地获得内容，并能够彻底地完成内容数据和表达方式的分离。
3．XML 通过Java 的JDBC与Web 数据库相结合。以XML为基础的新一代环境是直接面对Web数据的，不仅可以很好地兼容原有的Web应用，而且可以更好地实现Web中的信息共享与交换。XML可看作为一种半结构化的数据模型，很容易地将其文档描述与关系数据库中的属性一一对应起来，实施精确地查询与模型抽取。XML能增加结构和语义信息，使计算机和服务器即时处理多种形式的信息。因此，运用XML的扩展功能不仅能从Web服务器下载大量的信息，还能大大减少网络业务量。
4．XML 与 Java 的 EJB（Enterprise Java Bean） 结合。XML 在EJB 上应用，对于数据的沟通和EJB 的参数设置，使得EJB可以将自己所包含的数据依照JSP 和 Servlet 要求，以 XML 的形式返回，让JSP 和 Servlet 自行去处理和显示这些数据有关的工作。一个EJB 可能用到的参数会很多，并且很复杂，如果可以用XML 来定义一个清楚的参数表，这样就可以依据不同的需求来修改EJB 操作的方式，让工作更有效率。
5．Java 的JMS、Java/IDL(CORBA)、Java RMI 及SOAP 等各种分布式的处理，与XML 的XML-RPC 和 SOAP 都具有相似的功能。XML-RPC 和 SOAP 都是将原本是以二进制形式传递的消息，用XML 来表达，这样确保了所有的应用程序都可以读取这些消息，整个分布式的环境更加开放。
MySAXParser.java 的源程序代码如下(节选部分)：//MySAXParser.javaimport java.io.IOException;import java.io.FileInputStream;import java.util.Properties;import org.xml.sax.Attributes;import org.xml.sax.ContentHandler;import org.xml.sax.ErrorHandler;import org.xml.sax.Locator;import org.xml.sax.SAXException;import org.xml.sax.SAXParseException;import org.xml.sax.XMLReader;import org.xml.sax.helpers.XMLReaderFactory;/** * <code>SAXParser</code>可以从命令行下读入一个XML文件并且使用SAX标准的机制来分析该文件。 */public class MySAXParser{/** *<p> *我们将在这里使用标准的SAX的处理机制(handler)来处理XML文件 *</p> * @param uri 欲分析的XML文件的URI */public void parseXML(String uri) {try{System.out.println("正在分析中的XML文件: " + uri + "/n");XMLReader parser = XMLReaderFactory.createXMLReader( "org.apache.xerces.parsers.SAXParser");//XMLReader parser = new SAXParser();//注册所设计的内容处理器parser.setContentHandler(new MyContentHandler());//注册错误处理器parser.setErrorHandler(new MyErrorHandler());//分析文件parser.parse(uri);} catch(IOException ioe){System.out.println("文件读取错误："+ioe.getMessage());} catch(SAXException saxe){System.out.println("XML分析错误： "+saxe.getMessage());}}/** *<p> *主程序使用命令列的参数来指定所要分析的XML文件 *</p> */public static void main(String[] args) {//如果参数数目不对，则输出使用说明，并结束程序if( args.length != 1 ){System.out.println("请输入欲分析的文件名: " +"java example3_1 [XML URI]");System.exit(-1);}String uri = args[0];MySAXParser myParser = new MySAXParser();myParser.parseXML(uri);}}/** *<code>ContentHandler</code>实做<code>org.xml.sax. *ContentHandler</code>界面，并且提供提供相关的回调方法。 *所有和XML文件内容有关的分析处理都是在这里解决。 */class MyContentHandler implements ContentHandler {....................
Java 与 XML ——JAXP编程应用
在许多方面，Java 语言已变成供XML 选择的一种非常适合的编程语言。在JAXP(用于XML语法分析的Java API)中包含3个软件包：
1. org.w3c.dom —W3C 推荐的用于XML 标准规划文档对象模型的Java 工具;
2. org.xml.sax—用于对XML 进行语法分析的事件驱动的简单API;
3. Javax.xml.parsers —工厂化工具，允许应用程序开发人员获得并配置特殊的语法分析器工具。
JAXP 作为Java 应用软件和XML 的公共接口，用来保证Sun 、IBM 和 Micrsoft 等公司的XML 分析程序的完全兼容性。
JAXP 是由Sun 提供的Java 的标准XML 语言开发接口，目前最高版本为1.1 。JAXP1.1包含两个部分：一个是parser 部分，位于Javax.xml.parsers 包中，负责解析XML 文档；另一个是transform(TrAX)部分，位于Java.xml.transform 包中，负责进行xslt 转换工作。
JAXP1.1 中包含3个jar 文件，分别是JAXP.jar、crimson.jar 和 xalan.jar 。JAXP.jar 提供了一系列的界面和抽象类，是开发时使用的接口；crimson.jar 中定义了实际上使用的解析器；xalan.jar 中定义了transform 处理器。
JAXP1.1 的解析器提供了SAX2 和 DOM2 支持，同时支持XML1.0 第二版，也支持名空间。JAXP1.1 的TrAX 部分提供了对Xslt 推荐标准1.0 版本的支持。
下面的例子分别是使用JAXP获得 Document Builder 建立一个DOM 对象套式文件，以及使用JAXP获得一个 SAX 语法分析器剖析一个XML 文件。
(1)DOMDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
(2)SAXDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
有关JAXB 和 JDOM 的编程，由于篇幅有限，在此就不多说了。
1．Java 与 XML 结合从用户使用的应用界面来说，XML 可以用来自定义用户界面。如果将Java 的图形界面Swing 技术应用以XML 的形式来设置，就可以同时发挥Java 的“write one, use many”特性。
2．Java 提供了Servlet 和 JSP （JavaServer Page） 。实际上 XML 和 Servlet、JSP 的相互结合，XML 可以成为Servlet或JSP的输出输入语言。XML 不仅提供具有意义的数据，也提供了验证的方式(DTD)，使得程序能轻易地获得内容，并能够彻底地完成内容数据和表达方式的分离。
3．XML 通过Java 的JDBC与Web 数据库相结合。以XML为基础的新一代环境是直接面对Web数据的，不仅可以很好地兼容原有的Web应用，而且可以更好地实现Web中的信息共享与交换。XML可看作为一种半结构化的数据模型，很容易地将其文档描述与关系数据库中的属性一一对应起来，实施精确地查询与模型抽取。XML能增加结构和语义信息，使计算机和服务器即时处理多种形式的信息。因此，运用XML的扩展功能不仅能从Web服务器下载大量的信息，还能大大减少网络业务量。
4．XML 与 Java 的 EJB（Enterprise Java Bean） 结合。XML 在EJB 上应用，对于数据的沟通和EJB 的参数设置，使得EJB可以将自己所包含的数据依照JSP 和 Servlet 要求，以 XML 的形式返回，让JSP 和 Servlet 自行去处理和显示这些数据有关的工作。一个EJB 可能用到的参数会很多，并且很复杂，如果可以用XML 来定义一个清楚的参数表，这样就可以依据不同的需求来修改EJB 操作的方式，让工作更有效率。
5．Java 的JMS、Java/IDL(CORBA)、Java RMI 及SOAP 等各种分布式的处理，与XML 的XML-RPC 和 SOAP 都具有相似的功能。XML-RPC 和 SOAP 都是将原本是以二进制形式传递的消息，用XML 来表达，这样确保了所有的应用程序都可以读取这些消息，整个分布式的环境更加开放。
<?xml version="1.0" standalone="yes"?><?xml-stylesheet type="text/css" href="hello.css"?><hello>Hello,the world!</hello>
2．调用XSL 文件
通过语句“
<xsl:for-each select="hello"> <h1> <xsl:value-of/> </h1></xsl:for-each>
其中“
<?xml version="1.0" standalone="yes"?><?xml-stylesheet type="text/xsl" href="2.xsl"?><hello>Hello,the world!</hello>
2.xsl 文件的源代码如下：
<?xml version="1.0" ?><xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl"> <xsl:template match="/"> <html> <body> <xsl:for-each select="hello"> <h1> <xsl:value-of/> </h1> </xsl:for-each> </body> </html> </xsl:template></xsl:stylesheet>
3．XSLT
XSLT(XSL Transformations) 主要用于处理和输出XML 文档。处理功能指的是对XML 文档进行转换，对XML 文档中的元素进行提取、排序等操作。输出功能则是指用某种方式表现XML 文档。通过使用XSLT开发者可以描述一种从现有的XML 文档建立新的结构化文档的方法，而这种方法由XSLT引擎来实现。XSLT并不是一种编程语言。它的实现方法是给出实例，而不是描述执行过程。
XSLT是将模式(Pattern)与模板(Template)相结合实现的。模式与源树中的元素相匹配。模板被实例化产生部分结果树,结果树与源树是分离的，并且结果树的结构可以和源树截然不同。在结果树的构造中源树可以被过滤和重新排序，还可以增加任意的结构。
下面我们建立自己的XSLT，先将所需要用到的包加载到程序中。MyTransformer 的结构和DOM 及 SAX 很像，都有一个XXXFactory 和相对应的错误。除了基本的对象外MyTransformer 还需要加载DOMSource 和 StreamResult两个对象，分别作为Transformer 的输入和输出。
MyTransformer 的源代码如下：
//MyTransformer.javaimport javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.parsers.FactoryConfigurationError;import javax.xml.parsers.Parser ConfigurationException;import javax.xml.transform.Transformer;import javax.xml.transform.TransformerFactory;import javax.xml.transform.TransformerException;import javax.xml.transform.TransformerFactory ConfigurationError;import javax.xml.transform.dom.DOMSource;import javax.xml.transform.stream.StreamResult;import java.io.File;import org.w3c.dom.Document;public class MyTransformer { public static void main(String[] args) { if(args.length != 1){ System.out.println("java MyTransformer [目的文件]"); return; } DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance(); domFactory.setNamespaceAware(true); domFactory.setValidating(true); try { DocumentBuilder domParser = domFactory. newDocumentBuilder(); Document doc = domParser.parse(args[0]); TransformerFactory factory = TransformerFactory.newInstance(); Transformer transformer = factory.newTransformer(); DOMSource source = new DOMSource(doc); StreamResult target = new StreamResult(System.out); transformer.transform(source, target); }catch ( FactoryConfigurationError fce ) { System.err.println("domFactory设置错误" + fce.getMessage() ); }catch ( ParserConfigurationException pce ) { System.err.println("domBuilder设置错误" + pce.getMessage() ); }catch ( Exception e ) { System.err.println("其他错误" + e.getMessage() ); e.printStackTrace(); } }}
XML 编程接口—DOM 和 SAX
1． DOM 编程
DOM 是一套为合法的Well-Formed 文件设计的API(应用程序接口)，它同时定义了这些文件的逻辑结构、访问及操作方法。在DOM 的规范里，文件的定义很广泛，其中包括了HTML 和XML。所以，DOM 也可以用来操作XML 及 HTML 文件，也可以用DOM 建立文件、浏览文件结构以及增加或删除文件的某些内容。
DOM 由W3C 制定，目标是提供一个可以通用于各种程序语言、操作系统和应用程序的API，所以DOM 具有极高的兼容性，不论CORBA、COM、Java、C++等都可以使用同样的DOM 接口。也因为这种跨平台的需求，DOM 在定义时就采用了CORBA 标准，因此它可以为各个语言提供完全相同的接口。
DOM 是文档对象模型。XML 将数据组织为一棵树，DOM 就是对这棵树的一个对象描述。通俗地说，就是通过解析XML 文档，为XML 文档在逻辑上建立一个树模型，树的节点是一个个对象。我们通过存取这些对象就能够存取XML 文档的内容。
DOM 的基本对象有5个，分别是Document、Node、NodeList、Element 和 Attr。
下面举一个通过一个图形界面观察DOM 对象的例子。在Java 的标准包里有JTree 可以来表达树的概念，结合Java 的窗口JFrame ，完成一个类似于IE浏览器功能的DOM 对象查看器。
DOMTreeView.java 的源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
2．SAX 编程
SAX(Simple Application interface for XML)是一个为基于事件XML解析器定义的、可以免费获得的、与平台和语言无关的API，它允许程序和脚本动态的访问和更新文档内容、结构和风格。所以，它作为一个中间件层用来把XML文档中的数据解释成相应的Java事件。SAX这个接口规范是XML分析器和处理器提供的、较XML更底层的接口，它能提供应用以较大的灵活性。SAX是一种事件驱动的接口。它的基本原理是，由接口的用户提供符合定义的处理器，XML分析时遇到特定的事件，就去调用处理器中特定事件的处理函数。一般SAX都是Java的接口，但C++也可以用SAX接口，只是C++的分析器比较少。SAX需要用户提供以下三个处理器类的实现：
（1）DocumentHandlerXML：文件事件的处理器；
（2）DTDHandler：DTD中事件的处理器；
（3）ErrorHandler：出错处理器。
下面举一个例子，它实现了许多处理XML 文件时重要事件的ContentHandler 接口，并且说明SAX 是如何分析XML 数据的。
Java 与 XML ——JAXP编程应用
在许多方面，Java 语言已变成供XML 选择的一种非常适合的编程语言。在JAXP(用于XML语法分析的Java API)中包含3个软件包：
1. org.w3c.dom —W3C 推荐的用于XML 标准规划文档对象模型的Java 工具;
2. org.xml.sax—用于对XML 进行语法分析的事件驱动的简单API;
3. Javax.xml.parsers —工厂化工具，允许应用程序开发人员获得并配置特殊的语法分析器工具。
JAXP 作为Java 应用软件和XML 的公共接口，用来保证Sun 、IBM 和 Micrsoft 等公司的XML 分析程序的完全兼容性。
JAXP 是由Sun 提供的Java 的标准XML 语言开发接口，目前最高版本为1.1 。JAXP1.1包含两个部分：一个是parser 部分，位于Javax.xml.parsers 包中，负责解析XML 文档；另一个是transform(TrAX)部分，位于Java.xml.transform 包中，负责进行xslt 转换工作。
JAXP1.1 中包含3个jar 文件，分别是JAXP.jar、crimson.jar 和 xalan.jar 。JAXP.jar 提供了一系列的界面和抽象类，是开发时使用的接口；crimson.jar 中定义了实际上使用的解析器；xalan.jar 中定义了transform 处理器。
JAXP1.1 的解析器提供了SAX2 和 DOM2 支持，同时支持XML1.0 第二版，也支持名空间。JAXP1.1 的TrAX 部分提供了对Xslt 推荐标准1.0 版本的支持。
下面的例子分别是使用JAXP获得 Document Builder 建立一个DOM 对象套式文件，以及使用JAXP获得一个 SAX 语法分析器剖析一个XML 文件。
(1)DOMDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
(2)SAXDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
有关JAXB 和 JDOM 的编程，由于篇幅有限，在此就不多说了。
1．Java 与 XML 结合从用户使用的应用界面来说，XML 可以用来自定义用户界面。如果将Java 的图形界面Swing 技术应用以XML 的形式来设置，就可以同时发挥Java 的“write one, use many”特性。
2．Java 提供了Servlet 和 JSP （JavaServer Page） 。实际上 XML 和 Servlet、JSP 的相互结合，XML 可以成为Servlet或JSP的输出输入语言。XML 不仅提供具有意义的数据，也提供了验证的方式(DTD)，使得程序能轻易地获得内容，并能够彻底地完成内容数据和表达方式的分离。
3．XML 通过Java 的JDBC与Web 数据库相结合。以XML为基础的新一代环境是直接面对Web数据的，不仅可以很好地兼容原有的Web应用，而且可以更好地实现Web中的信息共享与交换。XML可看作为一种半结构化的数据模型，很容易地将其文档描述与关系数据库中的属性一一对应起来，实施精确地查询与模型抽取。XML能增加结构和语义信息，使计算机和服务器即时处理多种形式的信息。因此，运用XML的扩展功能不仅能从Web服务器下载大量的信息，还能大大减少网络业务量。
4．XML 与 Java 的 EJB（Enterprise Java Bean） 结合。XML 在EJB 上应用，对于数据的沟通和EJB 的参数设置，使得EJB可以将自己所包含的数据依照JSP 和 Servlet 要求，以 XML 的形式返回，让JSP 和 Servlet 自行去处理和显示这些数据有关的工作。一个EJB 可能用到的参数会很多，并且很复杂，如果可以用XML 来定义一个清楚的参数表，这样就可以依据不同的需求来修改EJB 操作的方式，让工作更有效率。
5．Java 的JMS、Java/IDL(CORBA)、Java RMI 及SOAP 等各种分布式的处理，与XML 的XML-RPC 和 SOAP 都具有相似的功能。XML-RPC 和 SOAP 都是将原本是以二进制形式传递的消息，用XML 来表达，这样确保了所有的应用程序都可以读取这些消息，整个分布式的环境更加开放。
MySAXParser.java 的源程序代码如下(节选部分)：//MySAXParser.javaimport java.io.IOException;import java.io.FileInputStream;import java.util.Properties;import org.xml.sax.Attributes;import org.xml.sax.ContentHandler;import org.xml.sax.ErrorHandler;import org.xml.sax.Locator;import org.xml.sax.SAXException;import org.xml.sax.SAXParseException;import org.xml.sax.XMLReader;import org.xml.sax.helpers.XMLReaderFactory;/** * <code>SAXParser</code>可以从命令行下读入一个XML文件并且使用SAX标准的机制来分析该文件。 */public class MySAXParser{/** *<p> *我们将在这里使用标准的SAX的处理机制(handler)来处理XML文件 *</p> * @param uri 欲分析的XML文件的URI */public void parseXML(String uri) {try{System.out.println("正在分析中的XML文件: " + uri + "/n");XMLReader parser = XMLReaderFactory.createXMLReader( "org.apache.xerces.parsers.SAXParser");//XMLReader parser = new SAXParser();//注册所设计的内容处理器parser.setContentHandler(new MyContentHandler());//注册错误处理器parser.setErrorHandler(new MyErrorHandler());//分析文件parser.parse(uri);} catch(IOException ioe){System.out.println("文件读取错误："+ioe.getMessage());} catch(SAXException saxe){System.out.println("XML分析错误： "+saxe.getMessage());}}/** *<p> *主程序使用命令列的参数来指定所要分析的XML文件 *</p> */public static void main(String[] args) {//如果参数数目不对，则输出使用说明，并结束程序if( args.length != 1 ){System.out.println("请输入欲分析的文件名: " +"java example3_1 [XML URI]");System.exit(-1);}String uri = args[0];MySAXParser myParser = new MySAXParser();myParser.parseXML(uri);}}/** *<code>ContentHandler</code>实做<code>org.xml.sax. *ContentHandler</code>界面，并且提供提供相关的回调方法。 *所有和XML文件内容有关的分析处理都是在这里解决。 */class MyContentHandler implements ContentHandler {....................
Java 与 XML ——JAXP编程应用
在许多方面，Java 语言已变成供XML 选择的一种非常适合的编程语言。在JAXP(用于XML语法分析的Java API)中包含3个软件包：
1. org.w3c.dom —W3C 推荐的用于XML 标准规划文档对象模型的Java 工具;
2. org.xml.sax—用于对XML 进行语法分析的事件驱动的简单API;
3. Javax.xml.parsers —工厂化工具，允许应用程序开发人员获得并配置特殊的语法分析器工具。
JAXP 作为Java 应用软件和XML 的公共接口，用来保证Sun 、IBM 和 Micrsoft 等公司的XML 分析程序的完全兼容性。
JAXP 是由Sun 提供的Java 的标准XML 语言开发接口，目前最高版本为1.1 。JAXP1.1包含两个部分：一个是parser 部分，位于Javax.xml.parsers 包中，负责解析XML 文档；另一个是transform(TrAX)部分，位于Java.xml.transform 包中，负责进行xslt 转换工作。
JAXP1.1 中包含3个jar 文件，分别是JAXP.jar、crimson.jar 和 xalan.jar 。JAXP.jar 提供了一系列的界面和抽象类，是开发时使用的接口；crimson.jar 中定义了实际上使用的解析器；xalan.jar 中定义了transform 处理器。
JAXP1.1 的解析器提供了SAX2 和 DOM2 支持，同时支持XML1.0 第二版，也支持名空间。JAXP1.1 的TrAX 部分提供了对Xslt 推荐标准1.0 版本的支持。
下面的例子分别是使用JAXP获得 Document Builder 建立一个DOM 对象套式文件，以及使用JAXP获得一个 SAX 语法分析器剖析一个XML 文件。
(1)DOMDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
(2)SAXDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
有关JAXB 和 JDOM 的编程，由于篇幅有限，在此就不多说了。
1．Java 与 XML 结合从用户使用的应用界面来说，XML 可以用来自定义用户界面。如果将Java 的图形界面Swing 技术应用以XML 的形式来设置，就可以同时发挥Java 的“write one, use many”特性。
2．Java 提供了Servlet 和 JSP （JavaServer Page） 。实际上 XML 和 Servlet、JSP 的相互结合，XML 可以成为Servlet或JSP的输出输入语言。XML 不仅提供具有意义的数据，也提供了验证的方式(DTD)，使得程序能轻易地获得内容，并能够彻底地完成内容数据和表达方式的分离。
3．XML 通过Java 的JDBC与Web 数据库相结合。以XML为基础的新一代环境是直接面对Web数据的，不仅可以很好地兼容原有的Web应用，而且可以更好地实现Web中的信息共享与交换。XML可看作为一种半结构化的数据模型，很容易地将其文档描述与关系数据库中的属性一一对应起来，实施精确地查询与模型抽取。XML能增加结构和语义信息，使计算机和服务器即时处理多种形式的信息。因此，运用XML的扩展功能不仅能从Web服务器下载大量的信息，还能大大减少网络业务量。
4．XML 与 Java 的 EJB（Enterprise Java Bean） 结合。XML 在EJB 上应用，对于数据的沟通和EJB 的参数设置，使得EJB可以将自己所包含的数据依照JSP 和 Servlet 要求，以 XML 的形式返回，让JSP 和 Servlet 自行去处理和显示这些数据有关的工作。一个EJB 可能用到的参数会很多，并且很复杂，如果可以用XML 来定义一个清楚的参数表，这样就可以依据不同的需求来修改EJB 操作的方式，让工作更有效率。
5．Java 的JMS、Java/IDL(CORBA)、Java RMI 及SOAP 等各种分布式的处理，与XML 的XML-RPC 和 SOAP 都具有相似的功能。XML-RPC 和 SOAP 都是将原本是以二进制形式传递的消息，用XML 来表达，这样确保了所有的应用程序都可以读取这些消息，整个分布式的环境更加开放。
因为XML的信息编码容易阅读、处理和产生，所以在许多信息交换中XML是一种首选的技术。Java可以认为是XML的“同事”，因为这两种语言都有相同的历史背景(C++、 SGML)，都具有简单性、方便性和可移植性，并且都继续在工业上、学术上开发(W3C、JCP)。 理所当然Java在服务器和客户端的XML程序开发上成为一种首选语言。
Java 软件平台为了建立基于XML的程序已经全面地收集了API核心规范，具体有6个(JDK1.4)。它们分别是JAXP (Java API for XML Processing) 、JAXB (Java Architecture for XML Binding) 、JAXM (Java API for XML Messaging)、JAX-RPC (Java API for XML-based RPC)、JAXR (Java API for XML Registries)、JDOM (Java DOM)。简介如下：
1．JAXP支持使用 DOM、 SAX和XSLT处理XML文档。JAXP允许程序分析和转换XML 文档独立于一个特殊的 XML 处理进程。根据程序的需要，开发者们可以机动地与XML处理机间交换而不用改变程序代码。这样，程序和工具开发者们能够快速和容易地写出可以支持XML的Java应用程序。
JAXP参数的实现包括一个支持SAX和DOM的、高质量的解析器和一个支持XSLT的转换引擎。最新的版本JAXP 1.1允许使用最近的 SAX-2和 DOM level 2， 同样它也包括一个基于TrAX框架 (为XML转换API)的XSLT。 而最初的版本JAXP 1.0支持 SAX-1 和 DOM level 1。JAXP 1.1将来可当作一个用于JDK 1.1.8和更高平台的、可选择的包，也许将来还会包括在 J2SE（Java 2 Platform Standard Edition） 1.4和J2EE（Java 2 Platform Enterprise Edition）1.3 中。
2．JAXB 提供了一个API工具，它可以自动地在XML文档和Java对象间建立映射。JAXB可以使XML方便使用编译进一个XML计划的一个或多个类。已经产生的类提供所有的有关XML解析和格式的细节，它们能保证在计划中的强制约束有效。在许多事件里，使用一个SAX(Simple API for XML)解析器或执行一个DOM(Document Object Model) API是非常有效的。JAXB 1.0 将会成为一个Java 2平台的可选择性的包。
3．JAXM 的可选择包允许程序发送和接收用纯Java API导向XML的文档。 JAXM工具的SOAP（Simple Object Access Protocol） 1.1及其附件可使开发者能集中于为它们的程序建立、发送、接收和分解信息包，这样就代替了低层次的XML通信程序。
这个版本的JAXM规范包括Messaging Profiles概念。它的目的就是为了建立一个基础，使之可支持一类高层次基于标准的信息协议。 一个Profile的例子就是执行ebXML 的传输、路由和打包的信息处理服务，或者基于JAXM 的W3C 的XMLP。因此，Java技术开发者们在使用JAXM 时，将有挂接XML信息的能力。
这些高层次的协议常常在基本的基于SOAP信息之外，实现一些额外的功能。这个额外的功能对信息的安全性、可升级性及完整性经常是有用的。
JAXM 1.0 将可当作一个可选择的包用于J2SE。
4.JAX-RPC为基于RPC协议的标准XML提供了一个独立传输的API。JAX-RPC 1.0 将可当作一个可选择的包用于J2SE。JAX-RPC 将来也许会包括J2SE发行版或者J2EE。JAX-RPC 最近被 Executive Committee of the Java Community ProcessSM 认可，并且已经建立起专家组。 JAX-RPC 规范将作为 JSR-101被用于开发 JCP 进程。
5.JAXR提供一个统一和标准的 Java API 来传递不同种类的XML Registries。 XML Registries 能够建立、配置和发现Web服务器。
现在的XML Registries规范有ISO 11179、OASIS、 eCo Framework、 ebXML 和 UDDI。 JAXR API 允许 Java 程序员通过不同的XML Registries使用一个简单、容易使用的抽象API。JAXR API的JAXR 信息模式使它方便在XML registries中记录内容和数据。
JDK1.4的JAXR API规范包括在JAXR信息模式同ebXML Registry 和 UDDI Registry规范间建立的细节。
JAXR API 工作在与Java APIs for XML相关的核心规范上，比如说 JAXP、JAXB、 JAX-RPC 和 JAXM, 以允许 Web 服务器包含J2EE平台。
JAXR 1.0 将当作一个可选择的包用于J2SE，将来也许会包括在J2EE中。
6.JDOM是一种面向Java 的读、写和操作XML 文档的API。JDOM 与现行的SAX 和DOM标准兼容，为Java 程序员提供了一个简单、轻量的XML 文档操作方法。需要指出的是JDOM是专门为Java 程序员开发的，所以采用许多Java 语言的优秀特性，比如方法重载、集合(Collections，这是在Java2中出现的数据操作类型)和类映射(Reflection)。
JDOM 是一种使用XML 的独特Java 工具包，用于快速开发XML应用程序。它能够替换org.w3c.dom 软件包来有计划地操作XML 文档。实际上JDOM 和DOM 能够并存。
标准的 DOM 文件是由文字结点、元素结点、处理命令结点和其它许多的结点组成的。不过这些结点造成了一个松散的DOM 对象，也造成了应用上的困难。由于JDOM具有没有层次性的特点，所以它将XML 文件建立成一个Java 对象，这种方法让在Java 中使用XML 变得非常的容易，同时解决了DOM 应用上的困难。其次，JDOM 采用类驱动，不需要像DOM 那样进行工厂化接口配置，所以JDOM 的使用是直截了当的。由于使用JDOM对象就像使用Document、Element 和 Attribute 这些类的直接实例，所以创建一个新JDOM 对象在Java 语言中就像使用new 操作符一样容易。
建立一个良构(Well-Formed)的XML 文档及验证的实例
对于一个XML文件是否符合Well-Formed 所规定的各项XML 基本语法，必须借助XML 分析器来加以检查。比较常见的XML 分析器有Xerces、JAXP 和MSXML。
一个XML 文档是有明显特征的。下面是一个XML 文档的实例People.xml，代码如下：
<? xml version="1.0" encoding="GB2312"? ><PeopleInfo><People PeopleId="YOUR"> <PeopleName> 古董 </PeopleName> <PeopleSex> 男 </PeopleSex> <PeopleAge> 23 </PeopleAge></People><People PeopleId="SHEN"> <PeopleName> 王冠 </PeopleName> <PeopleSex> 女 </PeopleSex> <PeopleAge> 25 </PeopleAge> </People></PeopleInfo>
如果一个XML文档符合上述文档所表现出来的一些特征，即可称之为良构的XML文档。这些特征如下：
1. 每个元素必须有起始和结束标记；
2. 文档只有一个根元素；
3. 正确地对空元素进行格式化；
4. 开始和结束标注必须匹配(区分大小写)；
5. 元素必须正确地嵌套；
6. 属性值必须用引号括起来。
IsXMLAvailable.java 是用于进行XML文档良构检验的Java程序，代码如下：
运行“java IsXMLAvailable People.xml”命令，如程序出错，则显示第几行有错，并给出可能的错误提示；如程序正确，则显示 “XML 文件结构正确!”
建立一个有效的XML 文档(DTD)及验证的实例
良好的XML 文档只说明了其语法正确，并没有解决语义问题。XML 描述了有一定含义的数据，其中可以指定包含数据的规则。通过这种指定的规则，可以验证已声明符合规则的XML 文档的有效性，即DTD——文档类型定义。
DTD 可以确保应用程序接收到一个有效的XML 文档，然后可以针对某一类XML 设计出应用程序接口。这样符合某种DTD 的XML 文档都可以被应用程序解析，也可以用DTD 制定自己的文档规则，而这个规则可被其它应用程序利用。DTD 有两种方法声明XML文件：
(1) 外部 DTD 声明如下：
<!DOCTYPE peopleinfo SYSTEM "People.dtd">
(2) 内部 DTD 声明(PeopleDTD.xml)如下：
<? xml version="1.0" encoding="GB2312"?><! DOCTYPE PeopleInfo[<! ELEMENT PeopleInfo(People+)> <!ELEMENT People(Peoplename, PeopleSex,PeopleAge)> <! ELEMENT PeopleName(#PCDATA)> <! ELEMENT PeopleSex(#PCDATA)> <! ELEMENT PeopleAge(#PCDATA)> <! ATTLIST People PeopleId CDATA #REQUIRED> ]><PeopleInfo><People PeopleId="YOUR"> <PeopleName> 古董 </PeopleName> <PeopleSex> 男 </PeopleSex> <PeopleAge> 23 </PeopleAge></People><People PeopleId="SHEN"> <PeopleName> 王冠 </PeopleName> <PeopleSex> 女 </PeopleSex> <PeopleAge> 25 </PeopleAge> </People> </PeopleInfo>
从上面的文件可以看到内嵌的DTD 在
要检验一个XML 文件是否有效需要在解析XML 文件时检验其是否有效。首先在创建DocumentBuilder 对象之前，利用语句设置有效性检验，语句如下：
dbf.setValidating(true);//设置对XML 文件进行有效验证
因为SAX 在解析XML 文件时，遇到不符合DTD规定的地方要触发相应的事件，所以还要在程序中定义实现了事件接口的类。在这里用的是常用的处理事件的静态内部类，在此类中必须实现的方法语句如下：
public void warning(SAXParseException spe) throws SAXExceptonpublic void error(SAXParseException spe) throws SAXExceptonpublic void fatalError(SAXParseException spe) throws SAXExcepton
不同级别的错误事件将分别触发这3个方法中的一个。
在IsXMLAvailableDTD.java 中，提供了对XML 文档进行有效性检验的源程序。从中可以看到SAX事件驱动的解析XML程序的编写方式http:。
运行“java IsXML AvailableDTD PeopleDTD.xml”命令，如果XML文件有效符合DTD的定义，程序则会提示“XML文件有效!”。
显示XML 数据的两种方法和XSLT
1．调用CSS 文件
（1） 编写一个hell.css 的样式单；
编写语句为“hello{display:block;font-size:48pt;font-weight:bold;font-style:italic;}”，其中的hello 是样式单的名称，随后定义的属性display、font-size、font-weight 和font-style 分别表示文字采用块(block)显示、文字的大小为48磅、文字是粗体、字体是斜体。
（2） 编写XML 文件。
在XML 文件中，如1.xml，加入一行代码为，1.xml 源程序代码如下：
2．调用XSL 文件
通过语句“
<xsl:for-each select="hello"> <h1> <xsl:value-of/> </h1></xsl:for-each>
其中“
<?xml version="1.0" standalone="yes"?><?xml-stylesheet type="text/xsl" href="2.xsl"?><hello>Hello,the world!</hello>
2.xsl 文件的源代码如下：
<?xml version="1.0" ?><xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl"> <xsl:template match="/"> <html> <body> <xsl:for-each select="hello"> <h1> <xsl:value-of/> </h1> </xsl:for-each> </body> </html> </xsl:template></xsl:stylesheet>
3．XSLT
XSLT(XSL Transformations) 主要用于处理和输出XML 文档。处理功能指的是对XML 文档进行转换，对XML 文档中的元素进行提取、排序等操作。输出功能则是指用某种方式表现XML 文档。通过使用XSLT开发者可以描述一种从现有的XML 文档建立新的结构化文档的方法，而这种方法由XSLT引擎来实现。XSLT并不是一种编程语言。它的实现方法是给出实例，而不是描述执行过程。
XSLT是将模式(Pattern)与模板(Template)相结合实现的。模式与源树中的元素相匹配。模板被实例化产生部分结果树,结果树与源树是分离的，并且结果树的结构可以和源树截然不同。在结果树的构造中源树可以被过滤和重新排序，还可以增加任意的结构。
下面我们建立自己的XSLT，先将所需要用到的包加载到程序中。MyTransformer 的结构和DOM 及 SAX 很像，都有一个XXXFactory 和相对应的错误。除了基本的对象外MyTransformer 还需要加载DOMSource 和 StreamResult两个对象，分别作为Transformer 的输入和输出。
MyTransformer 的源代码如下：
//MyTransformer.javaimport javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.parsers.FactoryConfigurationError;import javax.xml.parsers.Parser ConfigurationException;import javax.xml.transform.Transformer;import javax.xml.transform.TransformerFactory;import javax.xml.transform.TransformerException;import javax.xml.transform.TransformerFactory ConfigurationError;import javax.xml.transform.dom.DOMSource;import javax.xml.transform.stream.StreamResult;import java.io.File;import org.w3c.dom.Document;public class MyTransformer { public static void main(String[] args) { if(args.length != 1){ System.out.println("java MyTransformer [目的文件]"); return; } DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance(); domFactory.setNamespaceAware(true); domFactory.setValidating(true); try { DocumentBuilder domParser = domFactory. newDocumentBuilder(); Document doc = domParser.parse(args[0]); TransformerFactory factory = TransformerFactory.newInstance(); Transformer transformer = factory.newTransformer(); DOMSource source = new DOMSource(doc); StreamResult target = new StreamResult(System.out); transformer.transform(source, target); }catch ( FactoryConfigurationError fce ) { System.err.println("domFactory设置错误" + fce.getMessage() ); }catch ( ParserConfigurationException pce ) { System.err.println("domBuilder设置错误" + pce.getMessage() ); }catch ( Exception e ) { System.err.println("其他错误" + e.getMessage() ); e.printStackTrace(); } }}
XML 编程接口—DOM 和 SAX
1． DOM 编程
DOM 是一套为合法的Well-Formed 文件设计的API(应用程序接口)，它同时定义了这些文件的逻辑结构、访问及操作方法。在DOM 的规范里，文件的定义很广泛，其中包括了HTML 和XML。所以，DOM 也可以用来操作XML 及 HTML 文件，也可以用DOM 建立文件、浏览文件结构以及增加或删除文件的某些内容。
DOM 由W3C 制定，目标是提供一个可以通用于各种程序语言、操作系统和应用程序的API，所以DOM 具有极高的兼容性，不论CORBA、COM、Java、C++等都可以使用同样的DOM 接口。也因为这种跨平台的需求，DOM 在定义时就采用了CORBA 标准，因此它可以为各个语言提供完全相同的接口。
DOM 是文档对象模型。XML 将数据组织为一棵树，DOM 就是对这棵树的一个对象描述。通俗地说，就是通过解析XML 文档，为XML 文档在逻辑上建立一个树模型，树的节点是一个个对象。我们通过存取这些对象就能够存取XML 文档的内容。
DOM 的基本对象有5个，分别是Document、Node、NodeList、Element 和 Attr。
下面举一个通过一个图形界面观察DOM 对象的例子。在Java 的标准包里有JTree 可以来表达树的概念，结合Java 的窗口JFrame ，完成一个类似于IE浏览器功能的DOM 对象查看器。
DOMTreeView.java 的源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
2．SAX 编程
SAX(Simple Application interface for XML)是一个为基于事件XML解析器定义的、可以免费获得的、与平台和语言无关的API，它允许程序和脚本动态的访问和更新文档内容、结构和风格。所以，它作为一个中间件层用来把XML文档中的数据解释成相应的Java事件。SAX这个接口规范是XML分析器和处理器提供的、较XML更底层的接口，它能提供应用以较大的灵活性。SAX是一种事件驱动的接口。它的基本原理是，由接口的用户提供符合定义的处理器，XML分析时遇到特定的事件，就去调用处理器中特定事件的处理函数。一般SAX都是Java的接口，但C++也可以用SAX接口，只是C++的分析器比较少。SAX需要用户提供以下三个处理器类的实现：
（1）DocumentHandlerXML：文件事件的处理器；
（2）DTDHandler：DTD中事件的处理器；
（3）ErrorHandler：出错处理器。
下面举一个例子，它实现了许多处理XML 文件时重要事件的ContentHandler 接口，并且说明SAX 是如何分析XML 数据的。
Java 与 XML ——JAXP编程应用
在许多方面，Java 语言已变成供XML 选择的一种非常适合的编程语言。在JAXP(用于XML语法分析的Java API)中包含3个软件包：
1. org.w3c.dom —W3C 推荐的用于XML 标准规划文档对象模型的Java 工具;
2. org.xml.sax—用于对XML 进行语法分析的事件驱动的简单API;
3. Javax.xml.parsers —工厂化工具，允许应用程序开发人员获得并配置特殊的语法分析器工具。
JAXP 作为Java 应用软件和XML 的公共接口，用来保证Sun 、IBM 和 Micrsoft 等公司的XML 分析程序的完全兼容性。
JAXP 是由Sun 提供的Java 的标准XML 语言开发接口，目前最高版本为1.1 。JAXP1.1包含两个部分：一个是parser 部分，位于Javax.xml.parsers 包中，负责解析XML 文档；另一个是transform(TrAX)部分，位于Java.xml.transform 包中，负责进行xslt 转换工作。
JAXP1.1 中包含3个jar 文件，分别是JAXP.jar、crimson.jar 和 xalan.jar 。JAXP.jar 提供了一系列的界面和抽象类，是开发时使用的接口；crimson.jar 中定义了实际上使用的解析器；xalan.jar 中定义了transform 处理器。
JAXP1.1 的解析器提供了SAX2 和 DOM2 支持，同时支持XML1.0 第二版，也支持名空间。JAXP1.1 的TrAX 部分提供了对Xslt 推荐标准1.0 版本的支持。
下面的例子分别是使用JAXP获得 Document Builder 建立一个DOM 对象套式文件，以及使用JAXP获得一个 SAX 语法分析器剖析一个XML 文件。
(1)DOMDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
(2)SAXDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
有关JAXB 和 JDOM 的编程，由于篇幅有限，在此就不多说了。
1．Java 与 XML 结合从用户使用的应用界面来说，XML 可以用来自定义用户界面。如果将Java 的图形界面Swing 技术应用以XML 的形式来设置，就可以同时发挥Java 的“write one, use many”特性。
2．Java 提供了Servlet 和 JSP （JavaServer Page） 。实际上 XML 和 Servlet、JSP 的相互结合，XML 可以成为Servlet或JSP的输出输入语言。XML 不仅提供具有意义的数据，也提供了验证的方式(DTD)，使得程序能轻易地获得内容，并能够彻底地完成内容数据和表达方式的分离。
3．XML 通过Java 的JDBC与Web 数据库相结合。以XML为基础的新一代环境是直接面对Web数据的，不仅可以很好地兼容原有的Web应用，而且可以更好地实现Web中的信息共享与交换。XML可看作为一种半结构化的数据模型，很容易地将其文档描述与关系数据库中的属性一一对应起来，实施精确地查询与模型抽取。XML能增加结构和语义信息，使计算机和服务器即时处理多种形式的信息。因此，运用XML的扩展功能不仅能从Web服务器下载大量的信息，还能大大减少网络业务量。
4．XML 与 Java 的 EJB（Enterprise Java Bean） 结合。XML 在EJB 上应用，对于数据的沟通和EJB 的参数设置，使得EJB可以将自己所包含的数据依照JSP 和 Servlet 要求，以 XML 的形式返回，让JSP 和 Servlet 自行去处理和显示这些数据有关的工作。一个EJB 可能用到的参数会很多，并且很复杂，如果可以用XML 来定义一个清楚的参数表，这样就可以依据不同的需求来修改EJB 操作的方式，让工作更有效率。
5．Java 的JMS、Java/IDL(CORBA)、Java RMI 及SOAP 等各种分布式的处理，与XML 的XML-RPC 和 SOAP 都具有相似的功能。XML-RPC 和 SOAP 都是将原本是以二进制形式传递的消息，用XML 来表达，这样确保了所有的应用程序都可以读取这些消息，整个分布式的环境更加开放。
MySAXParser.java 的源程序代码如下(节选部分)：//MySAXParser.javaimport java.io.IOException;import java.io.FileInputStream;import java.util.Properties;import org.xml.sax.Attributes;import org.xml.sax.ContentHandler;import org.xml.sax.ErrorHandler;import org.xml.sax.Locator;import org.xml.sax.SAXException;import org.xml.sax.SAXParseException;import org.xml.sax.XMLReader;import org.xml.sax.helpers.XMLReaderFactory;/** * <code>SAXParser</code>可以从命令行下读入一个XML文件并且使用SAX标准的机制来分析该文件。 */public class MySAXParser{/** *<p> *我们将在这里使用标准的SAX的处理机制(handler)来处理XML文件 *</p> * @param uri 欲分析的XML文件的URI */public void parseXML(String uri) {try{System.out.println("正在分析中的XML文件: " + uri + "/n");XMLReader parser = XMLReaderFactory.createXMLReader( "org.apache.xerces.parsers.SAXParser");//XMLReader parser = new SAXParser();//注册所设计的内容处理器parser.setContentHandler(new MyContentHandler());//注册错误处理器parser.setErrorHandler(new MyErrorHandler());//分析文件parser.parse(uri);} catch(IOException ioe){System.out.println("文件读取错误："+ioe.getMessage());} catch(SAXException saxe){System.out.println("XML分析错误： "+saxe.getMessage());}}/** *<p> *主程序使用命令列的参数来指定所要分析的XML文件 *</p> */public static void main(String[] args) {//如果参数数目不对，则输出使用说明，并结束程序if( args.length != 1 ){System.out.println("请输入欲分析的文件名: " +"java example3_1 [XML URI]");System.exit(-1);}String uri = args[0];MySAXParser myParser = new MySAXParser();myParser.parseXML(uri);}}/** *<code>ContentHandler</code>实做<code>org.xml.sax. *ContentHandler</code>界面，并且提供提供相关的回调方法。 *所有和XML文件内容有关的分析处理都是在这里解决。 */class MyContentHandler implements ContentHandler {....................
Java 与 XML ——JAXP编程应用
在许多方面，Java 语言已变成供XML 选择的一种非常适合的编程语言。在JAXP(用于XML语法分析的Java API)中包含3个软件包：
1. org.w3c.dom —W3C 推荐的用于XML 标准规划文档对象模型的Java 工具;
2. org.xml.sax—用于对XML 进行语法分析的事件驱动的简单API;
3. Javax.xml.parsers —工厂化工具，允许应用程序开发人员获得并配置特殊的语法分析器工具。
JAXP 作为Java 应用软件和XML 的公共接口，用来保证Sun 、IBM 和 Micrsoft 等公司的XML 分析程序的完全兼容性。
JAXP 是由Sun 提供的Java 的标准XML 语言开发接口，目前最高版本为1.1 。JAXP1.1包含两个部分：一个是parser 部分，位于Javax.xml.parsers 包中，负责解析XML 文档；另一个是transform(TrAX)部分，位于Java.xml.transform 包中，负责进行xslt 转换工作。
JAXP1.1 中包含3个jar 文件，分别是JAXP.jar、crimson.jar 和 xalan.jar 。JAXP.jar 提供了一系列的界面和抽象类，是开发时使用的接口；crimson.jar 中定义了实际上使用的解析器；xalan.jar 中定义了transform 处理器。
JAXP1.1 的解析器提供了SAX2 和 DOM2 支持，同时支持XML1.0 第二版，也支持名空间。JAXP1.1 的TrAX 部分提供了对Xslt 推荐标准1.0 版本的支持。
下面的例子分别是使用JAXP获得 Document Builder 建立一个DOM 对象套式文件，以及使用JAXP获得一个 SAX 语法分析器剖析一个XML 文件。
(1)DOMDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
(2)SAXDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
有关JAXB 和 JDOM 的编程，由于篇幅有限，在此就不多说了。
1．Java 与 XML 结合从用户使用的应用界面来说，XML 可以用来自定义用户界面。如果将Java 的图形界面Swing 技术应用以XML 的形式来设置，就可以同时发挥Java 的“write one, use many”特性。
2．Java 提供了Servlet 和 JSP （JavaServer Page） 。实际上 XML 和 Servlet、JSP 的相互结合，XML 可以成为Servlet或JSP的输出输入语言。XML 不仅提供具有意义的数据，也提供了验证的方式(DTD)，使得程序能轻易地获得内容，并能够彻底地完成内容数据和表达方式的分离。
3．XML 通过Java 的JDBC与Web 数据库相结合。以XML为基础的新一代环境是直接面对Web数据的，不仅可以很好地兼容原有的Web应用，而且可以更好地实现Web中的信息共享与交换。XML可看作为一种半结构化的数据模型，很容易地将其文档描述与关系数据库中的属性一一对应起来，实施精确地查询与模型抽取。XML能增加结构和语义信息，使计算机和服务器即时处理多种形式的信息。因此，运用XML的扩展功能不仅能从Web服务器下载大量的信息，还能大大减少网络业务量。
4．XML 与 Java 的 EJB（Enterprise Java Bean） 结合。XML 在EJB 上应用，对于数据的沟通和EJB 的参数设置，使得EJB可以将自己所包含的数据依照JSP 和 Servlet 要求，以 XML 的形式返回，让JSP 和 Servlet 自行去处理和显示这些数据有关的工作。一个EJB 可能用到的参数会很多，并且很复杂，如果可以用XML 来定义一个清楚的参数表，这样就可以依据不同的需求来修改EJB 操作的方式，让工作更有效率。
5．Java 的JMS、Java/IDL(CORBA)、Java RMI 及SOAP 等各种分布式的处理，与XML 的XML-RPC 和 SOAP 都具有相似的功能。XML-RPC 和 SOAP 都是将原本是以二进制形式传递的消息，用XML 来表达，这样确保了所有的应用程序都可以读取这些消息，整个分布式的环境更加开放。
//IsXMLAvailable.javaimport java.io.File;import javax.xml.parsers.*;import org.w3c.dom.*;import org.xml.sax.*;public class IsXMLAvailable{ public static void main(String argv[]){ if (argv.length!=1){ System.out.println("参数错误!"); System.exit(1); } try{ //取得工厂类的一个新实例 DocumentBuilderFactory dbf= DocumentBuilderFactory.newInstance(); //通过静态方法创建DocumentBuilder 实例 //准备建立Document 对象 DocumentBuilder db=dbf.newDocumentBuilder(); //建立XML 文档对象 Document doc=db.parse(new File(argv[0])); //格式化文档 doc.getDocumentElement().normalize(); System.out.println("XML 文件结构正确!"); } catch(SAXParseException e){ //错误提示，SystemID 为全路径的文件名 System.out.println("XML 在第" + e.getLineNumber()+"行出错异常，文件信息:"+e.getSystemId()); System.out.println("/n"+e.getMessage()); } catch(SAXException ex){ ex.printStackTrace(); } catch(Throwable th){ th.printStackTrace(); } }}
运行“java IsXMLAvailable People.xml”命令，如程序出错，则显示第几行有错，并给出可能的错误提示；如程序正确，则显示 “XML 文件结构正确!”
建立一个有效的XML 文档(DTD)及验证的实例
良好的XML 文档只说明了其语法正确，并没有解决语义问题。XML 描述了有一定含义的数据，其中可以指定包含数据的规则。通过这种指定的规则，可以验证已声明符合规则的XML 文档的有效性，即DTD——文档类型定义。
DTD 可以确保应用程序接收到一个有效的XML 文档，然后可以针对某一类XML 设计出应用程序接口。这样符合某种DTD 的XML 文档都可以被应用程序解析，也可以用DTD 制定自己的文档规则，而这个规则可被其它应用程序利用。DTD 有两种方法声明XML文件：
(1) 外部 DTD 声明如下：
<!DOCTYPE peopleinfo SYSTEM "People.dtd">
(2) 内部 DTD 声明(PeopleDTD.xml)如下：
<? xml version="1.0" encoding="GB2312"?><! DOCTYPE PeopleInfo[<! ELEMENT PeopleInfo(People+)> <!ELEMENT People(Peoplename, PeopleSex,PeopleAge)> <! ELEMENT PeopleName(#PCDATA)> <! ELEMENT PeopleSex(#PCDATA)> <! ELEMENT PeopleAge(#PCDATA)> <! ATTLIST People PeopleId CDATA #REQUIRED> ]><PeopleInfo><People PeopleId="YOUR"> <PeopleName> 古董 </PeopleName> <PeopleSex> 男 </PeopleSex> <PeopleAge> 23 </PeopleAge></People><People PeopleId="SHEN"> <PeopleName> 王冠 </PeopleName> <PeopleSex> 女 </PeopleSex> <PeopleAge> 25 </PeopleAge> </People> </PeopleInfo>
从上面的文件可以看到内嵌的DTD 在
要检验一个XML 文件是否有效需要在解析XML 文件时检验其是否有效。首先在创建DocumentBuilder 对象之前，利用语句设置有效性检验，语句如下：
dbf.setValidating(true);//设置对XML 文件进行有效验证
因为SAX 在解析XML 文件时，遇到不符合DTD规定的地方要触发相应的事件，所以还要在程序中定义实现了事件接口的类。在这里用的是常用的处理事件的静态内部类，在此类中必须实现的方法语句如下：
public void warning(SAXParseException spe) throws SAXExceptonpublic void error(SAXParseException spe) throws SAXExceptonpublic void fatalError(SAXParseException spe) throws SAXExcepton
不同级别的错误事件将分别触发这3个方法中的一个。
在IsXMLAvailableDTD.java 中，提供了对XML 文档进行有效性检验的源程序。从中可以看到SAX事件驱动的解析XML程序的编写方式http:。
运行“java IsXML AvailableDTD PeopleDTD.xml”命令，如果XML文件有效符合DTD的定义，程序则会提示“XML文件有效!”。
显示XML 数据的两种方法和XSLT
1．调用CSS 文件
（1） 编写一个hell.css 的样式单；
编写语句为“hello{display:block;font-size:48pt;font-weight:bold;font-style:italic;}”，其中的hello 是样式单的名称，随后定义的属性display、font-size、font-weight 和font-style 分别表示文字采用块(block)显示、文字的大小为48磅、文字是粗体、字体是斜体。
（2） 编写XML 文件。
在XML 文件中，如1.xml，加入一行代码为，1.xml 源程序代码如下：
2．调用XSL 文件
通过语句“
<xsl:for-each select="hello"> <h1> <xsl:value-of/> </h1></xsl:for-each>
其中“
<?xml version="1.0" standalone="yes"?><?xml-stylesheet type="text/xsl" href="2.xsl"?><hello>Hello,the world!</hello>
2.xsl 文件的源代码如下：
<?xml version="1.0" ?><xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl"> <xsl:template match="/"> <html> <body> <xsl:for-each select="hello"> <h1> <xsl:value-of/> </h1> </xsl:for-each> </body> </html> </xsl:template></xsl:stylesheet>
3．XSLT
XSLT(XSL Transformations) 主要用于处理和输出XML 文档。处理功能指的是对XML 文档进行转换，对XML 文档中的元素进行提取、排序等操作。输出功能则是指用某种方式表现XML 文档。通过使用XSLT开发者可以描述一种从现有的XML 文档建立新的结构化文档的方法，而这种方法由XSLT引擎来实现。XSLT并不是一种编程语言。它的实现方法是给出实例，而不是描述执行过程。
XSLT是将模式(Pattern)与模板(Template)相结合实现的。模式与源树中的元素相匹配。模板被实例化产生部分结果树,结果树与源树是分离的，并且结果树的结构可以和源树截然不同。在结果树的构造中源树可以被过滤和重新排序，还可以增加任意的结构。
下面我们建立自己的XSLT，先将所需要用到的包加载到程序中。MyTransformer 的结构和DOM 及 SAX 很像，都有一个XXXFactory 和相对应的错误。除了基本的对象外MyTransformer 还需要加载DOMSource 和 StreamResult两个对象，分别作为Transformer 的输入和输出。
MyTransformer 的源代码如下：
//MyTransformer.javaimport javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.parsers.FactoryConfigurationError;import javax.xml.parsers.Parser ConfigurationException;import javax.xml.transform.Transformer;import javax.xml.transform.TransformerFactory;import javax.xml.transform.TransformerException;import javax.xml.transform.TransformerFactory ConfigurationError;import javax.xml.transform.dom.DOMSource;import javax.xml.transform.stream.StreamResult;import java.io.File;import org.w3c.dom.Document;public class MyTransformer { public static void main(String[] args) { if(args.length != 1){ System.out.println("java MyTransformer [目的文件]"); return; } DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance(); domFactory.setNamespaceAware(true); domFactory.setValidating(true); try { DocumentBuilder domParser = domFactory. newDocumentBuilder(); Document doc = domParser.parse(args[0]); TransformerFactory factory = TransformerFactory.newInstance(); Transformer transformer = factory.newTransformer(); DOMSource source = new DOMSource(doc); StreamResult target = new StreamResult(System.out); transformer.transform(source, target); }catch ( FactoryConfigurationError fce ) { System.err.println("domFactory设置错误" + fce.getMessage() ); }catch ( ParserConfigurationException pce ) { System.err.println("domBuilder设置错误" + pce.getMessage() ); }catch ( Exception e ) { System.err.println("其他错误" + e.getMessage() ); e.printStackTrace(); } }}
XML 编程接口—DOM 和 SAX
1． DOM 编程
DOM 是一套为合法的Well-Formed 文件设计的API(应用程序接口)，它同时定义了这些文件的逻辑结构、访问及操作方法。在DOM 的规范里，文件的定义很广泛，其中包括了HTML 和XML。所以，DOM 也可以用来操作XML 及 HTML 文件，也可以用DOM 建立文件、浏览文件结构以及增加或删除文件的某些内容。
DOM 由W3C 制定，目标是提供一个可以通用于各种程序语言、操作系统和应用程序的API，所以DOM 具有极高的兼容性，不论CORBA、COM、Java、C++等都可以使用同样的DOM 接口。也因为这种跨平台的需求，DOM 在定义时就采用了CORBA 标准，因此它可以为各个语言提供完全相同的接口。
DOM 是文档对象模型。XML 将数据组织为一棵树，DOM 就是对这棵树的一个对象描述。通俗地说，就是通过解析XML 文档，为XML 文档在逻辑上建立一个树模型，树的节点是一个个对象。我们通过存取这些对象就能够存取XML 文档的内容。
DOM 的基本对象有5个，分别是Document、Node、NodeList、Element 和 Attr。
下面举一个通过一个图形界面观察DOM 对象的例子。在Java 的标准包里有JTree 可以来表达树的概念，结合Java 的窗口JFrame ，完成一个类似于IE浏览器功能的DOM 对象查看器。
DOMTreeView.java 的源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
2．SAX 编程
SAX(Simple Application interface for XML)是一个为基于事件XML解析器定义的、可以免费获得的、与平台和语言无关的API，它允许程序和脚本动态的访问和更新文档内容、结构和风格。所以，它作为一个中间件层用来把XML文档中的数据解释成相应的Java事件。SAX这个接口规范是XML分析器和处理器提供的、较XML更底层的接口，它能提供应用以较大的灵活性。SAX是一种事件驱动的接口。它的基本原理是，由接口的用户提供符合定义的处理器，XML分析时遇到特定的事件，就去调用处理器中特定事件的处理函数。一般SAX都是Java的接口，但C++也可以用SAX接口，只是C++的分析器比较少。SAX需要用户提供以下三个处理器类的实现：
（1）DocumentHandlerXML：文件事件的处理器；
（2）DTDHandler：DTD中事件的处理器；
（3）ErrorHandler：出错处理器。
下面举一个例子，它实现了许多处理XML 文件时重要事件的ContentHandler 接口，并且说明SAX 是如何分析XML 数据的。
Java 与 XML ——JAXP编程应用
在许多方面，Java 语言已变成供XML 选择的一种非常适合的编程语言。在JAXP(用于XML语法分析的Java API)中包含3个软件包：
1. org.w3c.dom —W3C 推荐的用于XML 标准规划文档对象模型的Java 工具;
2. org.xml.sax—用于对XML 进行语法分析的事件驱动的简单API;
3. Javax.xml.parsers —工厂化工具，允许应用程序开发人员获得并配置特殊的语法分析器工具。
JAXP 作为Java 应用软件和XML 的公共接口，用来保证Sun 、IBM 和 Micrsoft 等公司的XML 分析程序的完全兼容性。
JAXP 是由Sun 提供的Java 的标准XML 语言开发接口，目前最高版本为1.1 。JAXP1.1包含两个部分：一个是parser 部分，位于Javax.xml.parsers 包中，负责解析XML 文档；另一个是transform(TrAX)部分，位于Java.xml.transform 包中，负责进行xslt 转换工作。
JAXP1.1 中包含3个jar 文件，分别是JAXP.jar、crimson.jar 和 xalan.jar 。JAXP.jar 提供了一系列的界面和抽象类，是开发时使用的接口；crimson.jar 中定义了实际上使用的解析器；xalan.jar 中定义了transform 处理器。
JAXP1.1 的解析器提供了SAX2 和 DOM2 支持，同时支持XML1.0 第二版，也支持名空间。JAXP1.1 的TrAX 部分提供了对Xslt 推荐标准1.0 版本的支持。
下面的例子分别是使用JAXP获得 Document Builder 建立一个DOM 对象套式文件，以及使用JAXP获得一个 SAX 语法分析器剖析一个XML 文件。
(1)DOMDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
(2)SAXDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
有关JAXB 和 JDOM 的编程，由于篇幅有限，在此就不多说了。
1．Java 与 XML 结合从用户使用的应用界面来说，XML 可以用来自定义用户界面。如果将Java 的图形界面Swing 技术应用以XML 的形式来设置，就可以同时发挥Java 的“write one, use many”特性。
2．Java 提供了Servlet 和 JSP （JavaServer Page） 。实际上 XML 和 Servlet、JSP 的相互结合，XML 可以成为Servlet或JSP的输出输入语言。XML 不仅提供具有意义的数据，也提供了验证的方式(DTD)，使得程序能轻易地获得内容，并能够彻底地完成内容数据和表达方式的分离。
3．XML 通过Java 的JDBC与Web 数据库相结合。以XML为基础的新一代环境是直接面对Web数据的，不仅可以很好地兼容原有的Web应用，而且可以更好地实现Web中的信息共享与交换。XML可看作为一种半结构化的数据模型，很容易地将其文档描述与关系数据库中的属性一一对应起来，实施精确地查询与模型抽取。XML能增加结构和语义信息，使计算机和服务器即时处理多种形式的信息。因此，运用XML的扩展功能不仅能从Web服务器下载大量的信息，还能大大减少网络业务量。
4．XML 与 Java 的 EJB（Enterprise Java Bean） 结合。XML 在EJB 上应用，对于数据的沟通和EJB 的参数设置，使得EJB可以将自己所包含的数据依照JSP 和 Servlet 要求，以 XML 的形式返回，让JSP 和 Servlet 自行去处理和显示这些数据有关的工作。一个EJB 可能用到的参数会很多，并且很复杂，如果可以用XML 来定义一个清楚的参数表，这样就可以依据不同的需求来修改EJB 操作的方式，让工作更有效率。
5．Java 的JMS、Java/IDL(CORBA)、Java RMI 及SOAP 等各种分布式的处理，与XML 的XML-RPC 和 SOAP 都具有相似的功能。XML-RPC 和 SOAP 都是将原本是以二进制形式传递的消息，用XML 来表达，这样确保了所有的应用程序都可以读取这些消息，整个分布式的环境更加开放。
MySAXParser.java 的源程序代码如下(节选部分)：//MySAXParser.javaimport java.io.IOException;import java.io.FileInputStream;import java.util.Properties;import org.xml.sax.Attributes;import org.xml.sax.ContentHandler;import org.xml.sax.ErrorHandler;import org.xml.sax.Locator;import org.xml.sax.SAXException;import org.xml.sax.SAXParseException;import org.xml.sax.XMLReader;import org.xml.sax.helpers.XMLReaderFactory;/** * <code>SAXParser</code>可以从命令行下读入一个XML文件并且使用SAX标准的机制来分析该文件。 */public class MySAXParser{/** *<p> *我们将在这里使用标准的SAX的处理机制(handler)来处理XML文件 *</p> * @param uri 欲分析的XML文件的URI */public void parseXML(String uri) {try{System.out.println("正在分析中的XML文件: " + uri + "/n");XMLReader parser = XMLReaderFactory.createXMLReader( "org.apache.xerces.parsers.SAXParser");//XMLReader parser = new SAXParser();//注册所设计的内容处理器parser.setContentHandler(new MyContentHandler());//注册错误处理器parser.setErrorHandler(new MyErrorHandler());//分析文件parser.parse(uri);} catch(IOException ioe){System.out.println("文件读取错误："+ioe.getMessage());} catch(SAXException saxe){System.out.println("XML分析错误： "+saxe.getMessage());}}/** *<p> *主程序使用命令列的参数来指定所要分析的XML文件 *</p> */public static void main(String[] args) {//如果参数数目不对，则输出使用说明，并结束程序if( args.length != 1 ){System.out.println("请输入欲分析的文件名: " +"java example3_1 [XML URI]");System.exit(-1);}String uri = args[0];MySAXParser myParser = new MySAXParser();myParser.parseXML(uri);}}/** *<code>ContentHandler</code>实做<code>org.xml.sax. *ContentHandler</code>界面，并且提供提供相关的回调方法。 *所有和XML文件内容有关的分析处理都是在这里解决。 */class MyContentHandler implements ContentHandler {....................
Java 与 XML ——JAXP编程应用
在许多方面，Java 语言已变成供XML 选择的一种非常适合的编程语言。在JAXP(用于XML语法分析的Java API)中包含3个软件包：
1. org.w3c.dom —W3C 推荐的用于XML 标准规划文档对象模型的Java 工具;
2. org.xml.sax—用于对XML 进行语法分析的事件驱动的简单API;
3. Javax.xml.parsers —工厂化工具，允许应用程序开发人员获得并配置特殊的语法分析器工具。
JAXP 作为Java 应用软件和XML 的公共接口，用来保证Sun 、IBM 和 Micrsoft 等公司的XML 分析程序的完全兼容性。
JAXP 是由Sun 提供的Java 的标准XML 语言开发接口，目前最高版本为1.1 。JAXP1.1包含两个部分：一个是parser 部分，位于Javax.xml.parsers 包中，负责解析XML 文档；另一个是transform(TrAX)部分，位于Java.xml.transform 包中，负责进行xslt 转换工作。
JAXP1.1 中包含3个jar 文件，分别是JAXP.jar、crimson.jar 和 xalan.jar 。JAXP.jar 提供了一系列的界面和抽象类，是开发时使用的接口；crimson.jar 中定义了实际上使用的解析器；xalan.jar 中定义了transform 处理器。
JAXP1.1 的解析器提供了SAX2 和 DOM2 支持，同时支持XML1.0 第二版，也支持名空间。JAXP1.1 的TrAX 部分提供了对Xslt 推荐标准1.0 版本的支持。
下面的例子分别是使用JAXP获得 Document Builder 建立一个DOM 对象套式文件，以及使用JAXP获得一个 SAX 语法分析器剖析一个XML 文件。
(1)DOMDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
(2)SAXDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
有关JAXB 和 JDOM 的编程，由于篇幅有限，在此就不多说了。
1．Java 与 XML 结合从用户使用的应用界面来说，XML 可以用来自定义用户界面。如果将Java 的图形界面Swing 技术应用以XML 的形式来设置，就可以同时发挥Java 的“write one, use many”特性。
2．Java 提供了Servlet 和 JSP （JavaServer Page） 。实际上 XML 和 Servlet、JSP 的相互结合，XML 可以成为Servlet或JSP的输出输入语言。XML 不仅提供具有意义的数据，也提供了验证的方式(DTD)，使得程序能轻易地获得内容，并能够彻底地完成内容数据和表达方式的分离。
3．XML 通过Java 的JDBC与Web 数据库相结合。以XML为基础的新一代环境是直接面对Web数据的，不仅可以很好地兼容原有的Web应用，而且可以更好地实现Web中的信息共享与交换。XML可看作为一种半结构化的数据模型，很容易地将其文档描述与关系数据库中的属性一一对应起来，实施精确地查询与模型抽取。XML能增加结构和语义信息，使计算机和服务器即时处理多种形式的信息。因此，运用XML的扩展功能不仅能从Web服务器下载大量的信息，还能大大减少网络业务量。
4．XML 与 Java 的 EJB（Enterprise Java Bean） 结合。XML 在EJB 上应用，对于数据的沟通和EJB 的参数设置，使得EJB可以将自己所包含的数据依照JSP 和 Servlet 要求，以 XML 的形式返回，让JSP 和 Servlet 自行去处理和显示这些数据有关的工作。一个EJB 可能用到的参数会很多，并且很复杂，如果可以用XML 来定义一个清楚的参数表，这样就可以依据不同的需求来修改EJB 操作的方式，让工作更有效率。
5．Java 的JMS、Java/IDL(CORBA)、Java RMI 及SOAP 等各种分布式的处理，与XML 的XML-RPC 和 SOAP 都具有相似的功能。XML-RPC 和 SOAP 都是将原本是以二进制形式传递的消息，用XML 来表达，这样确保了所有的应用程序都可以读取这些消息，整个分布式的环境更加开放。
<?xml version="1.0" standalone="yes"?><?xml-stylesheet type="text/css" href="hello.css"?><hello>Hello,the world!</hello>
2．调用XSL 文件
通过语句“
<xsl:for-each select="hello"> <h1> <xsl:value-of/> </h1></xsl:for-each>
其中“
<?xml version="1.0" standalone="yes"?><?xml-stylesheet type="text/xsl" href="2.xsl"?><hello>Hello,the world!</hello>
2.xsl 文件的源代码如下：
<?xml version="1.0" ?><xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl"> <xsl:template match="/"> <html> <body> <xsl:for-each select="hello"> <h1> <xsl:value-of/> </h1> </xsl:for-each> </body> </html> </xsl:template></xsl:stylesheet>
3．XSLT
XSLT(XSL Transformations) 主要用于处理和输出XML 文档。处理功能指的是对XML 文档进行转换，对XML 文档中的元素进行提取、排序等操作。输出功能则是指用某种方式表现XML 文档。通过使用XSLT开发者可以描述一种从现有的XML 文档建立新的结构化文档的方法，而这种方法由XSLT引擎来实现。XSLT并不是一种编程语言。它的实现方法是给出实例，而不是描述执行过程。
XSLT是将模式(Pattern)与模板(Template)相结合实现的。模式与源树中的元素相匹配。模板被实例化产生部分结果树,结果树与源树是分离的，并且结果树的结构可以和源树截然不同。在结果树的构造中源树可以被过滤和重新排序，还可以增加任意的结构。
下面我们建立自己的XSLT，先将所需要用到的包加载到程序中。MyTransformer 的结构和DOM 及 SAX 很像，都有一个XXXFactory 和相对应的错误。除了基本的对象外MyTransformer 还需要加载DOMSource 和 StreamResult两个对象，分别作为Transformer 的输入和输出。
MyTransformer 的源代码如下：
//MyTransformer.javaimport javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.parsers.FactoryConfigurationError;import javax.xml.parsers.Parser ConfigurationException;import javax.xml.transform.Transformer;import javax.xml.transform.TransformerFactory;import javax.xml.transform.TransformerException;import javax.xml.transform.TransformerFactory ConfigurationError;import javax.xml.transform.dom.DOMSource;import javax.xml.transform.stream.StreamResult;import java.io.File;import org.w3c.dom.Document;public class MyTransformer { public static void main(String[] args) { if(args.length != 1){ System.out.println("java MyTransformer [目的文件]"); return; } DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance(); domFactory.setNamespaceAware(true); domFactory.setValidating(true); try { DocumentBuilder domParser = domFactory. newDocumentBuilder(); Document doc = domParser.parse(args[0]); TransformerFactory factory = TransformerFactory.newInstance(); Transformer transformer = factory.newTransformer(); DOMSource source = new DOMSource(doc); StreamResult target = new StreamResult(System.out); transformer.transform(source, target); }catch ( FactoryConfigurationError fce ) { System.err.println("domFactory设置错误" + fce.getMessage() ); }catch ( ParserConfigurationException pce ) { System.err.println("domBuilder设置错误" + pce.getMessage() ); }catch ( Exception e ) { System.err.println("其他错误" + e.getMessage() ); e.printStackTrace(); } }}
XML 编程接口—DOM 和 SAX
1． DOM 编程
DOM 是一套为合法的Well-Formed 文件设计的API(应用程序接口)，它同时定义了这些文件的逻辑结构、访问及操作方法。在DOM 的规范里，文件的定义很广泛，其中包括了HTML 和XML。所以，DOM 也可以用来操作XML 及 HTML 文件，也可以用DOM 建立文件、浏览文件结构以及增加或删除文件的某些内容。
DOM 由W3C 制定，目标是提供一个可以通用于各种程序语言、操作系统和应用程序的API，所以DOM 具有极高的兼容性，不论CORBA、COM、Java、C++等都可以使用同样的DOM 接口。也因为这种跨平台的需求，DOM 在定义时就采用了CORBA 标准，因此它可以为各个语言提供完全相同的接口。
DOM 是文档对象模型。XML 将数据组织为一棵树，DOM 就是对这棵树的一个对象描述。通俗地说，就是通过解析XML 文档，为XML 文档在逻辑上建立一个树模型，树的节点是一个个对象。我们通过存取这些对象就能够存取XML 文档的内容。
DOM 的基本对象有5个，分别是Document、Node、NodeList、Element 和 Attr。
下面举一个通过一个图形界面观察DOM 对象的例子。在Java 的标准包里有JTree 可以来表达树的概念，结合Java 的窗口JFrame ，完成一个类似于IE浏览器功能的DOM 对象查看器。
DOMTreeView.java 的源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
2．SAX 编程
SAX(Simple Application interface for XML)是一个为基于事件XML解析器定义的、可以免费获得的、与平台和语言无关的API，它允许程序和脚本动态的访问和更新文档内容、结构和风格。所以，它作为一个中间件层用来把XML文档中的数据解释成相应的Java事件。SAX这个接口规范是XML分析器和处理器提供的、较XML更底层的接口，它能提供应用以较大的灵活性。SAX是一种事件驱动的接口。它的基本原理是，由接口的用户提供符合定义的处理器，XML分析时遇到特定的事件，就去调用处理器中特定事件的处理函数。一般SAX都是Java的接口，但C++也可以用SAX接口，只是C++的分析器比较少。SAX需要用户提供以下三个处理器类的实现：
（1）DocumentHandlerXML：文件事件的处理器；
（2）DTDHandler：DTD中事件的处理器；
（3）ErrorHandler：出错处理器。
下面举一个例子，它实现了许多处理XML 文件时重要事件的ContentHandler 接口，并且说明SAX 是如何分析XML 数据的。
Java 与 XML ——JAXP编程应用
在许多方面，Java 语言已变成供XML 选择的一种非常适合的编程语言。在JAXP(用于XML语法分析的Java API)中包含3个软件包：
1. org.w3c.dom —W3C 推荐的用于XML 标准规划文档对象模型的Java 工具;
2. org.xml.sax—用于对XML 进行语法分析的事件驱动的简单API;
3. Javax.xml.parsers —工厂化工具，允许应用程序开发人员获得并配置特殊的语法分析器工具。
JAXP 作为Java 应用软件和XML 的公共接口，用来保证Sun 、IBM 和 Micrsoft 等公司的XML 分析程序的完全兼容性。
JAXP 是由Sun 提供的Java 的标准XML 语言开发接口，目前最高版本为1.1 。JAXP1.1包含两个部分：一个是parser 部分，位于Javax.xml.parsers 包中，负责解析XML 文档；另一个是transform(TrAX)部分，位于Java.xml.transform 包中，负责进行xslt 转换工作。
JAXP1.1 中包含3个jar 文件，分别是JAXP.jar、crimson.jar 和 xalan.jar 。JAXP.jar 提供了一系列的界面和抽象类，是开发时使用的接口；crimson.jar 中定义了实际上使用的解析器；xalan.jar 中定义了transform 处理器。
JAXP1.1 的解析器提供了SAX2 和 DOM2 支持，同时支持XML1.0 第二版，也支持名空间。JAXP1.1 的TrAX 部分提供了对Xslt 推荐标准1.0 版本的支持。
下面的例子分别是使用JAXP获得 Document Builder 建立一个DOM 对象套式文件，以及使用JAXP获得一个 SAX 语法分析器剖析一个XML 文件。
(1)DOMDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
(2)SAXDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
有关JAXB 和 JDOM 的编程，由于篇幅有限，在此就不多说了。
1．Java 与 XML 结合从用户使用的应用界面来说，XML 可以用来自定义用户界面。如果将Java 的图形界面Swing 技术应用以XML 的形式来设置，就可以同时发挥Java 的“write one, use many”特性。
2．Java 提供了Servlet 和 JSP （JavaServer Page） 。实际上 XML 和 Servlet、JSP 的相互结合，XML 可以成为Servlet或JSP的输出输入语言。XML 不仅提供具有意义的数据，也提供了验证的方式(DTD)，使得程序能轻易地获得内容，并能够彻底地完成内容数据和表达方式的分离。
3．XML 通过Java 的JDBC与Web 数据库相结合。以XML为基础的新一代环境是直接面对Web数据的，不仅可以很好地兼容原有的Web应用，而且可以更好地实现Web中的信息共享与交换。XML可看作为一种半结构化的数据模型，很容易地将其文档描述与关系数据库中的属性一一对应起来，实施精确地查询与模型抽取。XML能增加结构和语义信息，使计算机和服务器即时处理多种形式的信息。因此，运用XML的扩展功能不仅能从Web服务器下载大量的信息，还能大大减少网络业务量。
4．XML 与 Java 的 EJB（Enterprise Java Bean） 结合。XML 在EJB 上应用，对于数据的沟通和EJB 的参数设置，使得EJB可以将自己所包含的数据依照JSP 和 Servlet 要求，以 XML 的形式返回，让JSP 和 Servlet 自行去处理和显示这些数据有关的工作。一个EJB 可能用到的参数会很多，并且很复杂，如果可以用XML 来定义一个清楚的参数表，这样就可以依据不同的需求来修改EJB 操作的方式，让工作更有效率。
5．Java 的JMS、Java/IDL(CORBA)、Java RMI 及SOAP 等各种分布式的处理，与XML 的XML-RPC 和 SOAP 都具有相似的功能。XML-RPC 和 SOAP 都是将原本是以二进制形式传递的消息，用XML 来表达，这样确保了所有的应用程序都可以读取这些消息，整个分布式的环境更加开放。
MySAXParser.java 的源程序代码如下(节选部分)：//MySAXParser.javaimport java.io.IOException;import java.io.FileInputStream;import java.util.Properties;import org.xml.sax.Attributes;import org.xml.sax.ContentHandler;import org.xml.sax.ErrorHandler;import org.xml.sax.Locator;import org.xml.sax.SAXException;import org.xml.sax.SAXParseException;import org.xml.sax.XMLReader;import org.xml.sax.helpers.XMLReaderFactory;/** * <code>SAXParser</code>可以从命令行下读入一个XML文件并且使用SAX标准的机制来分析该文件。 */public class MySAXParser{/** *<p> *我们将在这里使用标准的SAX的处理机制(handler)来处理XML文件 *</p> * @param uri 欲分析的XML文件的URI */public void parseXML(String uri) {try{System.out.println("正在分析中的XML文件: " + uri + "/n");XMLReader parser = XMLReaderFactory.createXMLReader( "org.apache.xerces.parsers.SAXParser");//XMLReader parser = new SAXParser();//注册所设计的内容处理器parser.setContentHandler(new MyContentHandler());//注册错误处理器parser.setErrorHandler(new MyErrorHandler());//分析文件parser.parse(uri);} catch(IOException ioe){System.out.println("文件读取错误："+ioe.getMessage());} catch(SAXException saxe){System.out.println("XML分析错误： "+saxe.getMessage());}}/** *<p> *主程序使用命令列的参数来指定所要分析的XML文件 *</p> */public static void main(String[] args) {//如果参数数目不对，则输出使用说明，并结束程序if( args.length != 1 ){System.out.println("请输入欲分析的文件名: " +"java example3_1 [XML URI]");System.exit(-1);}String uri = args[0];MySAXParser myParser = new MySAXParser();myParser.parseXML(uri);}}/** *<code>ContentHandler</code>实做<code>org.xml.sax. *ContentHandler</code>界面，并且提供提供相关的回调方法。 *所有和XML文件内容有关的分析处理都是在这里解决。 */class MyContentHandler implements ContentHandler {....................
Java 与 XML ——JAXP编程应用
在许多方面，Java 语言已变成供XML 选择的一种非常适合的编程语言。在JAXP(用于XML语法分析的Java API)中包含3个软件包：
1. org.w3c.dom —W3C 推荐的用于XML 标准规划文档对象模型的Java 工具;
2. org.xml.sax—用于对XML 进行语法分析的事件驱动的简单API;
3. Javax.xml.parsers —工厂化工具，允许应用程序开发人员获得并配置特殊的语法分析器工具。
JAXP 作为Java 应用软件和XML 的公共接口，用来保证Sun 、IBM 和 Micrsoft 等公司的XML 分析程序的完全兼容性。
JAXP 是由Sun 提供的Java 的标准XML 语言开发接口，目前最高版本为1.1 。JAXP1.1包含两个部分：一个是parser 部分，位于Javax.xml.parsers 包中，负责解析XML 文档；另一个是transform(TrAX)部分，位于Java.xml.transform 包中，负责进行xslt 转换工作。
JAXP1.1 中包含3个jar 文件，分别是JAXP.jar、crimson.jar 和 xalan.jar 。JAXP.jar 提供了一系列的界面和抽象类，是开发时使用的接口；crimson.jar 中定义了实际上使用的解析器；xalan.jar 中定义了transform 处理器。
JAXP1.1 的解析器提供了SAX2 和 DOM2 支持，同时支持XML1.0 第二版，也支持名空间。JAXP1.1 的TrAX 部分提供了对Xslt 推荐标准1.0 版本的支持。
下面的例子分别是使用JAXP获得 Document Builder 建立一个DOM 对象套式文件，以及使用JAXP获得一个 SAX 语法分析器剖析一个XML 文件。
(1)DOMDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
(2)SAXDemo.java 源程序代码详见http://linux.ccidnet.com的期刊浏览第11期。
有关JAXB 和 JDOM 的编程，由于篇幅有限，在此就不多说了。
1．Java 与 XML 结合从用户使用的应用界面来说，XML 可以用来自定义用户界面。如果将Java 的图形界面Swing 技术应用以XML 的形式来设置，就可以同时发挥Java 的“write one, use many”特性。
2．Java 提供了Servlet 和 JSP （JavaServer Page） 。实际上 XML 和 Servlet、JSP 的相互结合，XML 可以成为Servlet或JSP的输出输入语言。XML 不仅提供具有意义的数据，也提供了验证的方式(DTD)，使得程序能轻易地获得内容，并能够彻底地完成内容数据和表达方式的分离。
3．XML 通过Java 的JDBC与Web 数据库相结合。以XML为基础的新一代环境是直接面对Web数据的，不仅可以很好地兼容原有的Web应用，而且可以更好地实现Web中的信息共享与交换。XML可看作为一种半结构化的数据模型，很容易地将其文档描述与关系数据库中的属性一一对应起来，实施精确地查询与模型抽取。XML能增加结构和语义信息，使计算机和服务器即时处理多种形式的信息。因此，运用XML的扩展功能不仅能从Web服务器下载大量的信息，还能大大减少网络业务量。
4．XML 与 Java 的 EJB（Enterprise Java Bean） 结合。XML 在EJB 上应用，对于数据的沟通和EJB 的参数设置，使得EJB可以将自己所包含的数据依照JSP 和 Servlet 要求，以 XML 的形式返回，让JSP 和 Servlet 自行去处理和显示这些数据有关的工作。一个EJB 可能用到的参数会很多，并且很复杂，如果可以用XML 来定义一个清楚的参数表，这样就可以依据不同的需求来修改EJB 操作的方式，让工作更有效率。
5．Java 的JMS、Java/IDL(CORBA)、Java RMI 及SOAP 等各种分布式的处理，与XML 的XML-RPC 和 SOAP 都具有相似的功能。XML-RPC 和 SOAP 都是将原本是以二进制形式传递的消息，用XML 来表达，这样确保了所有的应用程序都可以读取这些消息，整个分布式的环境更加开放。
- 整合Java与XML的新应用(zz)
- 整合Java与XML的新应用
- 整合Java与XML的新应用
- 整合Java与XML的新应用
- 整合Java与XML的新应用
- XML与java的应用
- 应用整合中SSO的技术实现(ZZ)
- [ZZ]Java虚拟机类装载：原理、实现与应用
- (zz) CString类与string类的比较与应用
- Apache xml-rpc与spring的整合
- Quartz与Spring整合的xml
- zz[Java基础]关于web.xml配置的详细说明
- Java与XML（三）web上的读写应用
- Java与XML（三）web上的读写应用
- XML Java与 XMLBeans结合应用的商业价值
- ssh整合！Struts.xml、hibernate与spring整合的applicationContext.xml、web.xml文件的配置！
- P2P技术与应用 zz
- (zz)POJO应用框架：Spring与EJB3.0的比较
- 关于Linux内核级后门的原理和简单实战
- 关于选择生意的朴素思考
- linux配置、编译内核实用工具
- 我的第一天
- 我回来拉
- 整合Java与XML的新应用(zz)
- 在线求教Vc++和vc.net的区别的问题
- 看Linux内核源码 练内力必备技能
- Struts源码研究 - html-Link标签篇
- Struts源码研究 - html-Cancel标签应用注意事项
- 将XML存入关系数据库
- asp事务处理的另外一个方法
- 内核编译问题详解
- Struts源码研究 - Action-Input属性
