A Web server exclusively handles HTTP requests, whereas an application server serves business logic to application programs through any number of protocols.

Let's examine each in more detail.

The Web server

A Web server handles the HTTP protocol. When the Web server receives an HTTP request, it responds with an HTTP response, such as sending back an HTML page. To process a request, a Web server may respond with a static HTML page or image, send a redirect, or delegate the dynamic response generation to some other program such as CGI scripts, JSPs (JavaServer Pages), servlets, ASPs (Active Server Pages), server-side JavaScripts, or some other server-side technology. Whatever their purpose, such server-side programs generate a response, most often in HTML, for viewing in a Web browser.

Understand that a Web server's delegation model is fairly simple. When a request comes into the Web server, the Web server simply passes the request to the program best able to handle it. The Web server doesn't provide any functionality beyond simply providing an environment in which the server-side program can execute and pass back the generated responses. The server-side program usually provides for itself such functions as transaction processing, database connectivity, and messaging.

While a Web server may not itself support transactions or database connection pooling, it may employ various strategies for fault tolerance and scalability such as load balancing, caching, and clustering—features oftentimes erroneously assigned as features reserved only for application servers.

The application server

As for the application server, according to our definition, an application server exposes business logic to client applications through various protocols, possibly including HTTP. While a Web server mainly deals with sending HTML for display in a Web browser, an application server provides access to business logic for use by client application programs. The application program can use this logic just as it would call a method on an object (or a function in the procedural world).

Such application server clients can include GUIs (graphical user interface) running on a PC, a Web server, or even other application servers. The information traveling back and forth between an application server and its client is not restricted to simple display markup. Instead, the information is program logic. Since the logic takes the form of data and method calls and not static HTML, the client can employ the exposed business logic however it wants.

In most cases, the server exposes this business logic through a component API, such as the EJB (Enterprise JavaBean) component model found on J2EE (Java 2 Platform, Enterprise Edition) application servers. Moreover, the application server manages its own resources. Such gate-keeping duties include security, transaction processing, resource pooling, and messaging. Like a Web server, an application server may also employ various scalability and fault-tolerance techniques.

XML现在已经成为一种通用的数据交换格式,平台的无关性使得很多场合都需要用到XML。本文将详细介绍用Java解析XML的四种方法。

XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关 性,系统无关性,给数据集成与交互带来了极大的方便。对于XML本身的语法知识与技术细节,需要阅读相关的技术文献,这里面包括的内容有 DOM(Document Object Model),DTD(Document Type Definition),SAX(Simple API for XML),XSD(Xml Schema Definition),XSLT(Extensible Stylesheet Language Transformations),具体可参阅w3c官方网站文档http://www.w3.org获取更多信息。

XML在不同的语言里解析方式都是一样的,只不过实现的语法不同而已。基本的解析方式有两种,一种叫SAX，另一种叫DOM。SAX是基于事件流的解析,DOM是基于XML文档树结构的解析。假设我们XML的内容和结构如下:

<?xml version="1.0" encoding="UTF-8"?> <employees> <employee> <name>ddviplinux</name> <sex>m</sex> <age>30</age> </employee> </employees>

本文使用JAVA语言来实现DOM与SAX的XML文档生成与解析。
首先定义一个操作XML文档的接口XmlDocument 它定义了XML文档的建立与解析的接口。

package com.alisoft.facepay.framework.bean; /** * * @author hongliang.dinghl * 定义XML文档建立与解析的接口 */ public interface XmlDocument { /** * 建立XML文档 * @param fileName 文件全路径名称 */ public void createXml(String fileName); /** * 解析XML文档 * @param fileName 文件全路径名称 */ public void parserXml(String fileName); }

1.DOM生成和解析XML文档

为 XML 文档的已解析版本定义了一组接口。解析器读入整个文档，然后构建一个驻留内存的树结构，然后代码就可以使用 DOM 接口来操作这个树结构。优点：整个文档树在内存中，便于操作；支持删除、修改、重新排列等多种功能；缺点：将整个文档调入内存（包括无用的节点），浪费时 间和空间；使用场合：一旦解析了文档还需多次访问这些数据；硬件资源充足（内存、CPU）。

