相对路径：相对与某个基准目录的路径。包含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 

 简介：

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

    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流被读入时，会有部分文档暂时隐藏在内存中）。

时间：2006-10-25 作者：Srini Penchikala 浏览次数： 5760 本文关键字：JDO, JDBC, SQLJ, Java, Srini Penchikala, jdbc, mustang, java se 6, RowID, driver, annotation, 驱动程序, 注释

文章工具  推荐给朋友  打印文章

　　 Java Platform, Standard Edition（Java SE）版本6（代码名称Mustang）现在已经推出了第二个beta版本，并计划于今年十月份交付使用。Java SE 6包括几处对Java Database Connectivity （JDBC）API的增强。这些增强将被发布为JDBC 4.0版本。新JDBC功能的主要目标是提供更为简单的设计方式和更好的开发人员体验。本文概要说明了JDBC 4.0增强，以及它们给企业Java开发人员带来的好处。我们将借助一个使用Apache Derby作为后端数据库而构建的贷款处理示例应用程序，对新的JDBC功能进行探讨。

Java SE 6.0

　　Java SE 6.0版本的主要目标是提供兼容性、稳定性和高质量。这个版本中有几处有趣的增强，尤其是在监控与管理（JMX）、Web service、脚本语言支持（使用Rhino脚本引擎JSR 223将JavaScript技术与Java源代码集成在一起）、数据库连接性、注释支持和安全性方面。JDBC API中还增加了几个新功能，从新的RowId支持到更多的SQLException子类。

JDBC 4.0功能

　　借助Mustang中包含的Java SE Service Provider机制，Java开发人员不再需要使用像Class.forName()这样的代码显式地加载JDBC驱动程序，就能注册JDBC驱动程序。通过在调用DriverManager.getConnection()方法时自动定位合适的驱动程序，DriverManager类可以做到这一点。这个功能是向后兼容的，所以无需修改现有的JDBC代码。

　　 在访问关系数据库的Java应用程序中，通过最小化我们需要编写的“模板”代码，JDBC 4.0还改善了开发人员体验。它还提供实用程序类，以改进JDBC驱动程序的注册和卸载机制，以及管理数据源和连接对象。

　　 借助JDBC 4.0，Java开发人员现在可以使用Annotations指定SQL查询，从而利用Java SE 5.0（Tiger）版本中提供的元数据支持。基于注释的SQL查询允许在Java代码中使用Annotation关键字指定SQL查询字符串。这样，我们就不必在两个不同文件中查看JDBC代码以及这些代码中调用的数据库查询了。例如，如果有一个叫做getActiveLoans()的方法，用于获取贷款处理数据库中的当前贷款，可以使用@Query(sql="SELECT * FROM LoanApplicationDetails WHERE LoanStatus = 'A'")注释来修饰它。

　　 此外，Java SE 6开发工具包（JDK 6）的最后版本——与运行时环境（JRE 6）相反——将会有一个基于与它绑定在一起的Apache Derby的数据库。这将帮助开发人员理解新的JDBC功能，而不必单独下载、安装和配置数据库产品。

　　 JDBC 4.0中加入的主要功能包括：

• 自动加载JDBC驱动程序类。
• 连接管理增强。
• 支持RowId SQL 类型。
• 使用Annotations的DataSet SQL实现。
• 处理增强的SQL异常。
• 支持SQL XML。

　　还存在其他功能，比如对大对象（BLOB/CLOB）的改进支持和National Character Set Support。接下来的内容将会详细分析这些功能。

自动加载JDBC驱动程序

　　在JDBC 4.0中，调用getConnection方法时，不再需要使用Class.forName()显式地加载JDBC驱动程序，因为DriverManager将会试着从初始化时加载的以及使用与当前应用程序相同的类加载器显式加载的JDBC驱动程序中，找出合适的驱动程序来。

