XML和相关规格：消化字母汤（“字母汤”alphabet soup是一种罐头汤，里面是切成ABC字母图案的细面条，让小朋友边喝汤边把里面的字母排成单词来玩）

现在，你已经对XML有了一个基本的理解，需要对与XML相关的缩写单词代表的意义有一个更深的认识。有很多的基于XML的工作要做，所以你需要学习很多的知识。

目前访问XML文档的API分成两种访问方式：顺序的和任意的访问，分别是：SAX和DOM。确认XML的合法性的规范是DTD (最初的机制，作为XML规范被定义)和不同的概要标准（Schema Standards）提案（一种更新的机制，它使用XML语法来做描述合法性准则的工作）。

其它的一些未来的标准已经接近完成，包括XSL标准（一种建立XML文档转换-例如XML文档转换到HTML或其他的XML文档， 和指示文档如何提交的机制）。XSL标准的转换部分（XSLT (+XPATH)）已经完成并且包含在本指南中。其他的接近完成的成果是XML连接语言（XML Link Language）规范（XML Linking），这个规范可以在XML文档之间做连接。

以上这些就是你将要了解的初步内容。这部分也纵览了一些其它的感兴趣的提案，包括HTML类似标准（HTML-lookalike standard）-- XHTML 和描述XML包含的信息的元标准-- RDF。有些标准成果扩展了XML的能力，比如Xlink和Xpointer。

最后，有很多的感兴趣的标准和标准提案建立在XML之上，包含同步的多媒体综合语言（Synchronized Multimedia Integration Language）-- (SMIL)，数学标记语言（Mathematical Markup Language）-- MathML ，可伸缩的向量图形（Scalable Vector Graphics）-- SVG，DrawML和许多的电子商务标准。

余下的部分使你了解这些初步的更详细的细节。为了保持连贯性，这部分被分为如下方面：
1. 基本标准
2. 概要标准
3. 连接和显示标准
4. 知识标准
5. 建立在XML上的标准
基本标准
一些你需要熟悉的基本标准。
SAX
针对XML的简单API(Simple API for XML)

这个API实际上一个协作产品，它不是W3C的产品。它被包含在里面是因为它拥有W3C建议的特征。

你也可以把这个标准想象为XML的连续访问协议。它拥有在服务器中读写XML数据的最快的执行机制。也可以称它为事件驱动协议，因为这个技术将在SAX parser中注册你的操作，注册完后，当parser看到一个新的XML标记时（或者遇到一个错误，或者parser想告诉你其他的事情），parser就会调用你的回调方法。

DOM

文档对象模型（Document Object Model）
文档对象模型协议将一个XML文档转换成一个对象集。然后你可以操作随意的操作这个对象模型。这个机制被称为“随意访问”协议，因为你能够在任何时候访问数据的任意部分。然后，你可以修改、删除和插入数据。

JDOM and dom4j
当文档对象模型（DOM）提供非常强大的面向文档的处理的时候，它却不能提供更多的面向对象的简化。Java开发者会做更多的面向数据处理，而不是面向书籍、文章和其他的完全的文档，他们发现面向对象的API（如:JDOM和dom4j）更容易使用和符合他们的需要。

下面是JDOM和dom4j的不同：
1. JDOM是更整齐、更小巧的API。在代码风格（coding style）重要的时候，JDOM是一个不错的选择。
2. JDOM是一个Java团体处理（Java Community Process--JCP）初步。当完成时，它将是一个认可的标准。
3. dom4j是一个更小巧、更快的实现，它使用的范围很广。
4. dom4j是一个基于制造商（factory-based）的实现。它更容易修改复杂的、特殊目的的应用程序。在dom4j编写的时候，JDOM还没有使用利用工厂（factory）来事例化分析器对象。所以，使用JDOM，你总是得到原始的分析器。

关于JDOM的更多的信息：http://www.jdom.org/.
关于dom4j的更多的信息：http://dom4j.org/.