package com.alisoft.facepay.framework.bean; 

import java.io.FileInputStream; 

import java.io.FileNotFoundException; 

import java.io.FileOutputStream; 

import java.io.IOException; 

import java.io.InputStream; 

import java.io.PrintWriter; 

import javax.xml.parsers.DocumentBuilder; 

import javax.xml.parsers.DocumentBuilderFactory; 

import javax.xml.parsers.ParserConfigurationException; 

import javax.xml.transform.OutputKeys; 

import javax.xml.transform.Transformer; 

import javax.xml.transform.TransformerConfigurationException; 

import javax.xml.transform.TransformerException; 

import javax.xml.transform.TransformerFactory; 

import javax.xml.transform.dom.DOMSource; 

import javax.xml.transform.stream.StreamResult; 

import org.w3c.dom.Document; 

import org.w3c.dom.Element; 

import org.w3c.dom.Node; 

import org.w3c.dom.NodeList; 

import org.xml.sax.SAXException; 

/** 

* 

* @author hongliang.dinghl 

* DOM生成与解析XML文档 

*/ 

public class DomDemo implements XmlDocument { 

private Document document; 

private String fileName; 

public void init() { 

try { 

DocumentBuilderFactory factory = DocumentBuilderFactory 

.newInstance(); 

DocumentBuilder builder = factory.newDocumentBuilder(); 

this.document = builder.newDocument(); 

} catch (ParserConfigurationException e) { 

System.out.println(e.getMessage()); 

} 

} 

public void createXml(String fileName) { 

Element root = this.document.createElement("employees"); 

this.document.appendChild(root); 

Element employee = this.document.createElement("employee"); 

Element name = this.document.createElement("name"); 

name.appendChild(this.document.createTextNode("丁宏亮")); 

employee.appendChild(name); 

Element sex = this.document.createElement("sex"); 

sex.appendChild(this.document.createTextNode("m")); 

employee.appendChild(sex); 

Element age = this.document.createElement("age"); 

age.appendChild(this.document.createTextNode("30")); 

employee.appendChild(age); 

root.appendChild(employee); 

TransformerFactory tf = TransformerFactory.newInstance(); 

try { 

Transformer transformer = tf.newTransformer(); 

DOMSource source = new DOMSource(document); 

transformer.setOutputProperty(OutputKeys.ENCODING, "gb2312"); 

transformer.setOutputProperty(OutputKeys.INDENT, "yes"); 

PrintWriter pw = new PrintWriter(new FileOutputStream(fileName)); 

StreamResult result = new StreamResult(pw); 

transformer.transform(source, result); 

System.out.println("生成XML文件成功!"); 

} catch (TransformerConfigurationException e) { 

System.out.println(e.getMessage()); 

} catch (IllegalArgumentException e) { 

System.out.println(e.getMessage()); 

} catch (FileNotFoundException e) { 

System.out.println(e.getMessage()); 

} catch (TransformerException e) { 

System.out.println(e.getMessage()); 

} 

} 

public void parserXml(String fileName) { 

try { 

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); 

DocumentBuilder db = dbf.newDocumentBuilder(); 

Document document = db.parse(fileName); 

NodeList employees = document.getChildNodes(); 

for (int i = 0; i < employees.getLength(); i++) { 

Node employee = employees.item(i); 

NodeList employeeInfo = employee.getChildNodes(); 

for (int j = 0; j < employeeInfo.getLength(); j++) { 

Node node = employeeInfo.item(j); 

NodeList employeeMeta = node.getChildNodes(); 

for (int k = 0; k < employeeMeta.getLength(); k++) { 

System.out.println(employeeMeta.item(k).getNodeName() 

+ ":" + employeeMeta.item(k).getTextContent()); 

} 

} 

} 

System.out.println("解析完毕"); 

} catch (FileNotFoundException e) { 

System.out.println(e.getMessage()); 

} catch (ParserConfigurationException e) { 

System.out.println(e.getMessage()); 

} catch (SAXException e) { 

System.out.println(e.getMessage()); 

} catch (IOException e) { 

System.out.println(e.getMessage()); 

} 

} 

}

