如果不使用IDE，对于初学者来说经常会出现  Exception in thread "main" java.lang.NoClassDefFoundError错误。
一般是以下几个原因。

建议：在你的硬盘上建立一个独立的存放代码的文件，比如D :\code，设置CLASSPATH指向这个文件夹；在创建一个专门存放类库（jar）文件夹，CLASSPAHT也指向这个文件夹，以后当你添加新的Jar包，例如JDBC驱动的时候，直接复制到这个文件夹下就可以了。

1、你的文件名对吗？
JAVA要求你的文件和你的类名严格对应的。
比如 public class HelloWorld{ .....
那么文件名一定只能是HelloWorld.java，看仔细了！

2、你的程序中有main方法吗？参数什么的对吗？
main方法的声明应该是这样子的：
public static void main(String[] args)
事实上如果你用开发工具来做的话，是不会错的。如果你用UltraEdit之类的来写程序的话，就一个字不要改的照抄吧！

3、记住，javac后面跟的参数是文件名，但java 后面跟的是类名！
这是我开始学JAVA是犯的错，java HelloWorld.class，然后就报错。后来才弄明白，应该是java HelloWorld。

4、设置了classpath了吗？
不仅是在安装JDK时要设置的内容，一般来说最好还要自己设置一个目录来存放自己的类文件的。比如d:\class目录。
设置classpath=%classpath%;d:\class
那么，现在将HelloWorld.class文件COPY到d:\class目录下，再java HelloWorld应该就OK了。

5、结合第3点和第4点
如果你的类是属于某一个包的，比如这样一个类sony.test.HelloWorld，那么按照我在第4点中说的目录来说，就应该将HelloWorld.class文件存放到d:\class\sony\test\目录下。
执行的时候应该参考第3点中说的，按类名执行：java sony.test.HelloWorld。

　　绝对路径：绝对路径就是你的主页上的文件或目录在硬盘上真正的路径，(URL和物理路径)例如：
C:\xyz\test.txt 代表了test.txt文件的绝对路径。http://www.sun.com/index.htm也代表了一个
URL绝对路径。

　　相对路径：相对与某个基准目录的路径。包含Web的相对路径（HTML中的相对目录），例如：在
Servlet中，"/"代表Web应用的跟目录。和物理路径的相对表示。例如："./" 代表当前目录,
"../"代表上级目录。这种类似的表示，也是属于相对路径。

另外关于URI，URL,URN等内容，请参考RFC相关文档标准。

RFC 2396: Uniform Resource Identifiers (URI): Generic Syntax,
(http://www.ietf.org/rfc/rfc2396.txt)

2.关于JSP/Servlet中的相对路径和绝对路径。

2.1服务器端的地址

　　 服务器端的相对地址指的是相对于你的web应用的地址，这个地址是在服务器端解析的
（不同于html和javascript中的相对地址，他们是由客户端浏览器解析的）也就是说这时候
在jsp和servlet中的相对地址应该是相对于你的web应用，即相对于http://192.168.0.1/webapp/的。

　　其用到的地方有：
 forward：servlet中的request.getRequestDispatcher(address);这个address是
在服务器端解析的，所以，你要forward到a.jsp应该这么写：
request.getRequestDispatcher(“/user/a.jsp”)这个/相对于当前的web应用webapp，
其绝对地址就是：http://192.168.0.1/webapp/user/a.jsp。
sendRedirect：在jsp中<%response.sendRedirect("/rtccp/user/a.jsp");%>

2.22、客户端的地址
 
       所有的html页面中的相对地址都是相对于服务器根目录(http://192.168.0.1/)的，
而不是(跟目录下的该Web应用的目录)http://192.168.0.1/webapp/的。
 Html中的form表单的action属性的地址应该是相对于服务器根目录(http://192.168.0.1/)的，
所以，如果提交到a.jsp为：action＝"/webapp/user/a.jsp"或action="<%=request.getContextPath()%>"/user/a.jsp；
　　提交到servlet为actiom＝"/webapp/handleservlet"  
 　　Javascript也是在客户端解析的，所以其相对路径和form表单一样。
 

　　因此，一般情况下，在JSP/HTML页面等引用的CSS,Javascript.Action等属性前面最好都加上
<%=request.getContextPath()%>,以确保所引用的文件都属于Web应用中的目录。
另外，应该尽量避免使用类似".","./","../../"等类似的相对该文件位置的相对路径，这样
当文件移动时，很容易出问题。

3. JSP/Servlet中获得当前应用的相对路径和绝对路径
3.1 JSP中获得当前应用的相对路径和绝对路径
 根目录所对应的绝对路径:request.getRequestURI()
 文件的绝对路径    　:application.getRealPath(request.getRequestURI());
 当前web应用的绝对路径 :application.getRealPath("/");
 取得请求文件的上层目录:new File(application.getRealPath(request.getRequestURI())).getParent()

3.2 Servlet中获得当前应用的相对路径和绝对路径
 根目录所对应的绝对路径:request.getServletPath();
 文件的绝对路径    :request.getSession().getServletContext().getRealPath
(request.getRequestURI())   
 当前web应用的绝对路径 :servletConfig.getServletContext().getRealPath("/");
     (ServletContext对象获得几种方式：
       javax.servlet.http.HttpSession.getServletContext()
       javax.servlet.jsp.PageContext.getServletContext()
       javax.servlet.ServletConfig.getServletContext()
     )

4.java 的Class中获得相对路径，绝对路径的方法
4.1单独的Java类中获得绝对路径
　　根据java.io.File的Doc文挡，可知:
 默认情况下new File("/")代表的目录为：System.getProperty("user.dir")。
 一下程序获得执行类的当前路径
package org.cheng.file;
import java.io.File;

public class FileTest {
    public static void main(String[] args) throws Exception {      

  System.out.println(Thread.currentThread().getContextClassLoader().getResource(""));    

  System.out.println(FileTest.class.getClassLoader().getResource(""));       

　　System.out.println(ClassLoader.getSystemResource(""));       
  System.out.println(FileTest.class.getResource(""));       
  System.out.println(FileTest.class.getResource("/")); //Class文件所在路径 
  System.out.println(new File("/").getAbsolutePath());       
  System.out.println(System.getProperty("user.dir"));   
 }
}

4.2服务器中的Java类获得当前路径（来自网络）
(1).Weblogic

WebApplication的系统文件根目录是你的weblogic安装所在根目录。
例如：如果你的weblogic安装在c:\bea\weblogic700.....
那么，你的文件根路径就是c:\.
所以，有两种方式能够让你访问你的服务器端的文件：
a.使用绝对路径：
比如将你的参数文件放在c:\yourconfig\yourconf.properties，
直接使用 new FileInputStream("yourconfig/yourconf.properties");
b.使用相对路径：
相对路径的根目录就是你的webapplication的根路径，即WEB-INF的上一级目录，将你的参数文件放

在yourwebapp\yourconfig\yourconf.properties，
这样使用：
new FileInputStream("./yourconfig/yourconf.properties");
这两种方式均可，自己选择。

(2).Tomcat

在类中输出System.getProperty("user.dir");显示的是%Tomcat_Home%/bin

(3).Resin

不是你的JSP放的相对路径,是JSP引擎执行这个JSP编译成SERVLET
的路径为根.比如用新建文件法测试File f = new File("a.htm");
这个a.htm在resin的安装目录下

(4).如何读相对路径哪？

在Java文件中getResource或getResourceAsStream均可

例：getClass().getResourceAsStream(filePath);//filePath可以是"/filename",这里的/代表web

发布根路径下WEB-INF/classes

默认使用该方法的路径是：WEB-INF/classes。已经在Tomcat中测试。

5.读取文件时的相对路径，避免硬编码和绝对路径的使用。（来自网络）
5.1 采用Spring的DI机制获得文件，避免硬编码。
   参考下面的连接内容：
   http://www.javajia.net/viewtopic.php?p=90213&
5.2 配置文件的读取
 参考下面的连接内容：
 http://dev.csdn.net/develop/article/39/39681.shtm
5.3 通过虚拟路径或相对路径读取一个xml文件，避免硬编码
 参考下面的连接内容：
 http://club.gamvan.com/club/clubPage.jsp?iPage=1&tID=10708&ccID=8
 
6.Java中文件的常用操作（复制，移动，删除，创建等）（来自网络）
 常用 java File 操作类
 http://www.easydone.cn/014/200604022353065155.htm
 
 Java文件操作大全（JSP中）
 http://www.pconline.com.cn/pcedu/empolder/gj/java/0502/559401.html

 java文件操作详解（Java中文网）
 http://www.51cto.com/html/2005/1108/10947.htm

 JAVA 如何创建\删除\修改\复制目录及文件
 http://www.gamvan.com/developer/java/2005/2/264.html

总结：
 通过上面内容的使用，可以解决在Web应用服务器端，移动文件，查找文件，复制
 删除文件等操作，同时对服务器的相对地址，绝对地址概念更加清晰。
建议参考URI,的RFC标准文挡。同时对Java.io.File. Java.net.URI.等内容了解透彻
对其他方面的理解可以更加深入和透彻。
==================================================================================

参考资料:
java/docs/

java.io.File
java.io.InputStream
java.io.OutputStream
java.io.FileInputStream
java.io.FileReader;
java.io.FileOutputStream
java.io.FileWriter;
java.net.URI
java.net.URL

绝对路径与相对路径祥解
http://www.webjx.com/htmldata/2005-02-26/1109430310.html

[『J道习练』]JSP和Servlet中的绝对路径和相对路径
http://w3china.org/blog/more.asp?name=pcthomas&id=9122&commentid=12376

JSP,Servlet,Class获得当前应用的相对路径和绝对路径
http://cy.lzu.edu.cn/cy/club/clubPage.jsp?ccStyle=0&tID=886&ccID=77

如何获得当前文件路径
http://www.matrix.org.cn/resource/article/44/44113_java.html

通过Spring注入机制，取得文件
http://www.javajia.net/viewtopic.php?p=90213&

配置文件的读取
http://dev.csdn.net/develop/article/39/39681.shtm

读取配置文件,通过虚拟路径或相对路径读取一个xml文件，避免硬编码！
http://club.gamvan.com/club/clubPage.jsp?iPage=1&tID=10708&ccID=8

常用 java File 操作类
http://www.easydone.cn/014/200604022353065155.htm

Java文件操作大全
http://www.pconline.com.cn/pcedu/empolder/gj/java/0502/559401.html

Java文件操作详解
http://www.51cto.com/html/2005/1108/10947.htm 

为了给浏览者一个友好的错误提示页面，我们可以象IIS一样自定义错误页面；

步骤如下：

一、打开WEB-INF文件夹下web.xml文件；

二、在里面新增：

''404页面不存在错误

<error-page>

   <error-code>404</error-code>

   <location>/errorpage404.htm</location>

</error-page>

''505服务器内部错误

<error-page>

   <error-code>505</error-code>

   <location>/errorpage505.htm</location>

</error-page>

''java.lang.NumberFormatException异常错误,依据这个标记你可以定义好多，you can any fire:)!@

<error-page>

   <exception-type>java.lang.NumberFormatException</exception-type>

   <location>/exception.htm</location>

</error-page>

三、保存web.xml文件，reload服务即ok!

Good Luck!!

作者：杨晓(http://blog.sina.com.cn/u/1237288325)

一、Tomcat背景
　　自从JSP发布之后，推出了各式各样的JSP引擎。Apache Group在完成GNUJSP1.0的开发以后，开始考虑在SUN的JSWDK基础上开发一个可以直接提供Web服务的JSP服务器，当然同时也支持Servlet, 这样Tomcat就诞生了。Tomcat是jakarta项目中的一个重要的子项目，其被JavaWorld杂志的编辑选为2001年度最具创新的java产品，同时它又是sun公司官方推荐的servlet和jsp容器，因此其越来越多的受到软件公司和开发人员的喜爱。servlet和jsp的最新规范都可以在tomcat的新版本中得到实现。其次，Tomcat是完全免费的软件，任何人都可以从互联网上自由地下载。Tomcat与Apache的组合相当完美。

二、Tomcat目录

tomcat
|---bin Tomcat：存放启动和关闭tomcat脚本；

|---conf Tomcat：存放不同的配置文件（server.xml和web.xml）；
|---doc：存放Tomcat文档；
|---lib/japser/common：存放Tomcat运行需要的库文件（JARS）；
|---logs：存放Tomcat执行时的LOG文件；
|---src：存放Tomcat的源代码；
|---webapps：Tomcat的主要Web发布目录（包括应用程序示例）；
|---work：存放jsp编译后产生的class文件；

三、Tomcat类加载

    Bootstrap($JAVA_HOME/jre/lib/ext/*.jar)
System($CLASSPATH/*.class和指定的jar)
Common($CATALINA_HOME/common 下的classes,lib,endores三个子目录)
Catalina ($CATALINA_HOME/server/下的classes和lib目录仅对Tomcat可见)
&Shared($CATALINA_HOME/shared/下的classes和lib目录以及$CATALINA_HOME/lib目录)仅对Web应用程序可见,对Tomcat不可见WebApp($WEBAPP/Web-INF/*仅对该WEB应用可见classes/*.class lib/*.jar)

加载类和资源的顺序为：
1、/Web-INF/classes

2、/Web-INF/lib/*.jar

3、Bootstrap

4、System

5、$CATALINA_HOME/common/classes
6、$CATALINA_HOME/common/endores/*.jar

7、$CATALINA_HOME/common/lib/*.jar

8、$CATALINA_HOME/shared/classes
9、$CATALINA_HOME/shared/lib/*.jar

四、server.xml配置简介：

下面讲述这个文件中的基本配置信息，更具体的配置信息请参考tomcat的文档：
    server:
          1、port 指定一个端口，这个端口负责监听关闭tomcat的请求
          2、shutdown 指定向端口发送的命令字符串
    service:
          1、name 指定service的名字
    Connector (表示客户端和service之间的连接)：
          1、port 指定服务器端要创建的端口号，并在这个断口监听来自客户端的请求
          2、minProcessors 服务器启动时创建的处理请求的线程数
          3、maxProcessors 最大可以创建的处理请求的线程数
          4、enableLookups 如果为true，则可以通过调用request.getRemoteHost()进行DNS查

询来得到远程客户端的实际主机名，若为false则不进行DNS查询，而是返回其ip

地址
          5、redirectPort 指定服务器正在处理http请求时收到了一个SSL传输请求后重定向的

端口号
          6、acceptCount 指定当所有可以使用的处理请求的线程数都被使用时，可以放到处理

队列中的请求数，超过这个数的请求将不予处理
          7、connectionTimeout 指定超时的时间数(以毫秒为单位)
    Engine (表示指定service中的请求处理机，接收和处理来自Connector的请求)：
          1、defaultHost 指定缺省的处理请求的主机名，它至少与其中的一个host元素的name

属性值是一样的 

　　Eclipse是目前非常流行的开发平台，开放扩展的架构让很多程序员找到了自己个性化的工作环境。

安装

JDK：1.5.0 从http://java.sun.com上去下载安装
Eclipse：3.1.1 从http://www.eclipse.org 上去下载解压
SQLExplorer 从http://eclipsesql.sourceforge.net/

技巧

　　Eclipse使用技巧之插件管理

　　提示：新下载的插件PlugIn一定不要都放在原始的Eclipse目录下去，一大堆，累死你：（

1. 前提是你已经安装好了Eclipse工具了，比如安装在E:\OpenSource\Eclipse\目录下，以下这个目录以%ECLIPSE_HOME%来进行表示；
2. 此时默认的插件是在%ECLIPSE_HOME%\plugins目录中的；
3. 在%ECLIPSE_HOME%下建立一个PlugInsNew的目录；

　　比如：E:\OpenSource\Eclipse\PlugInsNew\

1. 你下载了个新的插件，比如叫做：XYZ

　　那么就在%ECLIPSE_HOME%\PlugInsNew\目录下建立XYZ目录，目录里面是eclipse目录，eclipse目录包含有features与plugins两个子目录；结构如下图所示：

1. 把下载的新插件的文件放在以下相应目录中

   %ECLIPSE_HOME%\PlugInsNew\XYZ\eclipse\features
   %ECLIPSE_HOME%\PlugInsNew\ XYZ\eclipse\plugins

2. 建立相关的.link的文件

   然后在%ECLIPSE_HOME%\links目录里建立一个XYZ.link的文件
   内容如是：path=E:/OpenSource/Eclipse/PlugInsNew/XYZ就一行这样的路径指示而已。
   这样，如果你下载了多个插件就可以如法炮制建立多个Link文件，想加载哪个插件就把哪个插件的Link文件放到%ECLIPSE_HOME%\links的目录中即可，使用与管理都很方便，建议千万不要放在默认的安装目录中；
   如果你的%ECLIPSE_HOME%与此不同，请修改XYZ.link文件里的路径

3. 删除，关闭Eclipse

   删除%ECLIPSE_HOME%\links\XYZ.link文件即可
   删除%ECLIPSE_HOME%\PlugInsNew\XYZ整个目录及文件

4. 重新启动Eclipse即可

使用

　　SQLExplorer插件安装方法采用上一节的《Eclipse使用技巧之插件管理》
　　重新启动Eclipse后，可以在菜单Window => Show View => Other => 可以看到多了SQLExplorer
展开SQLExplorer有七项内容，分别为：

1. Aliases 别名，用来标识数据库连接串的
2. Connection Info 连接信息，用来显示连接数据库时的相关信息，如，数据库产品名称、版本、JDBC驱动程序的名称、版本、用户名、连接串、是否自动提交等等。
3. Connnections 显示活动的连接情况
4. Database Structure View 显示数据库结构
5. Drivers 配置驱动程序用
6. SQL History 执行SQL的历史记录
7. SQL Results 执行SQL的结果集

　　下面会分别介绍这七项内容的具体使用：
如下图所示：

　　菜单Window => Preferences => SQLExplorer
右边的项目中，可以设置预览表结果集时返回的行数、SQL集的返回行数、是否自动提交、还是关闭SQL编辑窗口后提交和写SQL时是否自动完成表和列名。

　　菜单Window => Preferences => SQLExplorer => SQL Editor
右边的项目中，可以设置SQL编辑器里的字体属性、文本属性

　　菜单Window => Show View => Other => SQLExplorer 把里面的七项内容全部显示出来，你也可以自己进行定制一下它

　　开始进行配置驱动程序，打开Drivers

　　默认加载成功插件后，只有JDBC ODBC Bridge是打勾可用的，其它都是打红Ｘ不可用的，想想就知道为什么了吧（^_^）

　　没有想出来，接下来看看吧
右键JDBC ODBC Bridge，在弹出的菜单中点击Change the selected Driver菜单

　　可以在弹出的修改驱动程序中看到如下信息，在Driver Class Name显示的是
sun.jdbc.odbc.JdbcOdbcDriver
因为从JDK1.2开始，在JDK里自动带有这个驱动程序了，所以显示为可用了：）

　　接下来我们开始配置MySQL和Oracle的驱动程序：
右键MMMySQL Driver，在弹出的菜单中点击Change the selected Driver菜单

　　在弹出的修改驱动程序中看到，在Driver Class Name显示的是org.gjt.mm.mysql.Driver
点击Extra Class Path => Add => 选择你的MySQL所在的路径，加入它

　　加入驱动程序如下所示：

　　单击List Drivers按钮，在Driver Class Name的右下框中可以看到三个驱动类名，选择你需要的一个，OK之即可。

　　可以看到这下MMMySQL Driver也为打勾可以使用的状态了。

　　以同样的方法配置Oracle Thin Driver驱动程序

　　默认驱动名称，添加驱动程序：

　　可以看到两个驱动程序的名称

　　配置好驱动程序后，可以开始创建连接了，切换到Aliases别名视图
点击创建图标，如下：

　　选择MMMySQL Driver

　　填入别名的名称、JDBC连接串URL、用户名、密码

　　确定后，在Aliases别名视图里出现刚建立的连接

　　右键刚建立的数据库连接别名，在弹出的菜单选择Open…打开之。

　　会弹出一个连接的确认框，你可以更改用户名与密码，也可以设置是否自动提交。

　　确定后，会自动切换到Database Structure View视图上，MySQL数据库，则可以看到Database

　　再打开它，可以看到数据库名，Table表及表的个数与名称了。

　　选中其中的表userpwd，这个表是自己建立的，可以看到以下显示列、索引、主键、外键、结果集预览、行数共六个信息内容。

　　以下显示表的列信息

　　以下显示索引信息

　　以下显示主键信息

　　　　以下显示外键信息

　　以下显示结果集预览的内容

　　以下显示的是记录行数信息

　　切换到Connection Info连接信息的视图，可以看到连接数据库时的相关信息，
如，数据库产品名称MySQL、版本4.1.0a-nt
JDBC驱动程序的名称MySQL-AB JDBC Driver、版本mysql-connector-java-3.0.16-ga
用户名test@localhost、连接串jdbc:mysql://localhost:3306/test、自动提交模式为是等等。

　　显示默认的事务状态

　　切换到Connnections视图，显示当前数据库活动的连接情况，有一个活动的连接。

　　右上角，可以打开Open New Connection图标来打开一个新的连接，比如连接到相同的数据库，但是却是不同的用户

　　右上角，单击New SQL Editor图标，创建一个新的SQL编辑器，来写你的SQL语句

　　在打开的SQL编辑器中，你可以开始写SQL语句了，如下：

按Ctrl + F9 或者点击Exceute SQL图标，执行所输入的语句

这样可以在SQL Results视图中看到如下执行的结果信息

　　　　切换到SQL History 执行SQL的历史记录的视图，可以看到你执行过的语句列表

　　再写一个不同的语句，演示结果集与SQL历史记录

执行后，记录是显示在最后的执行结果是在后面，依次递增的，即1、2、3、最后一个是你最后执行的结果信息内容显示的地方，不要弄错了。

　　这样在SQL History里就再增加上了一条执行语句的记录了

　　同样增加一个Oracle的连接测试

　　Oracle数据库，在Database Structure View视图里显示有Database、Monitor、Security、Instance四项内容

在SQL编辑器中，选择Oracle的链接，再输入查询语句测试一下

　　可以在结果集里得到如果内容，在第4个标签栏里了

再更改一下SQL语句

　　得到如下内容，在第4个标签栏里了

　　SQL历史记录里可以看到执行过的四条信息了

　　这个插件的使用应当不是很容易的，其它的应用技巧与方法继续中。

方法一
使用phpmyadmin，这是最简单的了，修改mysql库的user表，不过别忘了使用PASSWORD函数。

方法二
使用mysqladmin，这是前面声明的一个特例。
mysqladmin -u root -p password mypasswd
输入这个命令后，需要输入root的原密码，然后root的密码将改为mypasswd。
把命令里的root改为你的用户名，你就可以改你自己的密码了。
当然如果你的mysqladmin连接不上mysql server，或者你没有办法执行mysqladmin，那么这种方法就是无效的，而且mysqladmin无法把密码清空。

下面的方法都在mysql提示符下使用，且必须有mysql的root权限：
方法三
mysql> Insert INTO mysql.user (Host,User,Password)
VALUES('%','jeffrey',PASSWORD('biscuit'));
mysql> FLUSH PRIVILEGES
确切地说这是在增加一个用户，用户名为jeffrey，密码为biscuit。
在《mysql中文参考手册》里有这个例子，所以我也就写出来了。
注意要使用PASSWORD函数，然后还要使用FLUSH PRIVILEGES。

方法四
和方法三一样，只是使用了REPLACE语句
mysql> REPLACE INTO mysql.user (Host,User,Password)
VALUES('%','jeffrey',PASSWORD('biscuit'));
mysql> FLUSH PRIVILEGES

方法五
使用SET PASSWORD语句，
mysql> SET PASSWORD FOR jeffrey@"%" = PASSWORD('biscuit');
拟也必须使用PASSWORD()函数，但是不需要使用FLUSH PRIVILEGES。

方法六
使用GRANT ... IDENTIFIED BY语句
mysql> GRANT USAGE ON *.* TO jeffrey@"%" IDENTIFIED BY 'biscuit';
这里PASSWORD()函数是不必要的，也不需要使用FLUSH PRIVILEGES。

注意： PASSWORD() [不是]以在Unix口令加密的同样方法施行口令加密。
MySQL 忘记口令的解决办法
如果 MySQL 正在运行，首先杀之： killall -TERM mysqld。
启动 MySQL ：bin/safe_mysqld --skip-grant-tables &
就可以不需要密码就进入 MySQL 了。
然后就是
>use mysql
>update user set password=password("new_pass") where user="root";
>flush privileges;
重新杀 MySQL ，用正常方法启动 MySQL 。

mysql密码清空
Windows:
1.用系统管理员登陆系统。
2.停止MySQL的服务。
3.进入命令窗口，然后进入MySQL的安装目录，比如我的安装目录是c:\mysql,进入C:\mysql\bin
4.跳过权限检查启动MySQL，
c:\mysql\bin>mysqld-nt --skip-grant-tables
5.重新打开一个窗口，进入c:\mysql\bin目录，设置root的新密码
c:\mysql\bin>mysqladmin -u root flush-privileges password "newpassword"
c:\mysql\bin>mysqladmin -u root -p shutdown
将newpassword替换为你要用的root的密码，第二个命令会提示你输入新密码，重复第一个命令输入的密码。
6.停止MySQL Server，用正常模式启动Mysql
7．你可以用新的密码链接到Mysql了。

Unix&Linux：
1.用root或者运行mysqld的用户登录系统；
2．利用kill命令结束掉mysqld的进程；
3．使用--skip-grant-tables参数启动MySQL Server
shell>mysqld_safe --skip-grant-tables &
4.为root@localhost设置新密码
shell>mysqladmin -u root flush-privileges password "newpassword"
5．重启MySQL Server

mysql修改密码
　　mysql修改，可在mysql命令行执行如下：
　　mysql -u root mysql
　　mysql> Update user SET password=PASSWORD("new password") Where user='name';
　　mysql> FLUSH PRIVILEGES;
　　mysql> QUIT

教你如何将MySQL数据库的密码恢复

因为MySQL密码存储于数据库mysql中的user表中，所以只需要将我windows 2003下的MySQL中的user表拷贝过来覆盖掉就行了。

在c:\mysql\data\mysql\(linux 则一般在/var/lib/mysql/mysql/)目录下有三个user表相关文件user.frm、user.MYD、user.MYI

user.frm //user表样式文件

user.MYD //user表数据文件

user.MYI //user表索引文件

为保险起见，三个都拷贝过来，不过其实如果之前在要恢复的那个MySQL上没有更改过表结构的话，只要拷贝user.MYD就行了

然后

#. /etc/rc.d/init.d/mysql stop
#. /etc/rc.d/init.d/mysql start
#mysql -u root -p XXXXXX

好了，可以用windows 2003下mysql密码登陆了

mysql>use mysql
mysql>update user set Password=PASSWORD('xxxxxx') where User='root';

这时候会出错，提示user表只有读权限

我分析了一下原因，只这样的，因为user.*文件的权限分配是windows 2003下的，在windows 2003下我ls -l一看权限是666

在linux下我一看，拷过来后权限变成了600(其实正常情况下600就行了，只不过这里的文件属主不是mysql，拷过来后的属主变为了 root,所以会出现权限不够，这时候如果你改成权限666则可以了，当然这样不好，没有解决问题的实质)，在 /var/lib/mysql/mysql/下ls -l看了一下

再

#chown -R mysql:mysql user.*
#chmod 600 user.*

//OK,DONE

重起一下MYSQL

重新连接

mysql>use mysql
mysql>update user set Password=PASSWORD('xxxxxx') where User='root';
mysql>FLUSH PRIVILEGES;

有一点值得注意:如果你windows 下mysql如果是默认配置的话，注意要还要执行

mysql>delete from user where User='';
mysql>delete from user where Host='%';
mysql>FLUSH PRIVILEGES;

好了，到这里恢复密码过程就完成了

这个方法么就是有点局限性，你必须也具备另外的user表文件

其他还有几种方法

其它方法一(这个是网上流传较广的方法,mysql中文参考手册上的)

1. 向mysqld server 发送kill命令关掉mysqld server(不是 kill -9),存放进程ID的文件通常在MYSQL的数据库所在的目录中。

killall -TERM mysqld

你必须是UNIX的root用户或者是你所运行的SERVER上的同等用户，才能执行这个操作。

2. 使用`--skip-grant-tables' 参数来启动 mysqld。 LINUX下：

/usr/bin/safe_mysqld --skip-grant-tables , windows下c:\mysql\bin\mysqld --skip-grant-tables

3. 然后无密码登录到mysqld server ，

>use mysql
>update user set password=password("new_pass") where user="root";
>flush privileges;

。你也可以这样做：

`
mysqladmin -h hostname -u user password 'new password''

4. 载入权限表：

`
mysqladmin -h hostname flush-privileges'

或者使用 SQL 命令

`FLUSH PRIVILEGES'

5.

killall -TERM mysqld

6.用新密码登陆

其它方法二

直接用十六进制编辑器编辑user.MYD文件

不过这个里面我要说明一点，我这里编辑的时候发现个问题，加密的密码串有些是连续存储的，有些的最后两位被切开了，后两位存储在后面其他地方.这一 点我还没想明白.还有注意一点就是编辑的是加密过的密码串，也就是说你还是需要另外有user表文件。这种方法和我最上面介绍的方法的区别在于，这种方法 直接编辑linux下的user表文件，就不需要重新改文件属主和权限了 

修正一下：我在Windows下的实际操作如下

1.关闭正在运行的MySQL。

2.打开DOS窗口，转到mysql\bin目录。

3.输入

mysqld-nt --skip-grant-tables

回车。如果没有出现提示信息，那就对了。

4.再开一个DOS窗口（因为刚才那个DOS窗口已经不能动了），转到mysql\bin目录。

5.输入mysql回车，如果成功，将出现MySQL提示符 >

6. 连接权限数据库

>use mysql;
(>是本来就有的提示符,别忘了最后的分号)

6.改密码：

> update user set password=password("123456") where user="root"; (别忘了最后的分号)

7.刷新权限（必须的步骤）

>flush privileges;

8.退出

> \q

9.注销系统，再进入，开MySQL，使用用户名root和刚才设置的新密码123456登陆。

据说可以用直接修改user表文件的方法：

关闭MySQL，Windows下打开Mysql\data\mysql，有三个文件user.frm,user.MYD,user.MYI找个知道密码的MySQL，替换相应的这三个文件，如果user表结构没改过，一般也没人去改，替换user.MYD就可以了。

也可以直接编辑user.MYD，找个十六进制编辑器，UltraEdit就有这个功能。关闭MySQL，打开user.MYD。将用户名root 后面的八个字符改为565491d704013245，新密码就是123456。或者将它们对应的十六进制数字，（左边那里，一个字符对应两个数字），改 为 00 02 02 02 02 02 02 02,这就是空密码，在编辑器右边看到的都是星号*，看起来很象小数点。重开MySQL，输入root和你的新密码。

Introduction to XML Schema
[XML Schema介绍]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

XSD How To
[XSD如何]

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

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

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

A Simple DTD
[一个简单的DTD]

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

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

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

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

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

A Reference to a DTD
[DTD的引用]

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

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

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

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

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

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

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

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

The following fragment:
[以下片段:]

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

This fragment:
[如下片段:]

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

This fragment:
[如下片段:]

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

This fragment:
[如下片段:]

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

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

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

The following fragment:
[下面片段:]

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

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

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

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

内容目录

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

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

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

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

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

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

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

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

<rss version="2.0">

<channel>

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

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

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

</channel>
</rss>

<rss version="2.0">

<channel>

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

<description>W3Schools Web Tutorials</description>

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

</channel>
</rss>

<!-- This is a comment -->

<title>W3Schools News Update</title>

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

<description>W3Schools Web Tutorials</description>

<title>W3Schools New RSS Tutorial</title>

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

<description>W3Schools RSS Tutorial</description>

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

第三可采用如下几种方式来修改：

1.从终端服务配置中修改：
打开管理工具里的终端服务配置，再单击连接，双击右边的RDP-Tcp，弹出RDP-Tcp属性，选择网卡，可设置最多连接数，或者设置为无限制的连接数。当然这个值不也能太大，否则会占用较多的系统资源。不过这里修改的值好像不起作用，设置成无限制时照样还是会出现本文所说的情况。

修改会话存在时间：运行－Tscc.msc－连接－双击RDP-Tcp或右击－属性－会话－选中第一个的替代用户设置(O)－结束已断开的会话［将默认值“从不”改为一个适当的时间，比如30分钟］
　　
2.打开“控制面板”，双击“添加删除程序”，单击“添加删除Windows组件”*“组件”
，在Windows组件向导对话框中选中“终端服务” * “下一步” * “应用服务器” * “下
一步”，然后按照提示即可改变终端服务的模式。 
不过听说用此法，改了应用需要许可证，90天后过期:(

3.win2003的话可以从组策略修改：
　　组策略级别要高于终端服务配置，当启用组策略后终端服务配置中的相应选项会变成灰色不可修改
　　运行－gpedit.msc－计算机配置－管理模板－Windows组件－终端服务
　　双击右边的”限制连接数量“－选择”已启用“－填入允许的最大连接数

J2EE可以说指Java在数据库信息系统上实现，数据库信息系统从早期的dBase、到Delphi/VB等C/S结构，发展到B/S（Browser浏览器/Server服务器）结构，而J2EE主要是指B/S结构的实现。

J2EE又是一种框架和标准，框架类似API、库的概念，但是要超出它们。

J2EE是一个虚的大的概念，J2EE标准主要有三种子技术标准：WEB技术、EJB技术和JMS，谈到J2EE应该说最终要落实到这三个子概念上。

这三种技术的每个技术在应用时都涉及两个部分：容器部分和应用部分，Web容器也是指Jsp/Servlet容器，你如果要开发一个Web应用，无论是编译或运行，都必须要有Jsp/Servlet库或API支持（除了JDK/J2SE以外）。

Web技术中除了Jsp/Servlet技术外，还需要JavaBeans或Java Class实现一些功能或者包装携带数据，所以Web技术最初简称为Jsp/Servlet+JavaBeans系统。

谈到JavaBeans技术，就涉及到组件构件技术（component），这是Java的核心基础部分，很多软件设计概念（设计模式）都是通过JavaBeans实现的。

JavaBeans不属于J2EE概念范畴中，如果一个JavaBeans对象被Web技术（也就是Jsp/Servlet）调用，那么JavaBeans就运行在J2EE的Web容器中；如果它被EJB调用，它就运行在EJB容器中。

EJB（企业JavaBeans）是普通JavaBeans的一种提升和规范，因为企业信息系统开发中需要一个可伸缩的性能和事务、安全机制，这样能保证企业系统平滑发展，而不是发展到一种规模重新更换一套软件系统。

J2EE集群原理: http://www.jdon.com/jive/article.jsp?forum=121&thread=22282

至此，JavaBeans组件发展到EJB后，并不是说以前的那种JavaBeans形式就消失了，这就自然形成了两种JavaBeans技术：EJB和POJO，POJO完全不同于EJB概念，指的是普通JavaBeans，而且这个JavaBeans不依附某种框架，或者干脆可以说：这个JavaBeans是你为这个应用程序单独开发创建的。

J2EE应用系统开发工具有很多：如JBuilder、Eclipse等，这些IDE首先是Java开发工具，也就是说，它们首要基本功能是可以开发出JavaBeans或Java class，但是如果要开发出J2EE系统，就要落实到要么是Web技术或EJB技术，那么就有可能要一些专门模块功能，最重要的是，因为J2EE系统区分为容器和应用两个部分，所以，在任何开发工具中开发J2EE都需要指定J2EE容器。

J2EE容器分为WEB容器和EJB容器，Tomcat/Resin是Web容器；JBoss是EJB容器+Web容器等，其中Web容器直接使用Tomcat实现的。所以你开发的Web应用程序可以在上面两种容器运行，而你开发的Web+EJB应用则只可以在JBoss服务器上运行，商业产品Websphere/Weblogic等和JBoss属于同一种性质。

J2EE容器也称为J2EE服务器，大部分时它们概念是一致的。

如果你的J2EE应用系统的数据库连接是通过JNDI获得，也就是说是从容器中获得，那么你的J2EE应用系统基本与数据库无关，如果你在你的J2EE应用系统耦合了数据库JDBC驱动的配置，那么你的J2EE应用系统就有数据库概念色彩，作为一个成熟需要推广的J2EE应用系统，不推荐和具体数据库耦合，当然这其中如何保证J2EE应用系统运行性能又是体现你的设计水平了。

高质量的Java企业系统

衡量J2EE应用系统设计开发水平高低的标准就是：解耦性；你的应用系统各个功能是否能够彻底脱离？是否不相互依赖，也只有这样，才能体现可维护性、可拓展性的软件设计目标。

为了达到这个目的，诞生各种框架概念，J2EE框架标准将一个系统划分为WEB和EJB主要部分，当然我们有时不是以这个具体技术区分，而是从设计上抽象为表现层、服务层和持久层，这三个层次从一个高度将J2EE分离开来，实现解耦目的。

因此，我们实际编程中，也要将自己的功能向这三个层次上靠，做到大方向清楚，泾渭分明，但是没有技术上约束限制要做到这点是很不容易的，因此我们还是必须借助J2EE具体技术来实现，这时，你可以使用EJB规范实现服务层和持久层，Web技术实现表现层；

EJB为什么能将服务层从Jsp/Servlet手中分离出来，因为它对JavaBeans编码有强制的约束，现在有一种对JavaBeans弱约束，使用Ioc模式实现的（当然EJB 3.0也采取这种方式），在Ioc模式诞生前，一般都是通过工厂模式来对JavaBeans约束，形成一个服务层，这也是是Jive这样开源论坛设计原理之一。

由此，将服务层从表现层中分离出来目前有两种可选架构选择：管理普通JavaBeans（POJO）框架(如Spring、JdonFramework)以及管理EJB的EJB框架，因为EJB不只是框架，还是标准，而标准可以扩展发展，所以，这两种区别将来是可能模糊，被纳入同一个标准了。

但是，通常标准制定是为某个目的服务的，总要牺牲一些换取另外一些，所以，这两种架构会长时间并存。

前面谈了服务层框架，使用服务层框架可以将JavaBeans从Jsp/Servlet中分离出来，而使用表现层框架则可以将Jsp中剩余的JavaBeans完全分离，这部分JavaBeans主要负责显示相关，一般是通过标签库（taglib）实现，不同框架有不同自己的标签库，Struts是应用比较广泛的一种表现层框架。

这样，表现层和服务层的分离是通过两种框架达到目的，剩余的就是持久层框架了，通过持久层的框架将数据库存储从服务层中分离出来是其目的，持久层框架有两种方向：直接自己编写JDBC等SQL语句（如iBatis）；使用O/R Mapping技术实现的Hibernate和JDO技术；当然还有EJB中的实体Bean技术。

持久层框架目前呈现百花齐放，各有优缺点的现状，所以正如表现层框架一样，目前没有一个框架被指定为标准框架，当然，表现层框架现在又出来了一个JSF，它代表的页面组件概念是一个新的发展方向，但是复杂的实现让人有些忘而却步。

最后，你的J2EE应用系统如果采取上面提到的表现层、服务层和持久层的框架实现，基本可以在无需深刻掌握设计模式的情况下开发出一个高质量的应用系统了。

还要注意的是: 开发出一个高质量的J2EE系统还需要正确的业务需求理解，那么域建模提供了一种比较切实可行的正确理解业务需求的方法，相关详细知识可从UML角度结合理解。

当然，如果你想设计自己的行业框架，那么第一步从设计模式开始吧，因为设计模式提供你一个实现JavaBeans或类之间解耦参考实现方法，当你学会了系统基本单元JavaBeans或类之间解耦时，那么系统模块之间的解耦你就可能掌握，进而你就可以实现行业框架的提炼了，这又是另外一个发展方向了。

以上理念可以总结为一句话：

J2EE开发三件宝: Domain Model（域建模）、patterns（模式）和framework（框架）。

 简介：

安装TPTP

　　安装TPTP最容易的方式是使用Remote Update站点（参见图1）。打开Remote Update窗口（Help -> Software Updates -> Find and Install），然后选择Callisto Discovery Site。Eclipse将建议安装Callisto插件集。TPTP工具列在“Testing and Performance”下面。最容易也是最耗时的选择，就是安装所有建议的插件。即使不安装整个Callisto工具集，您仍然需要安装一些其他TPTP需要的组件，例如"Charting and Reporting"、"Enabling Features"和"Data Tool Performance"。

　　 图 1.从远程站点安装TPTP

分析Java应用程序

　　测试与性能工具平台基本上是一套分析工具。分析应用程序通常涉及到观察应用程序在压力之下的处理方式。这样做的一种常见方式是对已部署的应用程序运行一组负载测试，然后使用分析工具来记录应用程序的行为。接着，可以对结果进行研究来调查任何性能问题。这些事情通常是在项目结束时进行的，因为此时应用程序几乎已经准备好进入生产阶段了。

　　TPTP非常适合这类任务。一个典型的用例是使用像JMeter这样的工具来运行负载测试，然后使用TPTP归纳工具记录和分析性能统计数据。

　　然而，这并非使用TPTP分析应用程序的唯一方式。通常，越早进行测试，后面遇到的问题就越少。借助TPTP，您可以在很多上下文中分析代码，包括JUnit测试用例、Java 应用程序和web应用程序。而且它很好地集成到了Eclipse IDE中。所以，没有理由不在早期开始初步性能测试和分析工作。

　　TPTP让您可以测试应用程序行为的几个方面，包括内存使用（创建了多少对象，这些对象的大小如何）、执行统计数据（应用程序在哪些地方所花的时间较多）和测试覆盖（测试期间执行代码的确切数量）。每个方面均可提供有关应用程序性能的独立信息。

　　不管怎么说，内存泄漏可能而且的确存在于Java中。创建（并保存）不必要的对象会增加对内存的需求，并加重垃圾收集器的工作负担，这都会损害应用程序的性能。而且，如果运行应用程序的服务器的持续正常运行时间很长，累积下来的内存泄漏可能最终导致应用程序崩溃或服务器停止运行。这些都是留心应用程序内存泄漏情况的充分理由。

　　根据80-20经验法则，80%的性能问题出现在20%的代码中。或者，换句话说，只要把精力集中在应用程序中执行最经常的部分上，就可以花费相对较少的气力使性能有实质性的提高。在这种情况下，执行统计数据就可以派上用场了。

　　除此以外，TPTP还提供一些基本的测试覆盖数据。尽管这些统计数据不如Cobertura或Clover这样的专用工具提供的完整，您仍然可以通过它们快速了解性能测试正在有效地测试哪些方法。

　　在本文中，我讨论的测试种类同样是没有经过优化的。优化涉及到使用像缓冲这样的技术对应用程序性能进行微调。这是一项对技术要求很高的操作，最好留到项目的最后完成。

　　这里所讨论的这种初步性能测试和分析仅仅包括，确保应用程序从一开始就正确执行，以及没有编码错误或糟糕的编码实践会在后面的阶段中对性能产生不利的影响。事实上，修复内存泄漏和避免不必要的对象创建并不是优化——这只不过是调试，而且同样应该尽可能早地完成。

　　让我们通过使用一些单元测试来分析一个类的方式开始。可以分析常规的单元或集成测试，或者编写针对性更强的面向性能的测试。通常，您应该尝试分析与生产代码最接近的代码。许多人使用模拟对象来代替DAO对象进行单元测试，使用这项功能强大的技术可以加速开发生命周期。如果使用这类方法，一定要使用这些测试来运行分析工具，它可以揭示有关内存使用和测试覆盖的有用信息。然而，性能测试的价值是有限的，因为对于与数据库相关的应用程序来说，其性能往往是由数据库的性能所决定的，所以在这个上下文中，应该进行所有重要的性能测试。简而言之，不要忘了分析基于实际数据库而运行的集成测试。

　　出于本文的需要，我们将对以下类进行测试，这个类代表了一个到库目录的简单接口。

interface Catalog {
List<Book> findBooksByAuthor(String name);
List<Book> findAllBooks();
}

　　基本的单元测试如下：

public class CatalogTest extends TestCase {
...
public Catalog getCatalog() {
...
}
public void testFindBooksByAuthor() {
List<Book> books = getCatalog().findBooksByAuthor("Lewis");
}
public void testLoadFindBooksByAuthor() {
for(int i = 0; i < 10; i++) {
List<Book> books
= getCatalog().findBooksByAuthor("Lewis");
}
}
public void testFindAll() {
List<Book> books = getCatalog().findAllBooks();
}
}

　　您需要做的第一件事情就是建立一个分析。在Eclipse主菜单中选择"Run -> Profile"，这将打开一个向导，您可以在其中配置不同种类的测试分析，如图2所示。

　　图 2. 创建一个TPTP分析

　　在这个例子中，我们感兴趣的是JUnit测试分析。双击这一项；向导应该为每个单元测试类创建新的项。TPTP相当灵活，您可以在此屏幕中配置各个选项。例如，在Test选项卡上，可以单独分析单元测试类，也可以按照项目或软件包对它们进行分组。在Arguments选项卡上，可以指定运行时参数，而在Environment选项卡上可以定义环境变量。在Destination选项卡中，可以指定一个外部文件，用于保存分析数据以供以后使用。但是，最有用的是Monitor选项卡（参见图3），可以在上面指定要记录和研究的性能相关数据：

• Basic Memory Analysis（基本内存分析）：这个选项用于记录内存使用的统计数据，包括对象实例的数量和已经使用的全部内存。
• Execution Time Analysis（执行时间分析）：这个选项用于记录性能数据——即应用程序分别在每个方法上所花的时间长短。
• Method Code Coverage（方法代码覆盖）：这个选项用于通知在测试期间执行了哪些类和方法。

　　 图 3: 在Monitor选项卡上定义要记录数据的类型。

　　您可以直接从这个窗口运行分析工具，也可以使用位于要分析的测试类上的上下文菜单，方法是选择Profile As菜单项（参见图4）。

　　图 4:可以使用上下文菜单运行TPTP分析工具。

　　运行分析工具可能要花上一段时间，这取决于测试用例的大小。完成之后，Eclipse将显示一个Profiling Monitor视图，可以在其中显示每种类型分析的结果的详细信息（参见图5）。

　　图 5: 分析结果

　　Memory Statistics视图显示了应用程序创建的对象的数量。结果可以按照软件包来组织（以树视图的形式），或者显示为类或实例的一个列表。这些数据可以让您了解每种类型创建了多少个对象；应该对创建的对象（特别是高级对象，例如域对象）不正常的高数量持怀疑态度。

　　用于检测内存泄漏的另一个有用工具是Object References视图。为了获得这些数据，您需要激活引用收集。启动分析之后，点击monitoring项，然后在上下文菜单中选择Collect Object References（参见图6）。接下来，通过上下文菜单（Open with -> Object References）打开Object References视图。您将获得一个类的列表，它带有对每个类的引用的次数。这可以为可能的内存泄漏提供一些线索。

　　图 6: 激活引用收集

　　如图7所示，从Execution Statistics视图可以清楚地了解到应用程序执行到了哪里。"organization by"软件包可以帮助您找出执行时间最长的类和方法。点击一个方法将打开Method Invocation Details视图，它将显示有关方法被调用次数、调用地点以及它本身调用了哪些其他方法的更详细信息。尽管与一些可以向下发掘到源代码本身的商业工具相比，这个视图与源代码视图的集成度没有那么高，但是它还是可以给出一些重要线索，帮助您找出执行错误的方法。

　　图 7: Execution Statistics视图

　　Coverage Statistics视图（参见图8）提供的信息是关于，您刚刚运行的测试用例使用了（因此至少在某种程度上测试了）哪些方法。覆盖统计数据是一项优秀的功能，尽管它们提供的信息的详细程度还无法与像Cobertura、Clover和jcoverage这样的专业覆盖工具相提并论（它们可以提供行精度的覆盖数据，以及行和分支覆盖的统计数据）。尽管如此，它也有自身的优点，那就是可以提供实时的覆盖结果，而目前，只有商业的代码覆盖工具，例如Clover和jcoverage，才能提供行级别的覆盖报告和完整的IDE集成。

　　图 8: Coverage Statistics视图

静态分析工具

　　在TPTP工具箱中，另一件有趣的工具就是静态分析工具。Java静态分析工具，例如PMD，允许通过基于一组代码预定义规则和最佳实践检查来检查代码，从而自动验证代码质量。现在，TPTP也包含一个静态分析工具。除了提供它自己的一组静态分析规则之外，这个工具还可以提供一个一致的接口，其他工具厂商可以在这个接口中集成他们自己的规则。

　　要对代码进行静态分析，需要创建分析配置。在Java视图或Analysis图标中，使用上下文菜单打开Analysis窗口，它现在应该出现在工具栏上（参见图9）。分析配置决定了要分析的代码（Scope）和应该遵循的规则（Rules）。有71条规则可供选择，例如"Avoid casting primitive types to lower precision"和"Always provide a break at the end of every case statement"。您还可以使用预定义的规则，例如"Java Quick Code Review"（在这里，71条规则中只有19条适用）。

　　图 9:建立静态分析规则

　　要分析代码，使用工具栏中的Analysis图标。分析不是实时完成的，就像一些其他的类似工具一样，例如Checkstyle。然而，给出的结果很清晰（参见图10）：错误在源代码视图中标出，并且按照错误类型，以树视图的形式在Analysis Results视图中列出。"Quick Fix"是一项优雅的特性，它出现在错误类型的上下文菜单中，而且如果可能，它可以自动为您纠正问题。

　　图 10: 静态代码分析结果

结束语

　　Eclipse测试与性能工具平台是Eclipse IDE工具箱中极具价值的部分。它支持的性能测试的范围很宽，这有助于从第一个单元测试开始，就确保获得高质量和高性能的代码。

　　TPTP无疑还比不上一些可用的商业工具，例如OptimizeIt和JProbe，后者的报告和分析功能要更加完善，而且表示通常更加精练。然而，商业的分析工具往往非常昂贵，而且很难在最严峻的环境中来验证它们的使用情况。尽管TPTP还相对较为不成熟，它仍然可算作一款功能强大的产品，毋庸置疑，它可以提供对于许多项目来说不可或缺的有价值的分析数据。

参考资料

• Eclipse网站
• Callisto网站
• TPTP网站

什么是SCA？

　　SCA是一种规范，它使开发人员可以将注意力集中在业务逻辑的编写上。更直接地说，它是一种大大改进了的部署描述符，它可以使用任何语言而不限于Java。此外，您还可以使用编程式语言和声明式语言，比如BPEL和XSLT。SCA的特别之处在于，它对安全性、事务和可靠消息传递之类的特性使用了声明式策略的理念。

　　使SCA脱颖而出的是，它是专门针对SOA设计的，而不像J2EE只是面向SOA做了修改。SCA关注的是如何描述按照各种编程模型和协议编写的组件所组成的程序集。
SCA的目标与BEA的目标是一致的：使事情（这次是应用程序的构建）更容易。SCA允许开发应用程序集而不考虑特定的中间件API或具体语言。

　　SCA的核心概念是服务及其相关实现。服务由接口定义，而接口包含一组操作。服务实现可以引用其他服务，称为引用。服务可以有一个或多个属性，这些属性是可以在外部配置的数据值。

　　SCA中的一个关键推动因素是Service Data Object（服务数据对象，SDO）。AquaLogic Data Services Platform一直在使用它。SDO用于表示业务数据、参数以及服务调用的返回值，当它遍历服务网络时，它还是一种表示数据的方式。注意，也可以使用XMLBeans及其它技术。

　　SCA组件被组成为程序集。程序集是服务级的应用程序，它是服务的集合，这些服务被连接在一起，并进行了正确的配置。SCA程序集运行在两个级别：第一种情况，程序集是系统内的一组松散连接的组件；另一种情况，程序集是模块内的一组松散连接的组件。二者的区别在于，一般来说，模块是组件的集合，而系统是模块的集合。此外，系统对应于“大规模编程”（programming in the large或megaprogramming），而模块对应于“小规模编程”（programming in the small），比如构建当今的典型应用程序。相关例子以及更详细的说明请参见Dev2Dev站点上的SCA白皮书。

　　将组件连接到它所依赖的服务的方式就是服务网络“装配”的方式。程序集已经在许多技术和框架中广为应用，比如CORBA、J2EE、ATG Dynamo和Spring，也就是说，它并不是新出现的。从这些技术中我们可以知道，程序集提供了许多重要的优点，比如更轻松的迭代开发，以及避免使业务逻辑依赖于中间件容器。SCA使用程序集解决了许多SOA开发中的重要问题，包括：

1. 业务逻辑与底层基础架构、服务质量和传输的分离。
2. “小规模编程”与“大规模编程”的联系。
3. 为架构的设计、编码和操作性部署在自底向上（bottom-up）和自顶向下（top-down）两种方法中来回切换提供了一种统一的方式。

对BEA来说，它意味着什么？

　　SDO 2.0规范是整个SCA技术平台的一个组成部分，它将在AquaLogic Data Services Platform (ALDSP)产品家族（已经支持SDO 1.0）的下一个主版本中实现。BEA AquaLogic Data Services Platform完全是针对SOA构建的，它自3.0版本开始就采用SCA技术。它提供企业数据服务的自动创建和维护，这可以帮助客户获得更高的生产力，进行业务优化，并更快地创造价值。BEA AquaLogic Data Services Platform提供了一个捕获与数据访问和数据更新有关的逻辑的单一位置。数据服务层提供了对相关的不同实时数据的可重用的、简化了的访问。注意，BEA Workshop中即将包含SCA支持。还有，BEA Workshop可免费下载。

为什么SCA如此重要？

　　SCA具有重大意义，因为它是第一项承诺提供一个组合模型以启用服务网络并支持构建下一代面向服务应用程序的技术。这一领域的每一次革新，都会导致出现一个新的抽象层，从而产生一批新的应用程序。C允许我们构建不能在汇编程序中构建的应用程序，而C++允许我们构建不能使用C构建的应用程序，Java又允许我们构建不能使用C++构建的应用程序。所有这些都是SCA的先例，简单地说，SCA就是未来用于构建大规模企业组合应用程序的技术。

使用Windows操作系统的朋友对Excel（电子表格）一定不会陌生，但是要使用Java语言来操纵Excel文件并不是一件容易的事。在Web应用日益盛行的今天，通过Web来操作Excel文件的需求越来越强烈，目前较为流行的操作是在JSP或Servlet 中创建一个CSV （comma separated values）文件，并将这个文件以MIME，text/csv类型返回给浏览器，接着浏览器调用Excel并且显示CSV文件。这样只是说可以访问到Excel文件，但是还不能真正的操纵Excel文件，本文将给大家一个惊喜，向大家介绍一个开放源码项目，Java Excel API，使用它大家就可以方便地操纵Excel文件了。

JAVA EXCEL API简介

Java Excel是一开放源码项目，通过它Java开发人员可以读取Excel文件的内容、创建新的Excel文件、更新已经存在的Excel文件。使用该API非Windows操作系统也可以通过纯Java应用来处理Excel数据表。因为是使用Java编写的，所以我们在Web应用中可以通过JSP、Servlet来调用API实现对Excel数据表的访问。

现在发布的稳定版本是V2.0，提供以下功能：

• 从Excel 95、97、2000等格式的文件中读取数据；
• 读取Excel公式（可以读取Excel 97以后的公式）；
• 生成Excel数据表（格式为Excel 97）；
• 支持字体、数字、日期的格式化；
• 支持单元格的阴影操作，以及颜色操作；
• 修改已经存在的数据表；

现在还不支持以下功能，但不久就会提供了：

1. 不能够读取图表信息；
2. 可以读，但是不能生成公式，任何类型公式最后的计算值都可以读出；

回页首

应用示例

1 从Excel文件读取数据表

Java Excel API既可以从本地文件系统的一个文件(.xls)，也可以从输入流中读取Excel数据表。读取Excel数据表的第一步是创建Workbook(术语：工作薄)，下面的代码片段举例说明了应该如何操作：(完整代码见ExcelReading.java)

import java.io.*;
            import jxl.*;
            … … … …
            try
            {
            //构建Workbook对象, 只读Workbook对象
            //直接从本地文件创建Workbook
            //从输入流创建Workbook
            InputStream is = new FileInputStream(sourcefile);
            jxl.Workbook rwb = Workbook.getWorkbook(is);
            }
            catch (Exception e)
            {
            e.printStackTrace();
            }
            

一旦创建了Workbook，我们就可以通过它来访问Excel Sheet(术语：工作表)。参考下面的代码片段：

//获取第一张Sheet表
            Sheet rs = rwb.getSheet(0);
            

我们既可能通过Sheet的名称来访问它，也可以通过下标来访问它。如果通过下标来访问的话，要注意的一点是下标从0开始，就像数组一样。

一旦得到了Sheet，我们就可以通过它来访问Excel Cell(术语：单元格)。参考下面的代码片段：

//获取第一行，第一列的值
            Cell c00 = rs.getCell(0, 0);
            String strc00 = c00.getContents();
            //获取第一行，第二列的值
            Cell c10 = rs.getCell(1, 0);
            String strc10 = c10.getContents();
            //获取第二行，第二列的值
            Cell c11 = rs.getCell(1, 1);
            String strc11 = c11.getContents();
            System.out.println("Cell(0, 0)" + " value : " + strc00 + "; type : " + c00.getType());
            System.out.println("Cell(1, 0)" + " value : " + strc10 + "; type : " + c10.getType());
            System.out.println("Cell(1, 1)" + " value : " + strc11 + "; type : " + c11.getType());
            

如果仅仅是取得Cell的值，我们可以方便地通过getContents()方法，它可以将任何类型的Cell值都作为一个字符串返回。示例代码中Cell(0, 0)是文本型，Cell(1, 0)是数字型，Cell(1,1)是日期型，通过getContents()，三种类型的返回值都是字符型。

如果有需要知道Cell内容的确切类型，API也提供了一系列的方法。参考下面的代码片段：

String strc00 = null;
            double strc10 = 0.00;
            Date strc11 = null;
            Cell c00 = rs.getCell(0, 0);
            Cell c10 = rs.getCell(1, 0);
            Cell c11 = rs.getCell(1, 1);
            if(c00.getType() == CellType.LABEL)
            {
            LabelCell labelc00 = (LabelCell)c00;
            strc00 = labelc00.getString();
            }
            if(c10.getType() == CellType.NUMBER)
            {
            NmberCell numc10 = (NumberCell)c10;
            strc10 = numc10.getValue();
            }
            if(c11.getType() == CellType.DATE)
            {
            DateCell datec11 = (DateCell)c11;
            strc11 = datec11.getDate();
            }
            System.out.println("Cell(0, 0)" + " value : " + strc00 + "; type : " + c00.getType());
            System.out.println("Cell(1, 0)" + " value : " + strc10 + "; type : " + c10.getType());
            System.out.println("Cell(1, 1)" + " value : " + strc11 + "; type : " + c11.getType());
            

在得到Cell对象后，通过getType()方法可以获得该单元格的类型，然后与API提供的基本类型相匹配，强制转换成相应的类型，最后调用相应的取值方法getXXX()，就可以得到确定类型的值。API提供了以下基本类型，与Excel的数据格式相对应，如下图所示：

每种类型的具体意义，请参见Java Excel API Document。

当你完成对Excel电子表格数据的处理后，一定要使用close()方法来关闭先前创建的对象，以释放读取数据表的过程中所占用的内存空间，在读取大量数据时显得尤为重要。参考如下代码片段：

//操作完成时，关闭对象，释放占用的内存空间
            rwb.close();
            

Java Excel API提供了许多访问Excel数据表的方法，在这里我只简要地介绍几个常用的方法，其它的方法请参考附录中的Java Excel API Document。

Workbook类提供的方法

1. int getNumberOfSheets()
获得工作薄（Workbook）中工作表（Sheet）的个数，示例：

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
            int sheets = rwb.getNumberOfSheets();
            

2. Sheet[] getSheets()
返回工作薄（Workbook）中工作表（Sheet）对象数组，示例：

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
            Sheet[] sheets = rwb.getSheets();
            

3. String getVersion()
返回正在使用的API的版本号，好像是没什么太大的作用。

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
            String apiVersion = rwb.getVersion();
            

Sheet接口提供的方法

1) String getName()
获取Sheet的名称，示例：

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
            jxl.Sheet rs = rwb.getSheet(0);
            String sheetName = rs.getName();
            

2) int getColumns()
获取Sheet表中所包含的总列数，示例：

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
            jxl.Sheet rs = rwb.getSheet(0);
            int rsColumns = rs.getColumns();
            

3) Cell[] getColumn(int column)
获取某一列的所有单元格，返回的是单元格对象数组，示例：

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
            jxl.Sheet rs = rwb.getSheet(0);
            Cell[] cell = rs.getColumn(0);
            

4) int getRows()
获取Sheet表中所包含的总行数，示例：

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
            jxl.Sheet rs = rwb.getSheet(0);
            int rsRows = rs.getRows();
            

5) Cell[] getRow(int row)
获取某一行的所有单元格，返回的是单元格对象数组，示例子：

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
            jxl.Sheet rs = rwb.getSheet(0);
            Cell[] cell = rs.getRow(0);
            

6) Cell getCell(int column, int row)
获取指定单元格的对象引用，需要注意的是它的两个参数，第一个是列数，第二个是行数，这与通常的行、列组合有些不同。

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
            jxl.Sheet rs = rwb.getSheet(0);
            Cell cell = rs.getCell(0, 0);
            

2 生成新的Excel工作薄

下面的代码主要是向大家介绍如何生成简单的Excel工作表，在这里单元格的内容是不带任何修饰的(如：字体，颜色等等)，所有的内容都作为字符串写入。(完整代码见ExcelWriting.java)

与读取Excel工作表相似，首先要使用Workbook类的工厂方法创建一个可写入的工作薄(Workbook)对象，这里要注意的是，只能通过API提供的工厂方法来创建Workbook，而不能使用WritableWorkbook的构造函数，因为类WritableWorkbook的构造函数为protected类型。示例代码片段如下：

import java.io.*;
            import jxl.*;
            import jxl.write.*;
            … … … …
            try
            {
            //构建Workbook对象, 只读Workbook对象
            //Method 1：创建可写入的Excel工作薄
            jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(new File(targetfile));
            //Method 2：将WritableWorkbook直接写入到输出流
            /*
            OutputStream os = new FileOutputStream(targetfile);
            jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(os);
            */
            }
            catch (Exception e)
            {
            e.printStackTrace();
            }
            

API提供了两种方式来处理可写入的输出流，一种是直接生成本地文件，如果文件名不带全路径的话，缺省的文件会定位在当前目录，如果文件名带有全路径的话，则生成的Excel文件则会定位在相应的目录；另外一种是将Excel对象直接写入到输出流，例如：用户通过浏览器来访问Web服务器，如果HTTP头设置正确的话，浏览器自动调用客户端的Excel应用程序，来显示动态生成的Excel电子表格。

接下来就是要创建工作表，创建工作表的方法与创建工作薄的方法几乎一样，同样是通过工厂模式方法获得相应的对象，该方法需要两个参数，一个是工作表的名称，另一个是工作表在工作薄中的位置，参考下面的代码片段：

//创建Excel工作表
            jxl.write.WritableSheet ws = wwb.createSheet("Test Sheet 1", 0);
            

"这锅也支好了，材料也准备齐全了，可以开始下锅了！"，现在要做的只是实例化API所提供的Excel基本数据类型，并将它们添加到工作表中就可以了，参考下面的代码片段：

//1.添加Label对象
            jxl.write.Label labelC = new jxl.write.Label(0, 0, "This is a Label cell");
            ws.addCell(labelC);
            //添加带有字型Formatting的对象
            jxl.write.WritableFont wf = new jxl.write.WritableFont(WritableFont.TIMES, 18, WritableFont.BOLD, true);
            jxl.write.WritableCellFormat wcfF = new jxl.write.WritableCellFormat(wf);
            jxl.write.Label labelCF = new jxl.write.Label(1, 0, "This is a Label Cell", wcfF);
            ws.addCell(labelCF);
            //添加带有字体颜色Formatting的对象
            jxl.write.WritableFont wfc = new jxl.write.WritableFont(WritableFont.ARIAL, 10, WritableFont.NO_BOLD, false,
            UnderlineStyle.NO_UNDERLINE, jxl.format.Colour.RED);
            jxl.write.WritableCellFormat wcfFC = new jxl.write.WritableCellFormat(wfc);
            jxl.write.Label labelCFC = new jxl.write.Label(1, 0, "This is a Label Cell", wcfFC);
            ws.addCell(labelCF);
            //2.添加Number对象
            jxl.write.Number labelN = new jxl.write.Number(0, 1, 3.1415926);
            ws.addCell(labelN);
            //添加带有formatting的Number对象
            jxl.write.NumberFormat nf = new jxl.write.NumberFormat("#.##");
            jxl.write.WritableCellFormat wcfN = new jxl.write.WritableCellFormat(nf);
            jxl.write.Number labelNF = new jxl.write.Number(1, 1, 3.1415926, wcfN);
            ws.addCell(labelNF);
            //3.添加Boolean对象
            jxl.write.Boolean labelB = new jxl.write.Boolean(0, 2, false);
            ws.addCell(labelB);
            //4.添加DateTime对象
            jxl.write.DateTime labelDT = new jxl.write.DateTime(0, 3, new java.util.Date());
            ws.addCell(labelDT);
            //添加带有formatting的DateFormat对象
            jxl.write.DateFormat df = new jxl.write.DateFormat("dd MM yyyy hh:mm:ss");
            jxl.write.WritableCellFormat wcfDF = new jxl.write.WritableCellFormat(df);
            jxl.write.DateTime labelDTF = new jxl.write.DateTime(1, 3, new java.util.Date(), wcfDF);
            ws.addCell(labelDTF);
            

这里有两点大家要引起大家的注意。第一点，在构造单元格时，单元格在工作表中的位置就已经确定了。一旦创建后，单元格的位置是不能够变更的，尽管单元格的内容是可以改变的。第二点，单元格的定位是按照下面这样的规律(column, row)，而且下标都是从0开始，例如，A1被存储在(0, 0)，B1被存储在(1, 0)。

最后，不要忘记关闭打开的Excel工作薄对象，以释放占用的内存，参见下面的代码片段：

//写入Exel工作表
            wwb.write();
            //关闭Excel工作薄对象
            wwb.close();
            

这可能与读取Excel文件的操作有少少不同，在关闭Excel对象之前，你必须要先调用write()方法，因为先前的操作都是存储在缓存中的，所以要通过该方法将操作的内容保存在文件中。如果你先关闭了Excel对象，那么只能得到一张空的工作薄了。

3 拷贝、更新Excel工作薄

接下来简要介绍一下如何更新一个已经存在的工作薄，主要是下面二步操作，第一步是构造只读的Excel工作薄，第二步是利用已经创建的Excel工作薄创建新的可写入的Excel工作薄，参考下面的代码片段：(完整代码见ExcelModifying.java)

//创建只读的Excel工作薄的对象
            jxl.Workbook rw = jxl.Workbook.getWorkbook(new File(sourcefile));
            //创建可写入的Excel工作薄对象
            jxl.write.WritableWorkbook  wwb = Workbook.createWorkbook(new File(targetfile), rw);
            //读取第一张工作表
            jxl.write.WritableSheet ws = wwb.getSheet(0);
            //获得第一个单元格对象
            jxl.write.WritableCell wc = ws.getWritableCell(0, 0);
            //判断单元格的类型, 做出相应的转化
            if(wc.getType() == CellType.LABEL)
            {
            Label l = (Label)wc;
            l.setString("The value has been modified.");
            }
            //写入Excel对象
            wwb.write();
            //关闭可写入的Excel对象
            wwb.close();
            //关闭只读的Excel对象
            rw.close();
            

之所以使用这种方式构建Excel对象，完全是因为效率的原因，因为上面的示例才是API的主要应用。为了提高性能，在读取工作表时，与数据相关的一些输出信息，所有的格式信息，如：字体、颜色等等，是不被处理的，因为我们的目的是获得行数据的值，既使没有了修饰，也不会对行数据的值产生什么影响。唯一的不利之处就是，在内存中会同时保存两个同样的工作表，这样当工作表体积比较大时，会占用相当大的内存，但现在好像内存的大小并不是什么关键因素了。

一旦获得了可写入的工作表对象，我们就可以对单元格对象进行更新的操作了，在这里我们不必调用API提供的add()方法，因为单元格已经于工作表当中，所以我们只需要调用相应的setXXX()方法，就可以完成更新的操作了。

尽单元格原有的格式化修饰是不能去掉的，我们还是可以将新的单元格修饰加上去，以使单元格的内容以不同的形式表现。

新生成的工作表对象是可写入的，我们除了更新原有的单元格外，还可以添加新的单元格到工作表中，这与示例2的操作是完全一样的。

最后，不要忘记调用write()方法，将更新的内容写入到文件中，然后关闭工作薄对象，这里有两个工作薄对象要关闭，一个是只读的，另外一个是可写入的。

回页首

小结

本文只是对Java Excel API中常用的方法作了介绍，要想更详尽地了解API，请大家参考API文档，或源代码。Java Excel API是一个开放源码项目，请大家关注它的最新进展，有兴趣的朋友也可以申请加入这个项目，或者是提出宝贵的意见。

参考资料

1. Java Excel API 文档
2. http://www.andykhan.com/jexcelapi/

关于作者

		就叫我Rubber吧，我是一个Java迷，希望我们能成为朋友，我的Eamil： tim@trend.com.cn，我的联系电话0755-83501377

大多数 Java 程序员都熟悉对 JAR 文件的基本操作。但是只有少数程序员了解 JAR 文件格式的 强大功能。在本文中，作者探讨了JAR 格式的许多功能和优势，包括打包、可执行的 JAR 文件、安全性和索引。

JAR 文件是什么？

JAR 文件格式以流行的 ZIP 文件格式为基础，用于将许多个文件聚集为一个文件。与 ZIP 文件不同的是，JAR 文件不仅用于压缩和发布，而且还用于部署和封装库、组件和插件程序，并可被像编译器和 JVM 这样的工具直接使用。在 JAR 中包含特殊的文件，如 manifests 和部署描述符，用来指示工具如何处理特定的 JAR。

一个 JAR 文件可以用于：

• 用于发布和使用类库
• 作为应用程序和扩展的构建单元
• 作为组件、applet 或者插件程序的部署单位
• 用于打包与组件相关联的辅助资源

JAR 文件格式提供了许多优势和功能，其中很多是传统的压缩格式如 ZIP 或者 TAR 所没有提供的。它们包括：

• 安全性。可以对 JAR 文件内容加上数字化签名。这样，能够识别签名的工具就可以有选择地为您授予软件安全特权，这是其他文件做不到的，它还可以检测代码是否被篡改过。
  
• 减少下载时间。 如果一个 applet 捆绑到一个 JAR 文件中，那么浏览器就可以在一个 HTTP 事务中下载这个 applet 的类文件和相关的资源，而不是对每一个文件打开一个新连接。
  
• 压缩。JAR 格式允许您压缩文件以提高存储效率。
  
• 传输平台扩展。 Java 扩展框架(Java Extensions Framework)提供了向 Java 核心平台添加功能的方法，这些扩展是用 JAR 文件打包的(Java 3D 和 JavaMail 就是由 Sun 开发的扩展例子)。
  
• 包密封。存储在 JAR 文件中的包可以选择进行 密封，以增强版本一致性和安全性。密封一个包意味着包中的所有类都必须在同一 JAR 文件中找到。
  
• 包版本控制。一个 JAR 文件可以包含有关它所包含的文件的数据，如厂商和版本信息。
  
• 可移植性。处理 JAR 文件的机制是 Java 平台核心 API 的标准部分。

压缩的和未压缩的 JAR

jar 工具(有关细节参阅 jar 工具 )在默认情况下压缩文件。未压缩的 JAR 文件一般可以比压缩过的 JAR 文件更快地装载，因为在装载过程中要解压缩文件，但是未压缩的文件在网络上的下载时间可能更长。

META-INF 目录

大多数 JAR 文件包含一个 META-INF 目录，它用于存储包和扩展的配置数据，如安全性和版本信息。Java 2 平台识别并解释 META-INF 目录中的下述文件和目录，以便配置应用程序、扩展和类装载器：

• MANIFEST.MF。这个 manifest 文件定义了与扩展和包相关的数据。
  
• INDEX.LIST。 这个文件由 jar 工具的新选项 -i 生成，它包含在应用程序或者扩展中定义的包的位置信息。它是 JarIndex 实现的一部分，并由类装载器用于加速类装载过程。
  
• xxx.SF。 这是 JAR 文件的签名文件。占位符 xxx标识了签名者。
  
• xxx.DSA。 与签名文件相关联的签名程序块文件，它存储了用于签名 JAR 文件的公共签名。

jar 工具

为了用 JAR 文件执行基本的任务，要使用作为Java Development Kit 的一部分提供的 Java Archive Tool ( jar 工具)。用 jar 命令调用 jar 工具。表 1 显示了一些常见的应用：

表 1. 常见的 jar 工具用法

功能	命令
用一个单独的文件创建一个 JAR 文件	jar cf jar-file input-file...
用一个目录创建一个 JAR 文件	jar cf jar-file dir-name
创建一个未压缩的 JAR 文件	jar cf0 jar-file dir-name
更新一个 JAR 文件	jar uf jar-file input-file...
查看一个 JAR 文件的内容	jar tf jar-file
提取一个 JAR 文件的内容	jar xf jar-file
从一个 JAR 文件中提取特定的文件	jar xf jar-file archived-file...
运行一个打包为可执行 JAR 文件的应用程序	java -jar app.jar

回页首

可执行的 JAR

一个 可执行的 jar 文件是一个自包含的 Java 应用程序，它存储在特别配置的JAR 文件中，可以由 JVM 直接执行它而无需事先提取文件或者设置类路径。要运行存储在非可执行的 JAR 中的应用程序，必须将它加入到您的类路径中，并用名字调用应用程序的主类。但是使用可执行的 JAR 文件，我们可以不用提取它或者知道主要入口点就可以运行一个应用程序。可执行 JAR 有助于方便发布和执行 Java 应用程序。

创建可执行 JAR

创建一个可执行 JAR 很容易。首先将所有应用程序代码放到一个目录中。假设应用程序中的主类是 com.mycompany.myapp.Sample 。您要创建一个包含应用程序代码的 JAR 文件并标识出主类。为此，在某个位置(不是在应用程序目录中)创建一个名为 manifest 的文件，并在其中加入以下一行：

Main-Class: com.mycompany.myapp.Sample
            

然后，像这样创建 JAR 文件：

jar cmf manifest ExecutableJar.jar application-dir
            

所要做的就是这些了 -- 现在可以用 java -jar 执行这个 JAR 文件 ExecutableJar.jar。

一个可执行的 JAR 必须通过 menifest 文件的头引用它所需要的所有其他从属 JAR。如果使用了 -jar 选项，那么环境变量 CLASSPATH 和在命令行中指定的所有类路径都被 JVM 所忽略。

启动可执行 JAR

既然我们已经将自己的应用程序打包到了一个名为 ExecutableJar.jar 的可执行 JAR 中了，那么我们就可以用下面的命令直接从文件启动这个应用程序：

java -jar ExecutableJar.jar
            

回页首

包密封

密封 JAR 文件中的一个包意味着在这个包中定义的所有类都必须在同一个 JAR 文件中找到。这使包的作者可以增强打包类之间的版本一致性。密封还提供了防止代码篡改的手段。

要密封包，需要在 JAR 的 manifest 文件中为包添加一个 Name 头，然后加上值为“true”的 Sealed 头。与可执行的 JAR 一样，可以在创建 JAR 时，通过指定一个具有适当头元素的 manifest 文件密封一个 JAR，如下所示：

Name: com/samplePackage/
            Sealed: true
            

Name 头标识出包的相对路径名。它以一个“/”结束以与文件名区别。在 Name 头后面第一个空行之前的所有头都作用于在 Name 头中指定的文件或者包。在上述例子中，因为 Sealed 头出现在 Name 头后并且中间没有空行，所以 Sealed 头将被解释为只应用到包 com/samplePackage 上。

如果试图从密封包所在的 JAR 文件以外的其他地方装载密封包中的一个类，那么 JVM 将抛出一个 SecurityException 。

扩展打包
扩展为 Java 平台增加了功能，在 JAR 文件格式中已经加入了扩展机制。扩展机制使得 JAR 文件可以通过 manifest 文件中的 Class-Path 头指定所需要的其他 JAR 文件。

假设 extension1.jar 和 extension2.jar 是同一个目录中的两个 JAR 文件，extension1.jar 的 manifest 文件包含以下头：

Class-Path: extension2.jar

这个头表明 extension2.jar 中的类是 extension1.jar 中的类的 扩展类。extension1.jar 中的类可以调用 extension2.jar 中的类，并且不要求 extension2.jar 处在类路径中。

在装载使用扩展机制的 JAR 时，JVM 会高效而自动地将在 Class-Path 头中引用的 JAR 添加到类路径中。不过，扩展 JAR 路径被解释为相对路径，所以一般来说，扩展 JAR 必须存储在引用它的 JAR 所在的同一目录中。

例如，假设类 ExtensionClient 引用了类 ExtensionDemo ,它捆绑在一个名为 ExtensionClient.jar 的 JAR 文件中，而类 ExtensionDemo 则捆绑在 ExtensionDemo.jar 中。为了使 ExtensionDemo.jar 可以成为扩展，必须将 ExtensionDemo.jar 列在 ExtensionClient.jar 的 manifest 的 Class-Path 头中，如下所示：

Manifest-Version: 1.0 Class-Path: ExtensionDemo.jar

在这个 manifest 中 Class-Path 头的值是没有指定路径的 ExtensionDemo.jar，表明 ExtensionDemo.jar 与 ExtensionClient JAR 文件处在同一目录中。

回页首

JAR 文件中的安全性

JAR 文件可以用 jarsigner 工具或者直接通过 java.security API 签名。一个签名的 JAR 文件与原来的 JAR 文件完全相同，只是更新了它的 manifest，并在 META-INF 目录中增加了两个文件，一个签名文件和一个签名块文件。

JAR 文件是用一个存储在 Keystore 数据库中的证书签名的。存储在 keystore 中的证书有密码保护，必须向 jarsigner 工具提供这个密码才能对 JAR 文件签名。

JAR 的每一位签名者都由在 JAR 文件的 META-INF 目录中的一个具有 .SF 扩展名的签名文件表示。这个文件的格式类似于 manifest 文件 -- 一组 RFC-822 头。如下所示，它的组成包括一个主要部分，它包括了由签名者提供的信息、但是不特别针对任何特定的 JAR 文件项，还有一系列的单独的项，这些项也必须包含在 menifest 文件中。在验证一个签名的 JAR 时，将签名文件的摘要值与对 JAR 文件中的相应项计算的摘要值进行比较。

Contents of signature file META-INF/MANIFEST.MF
            Manifest-Version: 1.0
            Created-By: 1.3.0 (Sun Microsystems Inc.)
            Name: Sample.java
            SHA1-Digest: 3+DdYW8INICtyG8ZarHlFxX0W6g=
            Name: Sample.class
            SHA1-Digest: YJ5yQHBZBJ3SsTNcHJFqUkfWEmI=
            Contents of signature file META-INF/JAMES.SF
            Signature-Version: 1.0
            SHA1-Digest-Manifest: HBstZOJBuuTJ6QMIdB90T8sjaOM=
            Created-By: 1.3.0 (Sun Microsystems Inc.)
            Name: Sample.java
            SHA1-Digest: qipMDrkurQcKwnyIlI3Jtrnia8Q=
            Name: Sample.class
            SHA1-Digest: pT2DYby8QXPcCzv2NwpLxd8p4G4=
            

数字签名

一个数字签名是.SF 签名文件的已签名版本。数字签名文件是二进制文件，并且与 .SF 文件有相同的文件名，但是扩展名不同。根据数字签名的类型 -- RSA、DSA 或者 PGP -- 以及用于签名 JAR 的证书类型而有不同的扩展名。

Keystore

要签名一个 JAR 文件，必须首先有一个私钥。私钥及其相关的公钥证书存储在名为 keystores 的、有密码保护的数据库中。JDK 包含创建和修改 keystores 的工具。keystore 中的每一个密钥都可以用一个别名标识，它通常是拥有这个密钥的签名者的名字。

所有 keystore 项(密钥和信任的证书项)都是用唯一别名访问的。别名是在用 keytool -genkey 命令生成密钥对(公钥和私钥)并在 keystore 中添加项时指定的。之后的 keytool 命令必须使用同样的别名引用这一项。

例如，要用别名“james”生成一个新的公钥/私钥对并将公钥包装到自签名的证书中，要使用下述命令：

keytool -genkey -alias james -keypass jamespass
            -validity 80 -keystore jamesKeyStore
            -storepass jamesKeyStorePass
            

这个命令序列指定了一个初始密码“jamespass”，后续的命令在访问 keystore “jamesKeyStore”中与别名“james”相关联的私钥时，就需要这个密码。如果 keystore“jamesKeyStore”不存在，则 keytool 会自动创建它。

jarsigner 工具

jarsigner 工具使用 keystore 生成或者验证 JAR 文件的数字签名。

假设像上述例子那样创建了 keystore “jamesKeyStore”，并且它包含一个别名为“james”的密钥，可以用下面的命令签名一个 JAR 文件：

jarsigner -keystore jamesKeyStore -storepass jamesKeyStorePass
            -keypass jamespass -signedjar SSample.jar Sample.jar james
            

这个命令用密码“jamesKeyStorePass”从名为“jamesKeyStore”的 keystore 中提出别名为“james”、密码为“jamespass”的密钥，并对 Sample.jar 文件签名、创建一个签名的 JAR -- SSample.jar。

jarsigner 工具还可以验证一个签名的 JAR 文件，这种操作比签名 JAR 文件要简单得多，只需执行以下命令：

jarsigner -verify SSample.jar
            

如果签名的 JAR 文件没有被篡改过，那么 jarsigner 工具就会告诉您 JAR 通过验证了。否则，它会抛出一个 SecurityException ， 表明哪些文件没有通过验证。

还可以用 java.util.jar 和 java.security API 以编程方式签名 JAR(有关细节参阅 参考资料)。也可以使用像 Netscape Object Signing Tool 这样的工具。

回页首

JAR 索引

如果一个应用程序或者 applet 捆绑到多个 JAR 文件中，那么类装载器就使用一个简单的线性搜索算法搜索类路径中的每一个元素，这使类装载器可能要下载并打开许多个 JAR 文件，直到找到所要的类或者资源。如果类装载器试图寻找一个不存在的资源，那么在应用程序或者 applet 中的所有 JAR 文件都会下载。对于大型的网络应用程序和 applet，这会导致启动缓慢、响应迟缓并浪费带宽。

从 JDK 1.3 以后，JAR 文件格式开始支持索引以优化网络应用程序中类的搜索过程，特别是 applet。JarIndex 机制收集在 applet 或者应用程序中定义的所有 JAR 文件的内容，并将这些信息存储到第一个 JAR 文件中的索引文件中。下载了第一个 JAR 文件后，applet 类装载器将使用收集的内容信息高效地装载 JAR 文件。这个目录信息存储在根 JAR 文件的 META-INF 目录中的一个名为 INDEX.LIST 的简单文本文件中。

创建一个 JarIndex
可以通过在 jar 命令中指定 -i 选项创建一个 JarIndex。假设我们的目录结构如下图所示：

您将使用下述命令为 JarIndex_Main.jar、JarIndex_test.jar 和 JarIndex_test1.jar 创建一个索引文件：

jar -i JarIndex_Main.jar JarIndex_test.jar SampleDir/JarIndex_test1.jar
            

INDEX.LIST 文件的格式很简单，包含每个已索引的 JAR 文件中包含的包或者类的名字，如清单 2 所示：

JarIndex-Version: 1.0
            JarIndex_Main.jar
            sp
            JarIndex_test.jar
            Sample
            SampleDir/JarIndex_test1.jar
            org
            org/apache
            org/apache/xerces
            org/apache/xerces/framework
            org/apache/xerces/framework/xml4j
            

回页首

结束语

JAR 格式远远超出了一种压缩格式，它有许多可以改进效率、安全性和组织 Java 应用程序的功能。因为这些功能已经建立在核心平台 -- 包括编译器和类装载器 -- 中了，所以开发人员可以利用 JAR 文件格式的能力简化和改进开发和部署过程。.

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文.
  
  
• 参阅 jar 实用程序的命令行选项的文档。
  
  
  
• Raffi Krikorian 在 ONJava 上发表的文章提供了有关 programmatically signing a JAR file的帮助。
  
  
  
• 这篇关于 Java Archive Tool的文档解释了创建和操作 JAR 文件可以使用的选项。
  
  
  
• 文章“ Java Web Start”( developerWorks，2001 年 9 月)描述了如何使用这种技术，以便允许应用程序可以指定所需的 JAR 文件并动态下载它们。
  
  
  
• 有关 J2EE 服务器（比如 IBM WebSphere Application Server）使用 JAR 文件格式的不同方式，请参阅“ What are Java Archive (JAR) files?”
  
  
  
• JAR 格式是 WAR (Web Archive) 格式的基础，WAR用于在 J2EE 容器中部署 Servlet 和 JSP 应用程序。更多内容请参阅“ What are WAR files?”。
  
  
  
• JAR 格式也是 EAR (Enterprise Archive) 格式的基础，EAR 用于在 J2EE 容器中部署 EJB。更多内容请参阅“ What are Enterprise Archive (EAR) files?”。
  
  
  
• 在 developerWorks Java 技术专区 上可以找到数百篇关于 Java 编程的各个方面的文章。
  
  

作者简介

		Pagadala J. Suresh 是 IBM Global Services India 的软件工程师。他擅长的领域包括 Java 技术、WebSphere Application Server 和 WebSphere Studio Application Developer (WSAD)、Ariba Buyer。他参与了 WebSphere 的 IBM Redbook 项目。可以通过 pjsuresh@in.ibm.com 与 Pagadala 联系。

		Palaniyappan Thiagarajan 是位于印度班加罗尔的 IBM Global Services India 的软件工程师。他是IBM 认证的 IBM WebSphere Application Server V3.5 和 IBM DB2 UDB V7.1 Family Fundamentals 专家。可以通过 tpalaniy@in.ibm.com 与 Palaniyappan 联系。

2001 年 11 月，IBM 向开源社区捐献了 Eclipse 代码，自此 Eclipse 在开发者社区得到飞速发展。2006 年 1月19日，Eclipse 国际高峰论坛也首次登陆中国，在清华大学信息科学技术大楼举行。在这次 Eclipse 大会上 developerWorks 编辑团队与 IBM 的 Eclipse 策略经理 John Kellerman 进行了座谈，聆听了他对 Eclipse 历史的追溯、对 Eclipse 架构的分析、对 Eclipse 现状分析、对未来发展的展望。

John Kellerman，IBM 软件部 Rational 产品总经理，与 1984 年加入 IBM, 一直从事应用开发工作。2000 年初，John 开始加入了 Eclipse 项目，现在任职 IBM Eclipse 策略部总经理。他现在的主要工作是在 Eclipse 基金会、Eclipse 社区中代表 IBM 的利益，与 Eclipse 成员公司合作。

developerWorks: IBM 开发工具的发展经历了从最初的 Visual Age到今天基于 Eclipse 3.0 的产品, 可以说是非常大的飞跃，您可否给我们谈一下这其中的历史？

John: 我在加入 Eclipse 项目之前，是 IBM Visual Age for SmallTalk 的产品经理。Eclipse 起源的一个非常重要的原因是，当时IBM 面临着一些挑战需要去解决，即 IBM 开发工具 Visual Age for Java 和 WebSphere Studio 很难集成到一起，而且底层的技术比较脆弱，因此进一步发展非常艰难，无法满足业界应用开发的需求。
因此，1998 年，我们开始了下一代开发工具技术探索之路，成立了一个项目开发小组，经过两年的发展，2000年，我们决定给新一代开发工具项目命名为 Eclipse，Eclipse 叫法当时只是内部使用的名称。这时候的商业目标就是希望 Eclipse 项目能够吸引开发人员，能发展起一个强大而又充满活力的商业合作伙伴（独立软件供应商）社区。同时我们意识到需要用它来对抗 Microsoft Visual Studio 的发展，因此从商业目标考虑，通过开源的方式我们最有机会达到目的。此外，IBM 推出了 Eclipse 试用计划，允许 IBM 以外的开发人员使用 Eclipse。结果证明我们的决策非常正确，Eclipse 从此在开发社区广为流传。Eclipse 也就成为这个项目的正式名称。

我们认为开源 Eclipse 不能只是简单地贡献出源码，创建一个开源项目然后放在开源许可证下；我们需要建立起多家公司的合作关系，否则就不足信服，不是真正的开源项目，而只是 IBM 的一个项目。因此在 2000 年到 2001 年之间，我做的主要工作就是去拜访一些公司，与他们谈论 Eclipse,邀请他们加入 Eclipse 项目。 您可以想象，这是非常有趣的谈话，最终，我们与 8 家公司达成了一致，其中包括一些 IBM 的竞争对手 WebGain、Borland, 还有一些盟友如 Rational（Rational 当时还没有被 IBM 收购）。

2001 年 12 月，IBM 向世界宣布了两件事，第一件是创建开源项目，既 IBM 捐赠价值 4 千万美元的源码给开源社区；另外一件事是成立 Eclipse 协会（Eclipse Consortium）,这个协会由一些成员公司组成，主要任务是支持并促进 Eclipse 开源项目。

从此，我们看到了 Eclipse 本身、会员、插件（plug-in）和 Eclipse 社区飞速成长。2003 年，我们意识到这种会员模式很难进一步扩展，有些事务操作起来很困难，比如无法筹集赠款、无法成立合法理事会，这主要是因为 Eclipse 协会不是一个法律上的实体；此外，尽管 Eclipse 成功有目共睹，但仍然有些业界成员没有加入，他们认为是 Eclipse 的真正领导者是 IBM。因此我们认识到创建一个独立于 IBM 的 Eclipse 将会对 Eclipse 的发展非常有利, 于是 IBM 与其他成员公司合作起草了管理条例，准备成立 Eclipse 基金会（Eclipse Foundation）。2004 年初，Eclipse 基金会正式成立。

developerWorks: Eclipse 由一个很小的核心和核心之上的大量插件组成，这种插件式架构给当时的开发社区带来耳目一新的冲击。您能给我们介绍一下 Eclipse 插件架构吗？

John: 对于 Eclipse 插件架构，一个很好的比喻是 Web 浏览器，它也有插件，Eclipse 插件和浏览器相似，都是要解决扩展性问题。对于一个 Web 浏览器，如果你想既能浏览多媒体动画，又想浏览 PDF 文件，那么你就需要两个不同的插件，才能保证两种内容都能在 Web 浏览器中显示。 Eclipse 也一样，通过它的插件模式我们可以安装不同的插件来进行 HTML 的编辑、数据库的设计、Java 开发、C++ 开发等等，所有这些开发工作完全在一个 Eclipse 安装平台上进行。而且 Eclipse 模型所能做的远超过了这些，理解 Eclipse 插件的关键是首先要理解 Eclipse 扩展点，正是这个扩展点帮您在 Eclipse 中添加新功能。例如，如果希望在菜单中添加一项，就是通过 Eclipse 扩展点实现的。

所以当 Eclipse 插件实现了一个扩展点，就创建了一个扩展，此外，扩展还可以创建自己的扩展点。这种插件模式的扩展和扩展点是递归的，而且被证明是非常灵活的。记得当我们着手对 Eclipse 开发进行区域性调查时，最初的决定之一是："We will eat our own dog food"（编者注：谚语，指一个公司在日常运行中使用自己的产品），即 Eclipse 团队要使用 Eclipse 进行 Eclipse 的开发。事实上，Eclipse 本身是一个核心的运行时绑定了一些在插件之上构建的插件，换句话说，Eclipse 本身就是一系列的插件。这样随着使用 Eclipse 构建 Eclipse 的经验累积，这种插件模式就变得日臻成熟。

developerWorks: IBM 对 Eclipse 已经投入了非常多的资源，IBM 在 Eclipse 的将来会扮演什么角色呢？

John: 目前 Eclipse 项目有 100 多个，IBM 参与了其中超过一半的项目，有 3 个主管在主持 Eclipse 相关的工作。2005 年我们还赞助了一些 Eclipse 创新基金和 Eclipse 奖学金。IBM 承诺在未来的几年内会一如既往地参与 Eclipse 研究，我们将会看到 IBM 研发出新项目，而在某些 Eclipse 项目上减少参与，这要看 IBM 的商业目标。最近我们提议了一个项目叫 Beacon, 是关于 Eclipse 流程框架的。我们将捐献一些 Rational Unified Process (RUP) 技术，基本上这个提议是要提供流程方面的内容。IBM 现在与一家叫做 Zend 的公司合作，希望在 Eclipse 上开发出用于 PHP 的开发工具。从商业方面看 IBM, 您会发现 Eclipse 是 Rational 软件开发平台的基础。此外由于 Eclipse 的插件模式、扩展性、集成性，我们为Rational, WebSphere, Lotus 和 Tivoli 构建了统一的平台。

developerWorks: 目前 IBM 的五大旗舰品牌都有基于 Eclipse 的产品, 这对 IBM 有什么好处？

John: 我们的目标是创建集成统一平台，我们有基于 Eclipse 构建的 DB2, Rational, WebSphere 等工具，这样客户就可以共同使用这些工具，有统一的界面风格，使用起来非常方便。对 IBM 自身来说，各个开发部门就可以关注于软件的核心性能开发，而不必要浪费资源做一些重新实现的工作，从而 DB2 开发部门就专注于数据库开发、WebSphere 专注应用服务器的开发、Rational 专注于建模、源代码管理，至于其他方面的辅助开发对于 Eclipse 来说是共同的。

developerWorks: Eclipse 是一个开源 IDE, 那如何通过 Eclipse 创造商业利益呢？

John: 对于 IBM, 在 Eclipse 技术开发方面与上百家公司合作，因为 IBM 看到了 Eclipse 作为通用的、开放的、标准的技术基础，其价值日益成长。当然，这种基础技术是不会带来创收的，没有人可以使用 Eclipse 技术来赚钱，但这并不重要，就像 Borland, Sybase 等公司都在花费钱做同样的构建工作，当然我们在这方面还有合作，但是我们还专注于将我们的核心功能组件构建在 Eclipse 平台上，例如，IBM 的 Rational Application Developer, 它是使用 Eclipse 作为基础，然后在这基础上添加了建模插件、Web 开发插件，还有其它更有价值的插件，这些插件我们是收费的。这就是使用 Eclipse 进行商业创收的模式之一。
此外，人们还可以直接为 Eclipse 构建插件，然后出售这些插件来赚钱，因为插件可以使用商业许可证发行。事实上我们建立 Eclipse 公共许可证，就是为了让 Eclipse 能很好的被商业采用，从而可以用它来赚钱，Eclipse 的所有成员公司基本都是商业软件提供商。目前全球有上百万开发人员在使用 Eclipse, 因此中国开发人员完全可以构建有价值的插件和工具，然后进行销售。同时 IBM 有一个合作伙伴计划，帮助合作伙伴宣传在 IBM 基于 Eclipse 的产品之上构建的应用。

developerWorks: 富客户端平台(RCP)目前是比较流行的应用开发模式，请谈一下 Eclipse 是如何支持富客户端的？

John: 在 Eclipse 的早期，有些用户试图除了将 Eclipse用于开发工具基础平台外，还用作更普遍的商业应用基础。他们认为一个 IDE 就是一个特殊的富客户端应用。这就是开放源码开发的魅力所在，当这些用户试着用 Eclipse 作为通用富客户端时，他们就把这些想法建议反馈给 Eclipse 开发小组。就这样 Eclipse 经过了 2.0 到 2.1 的发展，不断收到来自社区的建议和反馈，终于到了一个通用化的阶段。在3.0 版发行时，我们觉得时机成熟，于是正式声明将 Eclipse 作为通用的富客户端和 IDE。

其实最早的反馈是来自我们的 Lotus 开发小组，他们在 Eclipse 3.0 之前就意识到可以使用 Eclipse 来提供他们 Workplace 客户端的富客户端版本。从 Eclipse 3.0 到 3.1 再到 3.2, 我们看到富客户端平台应用的快速增长，同时也收到越来越多反馈帮我们完善提高。

我最欣赏的 RCP 应用之一是在EclipseCon 2005 上的一个演示，演示的是美国国家航空航天管理局(NASA)的一个项目，当时 NASA 在加利福尼亚州有个实验室叫 Jet Propulsion Laboratory (JPL)，负责火星探测计划，他们的管理用户界面就是一个 Eclipse RCP 应用，通过这个应用，加利福尼亚州的工作人员就可以控制在火星上运行的火星车。在演示过程中，有人问为什么使用 Eclipse, 回答是，使用 Eclipse 这门技术，他们不用担心，而且还节省了不少纳税人的钱，因为他们只需要集中资源开发控制火星车的应用就可以了。

developerWorks: Eclipse 现在非常热门，您认为从微软的开发平台转到 Eclipse 上容易吗？

John: 这个问题可以从两方面来说明，一是软件提供商从 Visual Studio 移到 Eclipse 上，另一方面是微软平台上开发的程序的移植。

Eclipse 提供了不同的集成方法，可以是非常轻量级的集成，即只是简单的调用和返回。Eclipse可以处理 ActiveX 控件，这样 Word, Excel 就可以在 Eclipse 里打开，这是另一种集成模式。有些供应商选择把他们的工具封装在 Java 层，即保留 C/C++ 工具，封装在 Java 里与 Eclipse 进行通信。如果软件供应商希望将工具构建成 Eclipse 插件，那么我们通常建议在 Eclipse 中用 Java 重新实现，因为几乎所有的微软工具都是 C/C++ 工具。因此工具的迁移可以分三步走：轻量级集成、重量级集成和重新实现。

如果要迁移程序，Eclipse 提供了一些设施。但难易程度取决于程序是用什么工具开发的，因为最重要的部分是（版本控制系统的）代码库本身，如果代码库同时支持 Visual Studio 和 Eclipse, 那就容易的多。此外有一些公司提供了迁移系统，在 Eclipse 网站的社区部分中可以查看这些公司列表。

developerWorks: 对个体开发人员，他们如何能够参与 Eclipse 项目？

John: Eclipse 是完全开放的，任何人都可以参与，参与的最简单方法是关注它的新闻组，选择一个感兴趣的技术领域，然后下载代码，自己做些实验，并在新闻组上回答一些问题，这样随着技术的提高，就可以向 Bugzilla 提交 bug 和修复包，或去修复其他 bug。如果得到项目工作组的认可，便可以承担项目的一些义务，成为项目开发组的真正成员。此外还可以写一些文章发送到 Eclipse 组织，参加本地的 Eclipse 用户组等等方式。

如果有兴趣成立一个 Eclipse 开源项目，Eclipse 上有一个文档"Eclipse Development Process",描述了如何操作。

developerWorks: 最后请给我们谈谈 Eclipse 下个版本的情况？

John: Eclipse 3.2 计划于今年 6 月面世，名称是 Callisto, 选择 Callisto 作为名称是按社区要求的，因为这次目标是同时发布 10 个主要的 Eclipse 项目，以支持成员公司生态系统需求，他们将要把 Eclipse 框架集成到各自的软件产品中。

developerWorks: 感谢您接受我们的采访。

使用 Java 语言所进行的面向对象编程变得空前普及。它使软件开发发生了某种程度上的变革，但最近的研究表明，有半数软件开发项目滞后，而三分之一的项目则超出预算。问题不在于技术，而是开发软件所使用的方法。所谓的“轻量型”或“灵活”方式，与如 Java 这样的面向对象语言的威力和灵活性结合起来，提供了一种很有意思的解决方案。最常见的灵活方式称为极端编程（Extreme Programming）或者 XP，但许多人并不真正了解它。对 Java 项目使用 XP 可以大大增加成功的机会。本文提供了 XP 的概述，并解释了它为什么很重要 -- 不是传言，也没有骗局。

在过去的十年中，CEO 们在产生稳步增加的收入方面面临巨大的压力。他们通过在许多方面采取一系列举措来解决这一问题，例如缩小公司规模、外包、再工程、企业资源规划 (ERP) 等等。这些对低效率的解决措施让 S&P 500 中的许多企业在 90 年代末能够连续几年保持两位数的收入增长。但这种方式也带来了一些负面影响。

在 Gary Hamel 所著的 Leading the Revolution（请参阅 参考资料）一书中，他声称已有一些迹象证明传统企业模式的优势已不那么明显。我们必须找到一些替代方法来为收入的持续增长提供动力。他建议唯一能让公司继续增长的办法是进行一次彻底的创新。我们认为在软件开发领域中尤其需要这样。

企业问题

如果使用标准软件开发方法，那么即使在 Java 平台上进行开发，也要做好失望的准备。如图 1 所示，最近的研究表明，有一半项目将滞后，而三分之一的项目将超过预算。这一推测比 1979 年由美国总审计局的研究结果好不了多少。

如果我们希望这些数字有显著提高，则需要彻底创新的方法来开发软件。有两个主要因素影响现有的方法：

• 惧怕失败
• 对软件本质的误解

没有人打算失败。具有讽刺意味的是为使失败最小化而创建的方法是失败的。对软件的误解是问题的根源。恐惧实际上只是一种症状。现有的方法是由那些有良好愿望但忘记了软件中的“软”的那些聪明人所创建的。他们假定开发软件就象造桥。因此他们从各种设计规范中借鉴了一些适用于“硬”物体（例如桥梁）的最优方法。结果是基于 Big Design Up-front (BDUF) 思想的反映迟钝的开发方法，软件不堪一击，人们无法使用它们。

回页首

一种解决方案：灵活方法

最近发生了一些转变，从所谓的“重量型”方法转向了“轻量型”或“灵活”方法，例如 Crystal 方法、适应性软件开发和（当前最流行的）XP。所有这些过程都有这样一个事实，即需要人们共同来开发软件。成功的软件过程必须将人们的长处最大化，将他们的缺点最小化，因为优点和缺点毋庸质疑都存在。在我们看来，XP 最出色的地方在于它能够解决所有影响参加人员的互补力量。

XP 提供了十年来最大的一次机会，给软件开发过程带来彻底变革。就象 Peopleware 作家 Tom DeMarco 所说，“XP 是当今我们所处领域中最重要的一项运动。预计它对于目前一代的重要性就象 SEI 及其能力成熟度模型对上一代的重要性一样。”

XP 规定了一组核心价值和方法，可以让软件开发人员发挥他们的专长：编写代码。XP 消除了大多数重量型过程的不必要产物，通过减慢开发速度、耗费开发人员的精力（例如干特图、状态报告，以及多卷需求文档）从目标偏离。我们认识到一个称为“极端编程”的东西可能很难作为正式的开发过程推荐给管理层，但如果您的公司从事软件行业，您应该帮助管理层绕过其名称认识到 XP 可以提供的竞争优势。

Kent Beck 在他所著的 Extreme Programming Explained: Embrace Change一书中概括了 XP 的核心价值（请参阅 参考资料）。我们对它们进行了总结：

• 交流。 项目的问题往往可以追溯到某人在某个时刻没有和其他人一起商量某些重要问题上。使用 XP，不交流是不可能的事。
  
• 简单。 XP 建议您总是尽可能围绕过程和编写代码做最简单的事情。按照 Beck 的说法，“XP 就是打赌。它打赌今天最好做些简单的事...而不是做更复杂但可能永远也不会用到的事。”
  
• 反馈。 更早和经常来自客户、团队和实际最终用户的具体反馈意见为您提供更多的机会来调整您的力量。反馈可以让您把握住正确的方向，少走弯路。
  
• 勇气。 勇气存在于其它三个价值的环境中。它们相互支持。需要勇气来相信一路上具体反馈比预先知道每样事物来得更好。需要勇气来在可能暴露您的无知时与团队中其他人交流。需要勇气来使系统尽可能简单，将明天的决定推到明天做。而如果没有简单的系统、没有不断的交流来扩展知识、没有掌握方向所依赖的反馈，勇气也就失去了依靠。

XP 的方法将这些价值转换成开发人员每天应做的事情。这里没什么新鲜内容。多年以来，行业认识到 XP 方法是“最优方法”。实际上，XP 中的“极端”来自两方面：

• XP 采取经过证明的业界最优方法并将其发挥到极致。
• XP 将这些方法以某种方式进行结合，使它们产生的结果大于各部分的总和。

这是怎样的情景呢？代码复查是个好的做法，因此始终通过成对地编写代码来做到。测试也是个好的做法，因此总是通过在编写代码之前编写测试来做到。文档很少与代码保持一致，因此只做那些最需要的事，余下的部分则取决于明确编写的代码和测试。XP 不保证人们总做正确的事，但它允许人们这样做。它将这些“极端”方法以一种相互支持的方式结合起来，显著提高了速度和有效性。

回页首

XP 的十二种方法

XP 的十二种方法（如图 2 所示）将其定义为规则。让我们仔细研究每一个方法来对“执行 XP”表示什么有个更全面的理解。

规划策略
有些人会指责 XP 是一种美其名的剽窃，只是一群牛仔在没有任何规则的情况下将一个系统拼凑在一起。错。XP 是为数不多的几种承认您在开始时不可能事事通晓的方法之一。无论是用户还是开发人员都是随着项目的进展过程才逐步了解事物的。只有鼓励和信奉这种更改的方法才是有效方法。状态限定方法忽视更改。而 XP 则留心更改。它倾听所用的方法就是“规划策略”，一个由 Kent Beck 创造的概念。

这一方法背后的主要思想是迅速地制定粗略计划，然后随着事物的不断清晰来逐步完善。规划策略的产物包括：一堆索引卡，每一张都包含一个客户素材，这些素材驱动项目的迭代；以及对下一两个发行版的粗略计划，如 Kent Beck 和 Martin Fowler 在他们的 Planning Extreme Programming中描述的那样（请参阅 参考资料）。让这种形式的计划得以发挥作用的关键因素是让用户做企业决策，让开发小组做技术决策。如果没有这一前提，整个过程就会土崩瓦解。

开发小组要决定：

• 估计开发一个素材要花多长时间
• 使用各种技术选项所花费的成本
• 团队组织
• 每个素材的“风险”
• 迭代中素材开发的顺序（先开发风险最大的那一个可以减轻风险）

客户需要决定：

• 范围（一个发行版的素材和每一次迭代的素材）
• 发行日期
• 优先级（根据企业价值先开发哪些特性）

规划经常发生。这样，在客户或开发人员学习新事物的同时，就为他们调整计划提供了频繁机会。

成对编程
使用 XP，成对的开发人员编写所有产品代码。这种方式听上去好象缺乏效率。Martin Fowler 说，“当人们说成对编程降低生产力时，我回答，‘那是因为大多数耗费时间的编程部分是靠输入来完成的。’”实际上，成对编程无论在经济还是其它方面都提供了许多好处：

• 所有设计决策都牵涉到至少两个人。
• 至少有两个人熟悉系统的每一部分。
• 几乎不可能出现两个人同时疏忽测试或其它任务。
• 改变各对的组合在可以在团队范围内传播知识。
• 代码总是由至少一人复查。

研究还显示成对的编程实际上比单独编程更有效（有关详细信息，请参阅 参考资料 中 Alistair Cockburn 和 Laurie Williams 所著的 The Costs and Benefits of Pair Programming）。

测试
在 XP 中有两种测试：

1. 单元测试
2. 验收测试

开发人员在他们编写代码的同时编写单元测试。客户在他们定义了素材后编写验收测试。单元测试及时告诉开发人员系统在某一点上是否“工作”。验收测试告诉团队系统是否执行用户希望它执行的操作。

假设团队使用的是如 Java 这样的面向对象语言，开发人员在为一些方法编写代码之前为每种有可能失败的方法编写单元测试。然后他们编写足够的代码使之能通过测试。有时人们会发现这有点奇怪。答案很简单。编写测试首先为您提供：

• 一组可能最完整的测试
• 可能能工作的最简单的代码
• 代码意图的明确景象

开发人员只有在通过所有单元测试后才可以将代码检入到源代码资源库中。单元测试使开发人员有信心相信他们的代码能够工作。这为其他开发人员留下线索，可以帮助他们理解最早的开发人员的意图（实际上，这是我们看到过的最好的文档）。单元测试还给了开发人员勇气重新划分代码，因为测试失败可以立刻告诉开发人员存在错误。应该将单元测试自动化，并提供明确的通过／失败结果。xUnit 框架（请参阅 参考资料 ）做到的远不止这些，因此大多数 XP 小组都使用它们。

用户负责确保每个素材都有验收测试来确认它们。用户可以自己编写测试、可以征募组织中的其他成员（例如 QA 人员或业务分析员）编写它们，也可以将这两种方法结合起来。测试告诉他们系统是否具有应该具有的那些特性，以及是否可以正确工作。理想情况下，用户在迭代完成之前就应该写好迭代中那些素材的验收测试了。应该将验收测试自动化，并要经常运行来确保开发人员在实现新特性时没有破坏任何现有的特性。通常情况下，客户需要来自开发团队的某些帮助来编写验收测试。我们对一个项目开发一个可重用的自动验收测试框架，可以让用户在简单编辑器中输入他们的输入和所期望的输出。框架将输入转换成 XML 文件、运行文件中的测试，然后为每个测试显示“通过”或“失败”。客户喜欢这一做法。

不是所有验收测试都必须在所有情况下通过。问题是验收测试帮助客户衡量项目“完成”的情况如何。它们还可以让客户获悉有关某些事物是否可以发行的决定。

重新划分
重新划分是在不更改功能性的前提下对代码加以改进。XP 小组在进行重新划分时毫不手软。

开发人员重新划分有两个重要时机：实现特性之前和之后。开发人员尝试确定更改现有代码是否可以让新特性的开发更容易。他们查看刚刚写好的代码，看是否有方法可以对它进行简化。例如，如果他们认为有抽象的机会，就会进行重新划分来从具体实现中除去重复的代码。

XP 建议您应该编写可能运行的最简单的代码，但同时也建议您应该不断学习。重新划分让您将学到的知识加入到代码中，同时又不会破坏测试。它使您的代码简练。这意味着它可以存在相当长的时间、为以后的开发人员引入更少问题，并为他们指引正确的方向。

简单的设计
XP 的诽谤者说该过程忽略了设计。事实不是这样。问题是重量型方法建议您做的不过是提前完成大部分琐碎的设计任务。这就象是拍一张静态的地平线的照片，静止不动，然后尝试画一张如何到达那里的完美的地图。XP 说设计不应该在事物将保持不变的前提下预先仓促进行。XP 认为设计非常重要，因此应该是一个持续的事务。我们总是先尝试使用能够工作的最简单的设计，然后随着现实的不断显现来更改它。

什么是可能工作的最简单的设计？它是符合以下条件的设计（感谢 Kent Beck 为我们一一列出）：

• 运行所有测试
• 不包含重复代码
• 明确陈述程序员对所有代码的意图
• 包含尽可能最少的类和方法

对简单设计的需求并不是说所有设计都很小，也不表示它们是无足轻重的。它们只不过需要尽可能简单，但是仍能工作。不要包括不使用的额外特性。我们称这样的事物为 YAGNI，表示“您将不需要它（You Aren't Going to Need It）。”不要让 YAGNI 破坏您成功的机会。

集合体代码所有权
小组中的任何人都应该有权对代码进行更改来改进它。每个人都拥有全部代码，这意味着每个人都对它负责。这种技术可以让人们对部分代码进行必要的更改而不用经过代码拥有者个人的瓶颈。每个人都负责这一事实消除了无代码所有权所带来的混乱。

“每人拥有所有代码”与“没人拥有代码”的说法并不一样。没人拥有代码时，人们可以随处进行破坏而不必负任何责任。而 XP 说，“如果是您破坏的，应该您来弥补。”我们有一些必须在每次集成之前和之后运行的单元测试。如果您破坏了某些事物，您要负责进行修补，无论它位于代码的哪一部分。这需要极端规则。可能这是名称中带有“极端”的另一个原因。

持续的集成
经常进行代码集成可以帮助您避免集成梦魇。XP 团队在一天中集成了代码几次，每次都在所有单元测试对系统运行后执行。

传统方法工作方式如下：编写大量代码后执行一次大爆炸式的集成，然后花费相当长的时间来改正问题。这种笨拙的形式的确使项目速度减缓。大爆炸式的集成给团队立即带来大量问题，并且这些问题通常都有几百种可能的原因。

如果经常进行集成，任何特定集成失败的原因都会非常明显（以前运行过测试，因此错误一定是新事物犯下的）。使用这种方法，当遇到问题时，可能的原因就相当有限。修改起来更容易，花的时间少得多，使团队保持最快速度前进。

现场客户
要使功能最理想，XP 小组需要在现场有一位客户来明确素材，并做出重要的企业决策。开发人员是不允许单独做这些事情的。让客户随时在场可以消除开发人员等待决策时出现的瓶颈。

XP 不会假装素材卡是开发人员交付必要代码所需的唯一指示。素材是对以后在客户和开发人员之间填写细节的对话的一项承诺。与将所有要求写在一个静态文档中不同，其思想是进行面对面的交流，减少产生误解的机会。

我们发现让客户在现场是可能最好的一种情形，但这不是解决问题的唯一方案。底线是客户必须随时在需要回答问题和根据企业价值为团队提供指示时有空。如果客户并非在现场专职陪伴团队的情况下就能做到这些，那很好。如果能和团队待在一起，这会更方便，但只是建议而已。

小发行版
发行版应该尽可能地小，同时仍然提供足够的企业价值以证明它们值得。

只要觉得有意义就可以发布系统。这样就尽可能早为用户提供了价值（请记住，今天的钱比明天的钱来得值钱）。小发行版将为开发人员提供具体的反馈意见，告诉他们哪些符合客户需要，哪些不符合客户需要。然后，小组可以将这些经验教训包括在其下一发行版的规划中。

一周 40 小时
Kent Beck 说他希望“...每天早晨都感到有活力有激情，每天晚上都感到疲惫而满足。”一周 40 小时工作可以让您做到这一点。确切的小时数并不重要，重要的是原则。长时间地持续工作会扼杀工作绩效。疲劳的开发人员会犯更多错误，从长期来说，将比按“正常”时间表进行的开发慢得多。

即使开发人员可以在长时间很好工作，这也不意味着他们应该这样。最终他们会厌倦，会离开他们的工作，或者产生影响他们工作绩效的非工作问题。如果您打乱了人们的生活，将会尝到它所带来的恶果。加班并不是解决项目问题的答案。实际上，它是更大问题的症状。如果您要走向灭亡，就无药可救了。

编码标准
拥有编码标准有两个目的：

• 防止团队被一些例如事物没有以最大速度发展这种无关紧要的愚蠢争论搞得不知所措。
• 它支持其它方法。

如果没有编码标准，重新划分代码会更加困难，按应当的频度交换对更困难，快速前进也更困难。目标应该是团队中没有人辨认得出是谁写的哪一部分代码。以团队为单位对某一标准达成协议，然后遵守这一标准。目标不是创建一个事无巨细的规则列表，而是提供将确保您的代码可以清晰交流的指导方针。编码标准开始时应该很简单，然后根据团队经验逐步进化。不要预先花费太多时间。创建能够工作的最简单标准，然后逐步发展。

系统比喻
体系结构是做什么用的？它提供了系统各种组件以及它们是如何交互的画面 -- 一种映射，可以让开发人员了解新的代码部分适合放在哪里。

XP 中的系统比喻与大多数方法称作的体系结构差不多。比喻为团队提供了一致的画面，他们可以用它来描述现有系统的工作方式、新部件适合的位置，以及它们应该采取的形式。

重要的是要记住，关键要让每个人理解系统是如何组合在一起的，而不是美丽的比喻。有时您就是无法想到一个好的比喻。想到时就太好了。

回页首

一起工作的方法

整体大于各个部分之和。您可以实现单一方法或一小部分方法，比不使用任何方法得到更大收益。但您只能在实现所有方法的情况下获得最大收益，因为它们的力量来自它们之间的交互。

最初时按照书籍来执行 XP，作为基准。一旦理解了如何进行交互，就拥有了将它们适应于自身环境所需的知识。请记住，“进行 XP”不是目的，而是到达终点的一种手段。目标是快速地开发高级软件。如果您的过程有一些变异，已称不上是在进行 XP，但结果仍能让您战胜所有竞争对手，您已经成功了。

回页首

为什么 XP 很重要

坦率地说，XP（或者任何其它灵活方法）根本就不重要。它能够产生的 结果 才是关键。如果如 XP 这样的灵活方式可以帮助您更快地开发更好的软件而少受痛苦，那么它值得考虑。

还记得我们在这篇文章开始时提到的那些令人生畏的数字吗？我们相信使用 XP 开发面向对象软件可以有机会将它们变得更好。目前我们的经验已经证实了这一信念。

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文.
  
  
• 在 RoleModel Software 的 XP Portal 中了解有关 XP 的详细信息。
  
  
• 可以在 Alistair Cockburn 和 Laurie Williams (XP2000 submission, 2000) 所著的 The Costs and Benefits of Pair Programming 中了解到有关成对编程所具有的经济方面的意义。
  
  
• 在 Pairprogramming.com 上可以知道成对编程的常规详细信息。
  
  
• 下载 xUnit 测试工具。
  
  
• 如果您希望了解有关 XP 的详细信息，请务必选取一本本书中引用的书籍：
  • Planning Extreme Programming ，由 Kent Beck 和 Martin Fowler 著 (Addison-Wesley, 2000)
  • Extreme Programming Explained: Embrace Change ，由 Kent Beck 著 (Addison-Wesley, 1999)
  • Leading the Revolution 由 Gary Hamel 著 (Harvard Business School, 2000)
  
  
• Jeff Canna 有关 单元和功能测试 的文章（developerWorks，2001 年 3 月）将 XP 哲学用在测试上。
  

作者简介

		Roy W. Miller 是 RoleModel Software, Inc 的软件开发人员。在 RoleModel 期间，Roy 开发了基于 Java/XML 的自动验收测试框架，并为 Dallas Semiconductor 的 TINI Java 平台创建了几个应用的原型。在加盟 RoleModel 之前，他在 Andersen Consulting（现在是 Accenture）中服务了六年，用过他们的专用重量型商业集成方法 (MIB) 及其变体。自从加盟 RoleModel 后，他获得了许多有关 XP 以及对该方法的本地适应的经验。Roy 与他人合著了 Addison-Wesley XP 系列中的一本书（ XP Applied ，将于 2001 年 10 月出版），并是在 XP2001 "Business of XP" 展示会上的一名特邀专题讨论小组成员。可以通过 rmiller@rolemodelsoft.com 与 Roy 联系。

		Christopher T. Collins 是 RoleModel Software, Inc 的高级软件开发人员。在 RoleModel 期间，Chris 参与了运行将近两年的一个 XP 项目，为新的摩托罗拉蜂窝式电话平台开发了一个嵌入式 Java 应用程序，并将 JUnit 移植到 Sun 的 J2ME 平台上运行。在加盟 RoleModel 之前，他花了 5 年的时间使用许多不同的语言为一些组织开发软件，最近的一次是为美国国防部开发应用程序。他拥有使用和适应涉及几种灵活和重量型的不同开发方法的经验，包括 RUP 和 XP。Chris 拥有美国西佛罗里达大学计算机科学和软件工程的硕士学位，目前在北卡罗来纳州立大学教授 Java 编程课程。他曾是杜克大学有关 XP 的特邀演讲人，并将在 XP2001 上介绍有关过程适应的论文。通过 ccollins@rolemodelsoft.com 与 Chris 联系。

2000 年 11 月 01 日

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

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

什么是 JAXP？

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

回页首

API 还是抽象？

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

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

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

回页首

Sun 的 JAXP 和 Sun 的语法分析器

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

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

回页首

旧和新

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

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

回页首

从 SAX 开始

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

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

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

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

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

SAX 语法分析器一瞥

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

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

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

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

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

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

使用 SAX 语法分析器

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

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

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

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

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

回页首

处理 DOM

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

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

DOM 语法分析器类厂一瞥

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

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

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

使用 DOM 语法分析器

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

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

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

回页首

更改语法分析器

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

回页首

结束语

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

参考资料

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

关于作者

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

    1）DOM（JAXP Crimson解析器）

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

    2）SAX

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    2…… 比较

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

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

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