　　 DriverManager方法getConnection和getDrivers已经增强为支持Java SE Service Provider机制（SPM）。根据SPM，服务被定义为一组众所周知的接口和抽象类，而服务提供程序则是服务的特定实现。它还指定在META-INF/services目录中保存服务提供程序配置文件。JDBC 4.0驱动程序必须包含文件META-INF/services/java.sql.Driver。这个文件包含JDBC驱动程序的java.sql.Driver实现的名称。例如，要加载JDBC驱动程序以连接到Apache Derby数据库，META-INF/services/java.sql.Driver文件就要包含以下项：

　　 org.apache.derby.jdbc.EmbeddedDriver

　　 让我们尽快了解如何使用这项新功能加载JDBC驱动程序管理器。下面的列表显示了加载JDBC驱动程序通常使用的示例代码。我们假定需要连接到一个Apache Derby数据库，因为我们在文章后面提到的示例应用程序中将使用这个数据库：

 Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
Connection conn

=DriverManager.getConnection(jdbcUrl, jdbcUser, jdbcPassword);

　　但是在JDBC 4.0中，我们不需要Class.forName()这一行。我们只要调用getConnection()就可以获得数据库连接。

　　 注意，这仅适用于在单机模式中获得数据库连接。如果使用某种数据库连接池来管理连接，代码将会有所区别。

连接管理

　　在JDBC 4.0之前，我们依赖于JDBC URL来定义数据源连接。现在有了JDBC 4.0，我们只要提供一组参数（比如主机名称和端口号）给标准的连接工厂机制，就能获得到任意数据源的连接。Connection和Statement接口中加入了新的方法，以便在管理池环境中的Statement对象时可以支持连接状态跟踪改进和更大的灵活性。元数据工具（JSR-175）用于管理活动连接。我们还可以获得元数据信息，比如活动连接的状态，还可以把连接指定为标准的（Connection，用于单机应用程序）、池化的（PooledConnection）或者甚至是用于XA事务的分布式连接（XAConnection）。注意，我们没有直接使用XAConnection。它是由诸如WebLogic、WebSphere或JBoss这样的Java EE应用服务器内部的事务管理器来使用的。

RowId支持

　　RowID接口被添加到JDBC 4.0中以支持ROWID数据类型，Oracle和DB2等数据库也支持这种数据类型。当有多条记录没有惟一标识符列，而且需要在不允许复制的Collection（比如Hashtable）中保存查询输出时，RowId很有用。我们可以使用ResultSet的getRowId()方法来获得RowId，并使用PreparedStatement的setRowId()方法在查询中使用RowId。

　　 关于RowId对象要记住的一件重要事情是，分别在PreparedStatement和ResultSet中使用set或update方法时，RowId对象的值无法在数据源之间移植，可以认为它是特定于数据源的。所以，禁止在不同的Connection和ResultSet对象之间共享它。

　　 DatabaseMetaData中的getRowIdLifetime()方法可用于确定RowId对象的生存期有效性。表1中列出了返回值或行id可能取的值。

基于注释的SQL查询

　　JDBC 4.0规范利用注释（Java SE 5中加入）允许开发人员把SQL查询与Java类关联在一起，同时不用编写大量的代码。此外，通过使用Generics（JSR 014）和元数据（JSR 175）API，我们可以把SQL查询与Java对象关联在一起，从而指定查询输入和输出参数。我们还可以把查询结果绑定到Java类，以加速对查询输出的处理。我们无需编写通常用于把查询结果填充到Java对象中的所有代码。在Java代码中指定SQL查询时，有2种主要的注释：Select和Update。

Select注释

　　Select注释用于在Java类中指定选择查询，以便使用get方法从数据库表中获取数据。表2显示了Select注释的各种属性以及它们的用法。

　　下面是Select注释的一个例子，用于从贷款数据库获得所有当前贷款：

interface LoanAppDetailsQuery extends BaseQuery {
@Select("SELECT * FROM LoanDetais where LoanStatus = 'A'")
DataSet<LoanApplication> getAllActiveLoans();
}

　　sql注释也支持I/O参数（参数标记由一个问号后面跟一个整数来表示）。下面是参数化sql查询的一个例子：