2.SAX生成和解析XML文档

为 解决DOM的问题，出现了SAX。SAX ，事件驱动。当解析器发现元素开始、元素结束、文本、文档的开始或结束等时，发送事件，程序员编写响应这些事件的代码，保存数据。优点：不用事先调入整个 文档，占用资源少；SAX解析器代码比DOM解析器代码小，适于Applet，下载。缺点：不是持久的；事件过后，若没保存数据，那么数据就丢了；无状态 性；从事件中只能得到文本，但不知该文本属于哪个元素；使用场合：Applet;只需XML文档的少量内容，很少回头访问；机器内存少；

Java代码

package com.alisoft.facepay.framework.bean;   

import java.io.FileInputStream;    

import java.io.FileNotFoundException;    

import java.io.IOException;    

import java.io.InputStream;    



import javax.xml.parsers.ParserConfigurationException;    

import javax.xml.parsers.SAXParser;    

import javax.xml.parsers.SAXParserFactory;    



import org.xml.sax.Attributes;    

import org.xml.sax.SAXException;    

import org.xml.sax.helpers.DefaultHandler;    

/**  

*    

* @author hongliang.dinghl  

* SAX文档解析  

*/  

public class SaxDemo implements XmlDocument {    



public void createXml(String fileName) {    

System.out.println("<<"+filename+">>");    

}    



public void parserXml(String fileName) {    

SAXParserFactory saxfac = SAXParserFactory.newInstance();    



try {    



SAXParser saxparser = saxfac.newSAXParser();    



InputStream is = new FileInputStream(fileName);    



saxparser.parse(is, new MySAXHandler());    



} catch (ParserConfigurationException e) {    



e.printStackTrace();    



} catch (SAXException e) {    



e.printStackTrace();    



} catch (FileNotFoundException e) {    



e.printStackTrace();    



} catch (IOException e) {    



e.printStackTrace();    



}    



}    



}    



class MySAXHandler extends DefaultHandler {    



boolean hasAttribute = false;    



Attributes attributes = null;    



public void startDocument() throws SAXException {    



System.out.println("文档开始打印了");    



}    



public void endDocument() throws SAXException {    



System.out.println("文档打印结束了");    



}    



public void startElement(String uri, String localName, String qName,    



Attributes attributes) throws SAXException {    



if (qName.equals("employees")) {    



return;    



}    



if (qName.equals("employee")) {    



System.out.println(qName);    



}    



if (attributes.getLength() > 0) {    



this.attributes = attributes;    



this.hasAttribute = true;    



}    



}    



public void endElement(String uri, String localName, String qName)    



throws SAXException {    



if (hasAttribute && (attributes != null)) {    



for (int i = 0; i < attributes.getLength(); i++) {    



System.out.println(attributes.getQName(0)    

+ attributes.getValue(0));    



}    



}    



}    



public void characters(char[] ch, int start, int length)    



throws SAXException {    



System.out.println(new String(ch, start, length));    



}    



}  

package com.alisoft.facepay.framework.bean; 

import java.io.FileInputStream; 

import java.io.FileNotFoundException; 

import java.io.IOException; 

import java.io.InputStream; 

import javax.xml.parsers.ParserConfigurationException; 

import javax.xml.parsers.SAXParser; 

import javax.xml.parsers.SAXParserFactory; 

import org.xml.sax.Attributes; 

import org.xml.sax.SAXException; 

import org.xml.sax.helpers.DefaultHandler; 

/** 

* 

* @author hongliang.dinghl 

* SAX文档解析 

*/ 

public class SaxDemo implements XmlDocument { 

public void createXml(String fileName) { 

System.out.println("<<"+filename+">>"); 

} 

public void parserXml(String fileName) { 

SAXParserFactory saxfac = SAXParserFactory.newInstance(); 

try { 

SAXParser saxparser = saxfac.newSAXParser(); 

InputStream is = new FileInputStream(fileName); 

saxparser.parse(is, new MySAXHandler()); 

} catch (ParserConfigurationException e) { 

e.printStackTrace(); 

} catch (SAXException e) { 

e.printStackTrace(); 

} catch (FileNotFoundException e) { 

e.printStackTrace(); 

} catch (IOException e) { 

e.printStackTrace(); 

} 

} 

} 