DTD
文档类型定义（Document Type Definition）

DTD规范是XML规范的一部分，而不是一个单独的实体。另一方面，它是可选的?你可以一个没有DTD的XML文档。有很多的概要（Schema）标准提案来提供更灵活的规范。所以，你完全可以将它看成是单独的部分。

一个DTD规范了不同种类的XML标识和合法的标识的布局。你能够使用DTD来确定你不能产生一个非法的XML结构。你也能够使用它来确定你正在读取得XML结构是合法的。

不幸的是，为一个复杂的文档指定一个DTD是非常的困难的。所以构建一个DTD在某种意义上讲是一门艺术。DTD可以出现在文档的前端，作为序的一部分。它也可以作为单独的一个实体，或者在文档的序和外部的实体中同时存在。

命名空间
命名空间标准允许你用两个或更多的XML标记集合编写XML文档。例如你产生一个基于XML的列表，这个列表使用的标记是另一个厂商提供的。在整个XML文档中“price”数据可能会很多，然而，你只是想显示针对一个结构的“price”数据。命名空间规范定义了一个限定名称的机制，这样可以避免混淆。这样我们写的程序就可以正确的处理文档中的信息。

最新的命名空间信息：http://www.w3.org/TR/REC-xml-names.

XSL
扩展样式表语言（Extensible Stylesheet Language）

XML标准指定怎样识别数据，而不是怎样显示数据。从另一方面来说，HTML是告诉数据怎样显示而不是怎样识别数据。XSL标准有两部分，XSLT和XSL-FO。XSL-FO为你提供页面上的多区域定义并将他们连接到一起。当一个文本流被导向这个集合，它首先流向第一个区域，在第一个区域被充满后会导向第二个区域。像这样的对象被使用在新闻组、一览表和杂志出版中。

最新的XSL标准：http://www.w3.org/TR/WD-xsl

XSLT(+XPATH)
针对转换的扩展样式表语言（Extensible Stylesheet Language for Transformations）

XSLT的转换标准本质上来讲是一个转换机制，它让你指定将一个XML标记转换成什么并用来显示。例如，转换成HTML标识。不同的XSL格式能够以不同的方式显示同样的数据。（XPATH标准是一个寻址机制，当你构造转换指令示会用到它。）

概要标准
一个DTD使验证相关的简单XML文档是否合法成为可能，但是做起来很难。

一个DTD不能限制元素中的内容，不能指定复杂的关系。例如，指定一个<book>中的<heading>必须包含有<title>和<author>，而一个<chapter>中的<heading>紧紧需要一个<title>。在DTD中，你只能一次的指定<heading>的结构。DTD不是上下文敏感的，因为DTD规范不是层次的。