interface LoanAppDetailsQuery extends BaseQuery {
@Select(sql="SELECT * from LoanDetails
where borrowerFirstName= 1 and borrowerLastName= 2")
DataSet<LoanApplication> getLoanDetailsByBorrowerName(String borrFirstName,
String borrLastName);
}

Update注释

　　Update注释用于修饰Query接口方法，用于更新数据库表中的一条或多条记录。每个Update注释都必须包含一个sql注释类型的元素。下面是Update注释的一个例子：

interface LoanAppDetailsQuery extends BaseQuery {
@Update(sql="update LoanDetails set LoanStatus = 1
where loanId = 2")
boolean updateLoanStatus(String loanStatus, int loanId);
}

处理增强的SQL异常

　　异常处理是Java编程的一个重要组成部分，特别是当连接到后端关系数据库或在后端关系数据库上运行查询的时候。我们一直使用SQLException类来指示与数据库相关的错误。JDBC 4.0在SQLException处理方面有几处增强。下面是JDBC 4.0版本中的一些增强，在处理SQLExceptions时它们可以为开发人员带来更好的体验：

• 新的SQLException子类
• 支持因果关系
• 支持增强的for-each循环

新的SQLException类

　　JDBC 4.0中创建了SQLException的新子类，以便为Java程序员提供一种编写更多可移植错误处理代码的手段。JDBC 4.0中引入了2类新的SQLException：

• SQL非瞬时异常
• SQL瞬时异常

　　非瞬时异常：同一项操作重试失败时抛出此异常，直到SQLException的原因得到纠正为止。表3显示了JDBC 4.0中加入的新异常类，它们都是SQLNonTransientException的子类（SQLState类值定义在SQL 2003规范中。）：

　　瞬时异常：当操作在没有任何应用程序级功能进行干涉的情况下重试，前面失败的JDBC操作能够成功时抛出此异常。表4中列出了对SQLTransientException进行扩展的新异常。

因果关系

　　现在，SQLException类支持配备有异常机制（也称为Cause工具）的Java SE，这种机制让我们能够处理JDBC操作中抛出的多种异常（如果后端数据库支持多异常功能）。这种场景发生在执行一条可能抛出多个SQLException的语句时。

　　 我们可以使用SQLException中的getNextException()方法，通过异常链进行迭代。下面给出一些用于处理SQLException因果关系的示例代码：

catch(SQLException ex) {
while(ex != null) {
LOG.error("SQL State:" + ex.getSQLState());
LOG.error("Error Code:" + ex.getErrorCode());
LOG.error("Message:" + ex.getMessage());
Throwable t = ex.getCause();
while(t != null) {
LOG.error("Cause:" + t);
t = t.getCause();
}
ex = ex.getNextException();
}
}

增强的For-Each循环

　　SQLException类实现了Iterable接口，为Java SE 5中加入的for-each循环功能提供支持。循环的导航将遍历SQLException及其原因。下面给出一个代码片段，对SQLException中加入的for-each循环进行了说明。

catch(SQLException ex) {
for(Throwable e : ex ) {
LOG.error("Error occurred: " + e);
}
}

对国家字符集转换的支持

　　下面列出了处理国家字符集（National Character Set）时JDBC类中所做的增强：

• JDBC数据类型：加入了新的JDBC数据类型，比如NCHAR、NVARCHAR、LONGNVARCHAR和NCLOB。
• PreparedStatement：加入了新方法setNString、setNCharacterStream和setNClob。
• CallableStatement：加入了新方法getNClob、getNString和getNCharacterStream。
• ResultSet：接口加入了新方法updateNClob、updateNString和updateNCharacterStream。

对大对象（BLOB和CLOB）的增强支持

　　下面列出了JDBC 4.0中对处理LOB所做的增强：

• Connection：加入了新方法（createBlob()、createClob()和createNClob()）以创建BLOB、CLOB和NCLOB对象的新实例。
• PreparedStatement：加入了新方法setBlob()、setClob()和setNClob()，以便使用InputStream对象插入BLOB对象，以及使用Reader对象插入CLOB和NCLOB对象。
• LOB：Blob、Clob和NClob接口中加入了新方法（free()），以便释放这些对象占用的资源。

　　现在，让我们看一看java.sql和javax.jdbc包中加入的一些新类，以及它们提供了哪些服务。

JDBC 4.0 API：新类

RowId (java.sql)

　　正如前面提过的那样，这个接口代表着数据库中的一个SQL ROWID值。ROWID是一个内置的SQL数据类型，用于识别数据库表中的特定数据行。ROWID通常用在这样的查询中：该查询从输出行没有惟一ID列的表中返回行。

　　 CallableStatement、PreparedStatement和ResultSet接口中的方法，比如getRowId和setRowId，允许程序员访问SQL ROWID值。接口还提供一个方法（叫做getBytes()）把ROWID的值返回为字节数组。DatabaseMetaData接口有一个叫做getRowIdLifetime的新方法，可用于确定RowId对象的生存期。RowId的作用域可以是下列3种类型之一：

• 在其中创建RowId的数据库事务的持续时间。
• 在其中创建RowId的会话的持续时间。
• 数据库表中的标识行，只要它尚未被删除。

DataSet (java.sql)

　　DataSet接口为从执行SQL查询返回的数据提供类型安全的视图。DataSet可以在已连接或未连接模式中进行操作。当在已连接模式中使用时，其功能类似于ResultSet。而在未连接模式中使用时，DataSet的功能则类似于CachedRowSet。因为DataSet扩展了List接口，我们可以遍历查询返回的行。

　　 现有的类中还加入了几个新方法，比如Connection（createSQLXML、isValid）和ResultSet（getRowId）。

示例应用程序

　　本文中使用的示例应用程序是一个贷款处理应用程序，它包含一个贷款查找页面，用户可以在这个页面上输入一个贷款ID以获得有关贷款的详细信息，然后提交表单。贷款查找页面调用一个控制器对象，而此控制器对象又调用DAO对象来访问后端数据库，从而获得有关贷款的详细信息。这些详细信息包括借款人姓名、贷款金额和贷款到期时间，它们均会显示在一个贷款详细信息页面上。在后端数据库中，我们使用一个叫做LoanApplicationDetails的表来保存贷款应用程序的详细信息。

　　 示例应用程序的用例是获得特定贷款ID的贷款详细信息。在注册贷款并针对抵押产品和利率锁定它之后，就可以获得这些贷款详细信息了。贷款处理应用程序的项目细节如表5所示。

　　下表列出了连接贷款详细信息Apache Derby数据库时需要用到的JDBC参数。这些参数都保存在一个叫做derby.properties的文本文件中，该文件位于项目基目录下的etc/jdbc目录中（参见表6）。

　　注意：Apache Derby数据库提供2类JDBC驱动程序：Embedded Driver（org.apache.derby.jdbc.EmbeddedDriver）和Client/Server Driver（org.apache.derby.jdbc.ClientDriver）。在示例应用程序中我使用的是Client/Server Driver版本。

　　 下面给出用于启动Derby数据库服务器和使用ij工具创建新数据库的命令。

　　 要启动Derby Network Server，打开一个命令提示，然后运行以下命令（修改DERBY_INSTALL和JAVA_HOME环境变量，从而影响本地环境）。

set DERBY_INSTALL=C:\dev\dbservers\db-derby-10.1.2.1-bin
set JAVA_HOME=C:\dev\java\jdk1.6.0
set DERBY_INSTALL=C:\dev\dbservers\db-derby-10.1.3.1-bin
set CLASSPATH=%CLASSPATH%;%DERBY_INSTALL%\lib\derby.jar;
%DERBY_INSTALL%\lib\derbytools.jar;
%DERBY_INSTALL%\lib\derbynet.jar;
cd %DERBY_INSTALL%\frameworks\ NetworkServer\bin
startNetworkServer.bat

　　要连接到数据库服务器和创建测试数据库，打开另一个命令提示，然后运行以下命令。确保修改了DERBY_INSTALL和JAVA_HOME环境变量，以适应环境。

set JAVA_HOME=C:\dev\java\jdk1.6.0
set DERBY_INSTALL=C:\dev\dbservers\db-derby-10.1.3.1-bin
set CLASSPATH=%DERBY_INSTALL%\lib\derbyclient.jar;
%DERBY_INSTALL%\lib\derbytools.jar;.
%JAVA_HOME%\bin\java org.apache.derby.tools.ij
connect 'jdbc:derby://localhost:1527/LoanDB;create=true';

测试

　　用于编译Java源代码的classpath设置应该包含位于项目主目录下lib目录中的derby.jar和junit4.jar文件。我们还需要在classpath中包含etc、etc/jdbc和etc/log4j目录，这样应用程序就能访问JDBC属性和Log4J配置文件。我创建了一个Ant编译脚本（位于JdbcApp/build目录中），以自动化编译和打包Java代码的任务。

　　 用于测试贷款详细信息数据访问对象的测试类叫做LoanAppDetailsDAOTest。我们传入参数（比如贷款ID和借款人姓名）以获得贷款详细信息。

　　 下面的内容给出了一些代码示例，这些代码是关于JDBC 4.0规范的JDBC驱动程序自动加载和给予注释的SQL查询功能的。

自动加载JDBC驱动程序

　　BaseDAO抽象类有一个叫做getConnection的方法，用于获得一个数据库连接。下面的代码片段显示了这个方法（注意，我们不必注册JDBC驱动程序）。只要java.sql.Driver文件中存在正确的驱动程序名称（org.apache.derby.jdbc.ClientDriver），就可以自动加载JDBC驱动程序。

protected Connection getConnection() throws DAOException {
// Load JDBC properties first
if (jdbcUrl == null || jdbcUser == null ||
jdbcPassword == null) {
loadJdbcProperties();
}
// Get Connection
Connection conn = null;
try {
conn = DriverManager.getConnection(jdbcUrl, jdbcUser,
jdbcPassword);
} catch (SQLException sqle) {
throw new DAOException("Error in getting a DB connection.",
sqle);
}
return conn;
}

SQL注释

　　LoanAppDetailsQuery接口有带有注释的SQL查询，用于获得当前贷款（条件是loanstatus="A"）的列表和基于贷款人姓名的贷款详细信息（在一个贷款人借贷多笔款项的情况下）。我们在本文的前面部分曾见过这些SQL注释。下面给出的示例代码说明了如何调用使用Annotation定义的SQL查询。

public DataSet<LoanAppDetails> getAllActiveLoans() throws Exception {
// Get Connection
Connection conn = getConnection();
LoanAppDetailsQuery query = null;
DataSet<LoanAppDetails> loanDetails = null;
query = QueryObjectFactory.createQueryObject(
LoanAppDetailsQuery.class, conn);
loanDetails = query.getAllActiveLoans();
return loanDetails;
}

public DataSet<LoanAppDetails> getLoanDetailsByBorrowerName(
String borrFirstName, String borrLastName) throws Exception {
// Get Connection
Connection conn = getConnection();
LoanAppDetailsQuery query = null;
DataSet<LoanAppDetails> loanDetails = null;
query = QueryObjectFactory.createQueryObject(
LoanAppDetailsQuery.class, conn);
loanDetails = query.getLoanDetailsByBorrowerName(
borrFirstName,borrLastName);
return loanDetails;
}

结束语

　　在使用SQL时，JDBC 4.0可以提供开发的简便性并改善开发人员体验。JDBC 4.0的另一个目标是提供企业级的JDBC功能，把API公开给涵盖范围更广的工具集，以便更好地管理JDBC资源。此外，JDBC 4.0 API为JDBC驱动程序提供了一条迁移路径，从而与J2EE Connector架构（JCA）保持兼容。这使得JDBC厂商能够继续实现JDBC技术Connector API。当在企业级面向服务架构（Service Oriented Architecture，SOA）应用程序中使用JDBC数据源时，这一点很重要，因为在企业级SOA应用程序中，可以把JDBC数据源部署为企业服务总线（Enterprise Service Bus，ESB）架构中的另一个适配器，而不必为JDBC数据源编写ESB特定实现代码。

　　 在本文中，我们讨论了JDBC 4.0中的增强，比如RowId支持、JDBC驱动程序加载和基于Annotations的SQL。JDBC 4.0中还将加入其他功能，以便在未来支持SQL 2003规范。要了解有关JDBC 4.0规范的更多信息，请参考规范文档。

参考资料

• 示例应用程序代码
• Java SE 6主页
• Java SE 6参考实现（Mustang）Web站点
• Java SE 6下载页面
• API规范
• Apache Derby主页
• Tomcat 5.5主页

=====================================================================

JAVA语言是1995年5月由SUN公司发布的，由于其安全性高、代码优化、跨平台等特性，迅速取代了很多传统高级语言，占据了企业级网络应用开发等诸多领域的霸主地位。

不过，JAVA最突出的跨平台优势使得它不能被编译成本地代码，而要以中间代码的形式运行在虚拟机环境中，这使得JAVA的反编译要比别的高级语言容易实现，并且反编译的代码经过优化后几乎可以与源代码相媲美。

为了更好地保护知识产权，避免本公司的智力成果轻易被人窃取，开发者有必要对反编译工具深入了解，以便有针对性地采取保护措施。

目前，比较流行的JAVA反编译工具超过30种，其中有三款堪称精品：

一、         应用广泛的JAD

在众多的JAVA反编译工具中，有几种非常著名的工具使用了相同的核心引擎——JAD，其中主要包括：Front End Plus、mDeJava、Decafe Pro、Cavaj Java Decompiler、DJ Java Decompiler、NMI’s Java Class Viewer和国产的JAVA源代码反编译专家等等。

JAD本身是一个命令行工具，没有图形界面，上述的这些工具大多是在JAD内核的基础之上加了一个图形界面而已。这么多种产品的共同选择，足可证明JAD在JAVA反编译领域中的尊贵地位。

笔者用来测试的JAD版本是1.5.8f。

JAD是使用Microsoft Visual C++开发的，运行速度非常快，可以处理很复杂的JAVA编译文件。众多的参数使JAD可以灵活应付多种加密手段，令反编译的代码更加优化和易读。由于JAD参数太多，没必要一一解释，其中有几个最常用的如下：