class MySAXHandler extends DefaultHandler { 

boolean hasAttribute = false; 

Attributes attributes = null; 

public void startDocument() throws SAXException { 

System.out.println("文档开始打印了"); 

} 

public void endDocument() throws SAXException { 

System.out.println("文档打印结束了"); 

} 

public void startElement(String uri, String localName, String qName, 

Attributes attributes) throws SAXException { 

if (qName.equals("employees")) { 

return; 

} 

if (qName.equals("employee")) { 

System.out.println(qName); 

} 

if (attributes.getLength() > 0) { 

this.attributes = attributes; 

this.hasAttribute = true; 

} 

} 

public void endElement(String uri, String localName, String qName) 

throws SAXException { 

if (hasAttribute && (attributes != null)) { 

for (int i = 0; i < attributes.getLength(); i++) { 

System.out.println(attributes.getQName(0) 

+ attributes.getValue(0)); 

} 

} 

} 

public void characters(char[] ch, int start, int length) 

throws SAXException { 

System.out.println(new String(ch, start, length)); 

} 

}

3.DOM4J生成和解析XML文档

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

Java代码

package com.alisoft.facepay.framework.bean;   

import java.io.File;    

import java.io.FileWriter;    

import java.io.IOException;    

import java.io.Writer;    

import java.util.Iterator;    



import org.dom4j.Document;    

import org.dom4j.DocumentException;    

import org.dom4j.DocumentHelper;    

import org.dom4j.Element;    

import org.dom4j.io.SAXReader;    

import org.dom4j.io.XMLWriter;    

/**  

*    

* @author hongliang.dinghl  

* Dom4j 生成XML文档与解析XML文档  

*/  

public class Dom4jDemo implements XmlDocument {    



public void createXml(String fileName) {    

Document document = DocumentHelper.createDocument();    

Element employees=document.addElement("employees");    

Element employee=employees.addElement("employee");    

Element name= employee.addElement("name");    

name.setText("ddvip");    

Element sex=employee.addElement("sex");    

sex.setText("m");    

Element age=employee.addElement("age");    

age.setText("29");    

try {    

Writer fileWriter=new FileWriter(fileName);    

XMLWriter xmlWriter=new XMLWriter(fileWriter);    

xmlWriter.write(document);    

xmlWriter.close();    

} catch (IOException e) {    



System.out.println(e.getMessage());    

}    





}    





public void parserXml(String fileName) {    

File inputXml=new File(fileName);    

SAXReader saxReader = new SAXReader();    

try {    

Document document = saxReader.read(inputXml);    

Element employees=document.getRootElement();    

for(Iterator i = employees.elementIterator(); i.hasNext();){    

Element employee = (Element) i.next();    

for(Iterator j = employee.elementIterator(); j.hasNext();){    

Element node=(Element) j.next();    

System.out.println(node.getName()+":"+node.getText());    

}    



}    

} catch (DocumentException e) {    

System.out.println(e.getMessage());    

}    

System.out.println("dom4j parserXml");    

}   

}  

4.JDOM生成和解析XML  

为减少DOM、SAX的编码量，出现了JDOM；优点：20-80原则，极大减少了代码量。使用场合：要实现的功能简单，如解析、创建等，但在底层，JDOM还是使用SAX（最常用）、DOM、Xanan文档。

    

package com.alisoft.facepay.framework.bean;    



import java.io.FileNotFoundException;    

import java.io.FileOutputStream;    

import java.io.IOException;    

import java.util.List;    



import org.jdom.Document;    

import org.jdom.Element;    

关于JAXP，DOM，SAX，JDOM，DOM4J的一些想法

这些API是XSLT的关键部分，它们构建在DOM和SAX解析器基础上。