例如，一个邮件地址包含几个“解析的字符数据（PCDATA）”元素，DTD可能会像下面这样：
<!ELEMENT mailAddress (name, address, zipcode)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT address (#PCDATA)>
<!ELEMENT zipcode (#PCDATA)>
像你看到的那样，这个规范是线性的。所以，在DTD中，如果你需要另一个“name”元素，那么你需要为它定义一个不同的识别符。你不能简单的称它为“name”，因为它会和<mailAddress>元素中使用的“name”冲突。

另一个问题是DTD的无层次性使得理解其中的注解很困难。一个在最上面的注解看起来更像是针对全文结构的注解，但也可能它只是对第一条的注解。最后，DTD不允许你形式上的指定合法域准则，例如对邮政编码域中的5位数限制。

最后，一个DTD使用的语法不同于XML，所以它不能被一个标准的XML分析器解析。这就意味着你不能将DTD读进DOM，和编辑、修改它。

为了修补这些缺点，很多的提案已经被提交。像层次性的“概要--schema”，它指定了合法性准则。后面介绍了一些主要的提案。

XML概要（Schema）
一个大而复杂的标准，它拥有两部分。一部分指定结构联系（这是最大最复杂的部分）。另一部分指定XML元素中的内容的合法性机制，可以通过为每个元素指定一个数据类型。一个好消息是，XML概要可以指定任何设想的关联。坏消息是他很难实现也很难学习。

XML概要的更多的信息，可以查看W3C specs XML Schema(Structures) and XML Schema(Datatypes).
http://www.w3c.org/XML/Schema.

RELAX NG
XML的规则语言描述（下一代）--（Regular Language description for XML（Next Generation））

RELAX NG是一个新兴标准，它要比XML结构概要简单。再不远的将来它也可能成为一个ISO标准。

RELAX NG使用规则表达式来表达结构关系上的限制，它使用XML概要数据类型机制来表达内容上的限制。这个标准也使用XML语法，它包含一个DTD到RELAX的转换器。（说它是“next generation”是因为它是结和TREX 的RELAX概要机制的新版本）。

关于RELAX NG的更多的信息：http://www.oasis-open.org/committees/relax-ng/

TREX
针对XML的树型规则表达式（Tree Regular Expressions for XML）

它是一个通过为XML文档中的结构和内容描述一个模版来表达合法性准则的手段。现在作为RELAX　NG的一部分。

SOX
面向对象的概要（Schema for Object-oriented XML）

SOX是一个概要提案，它包括扩展数据类型、命名空间和嵌入的文档。

SOX更多的信息：http://www.ascc.net/xml/resource/schematron/schematron.html.

连接和表现标准
可以证明，HTML中的文档之间的连接和简单的文档格式是最大的优点。下面的标准定位于在XML中保留HTML的好处并增加额外的功能。

XML Linking
这些规范提供一个不同的连接能力，但对XML的使用上形成了一次很大的冲击。

XLink
Xlink协议是一个在XML文档间处理连接的规范。这个规范允许一些恰当的改进连接，包含双向连接、连接到多文档、展开连接、内部指向连接等。

XML 基础
这个标准定义一个XML文档属性，这个属性定义一个“基础”地址，“基础”地址在查找一个关联的地址时被使用。（例如，一个简单的文件名可以在一个基础地址目录中被找到）

XPointer
一般情况下，Xlink规范是将使用它的ID的文档或文档片断作为目标的。XPointer规范定义的机制是针对“在一个XML文档内部结构的寻址”的。XPointer规范不需要文档的作者为一个文档片断定一个ID。

XML连接的更多的信息：http://www.w3.org/XML/Linking.
XHTML
XHTML规范是XML文档的一个用途，只不过XML文档更像HTML文档。既然XML文档可以包含任意的标识，那么为什么不能定义一个很像HTML标识的XML标识集呢？这就是XHTML的想法。这个规范的结果是一个文档既能在浏览器中显示，又能作为XML文档被处理。尽管它并不是纯正的XML，但是它比HTML更容易被处理。

例如，在一个格式良好的XML文档中，每一个标识必须有一个结束标识。所以在XHTML中，你可能看到<p>..</p>，或<p/>。但你绝对看不到单独的<p>。

XHTML规范是一个HTML4.0到XML的再形成。最新的信息在：http://www.w3.org/TR/xhtml1.

知识标准
RDF
资源描述框架（Resource Description Framework）

RDF是一个定义元数据的标准，元数据是描述一个特殊的数据条目是什么的信息并指定怎么样来使用这个数据条目。例如，联合XHTML规范或HTML页面来使用，RDF被用来描述页面的内容。例如，如果你的浏览器存储你的ID信息像FIRSTNAME、LASTNAME和EMAIL，一个RDF描述传输传输个需要NAME和EMAILADDRESS的应用程序相应的信息。想象一下，到那一天，你可能不需要在每个网站里输入你的名字和邮件地址。

关于RDF更多的信息：http://www.w3.org/TR/REC-rdf-syntax

RDF概要
RDF概要允许相容性原则和附加信息的规范。

更多的RDF概要信息：http://www.w3.org/TR/rdf-schema.

XTM
XML主题映射（XML Topic Maps）

在许多方面，主体映射标准是一个比RDF更简单的、更容易使用得知识表示，它更应该值得被关注。迄今为止，RDF是一个W3C标准，但是，主题映射可能只能作为一种开发者选择的标准。

XML主题映射更多的信息：http://www.topicmaps.org/xtm/index.html.

建立在XML上的标准
下面的标准和提案都是建立在XML之上的。因为XML基本上是一个定义语言的工具，所以这些标准使用它定义特殊目的标准语言。

扩展文档标准（Extended Document Standards）
这些标准定义了使用XML产生极端复杂的文档的机制。

SMIL
同步的多媒体综合语言（Synchronized Multimedia Integration Language）
SMIL是一个W3C建议的标准，它涵盖了音频、视频和动画。

更多关于SMIL的信息：http://www.w3.org/TR/REC-smil.

MathML
数学标记语言（Mathematical Markup Language）

MathML是一个W3C建议的标准，它处理数学公式的显示。

更多关于MathML的信息：http://www.w3.org/TR/REC-MathML.

SVG
可伸缩的向量图像（Scalable Vector Graphics）

SVG是一个W3C工作草案，它覆盖了向量图像的显示。

更多关于SVG的信息：http://www.w3.org/TR/WD-SVG.

DrawML
绘制元语言（Drawing Meta Language）

DrawML是一个W3C的附注，它涵盖了技术图表的2D图像。

更多的关于DrawML的信息：http://www.w3.org/TR/NOTE-drawml.

电子商务标准（eCommerce Standards）

这些标准定位于在B2B和B2C的范围里使用XML。

ICE
信息和内容交换（Information and Content Exchange）

ICE是一个被内容经营者使用的协议。它的焦点在“在传统出版和B2B联系上自动化内容转换和重用”

更多关于ICE的信息：http://www.w3.org/TR/NOTE-ice.

ebXML
基于XML的电子交易（Electronic Business with XML）

这个标准定位在使用XML建立模块化的电子交易框架。它是UN/CEFACT的一个起步产品。

更多关于ebXML的信息：http://www.ebxml.org/.

cxml
商业XML（Commerce XML）

cxml是一个RosettaNet（www.rosettanet.org）标准，它的目的是为了不同的买主建立一个在线的名单。

更多关于cxml的信息：http://www.cxml.org/

CBL
通用交易库（Common Business Library）

CBL是一个元素和属性定义的库。

更多关于CBL的信息：http://www.commerce.net/projects/currentprojects/eco/wg/eCo_Framework_Specifications.html.
UBL
统一商业语言（Universal Business Language）

一个OASIS初步定位在编译一个XML交易文档的标准库。

更多关于UBL的信息：http://www.oasis-open.org/committees/ubl.

总结
XML是一个正在被广泛的应用的标准，它正在被用在不同的领域。

原文地址：http://java.sun.com/developer/EJTechTips/2005/tt1122.html#1

by Greg Murray
作者：格雷格－默里
AJAX stands for Asynchronous JavaScript and XML. In essence, AJAX is an efficient way for a web application to handle user interactions with a web page -- a way that reduces the need to do a page refresh or full page reload for every user interaction. This enables rich behavior (similar to that of a desktop application or plugin-based web application) using a browser. AJAX interactions are handled asynchronously in the background. As this happens, a user can continue working with the page. AJAX Interactions are initiated by the JavaScript in the web page. When the AJAX interaction is complete, JavaScript updates the HTML source of the page. The changes are made immediately without requiring a page refresh. AJAX interactions can be used to do things such as validate form entries (while the user is entering them) using server-side logic, retrieve detailed data from the server, dynamically update data on a page, and submit partial forms from the page.
AJAX代表着异步的JAVASCRIPT和XML。本质上，AJAX是一种在WEB应用中通过网页与用户交互的有效方式，它减少了用户交互中刷新页面或整页重载的频率。这样使用浏览器可以进行更丰富的动作（与桌面应用或基于PLUGIN的WEB应用相似）。AJAX交互在后台异步执行，此时用户可以继续在这个页面上工作。AJAX是由网页中的JAVASCRIPT驱动的。当AJAX交互完成后，JS更新网页HTML代码。这个动作在不需要刷新页面的情况下迅速执行。AJAX可以用于许多方面，例如在用户输入的同时用服务器端规则验证其输入，获得服务器端详细数据并主动更新页面数据，或者提交页面表单的部分数据。
What is particularly attractive about this is that AJAX applications do not require a separate plug-in, and are platform and browser-neutral. That said, AJAX is not supported as well in older browsers. Care needs to be taken in writing client-side script that accounts for the differences between browsers. You might consider using a JavaScript library that abstracts the browser differences and in some cases support older browsers using alternative interaction techniques. For more details, see the AJAX FAQ for the Java Developer
是什么让AJAX技术具体如此魅力呢？AJAX应用不需用单独的插件，并且是平台和浏览器中立的。也就是说，AJAX并不被旧的浏览器良好支持。但是不必太过担心，你可以撰写跨不同浏览器的脚本。你应该考虑使用跨不同浏览器的JS库并且在一些情况下有选择性的使用交互技术以支持旧的浏览器。了解更多，请查看JAVA开发者的AJAX  FAQ。http://weblogs.java.net/blog/gmurray71/

So Where Does Java Technology Fit In?
那么JAVA技术适合在哪儿使用呢？
Java technology and AJAX work well together. Java technology provides the server-side processing for AJAX interactions. It can provide this through servlets, JavaServer Pages (JSP) technology, JavaServer Faces (JSF) technology, and web services. The programming model for handling AJAX requests uses the same APIs that you would use for conventional web applications. JSF technology can be used to create reusable components that generate the client-side JavaScript and corresponding server-side AJAX processing code. Let's look at an example that uses AJAX and servlets.
JAVA技术与AJAX搭配使用非常不错。JAVA技术为AJAX交互提供服务器端处理，通过servlets、JavaServer Pages (JSP)、JavaServer Faces (JSF) 及web服务。AJAX请求的编程模式使用与常规WEB应用相同的API。JSF技术可以用来创建可重用的组件，这些组件生成客户端JS并与服务器端AJAX处理代码通信。下面让我们来看一个使用AJAX和SERVLETS的例子。
Autocomplete Example
实例：自动完成
Imagine a web page in which a user can search for information about an employee. The page includes a field where the user can enter the name of the employee. In this example the entry field has an autocomplete feature. In other words, the user can type in part of the employee name, and the web application attempts to complete the name by listing all employees whose first or last name begins with the characters entered. The autocomplete feature saves the user from having to remember the complete name of the employee or from looking for the name on another page.
假设用户在一个网页中搜索雇员信息。这个页面包含一个输入域，用户在其中输入雇员的名字。在这个例子中输入域具有自动完成的功能。换句话说，用户输入雇员名的一部分，WEB应用通过列出所有姓名以输入字母开头的雇员来帮助完成输入。自动完成功能让用户可以无需记住员工的全名或者从另一个页面查找名字。（此句偶之前百思不得其解，后来经永华指点，大约是这样的：你可以有三种方式查询员工信息，1.记住员工的名字、2.从别的地方，比如其它页面找到后复制粘贴过来，3.使用自动完成功能，很显然，第三种是最省事的，优于其它方式，所以说3 SAVE FROM 1/2.）

Implementing autocomplete in a search field is something that can be performed using AJAX. To do it, you need to provide code on the client and on the server.
可以使用AJAX实现搜索输入域的自动完成。要实现这个，需要撰写相应的客户端和服务器端代码。

On the Client
客户端
First, the user specifies the URL of a page that is loaded by the browser. For this example let's assume the page is an HTML page that is generated by a JSF component, servlet, or JSP page. The page contains a form text field that has an attribute onkeyup with the name of a JavaScript function doCompletion(). This function is called each time a key is pressed in the form text field.
首先，用户打开一个网页。假设这个页面是一个由JSF组件、SERVLET或JSP产生的HTML页面。页面中包含一个表单文本域，它有一个ONKEYUP属性，其值为一个JS函数doCompletion()。这个每当文本域有输入改变，这个函数就会被调用。
    <input type="text"
          size="20"
          autocomplete="off"
          id="complete-field"
                      name="id"
          onkeyup="doCompletion();">

Let's assume that a user types in an "M" character in the form text field. In response, the doCompletion() function is called which, in turn, initializes an XMLHttpRequest object:
假设用户在表单文本域输入字母M，doCompletion()将被调用，初始化一个XMLHttpRequest对象。
   function initRequest(url) {
       if (window.XMLHttpRequest) {
           return new XMLHttpRequest();
       } else if (window.ActiveXObject) {
           isIE = true;
           return new ActiveXObject("Microsoft.XMLHTTP");
       }
   }

   function doCompletion() {
       if (completeField.value == "") {
           clearTable();
       } else {
           var url = "autocomplete?action=complete&id=" +
                   escape(completeField.value);
           var req = initRequest(url);
           req.onreadystatechange = function() {
               if (req.readyState == 4) {
                   if (req.status == 200) {
                       parseMessages(req.responseXML);
                   } else if (req.status == 204){
                       clearTable();
                   }
               }
           };
           req.open("GET", url, true);
           req.send(null);
       }
   }

The XMLHttpRequest object is not currently part of standard JavaScript (efforts are underway to standardize it), but is a de facto standard and is the heart of AJAX. This object is responsible for interacting over HTTP with a server-side component (in this case, a servlet).
XMLHttpRequest对象现在还不是JS标准中的一部分（正在努力将其标准化），但它却是事实上的标准并且是AJAX的核心。这个对象对于在HTTP协议上与服务器端组件（此例中是一个SERVLET）交互很可靠.

Three parameters are specified when you create an XMLHttpRequest object: a URL, the HTTP method (GET or POST), and whether or not the interaction is asynchronous. In the XMLHttpRequest example, the parameters are:
当创建XMLHttpRequest对象时需指定三个参数：一个URL,HTTP方式（GET或POST）, 交互是否异步。在这个XMLHttpRequest 例子中，这些参数如下：
    * The URL autocomplete, and the text from the complete-field (an M character):
*自动完成的URL和从输入域键入的文字：
     var url = "autocomplete?action=complete&id=" +
             escape(completeField.value);

    * GET, signifying the HTTP interactions uses the GET method, and true, signifying that the interaction is asynchronous:
*GET，表示HTTP交互使用GET方法；TRUE，表示交互是异步的：
     req.open("GET", url, true);

A callback function needs to be set when you use asynchronous calls. This callback function is called asynchronously at specific points during HTTP interaction when the readyState property on the XMLHttpRequest changes. In the example the callback function is processRequest(). It's set as the XMLHttpRequest.onreadystatechange property to a function. Notice the call to the parseMessages function when the readState is "4". The XMLHttpRequest.readyState of "4" signifies the successful completion of the HTTP interaction.
当使用异步调用时，需要建立一个回调函数。HTTP交互中当XMLHttpRequest中的readyState属性改变时，回调函数被异步调用。此例中回调函数是processRequest()。它为一个函数建立了一个XMLHttpRequest.onreadystatechange属性。（前两句还不太明白什么意思——译者注）。注意当readyState为4时对parseMessages函数的调用。XMLHttpRequest.readyState为4意味着HTTP交互的成功完成。
The HTTP interaction begins when XMLHttpRequest.send() is called. If the interaction is asynchronous, the browser continues to process events in the page.
HTTP交互以调用XMLHttpRequest.send()开始。如果交互是异步的，浏览器前继续执行页面事件（而不是中断用户当前动作去执行交互动作——译者注）。
On the Server
服务器端
The XMLHttpRequest makes an HTTP GET request to the URL autocomplete, which is mapped to a servlet called AutoComplete. The doGet() method of the AutoComplete servlet is called. Here is what the doGet() method looks like:
XMLHttpRequest为自动完成的URL产生了一个HTTP GET请求，这个URL被映射到一个名为AutoComplete的Servlet上。AutoComplete servlet的doGet() 方法被调用。这里的doGet()方法如下：
   public void doGet(HttpServletRequest request,
           HttpServletResponse response)
        throws IOException, ServletException {
       ...
       String targetId = request.getParameter("id");
       Iterator it = employees.keySet().iterator();
       while (it.hasNext()) {
           EmployeeBean e = (EmployeeBean)employees.get(
                   (String)it.next());
           if ((e.getFirstName().toLowerCase().startsWith(targetId) ||
              e.getLastName().toLowerCase().startsWith(targetId))
              && !targetId.equals("")) {
              sb.append("<employee>");
              sb.append("<id>" + e.getId() + "</id>");
              sb.append("<firstName>" + e.getFirstName() +
                      "</firstName>");
              sb.append("<lastName>" + e.getLastName() +
                      "</lastName>");
              sb.append("</employee>");
              namesAdded = true;
           }
       }
       if (namesAdded) {
           response.setContentType("text/xml");
           response.setHeader("Cache-Control", "no-cache");
           response.getWriter().write("<employees>" +
                   sb.toString() + "</employees>");
       } else {
           response.setStatus(HttpServletResponse.SC_NO_CONTENT);
       }
    }

As you can see in this servlet, there is nothing really new you need to learn to write server-side code for AJAX processing. The response content type needs to be set to text/xml for cases where you want to exchange XML documents. With AJAX, you can also exchange plain text or even snippets of JavaScript which may be evaluated or executed by the callback function on the client. Note too that some browsers might cache the results, and so it might be necessary to set the Cache-Control HTTP header to no-cache. In this example, the servlet generates an XML document that contains all employees with a first or last name beginning with the character M. Here is an example of an XML document that is returned to the XMLHttpRequest object that made the call:
如你在SERVLET中所看到，不需要为写服务器端AJAX处理代码而学习新知识。当你想要发送XML文档，只需将响应内容类型设置为text/xml。使用AJAX，你甚至可以发送普通文本或者小段JS代码，这些代码可能在客户端被回调函数计算或执行。注意：一些浏览器可能将结果缓存，所以有必要设置Cache-Control HTTP header为no-cache。此例中，SERVLET产生一个XML文档，它包含所有姓或名以M开头的雇员的姓名。下面是一个返回给XMLHttpRequest对象的XML文档例子：
   <employees>
      <employee>
        <id>3</id>
        <firstName>George</firstName>
        <lastName>Murphy</lastName>
      </employee>
      <employee>
        <id>2</id>
        <firstName>Greg</firstName>
        <lastName>Murphy</lastName>
      </employee>
      <employee>
        <id>11</id><firstName>Cindy</firstName>
        <lastName>Murphy</lastName>
        </employee>
      <employee>
        <id>4</id>
        <firstName>George</firstName>
        <lastName>Murray</lastName>
      </employee>
      <employee>
        <id>1</id>
        <firstName>Greg</firstName>
        <lastName>Murray</lastName>
     </employee>
   </employees>
Returning to the Client
再来看客户端
When the XMLHttpRequest object that made the initial call receives the response, it calls the parseMessages() function (see the initialization of the XMLHttpRequest earlier in this example for more details). Here is what the parseMessages() function looks like:
当最初发送请求的XMLHttpRequest对象收到回应，它调用parseMessages() 函数（参见此例前面XMLHttpRequest的初始化）。这个函数如下：
   function parseMessages(responseXML) {
       clearTable();
           var employees = responseXML.getElementsByTagName(
                   "employees")[0];
       if (employees.childNodes.length > 0) {
           completeTable.setAttribute("bordercolor", "black");
           completeTable.setAttribute("border", "1");
       } else {
           clearTable();
       }
   
       for (loop = 0; loop < employees.childNodes.length; loop++) {
           var employee = employees.childNodes[loop];
           var firstName = employee.getElementsByTagName(
                   "firstName")[0];
           var lastName = employee.getElementsByTagName(
                   "lastName")[0];
           var employeeId = employee.getElementsByTagName(
                   "id")[0];
           appendEmployee(
                   firstName.childNodes[0].nodeValue,
                   lastName.childNodes[0].nodeValue,
                   employeeId.childNodes[0].nodeValue);
       }
   }

The parseMessages() function receives as a parameter an object representation of the XML document returned by the AutoComplete servlet. The function programmatically traverses the XML document, and then uses the results to update the contents of the HTML page. This is done by injecting into a <div> element whose id is "menu-popup" the HTML source for the names in the XML document:
parseMessages() 函数接收AutoComplete servlet返回的XML文档对象做为参数。该函数自动转化XML文档并更新网页内容，通过在HTML源文件中为XML文档中的姓名插入一个 id 为 "menu-popup"的DIV元素：
   <div style="position: absolute;
      top:170px;left:140px" id="menu-popup">

As the user enters more characters, the list shortens. The user can then click on one of the names.
当用户输入更多字符，姓名列表变短。用户可以点击要查找的姓名。
Hopefully by now you realize that AJAX is simply exchanging information over HTTP in the background of a page, and updating that page dynamically based on the results. For more information about AJAX and Java technology, see the technical article Asynchronous JavaScript Technology and XML (AJAX) With Java 2 Platform, Enterprise Edition. （http://java.sun.com/developer/technicalArticles/J2EE/AJAX/index.html）Also see the AJAX BluePrints page, （http://java.sun.com/blueprints/ajax.html）and the AJAX FAQ for the Java Developer in Greg Murray's blog. （http://weblogs.java.net/blog/gmurray71/）
希望现在你已经了解到AJAX如何在后台简单地交换信息以及在此基础上动态地更新页面。欲了解更多关于AJAX和JAVA技术，可以看这篇技术文章《Asynchronous JavaScript Technology and XML (AJAX) With Java 2 Platform, Enterprise Edition》（http://java.sun.com/developer/technicalArticles/J2EE/AJAX/index.html）。或者看AJAX蓝图http://java.sun.com/blueprints/ajax.html，或Greg Murray的博客中为JAVA开发者写的AJAX FAQ。http://weblogs.java.net/blog/gmurray71/
About the Author
关于作者
Greg Murray is the servlet specification lead. Greg is a former member of the Java BluePrints team, and was responsible for the web tier recommendations. He is leading the AJAX effort at Sun with the help of the BluePrints team. Greg has experience with internationalization, web services, J2SE standalone clients, and AJAX-based web clients.
格雷格－默里是SERVLET规范领导。他曾是JAVA蓝图工作组会员，非常负责地对WEB TIER提出许多建议(或者是对XX负责)。在蓝图工作组的协助下他在SUN领导AJAX工作。格雷格在国际化、WEB服务、J2SE独立客户端和基于AJAX的WEB客户端方面有着丰富的经验。

About the Translater
关于译者
Ahdong is wide-interested boy in China.Ahdong is a member of Network Creative Lab of Huaqiao University,and is  responsible for the newbees' recommendations about learning.He is leading the software department at the lab with Younghua.Ahdong is interested in and has some experience with Linux,web development with JAVA or PHP,web standard,and AJAX-based web clients.
阿冬是一个兴趣广泛的中国男孩。他是华侨大学网络创新实验室的一员，负责任地对许多初学者提了许多中肯的建议。他和永华一起领导实验室软件部。阿冬在LINUX、PHP或JAVA WEB开发、WEB标准、基于AJAX的WEB客户端方面有着深厚的兴趣并多少有一点儿经验。