         -d

Java的线程调度操作在运行时是与平台无关的。一个多任务系统需要在任务之间实现QoS(Quality of Service)管理时，如果CPU资源的分配基于Java线程的优先级，那么它在不同平台上运行时的效果是很难预测的。本文利用协调式多任务模型，提出一个与平台无关、并且能在任务间动态分配CPU资源的方案。
　　现在，由于计算机系统已经从人机交互逐步向机机交互转化，计算机和计算机之间的业务对于时间的要求非常高。软件系统对于业务的支持已经不仅表现为对不同业务的逻辑和数据(算法+数据结构)支持，而且还表现为对同时处理不同任务的时效性(任务响应速度)支持。一般，任务响应的速度可以通过算法优化及并行运算分担负载等手段来提高。但是，用户业务逻辑的复杂度决定了算法优化的发挥空间，硬件规模决定了所能够承担负载的大小。我们利用Java平台的特点，借鉴协调式多任务思想，使CPU资源能够在任务间动态分配，从而为时间要求强的任务分配更多的CPU运行资源。这也可以充分利用现有硬件，为用户业务提供最大的保障。

　　用Java解决问题

　　本着软件系统结构和现实系统结构一致的思想，开发复杂业务服务的程序一般按照计算机任务和现实业务对应的思路，最终形成一个大规模的多任务系统。由于其跨平台性，Java系统可以随着业务的扩大，平滑地升级到各种硬件平台上。由于Java自身的发展及其应用场合的不断扩大，用它实现多任务系统已经成为当前的应用方向。在J2EE(Java2 Enterprise Edition)推出以后，Sun公司已经将Java的重心放在了服务器端(Server Side)系统的构造上。由于客户/服务器模型固有的多对一的关系，服务器端程序也必然是一个多任务系统。

　　在Java多任务应用中，动态地将CPU资源在任务间分配有很重要的意义。比如一个Inte.Net服务商的系统往往有多种任务同时运行，有HTTP、FTP、MAIL等协议的支持，也有商务、娱乐、生活、咨询等业务的服务。在白天，网站希望系统的CPU资源尽量保障网上用户的服务质量，提高电子商务等任务的响应速度;晚上则希望让自己的娱乐服务和资料下载尽可能满足下班后人们的需要。另外，在新兴的网管(比如TMN， Telecommunication Management.Network)等应用领域中，服务程序往往需要支持成千上万个并发响应事件的被管理对象(MO，Managed Object)。对于被管理对象执行的操作，不同用户在不同时刻往往有不同的时间要求。

　　方案选择

　　在考虑动态分配CPU资源的实施方案时，往往有以下两点要求：

　　1. 须充分利用现有硬件资源，在系统空闲时，让低优先级任务也能够得到系统所能给予的最快响应。

　　2.当硬件资源超负荷运行时，虽然系统中有大规模、多数量的任务不能处理，但它不应受影响，而能够顺利处理那些能够被处理的、最重要的高优先级任务。

　　多任务系统要用多线程实现的最简单方法就是将线程和任务一一对应，动态调整线程的优先级，利用线程调度来完成CPU资源在不同任务间动态分配。这种思路在以前使用本地化代码(Native Code)，充分利用特定硬件和操作系统技巧的基础上是基本可行的。但在跨平台的Java环境中，这个思路对仅有小规模任务数的简单系统才可行，原因有以下两点：

　　1. Java的线程虽然在编程角度(API)是与平台无关的，但它的运行效果却和不同操作系统平台密切相关。为了利用更多的CPU资源，Java中的一个线程(Thread)就对应着不同操作系统下的一个真实线程。因为Java虚拟机没有实现线程的调度，所以这些Java的线程在不同操作系统调度下运行的差异性也就比较明显。例如在Windows系统中，不仅线程的优先级少于Java API参数规定的十个优先级，而且微软明确反对程序员动态调整线程优先级。即使在操作系统中有足够的优先权，让线程优先级的参数和真实线程的优先级对应，不同操作系统的调度方式也会有许多不同。这最终会造成代码在不同平台上的行为变得不可预测。这就很难满足复杂的、大规模并发任务的众多优先级需求，从而很难达到用户业务需要达到的效果。

　　2. 由于在Java系统中，线程被包装在一个Java语言的对象类—Thread中，所以为了完成Java语言对象和操作系统线程的对应，Java线程的系统开销还是比较大的(在NT 4.0中，平均每个线程大致占用30KB内存)。因此如果让Thread对象个数和成千上万的任务数同比例增长，就显然是不合理的。

　　综上所述，根据并发多任务的大规模需求和Java平台固有的特点，想要利用Java Thread对象的优先级调整CPU资源的分配是非常困难的，所以应该尽量避免让线程和任务直接对应，也尽量避免使用操作系统线程优先级的调度机制。

　　解决方案

　　根据以上分析，问题的症结在于：多任务系统中的任务在Java语言中的对应以及任务间的相互调度。

　　从本质上看，一个任务就是一系列对象方法的调用序列，与Java的Thread对象或者别的类的对象没有必然联系。在避免使用不同操作系统线程调度且同时Java虚拟机又没有线程调度能力的情况下，要想构造一个协调式多任务系统，让各个任务相互配合就成了最直接的思路。协调式多任务系统一般有以下特点：

　　1. 任务由消息驱动，消息的响应代码完成任务逻辑的处理;

　　2. 消息队列完成消息的存储和管理，从而利用消息处理的次序体现任务优先级的不同;

　　3. 任务中耗时的消息响应逻辑能够主动放弃CPU资源，让别的任务执行(像Windows 3.1中的Yield函数、Visual Basic中的DoEvents语句)。

　　可能出于巧合，Java语言具有构造协调式多任务系统天然的条件。Java对象的方法不仅是一个函数调用，它还是一个Java.lang.reflect.Method类的对象。而所有对象的方法都可以通过Method类的invoke方法调用。如果能使每个任务所对应的一系列方法全部以对象形式包装成消息，放到消息队列中，然后再按照自己的优先级算法将队列中的消息取出，执行其Method对象的invoke调用，那么一个基本的协调式多任务系统就形成了。其中，任务的优先级和线程的优先级没有绑定关系。该系统的主体调度函数可以设置成一个“死循环”，按照需要的优先级算法处理消息队列。对于有多重循环、外设等待等耗时操作的消息响应函数，可以在响应函数内部递归调用主体调度函数,这一次调用把原来的“死循环”改成在消息队列长度减少到一定程度(或者为空)后退出。退出后，函数返回，执行刚才没有完成的消息响应逻辑，这样就非常自然地实现了协调式系统中任务主动放弃CPU资源的要求。

　　如果仅仅做到这一步，完成一个像Windows 3.1中的多任务系统，实际只用了一个线程，没有利用Java多线程的特点。应该注意到，虽然Java系统中线程调度与平台相关，但是相同优先级的线程之间分时运行的特点基本上是不受特定平台影响的。各个相同优先级的线程共享CPU资源，而线程又被映射成了Java语言中的Thread对象。这些对象就可以被认为是CPU资源的代表。Thread与线程执行代码主体的接口—Runnable之间是多对一的关系。一个Runnable可以被多个Thread执行。只要将Runnable的执行代码设置成上述的消息调度函数，并和消息队列对应上，那么就可以通过控制为它服务的Thread个数来决定消息队列执行的快慢，并且在运行时可以动态地新增(new)和退出Thread对象。这样就能任意调整不同消息队列在执行时所占用CPU资源的多少。至此，任何一个Java调用都可以在Thread个数不同的消息队列中选择，并可以调整这些消息队列服务的Thread个数，从而实现在运行时调整任务所占用的CPU资源。

　　纵观整个方案，由于仅仅基于Java语言固有的Method对象，不同任务间动态分配CPU资源并没有对任务的性质及其处理流程有任何限制，那么在消息队列中没有高优先级消息时，低优先级消息的处理函数自然会全部占用CPU资源。在不同消息队列处理速度任意设置时，并没有将特定的消息限制在快的或者慢的消息队列上。如果系统的负荷超出(比如消息队列长度超过一定限制)，只要将队列中低优先级消息换出或者拒绝不能处理的消息进入，那么系统的运行就可以基本上不受负荷压力的影响，从而最大保障用户的关键业务需求。

　　当然，协调式多任务的思想也有其局限性，主要就是它的调度粒度比较大。系统能够保证的粒度是一次消息处理过程。如果消息处理逻辑非常费时，那么编程人员就必须再处理函数内部，让系统主动让出CPU资源。这虽然需要在处理消息响应逻辑时增加一个考虑因素，但是，在Windows系统盛行的今天，这是一个已经被普遍接受的思路。由于方案中并没有局限为消息队列服务的线程数目，所以一个长时间的消息响应只会影响一个线程，而不会对整个系统产生致命的影响。除了调度粒度的问题以外，还有访问消息队列操作在各个线程间互斥的问题。取出消息的过程是串行化的，因此对于这一瓶颈的解决方案就是：假设取出一条消息的操作相对于处理消息的消耗可以忽略不计，那么对于多次调用且仅有两三行响应逻辑的消息，编程人员通过函数调用就可以直接执行。

　　前面比较详细地阐述了多任务系统中任务的划分以及执行等内容。虽然这些是一个系统的核心，但是在一个实用的系统中，还需要任务间的同步、互斥等机制。在上述框架内，互斥可以简单地用Java的Synchronized机制实现。由于任务可以主动让出执行权限，要实现等待(Wait任务中止)和通知(Notify任务继续)，从而实现任务同步也就比较容易了。