Sun在XML领域总是后知后觉，等到Sun重视XML的时候，XML的API早就满天飞了，尤其是IBM具有非常大的领先优势。不过Sun是规范 的制订者，于是参考WOffice:smarttags" />3C的标准制订了JAXP规范。JAXP不像Xerces和Crimon那样，它只是一个spec，本身是不做任何事情的，它的作用就是提出一 个统一的接口，让其它的XML API都来遵循JAXP编程，那么用JAXP写出来的程序，底层的API可以任意切换。

具体来说JAXP包括了几个工厂类，这就是JDK1.4里面的Javax.xml.parsers 包，用来寻找符合DOM标准的XML API实现类的位置；此外JAXP还包括一整套interface，这就是JDK1.4里面的org.w3c.dom那几个包。工厂类负责加载DOM的实 现类。

当你严格采用JAXP编程的时候，是遵循W3C的DOm标准的，那么在JAXP底层你实际上可以任意切换不同的DOM实现，例如Xerces，或者Crimon，再或者其它，切换方法就是配置jaxp.properties。因此JAXP就是一些标准接口而已。

JAXP应用程序 -> JAXP接口 -> Xerces DOM实现 -> Xerces DOM/SAX 解析器
JAXP应用程序 -> JAXP接口 -> Crimson DOM实现 -> Crimson DOM/SAX 解析器
JAXP应用程序 -> JAXP接口 -> Crimson DOM实现 -> Xerces DOM/SAX 解析器

W3C的DOM标准API难用的让人想撞墙，于是有一帮人开发Java专用的XML API目的是为了便于使用，这就是jdom的由来，开发到一半的时候，另一部分人又分了出来，他们有自己的想法，于是他们就去开发dom4j，形成了今天 这样两个API，至于他们之间的性能，功能之比较看看上面我推荐的文章就知道了，jdom全面惨败。

jdom 相当于上面的 JAXP接口 ＋ Xerces DOM实现部分，它本身没有解析器，它可以使用Xerces或者Crimson的解析器即
JAXP应用程序 -> JAXP接口 -> Xerces DOM实现 -> Crimson DOM/SAX 解析器 或 Xerces DOM/SAX 解析器

jdom应用程序 -> jdom API -> Xerces/Crimson解析器
dom4j应用程序 -> dom4j API -> Xerces/Crimson解析器
dom4j应用程序 -> dom4j API -> Alfred2解析器

因此可以看出采用dom4j/jdom编写的应用程序，已经不具备可移植性了。

Sun是JAXP标准的制订者，甚至很执著的在JDK1.4里面绑定Crimson DOM实现和解析器，然后可笑的是，Sun自己的JAXM RI竟然不是用JAXP写出来的，而是dom4j

我的举例：

1．   仅仅是XSL转换。XMLàHTML，通过XSL

Import javax.xml.transform.TransformerFactory;

Import javax.xml.transform.Transformer;

Import javax.xml.stream.StreamSource;

Import javax.xml.stream.StreamResult;

import java.io.FileOutputStream;

TransformerFactory transFactory = TransformerFactory.newInstance();

Transform transformer = transFacyory.newTransformer(new StreamSource(XMLSheetName));

Transformer.transform(new StreamSource(XMLFileName),new StreamResult(new FileOutputStream(outputURL)));

这里的stream是一个DOM对象。
我感觉这个就是JAXP应用程序 -> JAXP接口 -> Xerces DOM实现 -> Xerces DOM/SAX 解析器,不知道对不对。

2．遍历XML，通过DOM。不仅仅是XSL转换。中间有对XML元素内容的操作。
Import javax.xml.transform.TransformerFactory;

Import javax.xml.transform.Transformer;

Import javax.xml.stream.StreamSource;

Import javax.xml.stream.StreamResult;

import java.io.FileOutputStream;

//Xerces解析器来完成DOM遍历XML.DOMParser是Xerces包的一部分。

Import org.apache.xerces.parsers.DOMParser;

Import org.w3c.dom.Document;

Import org.w3c.dom.NodeList;

//DOM遍历XML

DOMParser parser = new DOMParser();

Parser.parse(XMLFileName);//解析并在内存中创建XML树。

Document document = parser.getDocument();//通过Document对象，可以使用内存中的树。

NodeList products = document.getElementByTagName(“product_id”);

Int num_products = products.getLength();

//XSL转化器

TransformerFactory transFactory = TransformerFactory.newInstance();

Transform transformer = transFacyory.newTransformer(new StreamSource(XMLSheetName));

Transformer.transform(new StreamSource(XMLFileName),new StreamResult(new FileOutputStream(outputURL)));

我感觉XSL转化和对XML对象的操作是两个过程。可以分别对待。最重要的是对对象的操作。这也就是为什么有DOM,JDOM,DOM4J。转化好像只需要JAXP就可以了，关心的是StreamSource和StreamResult。这两个是DOM对象。

3．JDOM使用，生成Document内容并保存到XML文件。
import org.jdom.Element;
import org.jdom.Document;//和Import org.w3c.dom.Document对比一下。一个是JAXP的一个是JDOM的Document

import org.jdom.output.XMLOutputter;

Element root = Element(“orders”);

root.addContent(“ ”);

org.jdom.Document document = new Document(root);//创建JDOM树。

FileOutputStream outStream = new FileOutputStream(XMLFileName);

XMLOutputter outToFile = new XMLOutputter();

outToFile.output(document,outStream);

outStream.flush();

outStream.close();

jdom应用程序 -> jdom API -> Xerces/Crimson解析器
VS
JAXP应用程序 -> JAXP接口 -> Xerces DOM实现 -> Xerces DOM/SAX 解析器

这里的没有Transform的过程，直接把Document的内容存到XML中。没有XSL转化，没有XSL文件。

JDOM提供了几种输出方法。这里XMLOutputter是保存到文件，输出一个实际的XML流。还有DOMOutputter,在内存中创建一个传统的DOM树。还有SAXOutputter，创建一串SAX事件以便被其他对象读取。

4．JDOM使用，读取已有的XML然后生成Document，修改Document
import org.jdom.Element;
import org.jdom.Document;

import org.jdom.output.XMLOutputter;
    import org.jdom.input.SAXBuilder;

    SAXBuilder builder = new SAXBuilder();
    Document document = builder.build(XMLFileName);

Element order = Element(“orders”);

orders.addAttribute(“order_id”,session_id);

Element root = document.getRootElement();//root是已经存在的根元素。

Root.addContent(order);//在根元素里增加orders元素。

//把document保存到文件中。

FileOutputStream outStream = new FileOutputStream(XMLFileName);

XMLOutputter outToFile = new XMLOutputter();

outToFile.output(document,outStream);

outStream.flush();

outStream.close();

即使创建一个DOM式的结构，这里仍使用SAXBuilder来做这这件事情。

DOMBuilder和SAXBuilder中的”DOM”和”SAX”指的是用于建立文档的方法，而不是生成的内容。

5．XSL转换,能把DOM对象转化成输出，也可以向上面所举例的把XMLFileName的流转化成输出的流（文件或屏幕显示）。但是不能把JDOM对象转化，所以需要把JDOM转化成DOM对象，然后再输出。
import org.jdom.Element;
import org.jdom.Document;

import org.jdom.output.XMLOutputter;
    import org.jdom.input.SAXBuilder;  
    //XSL转化需要的包
import org.jdom.output.DOMOutputter;//对比org.jdom.output.XMLOutputter;
Import javax.xml.transform.TransformerFactory;

Import javax.xml.transform.Transformer;

Import javax.xml.transform.DOMSource;//对比Import javax.xml.stream.StreamSource;

Import javax.xml.stream.StreamResult;

   org.w3c.dom.Document DOMDoc;
   DOMOutputter DomOut = DOMOutputter();
   DOMDoc = DomOut.output(org.jdom.Document);//把jdom的document转化成DOM的document

   TransformFactory transFactory = TransformFactory.newInstance();
   Transformer transformer = transFactory.newTransformer(new DOMSource(DOMDoc));//感觉错了，应该是XSL文件。
   Transformer.transform(new DOMSource(DOMDoc),new StreamResult(out));

//对比以前的转化，是从文件到文件，现在是DOM树到屏幕输出。
TransformerFactory transFactory = TransformerFactory.newInstance();

Transform transformer = transFacyory.newTransformer(new StreamSource(XMLSheetName));