对于Java由于默认的编码方式是 UNICODE,所以用中文也易出问题,常见的解决是
String s2 = new String(s1.getBytes(“ISO-8859-1”),”GBK”);


1、utf8解决JSP中文乱码问题
一般说来在每个页面的开始处，加入：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%
 request.setCharacterEncoding("UTF-8");
%>

charset=UTF-8  的作用是指定JSP向客户端输出的编码方式为“UTF-8”

pageEncoding="UTF-8"  为了让JSP引擎能正确地解码含有中文字符的JSP页面，这在LINUX中很有效

 request.setCharacterEncoding("UTF-8"); 是对请求进行了中文编码

有时，这样仍不能解决问题，还需要这样处理一下：

String msg = request.getParameter("message");
 String str=new String(msg.getBytes("ISO-8859-1"),"UTF-8");
 out.println(st);

2、Tomcat 5.5 中文乱码

)只要把%TOMCAT安装目录%/   webapps\servlets-examples\WEB-INF\classes\filters\SetCharacterEncodingFilter.class文件拷到你的webapp目录/filters下，如果没有filters目录，就创建一个。  
  2)在你的web.xml里加入如下几行：   <filter>  
  <filter-name>Set   Character   Encoding</filter-name>  
  <filter-class>filters.SetCharacterEncodingFilter</filter-class>  
  <init-param>  
  <param-name>encoding</param-name>  
  <param-value>GBK</param-value>  
  </init-param>  
  </filter>  
      <filter-mapping>  
  <filter-name>Set   Character   Encoding</filter-name>  
  <url-pattern>/*</url-pattern>  
  </filter-mapping>  
   
   
   
  3)完成.  
  2   get方式的解决办法  
  1)   打开tomcat的server.xml文件，找到区块，加入如下一行：  
  URIEncoding=”GBK”  
  完整的应如下：  
  <Connector    
  port="80"   maxThreads="150"   minSpareThreads="25"   maxSpareThreads="75"  
  enableLookups="false"   redirectPort="8443"   acceptCount="100"  
  debug="0"   connectionTimeout="20000"    
  disableUploadTimeout="true"    
  URIEncoding="GBK"  
  />     
   
  2)重启tomcat,一切OK。

3、xmlHttpRequest中文问题

页面jsp用的GBK编码

代码
<%@ page contentType="text/html; charset=GBK"%> 

javascript部分

代码
function addFracasReport() {  
    var url="controler?actionId=0_06_03_01&actionFlag=0010";  
    var urlmsg="&reportId="+fracasReport1.textReportId.value;  //故障报告表编号  
          
    var xmlHttp=Common.createXMLHttpRequest();  
    xmlHttp.onreadystatechange = Common.getReadyStateHandler(xmlHttp, eval("turnAnalyPage"));  
    xmlHttp.open("POST",url,true);  
    xmlHttp.setRequestHeader( " Content-Type " , " application/x-www-form-urlencoded);  
    xmlHttp.send(urlmsg);  
      
} 

后台java中获得的reportId是乱码，不知道该怎么转，主要是不知道xmlHttp.send(urlmsg);以后是什么编码？在后面用java来转，试了几种，都没有成功，其中有：

代码
public static String UTF_8ToGBK(String str) {  
        try {  
            return new String(str.getBytes("UTF-8"), "GBK");  
        } catch (Exception ex) {  
            return null;  
        }  
    }  
      
    public static String UTF8ToGBK(String str) {  
        try {  
            return new String(str.getBytes("UTF-16BE"), "GBK");  
        } catch (Exception ex) {  
            return null;  
        }  
    }  
      
    public static String GBK(String str) {  
        try {  
            return new String(str.getBytes("GBK"),"GBK");  
        } catch (Exception ex) {  
            return null;  
        }  
    }  
         public static String getStr(String str) {  
        try {  
            String temp_p = str;  
            String temp = new String(temp_p.getBytes("ISO8859_1"), "GBK");  
            temp = sqlStrchop(temp);  
            return temp;  
        } catch (Exception e) {  
            return null;  
        }  
    } 

4、JDBC ODBC Bridge的Bug及其解决方法

在编写一数据库管理程序时，发现JDBC-ODBC Bridge存在不易发现的Bug。在向数据表插入数据时，如果为英文字符，存储内容完全正确，如果存入中文字符，部分数据库只能存储前七八个中文字符，其他内容被截去，导致存储内容的不完整（有些数据库不存在这个问题，如Sybase SQL Anywhere 5.0。JDBC-ODBC Bridge还存在无法建表的Bug）。

　　对于广大需要存储中文信息的Java程序员来说，这可是一个不好的消息。要么改用其他语言编程，要么选择其他价格昂贵的数据库产品。“一次编写，到处运行”的目标，也大打折扣。能不能采用变通的方法，将中文信息进行处理后再存储来解决这个问题呢？答案是肯定的。

　　解决问题的具体思路、方法
　　Java采用Unicode码编码方式，中英文字符均采用16bit存储。既然存储英文信息是正确的，根据一定规则，将中文信息转换成英文信息后存储，自然不会出现截尾现象。读取信息时再进行逆向操作，将英文信息还原成中文信息即可。由GB2312编码规则可知，汉字一般为二个高位为1的ASCII码，在转换时将一个汉字的二个高位1去掉，还原时再将二个高位1加上。为了处理含有英文字符的中文字串，对英文字符则需要加上一个Byte 0标记。以下提供的两个公用静态方法，可加入任何一个类中使用。

　　将中英文字串转换成纯英文字串
　　public static String toTureAsciiStr(String str){

　　StringBuffer sb = new StringBuffer();

　　byte[] bt = str.getBytes();

　　for(int i =0 ;i〈bt.length;i++){

　　if(bt[i]〈0){

　　//是汉字去高位1

　　sb.append((char)(bt[i]&&0x7f));

　　 }else{//是英文字符 补0作记录

　　sb.append((char)0);

　　sb.append((char)bt[i]);

　　 }

　　 }

　　return sb.toString();

　　}

　　将经转换的字串还原
　　public static String unToTrueAsciiStr(String str){

　　 byte[] bt = str.getBytes();

　　 int i,l=0,length = bt.length,j=0;

　　 for(i = 0;i〈length;i++){

　　 if(bt[i] == 0){

　　 l++;

　　 }

　　 }

　　 byte []bt2 = new byte[length-l];

　　 for(i =0 ;i〈length;i++){

　　 if(bt[i] == 0){

　　 i++;

　　 bt2[j] = bt[i];

　　 }else{

　　 bt2[j] = (byte)(bt[i]|0x80);

　　 }

　　 j++;

　　 }

　　String tt = new String(bt2);

　　return tt;

　　}

　　上例在实际编程中效果很好，只是存储的中文信息需要经过同样处理，才能被其他系统使用。而且如果中文字串出现英文字符，实际上增加了额外的存储空间。

5、Solaris下Servlet编程的中文问题及解决办法
在使用Java开发Internet上的一个应用系统时，发现在Windows下调试完全正常的Servlet，上传到Solaris 服务器上，运行却出现故障——返回的网页不能显示中文，应为中文的信息全为乱码；用中文信息做关键字，不能正确检索数据库。后来采用加入检查代码等方法探知故障原因如下：

　　显示乱码主要是因为通过类 HttpServletResponse提供的方法setContentType 无法改变返回给客户的数据的编码方式，正确的编码方式应为GB2312或者GBK，而事实上为缺省的ISO8859-1。无法检索中文信息则是因为，客户提交的中文信息经浏览器编码到达服务器后，Servlet无法将其正确解码。

　　举例说明显示乱码解决方法
　　Servlet 一般通常做法如下：

　　public class ZldTestServlet extends HttpServlet {

　　public void doGet (HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException{

　　//在使用 Writer向浏览器返回数据前，设置 content-type header ，在这里设置相应的字符集gb2312

　　response.setContentType("text/html;charset=gb2312");

　　PrintWriter out = response.getWriter(); //*

　　// 正式返回数据

　　out.println("〈html〉〈head〉〈title〉Servlet test〈/title〉〈/head〉" );

　　out.println("这是一个测试页！");

　　out.println("〈/body〉〈/html〉");

　　out.close();

　　}

　　 ...

　　}

　　解决页面显示乱码问题，需将*处代码换成如下内容：

　　PrintWriter out = new PrintWriter(new OutputStreamWriter(response.getOutputStream(),"gb2312"));

　　Solaris中文信息检索问题的解决
　　浏览器利用表单向服务器提交信息时，一般采用x-www-form-urlencoded 的MIME格式对数据进行编码。如果使用get方法，参数名称和参数值经编码后附加在URL后，在Java中称作查询串（query string）。

　　在Servlet程序中，如果采用ServletRequest的方法getParameter取得参数值，在Solaris环境下，对汉字却不能正确解码。因而无法正确检索数据库。

　　在Java 1.2的包——java.net中提供了URLEncode和URLDecode类。类URLEncode提供了按x-www-form-urlencoded格式对给定串进行转换的方法。类URLEncode则提供了逆方法。

6、Common Mail乱码问题
common mail是一个小而方便的mail包，他实现了对Java Mail的封装，使用起来十分的方便，但是我在使用他的时候发现，使用纯文本的内容发送，结果是乱码，代码如下：
public class TestCommonMail {
public static void main(String[] args) throws EmailException, MessagingException {
SimpleEmail email = new SimpleEmail();
email.setCharset("GB2312");
email.setHostName("smtp.163.com");
email.setSubject("test");
email.addTo("test@163.com");
email.setFrom("test@163.com");
email.setMsg("我的测试");
email.setAuthentication("test", "test");
email.send();
}
}

分析了一下commons mail的源码找到了原因。源码如下:
public class SimpleEmail extends Email
{
public Email setMsg(String msg) throws EmailException, MessagingException
{
if (EmailUtils.isEmpty(msg))
{
throw new EmailException("Invalid message supplied");
}

setContent(msg, TEXT_PLAIN);
return this;
}
}

Email代码片段
public void setContent(Object aObject, String aContentType)
{
this.content = aObject;
if (EmailUtils.isEmpty(aContentType))
{
this.contentType = null;
}
else
{
// set the content type
this.contentType = aContentType;

// set the charset if the input was properly formed
String strMarker = "; charset=";
int charsetPos = aContentType.toLowerCase().indexOf(strMarker);
if (charsetPos != -1)
{
// find the next space (after the marker)
charsetPos += strMarker.length();
int intCharsetEnd =
aContentType.toLowerCase().indexOf(" ", charsetPos);

if (intCharsetEnd != -1)
{
this.charset =
aContentType.substring(charsetPos, intCharsetEnd);
}
else
{
this.charset = aContentType.substring(charsetPos);
}
}
}
}

email.send();的send方法将调用
public void buildMimeMessage() throws EmailException
{
try
{
this.getMailSession();
this.message = new MimeMessage(this.session);

if (EmailUtils.isNotEmpty(this.subject))
{
if (EmailUtils.isNotEmpty(this.charset))
{
this.message.setSubject(this.subject, this.charset);
}
else
{
this.message.setSubject(this.subject);
}
}

// ========================================================
// Start of replacement code
if (this.content != null)
{
this.message.setContent(this.content, this.contentType);
}
// end of replacement code
// ========================================================
else if (this.emailBody != null)
{
this.message.setContent(this.emailBody);
}
else
{
this.message.setContent("", Email.TEXT_PLAIN);
}

if (this.fromAddress != null)
{
this.message.setFrom(this.fromAddress);
}
else
{
throw new EmailException("Sender address required");
}

if (this.toList.size() + this.ccList.size() + this.bccList.size() == 0)
{
throw new EmailException(
"At least one receiver address required");
}

if (this.toList.size() > 0)
{
this.message.setRecipients(
Message.RecipientType.TO,
this.toInternetAddressArray(this.toList));
}

if (this.ccList.size() > 0)
{
this.message.setRecipients(
Message.RecipientType.CC,
this.toInternetAddressArray(this.ccList));
}

if (this.bccList.size() > 0)
{
this.message.setRecipients(
Message.RecipientType.BCC,
this.toInternetAddressArray(this.bccList));
}

if (this.replyList.size() > 0)
{
this.message.setReplyTo(
this.toInternetAddressArray(this.replyList));
}

if (this.headers.size() > 0)
{
Iterator iterHeaderKeys = this.headers.keySet().iterator();
while (iterHeaderKeys.hasNext())
{
String name = (String) iterHeaderKeys.next();
String value = (String) headers.get(name);
this.message.addHeader(name, value);
}
}

if (this.message.getSentDate() == null)
{
this.message.setSentDate(getSentDate());
}

if (this.popBeforeSmtp)
{
Store store = session.getStore("pop3");
store.connect(this.popHost, this.popUsername, this.popPassword);
}
}
catch (MessagingException me)
{
throw new EmailException(me);
}
}
由代码可以知道纯文本方式最终调用了Java Mail的
message.setContent(this.content, this.contentType);
content是内容
contentType是类型，如text/plain,
(我们可以试试直接用Java mail发邮件，设置文本内容不使用setText方法，也使用setContent("测试", "text/plain")方式，你可以看到内容也是乱码)
关键就在于text/plain，我们改成text/plain;charset=gb2312，ok乱码解决了。在commons mail我们看SimpleEmail 类中setMsg方法调用的就是 setContent(msg, TEXT_PLAIN);我们只需要将Email类中的常量TEXT_PLAIN修改一下加入 charset=你的字符集 ，重新打包jar，这样就可以了

7、toad的字符集的设置与oracle的安装
oracle数据库服务器的安装一般是中文字符集，有时安装在不同的平台下，设置为ISO编码，toad是oracle开发的最好工具，不是我说的，可是中文环境下安装的toad，打开英文字符的oracle时，中文全是乱码。必须进行设置

环境变量---〉系统变量
加
  NLS_lANG=SIMPLIFIED CHINESE_CHINA.ZHS16GBK
  或
  NLS_lANG=AMERICAN_AMERICA.WE8ISO8859P1

AMERICAN_AMERICA.WE8MSWIN1252
 
 或者

 打开注册表，点击HKEY_LOCAL_MATHINE
再点击Software,再点击ORACLE
在点击HOME（ORACLE所在目录）
在注册表的右半面有NLS_LANG,
双击它，将你想要的覆盖掉原来的就可以了
最好记下旧的，以便可以改回来。

connect sys/chang_on_install
update props$
set value$='ZHS16CGB231280'
where name='NLS_CHARACTERSET';
commit;
 这样就OK了

 
8、如何解決GWT(google web toolkit)中文的問題
GWT 中文乱码解决方法

1.把你要显示的中文“测试字符串”输入到一个文件，如:1.txt
2.进入命令行,进入1.txt所在的目录,敲入以下命令:native2ascii.exe 1.txt 2.txt 回车。这样就生成了另外一个文件2.txt。
3.2.txt的内容如下:\u6d4b\u8bd5\u5b57\u7b26\u4e32
4.然后用上面的编码，在gwt中使用，就可以了.

9、xmlHttp得到的网页怎么是乱码？
(1)在服务器端使用WebRequest而不是xmlHttp
(2) 将

StreamReader sr = new StreamReader(stream);

对于简体中文改成：

StreamReader sr = new StreamReader(stream , Encoding.Default );
对于utf-8改成：

StreamReader sr = new StreamReader(stream , Encoding.UTF8 );
当然，Encoding枚举还有很多其他的成员，对于不同的编码content-type可以有选择的应用

(3)后来我发现无论是content-type是gb2312还是utf-8,用

StreamReader sr = new StreamReader(stream , Encoding.Default );

都可以返回正常的汉字，所以统一的改成Encoding.Default

--------------------------------------------------------------------------------

最后，在服务器端从一个url获得网页的源代码的代码如下：

/// <summary>
/// post一个指定的url，获得网页的源代码(用WebRequest实现)
/// </summary>
/// <param name="url"></param>
/// <returns>
/// 如果请求失败，返回null
/// 如果请求成功，返回网页的源代码
/// </returns>
public static string GetContentFromUrl2( string url )
{
    //变量定义
    string respstr;

    WebRequest myWebRequest=WebRequest.Create(url);
    //            myWebRequest.PreAuthenticate=true;
    //            NetworkCredential networkCredential=new NetworkCredential( username , password , domain );
    //            myWebRequest.Credentials=networkCredential;

    // Assign the response object of 'WebRequest' to a 'WebResponse' variable.
    WebResponse myWebResponse=myWebRequest.GetResponse();
    System.IO.Stream stream = myWebResponse.GetResponseStream();
    StreamReader sr = new StreamReader(stream , Encoding.Default );
    //以字符串形式读取数据流
    respstr = sr.ReadToEnd();
    sr.Close();
   
    return respstr;
       
}

考虑将 SQLJ 用于 DB2 V8 Java 应用程序

文档选项 将此页作为电子邮件发送 未显示需要 JavaScript 的文档选项 级别: 初级 Connie Tsui, DB2 解决方案集成团队, IBM 多伦多实验室 2003 年 2 月 01 日 了解为什么 SQLJ 是注重安全性、性能和简单性的开发人员所选择的语言。其中还包含了代码样本。 简介 使用 Java™ 访问关系数据的标准方法有两种：SQLJ 和 JDBC™。对于 IBM® DB2® Universal Database™（UDB）应用程序，为什么应该考虑 SQLJ 呢？这是因为当应用程序员要考虑安全性、性能和简单性时，往往会选择 SQLJ 这样的语言。本文向您介绍了有关 SQLJ 的一些背景，讨论了相对于 JDBC，SQLJ 所具有的优势，还特别指出了 DB2 UDB V8.1 所提供的一些新增和改进的 SQLJ 特性。 回页首 SQLJ 的背景 1997 年 4 月，一个由数据库供应商组成的非正式和开放小组开始定期开会，交流有关如何在 Java 编程语言中使用静态 SQL 语句和构造的想法。主要参与者包括 IBM、Oracle、Compaq、Informix®、Sybase、Cloudscape 和 Sun Microsystems。该小组把他们正制定的规范命名为 JSQL。但他们发现术语 JSQL 是一个注册商标，因此就将 JSQL 重命名为 SQLJ。1997 年 12 月，Oracle 向其它成员提供了一个 Java 中嵌入式 SQL 的参考实现。这个参考实现可以在任何支持 JDK 1.1 的平台上运行，并且它与供应商无关。1998 年 12 月，完成了 Java 中嵌入式 SQL 规范的整个开发工作，并被接纳为 ANSI 标准 Database Language - SQL, Part 10 Object Language Bindings (SQL/OLB)ANSI x3.135.10-1998。这个规范一般称为 SQLJ 规范的第 0 部分。现在它被称为 SQL/OLB（对象语言绑定，Object Language Binding）。 SQLJ 规范目前由两部分组成： SQL/OLB：Java 中的嵌入式 SQL 这部分标准规定了在 Java 方法中嵌入 SQL 的语法和语义，还规定了一些机制来确保生成的 SQLJ 应用程序的二进制可移植性。这正是本文要阐述的主题。 SQL/JRT：使用 Java 编程语言的 SQL 例程和类型 这部分标准包含以下内容： 将 Java 静态方法作为 SQL 存储过程和用户定义的函数来调用的规范。它定义了 SQL 扩展，用于在 SQL 系统中安装 Java 类，在 SQL 中以 SQL 函数和存储过程方式调用 Java 类的静态方法，获取指定的参数输出值以及返回 SQL 结果集。 将 Java 类用作 SQL 用户定义的数据类型的规范。它定义了 SQL 扩展，用于将 Java 类用作 SQL 中的数据类型。 术语：当我们在本文其余部分使用术语 SQLJ 时，仅指 SQL/OLB。 回页首 SQLJ 编程环境 SQLJ 环境由两个阶段组成：开发和运行时。本节向您介绍每个阶段所涉及到的组件以及各组件间的关系。 开发 SQLJ 应用程序 使用 SQLJ 开发应用程序需要三个组件：转换程序、概要文件定制程序和概要文件绑定程序。有三个实用程序提供了支持这三个组件的功能，它们分别是： sqlj、db2sqljcustomize和 db2sqljbind。这里对 图 1中演示的过程作一个概述： 首先，调用 SQLJ 转换程序（sqlj）以读取 SQLJ 源文件并检查该程序中 SQLJ 语法的正确性。转换程序生成一个 Java 源文件，可能不生成 SQLJ 概要文件或生成多个 SQLJ 概要文件，并且如果所生成的 Java 源文件中没有错误，那么它还可以选择将该源文件编译成字节码（缺省情况）。生成的 Java 源文件将嵌入式 SQL 替代为对执行 SQL 操作的 SQLJ 运行时的调用。 接着，调用 SQLJ 概要文件定制程序（db2sqljcustomize）来为生成的序列化概要文件创建 DB2 定制。该定制程序可以选择（缺省情况下） 联机检查能够动态编译的 SQL 语句。联机检查执行语法、语义和模式验证。也可以选择（缺省情况下）调用 SQLJ 概要文件绑定程序以绑定 DB2 包。 如果选择在概要文件定制期间不执行自动绑定，那么可以单独调用 SQLJ 概要文件绑定程序（db2sqljbind），以将先前定制的 SQLJ 概要文件绑定到数据库。 不管概要文件是否被定制，要查看其内容，可以使用 SQLJ 概要文件打印程序（db2sqljprint）以文本格式打印出概要文件的内容。 图 1. SQLJ 开发环境 执行 SQLJ 应用程序 为访问数据库，SQLJ 运行时要依靠 JDBC 驱动程序来获取数据库连接。未定制的 SQLJ 应用程序可以与任何 JDBC 2.0 驱动程序一起运行。在开发期间，为了测试，只需运行未定制应用程序。要运行定制的 SQLJ 应用程序，可以使用 V8 基于 CLI 的 JDBC 类型 2 驱动程序 － 通用 JDBC 驱动程序（类型 2 或类型 4）来建立数据库连接。本节中，我们只描述用于定制的 SQLJ 应用程序的运行时环境。 当您运行 SQLJ 应用程序时，SQLJ 运行时从定制的概要文件中读取有关 SQL 操作的信息，并执行与存储在定制中的包关键信息（包名、包一致性标记和集合名）相符的 DB2 包中的语句。 图 2. SQLJ 运行时环境 回页首 SQLJ 相对于 JDBC 的优势 SQLJ 规范和 JDBC 规范都描述了如何使用 Java 来访问关系数据库。本节从以下几个方面讨论它们之间的差异： 标准和 SQL 规范级别 安全性 性能 语法 SQLJ 和 JDBC 互操作性 类型和模式检查 表 1汇总了我们在本节中所描述的 SQLJ 和 JDBC 之间的差异。 标准和 SQL 规范级别 SQLJ 是 ISO/IEC 9075-10:2000 Information technology -- Database languages -- SQL -- Part 10: Object Language Bindings (SQL/OLB)的实现。SQLJ 不属于 J2EE 平台。 JDBC 是 J2SE 1.4 和 J2EE 1.4 平台规范的一个必不可少的组件。它自 Java 软件开发工具箱（Java Software Development Kit，JDK）V1.1 之后已成为其核心部件。它包含在 java.sql 包中。JDBC 驱动程序必须至少支持 Entry SQL-92 语句，在该规范中还定义了一些扩展。 安全性 SQLJ 中实现的安全性权限模型是用户考虑使用 SQLJ 的一个主要原因。使用静态 SQL，安全性特权就被指派给了包创建者，并被存储在 DB2 包中。 使用定制的 DB2 SQLJ，静态地执行 SQL；因此使用包所有者的特权来执行 SQL 语句。任何运行 SQLJ 应用程序的其他用户都必须被授予具有该包的 EXECUTE 特权。即，被授权可以运行程序的用户未必有权对该程序所查询或正在修改的同一表或视图执行 SELECT、UPDATE、DELETE 或 INSERT 操作，除非显式地授予该用户相应的特权。 拥有连接到数据库并执行 JDBC 应用程序特权的人可以执行这些应用程序中的 SQL 语句。因此，用户必须获得访问表的特权。 性能 SQLJ 允许在 Java 程序中嵌入 SQL 语句，这类似于 SQL-92 允许 SQL 语句嵌入到 C、COBOL、FORTRAN 以及其它编程语言中的方式。但是，根据 SQLJ 概要文件是否被定制，可以决定 SQLJ 应用程序是动态还是静态地运行。当将包存储在 DB2 数据库中时，就会预编译 SQLJ 应用程序并优化 SQL 语句的路径长度。静态执行的 SQLJ 应用程序的性能会优于 JDBC 的性能。 如果想利用静态执行（我们建议这样做），必须使用 SQLJ 概要文件定制程序来定制概要文件。 JDBC 提供了 SQL 语句的动态执行。如果这些语句中存在语法或语义错误，那么在该应用程序运行时任何此类异常都会产生。 使用 DB2 UDB 监视器可以验证静态或动态的 SQL 语句处理。监控方法有两种：快照监控和事件监控。快照监视器提供有关数据库在某个特定时间点的活动信息。事件监视器记录了 DB2 UDB 事件发生的特定位置。下面的 清单 1 摘自从 JDBC 程序生成的事件监视器的样本输出。“Type: Dynamic”告诉您动态执行了 SELECT job FROM staff WHERE name = ? 语句。 清单 1. 从 JDBC 程序生成的事件监视器的样本输出 10) Statement Event ... Appl Handle: 23 Appl Id: G91AA377.G576.00F306261BF2 Appl Seq number: 0001 Record is the result of a flush: FALSE ------------------------------------------- Type : Dynamic Operation: Prepare Section : 1 Creator : NULLID Package : SYSSH200 Consistency Token : SYSLVL01 Package Version ID : Cursor : SQL_CURSH200C1 Cursor was blocking: FALSE Text : SELECT job FROM staff WHERE name = ? 清单 2摘自从 SQLJ 程序生成的事件监视器的样本输出。输出中的“Type: Static”和“Package: SRQT402”告诉您，对 SRQT402 包静态执行了该语句。 清单 2. 从 SQLJ 程序生成的事件监视器的样本输出 10) Statement Event ... Appl Handle: 12 Appl Id: G91ABD18.G47D.00F306C01D63 Appl Seq number: 0001 Record is the result of a flush: FALSE ------------------------------------------- Type : Static Operation: Execute Section : 1 Creator : NULLID Package : SRQT402 Consistency Token : SARoQCAp Package Version ID : Cursor : Cursor was blocking: FALSE 注：有些语句对于定制的 SQLJ 程序会正确执行，但对于未定制的 SQLJ 程序就不会正确执行。可滚动游标的 UPDATE/DELETE WHERE CURRENT OF 就是这样一个示例。一般而言，如果底层 JDBC 驱动程序不支持某个功能，那么未定制的 SQLJ 程序也不会支持该功能。 性能技巧： 对于单个 select 查询，与盲目地对庞大的 JDBC ResultSets 执行操作相比，可以通过使用由 SQLJ 提供的 SELECT INTO 语法来减少网络活动。 图 3比较了用于单个 select 查询的 SQLJ 和 JDBC 语法。 图 3. 使用 SQLJ 和 JDBC 检索一个行 SQLJ 语法： #sql [conCtx] { SELECT job INTO :job FROM staff WHERE name = :name }; JDBC 语法： PreparedStatement pstmt = con.prepareStatement( "SELECT job FROM staff WHERE name = ? FETCH FIRST 1 ROW ONLY" ); ResultSet rs = pstmt.executeQuery(); if ( rs.next() ) job = rs.getString(1); else job = null; pstmt.close(); 语法 图 3表明 SQLJ 语法在简单性方面优于 JDBC。SQLJ 的简单性受到了许多 Java 开发人员的欢迎。编写 SQLJ 模块通常要比 JDBC 模块简洁且容易。这暗示着 SQLJ 可以使开发周期缩短并减少开发和维护成本。 图 4向您显示了 SQLJ 可以多么简单地向数据库插入一行数据。如果您已有了用其它语言（如 C 或 COBOL）编写的嵌入式 SQL 应用程序，那么就可以使用 SQLJ 轻松地将应用程序迁移到 Java。 图 4. 使用 SQLJ vs. JDBC 插入一个行 SQLJ 语法： sql [conCtx] { INSERT INTO sales VALUES(:date, :salesperson, :region, :sales) }; JDBC 语法： PreparedStatement pstmt = con.prepareStatement( "INSERT INTO sales VALUES (?, ?, ?, ?)" ); // set input parameter pstmt.setObject(1, date); pstmt.setString(2, salesperson); pstmt.setString(3, region); pstmt.setInteger(4, sales); pstmt.executeUpdate(); pstmt.close(); SQLJ 和 JDBC 互操作性 SQLJ 语言允许您在 SQLJ 应用程序中使用 JDBC 语句。要使 JDBC 和 SQLJ 之间便于交互，SQLJ 提供了一种方法以便在同一应用程序内共享 SQLJ 连接和 JDBC 连接，这种方法还可以从 SQLJ 迭代器中获取 JDBC 结果集，或从 JDBC 迭代器中获取 SQLJ 结果集。 何时需要在 SQLJ 应用程序中使用 JDBC？ 您需要将 JDBC 用于动态操作时；即，在编写程序时不清楚 SQL 操作的时候。 清单 3演示了在 SQLJ 程序内用 JDBC 来执行动态查询（WHERE 子句中的名称在开发时是未知的），以及如何将 JDBC 结果集转换到 SQLJ 迭代器。 与 SQLJ 不同的是，JDBC 不能识别 SQLJ 语法，而且 SQL 语句不能嵌入到 JDBC 应用程序。 清单 3. 将 JDBC 结果集转换到 SQLJ 迭代器 Public class ResultSetInterop { #sql public static iterator Employees (String name, double salary); public static void main(String[] argv) throws SQLException { // the code for creating the SQLJ connection context (conCtx) and // the Connection object (con) is omitted // create a JDBC statement object to execute a dynamic query Statement stmt = con.createStatement(); String query = "SELECT name, salary FROM staff WHERE "; query += argv[0]; ResultSet rs = stmt.executeQuery(query); Employees SalReport; // turn a JDBC result set to an SQLJ interator using the CAST statement #sql [conCtx] SalReport = { CAST :rs }; while (SalReport.next()) { System.out.println( SalReport.name() + " earns " + SalReport.salary() ); } SalReport.close(); stmt.close(); } } 类型和模式检查 SQLJ 与 Java 类似的一点是，它也是强类型的。在将 SQLJ 源文件转换成 Java 源文件时，SQLJ 转换程序会检查 SQLJ 语法。这类似于其它 DB2 预编译器。而且，在转换阶段的 Java 编译期间执行迭代器数据类型的转换。例如，在禁止使用双精度的迭代器列（如雇员工资）中，Java 编译器就会阻止该列使用双精度类型。因此， String hv = employees.salary(); 这样的赋值在编译时就会生成一个错误。另外，在概要文件定制期间也执行联机检查，以便可以较早地捕获编程错误。 JDBC 不能在运行时之前进行语法或语义检查。如果存在语法或语义错误，那么在应用程序运行时任何此类异常都会产生。 注： 在 V8.1 中，在概要文件定制期间执行联机检查，而在以前的发行版中这一操作是在转换阶段执行的。 有些 SQLJ 错误只有在运行时才被捕获到。另外，不能动态编译的语句不会进行联机检查。 回页首 差异汇总 表 1汇总了 SQLJ 和 JDBC 之间的差异。 表 1. 比较 SQLJ 和 JDBC      SQLJ JDBC 标准 ISO/ANSI（不属于 J2EE） Sun（属于 J2EE） SQL 规范级别 SQL-1999 N/A（必须至少支持 Entry Level SQL-92） 安全性 强 一般 性能 较快（在开发期间创建了静态存取方案） 较慢（在应用程序执行期间创建了动态存取方案） 语法 高级（紧凑） 低级（繁琐） SQLJ 和 JDBC 互操作性 是 N/A 类型和模式检查 强（在开发期间执行） 弱（在运行时期间执行） 回页首 V8.1 中的新增功能 DB2 UDB V8.1 提供了新设计的 SQLJ 驱动程序，它有几个新特性。新的 SQLJ 驱动程序基于一种称为 Distributed Relational Database Architecture™（DRDA®）的开放分布式协议。基于 CLI 的 JDBC 驱动程序（类型 2 和类型 3）以及 V8.1 中引入的新的通用 JDBC 驱动程序（类型 2 和类型 4）都支持该协议。 SQLJ 的主要增强功能可以概括如下： 新的 SQLJ 实用程序和运行时 消除了特定于平台的文件 一些新特性 新的 SQLJ 实用程序和运行时 DB2 UDB V8.1 中的 SQLJ 实现了纯 Java SQLJ 实用程序和运行时，并带有一些新选项和可选的格式。新的运行时性能比 V7 的性能好得多。 在 V8.1 中，SQLJ 转换程序 sqlj 在缺省情况下总是编译所生成的 Java 源文件。在 V7 中，这个编译选项不能与某些 JDK 一起使用，因此您必须手工编译 Java 文件。 V8.1 中新的概要文件打印程序 db2sqljprint 不再需要您提供 URL，而且它提供了有关要执行的 SQL 语句的详细信息，例如 DB2 语句的类型、节号以及 DB2 结果集元数据信息。 消除了特定于平台的文件 V8.1 中的 SQLJ 概要文件定制程序包含新的序列化概要文件格式，它不必使用 DBRM 文件和绑定文件（.bnd 文件）。新格式完全可以移植到所有平台。它包含所有 BIND 操作所需的所有信息，用户不必在目标系统（UNIX®、Windows®、OS/390® 和 z/OS™）上重新定制序列化概要文件就可以部署在任何服务器平台上。 V8 中的新特性 DB2 UDB V8.1 中添加的主要特性包括以下各项： 使用 DataSource 创建 SQLJ 连接上下文 可滚动的迭代器 批处理更新 使用 DataSource 创建 SQLJ 连接上下文 有了 V8.1 SQLJ，您可以使用 JDBC DataSource 接口来创建 SQLJ 连接。而且，缺省连接上下文的实现也更改了。要获得缺省连接上下文，SQLJ 运行时要执行 JNDI 查询以获得 jdbc/defaultDataSource。如果没有注册任何 jdbc/defaultDataSource，那么在驱动程序试图访问上下文时，就会抛出一个空上下文异常。因此，必须向 JNDI 注册 jdbc/defaultDataSource，或者通过调用 DefaultContext.setDefaultContext(userctxt) 来设置缺省上下文。 建议：在 SQLJ 子句中使用显式的连接上下文。 清单 4. 使用数据源创建 SQLJ 连接上下文 // Create connection context class Ctx with the new dataSource keyword #sql public static context Ctx with (dataSource="jdbc/sampledb"); String userid, password; String empname; ? // Create connection context object conCtx for the connection to jdbc/sampledb Ctx conCtx = new Ctx(userid, password); #sql [conCtx] { SELECT lastname INTO :empname FROM emp WHERE empno = '000010' }; ? conCtx.close(); 可滚动的迭代器 可滚动的迭代器允许您向前移、向后移或移动到指定行。与 JDBC 中可滚动的游标相似，可滚动的迭代器可以是 不敏感的，也可以是 敏感的。 不敏感的迭代器意味着在迭代器打开后，它不能看到底层表中的更改。不敏感的迭代器是只读的。 敏感的迭代器意味着迭代器可以看到迭代器或其它处理对底层表所作的更改。例如， 清单 5中的代码演示了如何使用指定的迭代器对雇员表的所有行以逆序方式检索雇员号和雇员的姓氏。 清单 5. 使用可滚动的迭代器 // Declare a scrollable iterator. #sql iterator ScrollIter implements sqlj.runtime.Scrollable with (sensitivity = SENSITIVE) (String EmpNo, String LastName); { ScrollIter scrlIter; #sql [conCtx] scrlIter={ SELECT empno, lastname FROM emp }; scrlIter.afterLast(); while (scrlIter.previous()) { System.out.println(scrlIter.EmpNo() + " " + scrlIter.LastName()); } scrlIter.close(); } 批处理更新 批处理更新允许将语句集中到一起，随后将其以批处理方式发送到数据库，一次执行完这些语句。您可以在批处理更新中包含以下几种类型的语句： 搜索到的 INSERT、UPDATE 或 DELETE 语句 CREATE、ALTER、DROP、GRANT 或 REVOKE 语句 只带输入参数的 CALL 语句 与 JDBC 不同，SQLJ 允许异构批处理，这些批处理中包含带有输入参数或主机表达式的语句。因此在同一个 SQLJ 语句批处理中可以包含同一语句的实例、不同语句的实例、带输入参数或主机表达式的语句的实例以及不带输入参数或主机表达式的语句的实例等。 建议：在关闭批处理或在结束使用 ExecutionContext（会使批处理打开）之前，要显式地调用 executeBatch()。这将确保执行经过批处理的所有语句。 清单 6中的代码段向您显示了如何以批处理方式执行更新操作来给所有管理人员加薪。 清单 6. 执行批处理更新 #sql iterator getMgr(String); { getMgr deptIter; String mgrnum = null; int raise = 400; int currentSalary; String url = null, username = null, password = null; testContext conCtx = new testContext (url, username, password, false); // Acquire execution context. // All statements that execute in a batch must use this execution context. ExecutionContext exeCtx = new ExecutionContext(); // Invoke ExecutionContext.setBatching (true) to create a batch. exeCtx.setBatching(true); #sql [conCtx] deptIter = { SELECT mgrno FROM dept }; #sql {FETCH :deptIter INTO :mgrnum}; while (!deptIter.endFetch()) { #sql [conCtx] { SELECT SALARY INTO :currentSalary FROM emp WHERE empno = :mgrnum}; #sql [conCtx, exeCtx] { UPDATE emp SET SALARY = :(currentSalary+raise) WHERE empno =:mgrnum }; #sql { FETCH :deptIter INTO :mgrnum }; } exeCtx.executeBatch(); exeCtx.setBatching(false); #sql [conCtx] {COMMIT}; deptIter.close(); exeCtx.close(); conCtx.close(); } 回页首 结束语 相对于 JDBC，SQLJ 的 DB2 实现具有明显的优势。在预编译时 SQLJ 较简单语法和类型以及模式检查大大降低了开发成本。SQLJ 还具有在 SQLJ 应用程序中嵌入 JDBC 语句这样的灵活性。这意味着一个应用程序可以同时利用 SQLJ 和 JDBC 的优点。当安全性和性能对 Java 应用程序至关重要时，SQLJ 是正确的选择。 回页首 更多信息 Meet the Experts: John Campbell on Java Performance for DB2 Applications http://www7b.software.ibm.com/dmdd/library/techarticle/0202campbell/0202campbell.html DB2 Universal Database V8 Application Development http://www.ibm.com/software/data/db2/udb/ad/v8/java 使用 DB2 版本 8 开发企业 Java 应用程序 http://www.ibm.com/developerworks/cn/dmdd/library/techarticles/0209hutchison/index.shtml DB2 V8 信息中心 http://www.ibm.com/cgi-bin/db2www/data/db2/udb/winos2unix/support/index.d2w/report 在使用 SQLJ 和 JDBC 时获取最优的 DB2 性能（教程） http://www.ibm.com/developerWorks/cn/cndmdd.nsf/dmdd-onlinecourse-bynewest/9607CCEEE2E42D09C8256D18002359F4?OpenDocument IBM Java 技术专区 http://www.ibm.com/java/ DB2 开发者园地 Java 专区 http://www.ibm.com/software/data/db2/java SQL/OLB 标准 http://www.ansi.org/ 关于作者 Connie Tsui是 IBM 多伦多实验室 DB2 解决方案集成团队的专职软件分析师。她从多伦多大学（University of Toronto）获得了计算机科学学士学位。她目前主要从事 DB2 和 WebSphere® 的集成。

用 DB2 UDB V8.1 和 Application Developer V5.1.2 创建使用 SQLJ 的 Java 和 J2EE 应用程序

文档选项

将此页作为电子邮件发送

未显示需要 JavaScript 的文档选项

样例代码

级别: 初级

Owen Cline (owenc@us.ibm.com), 认证的 IT 咨询专家 - WebSphere 软件服务, IBM

2005 年 2 月 01 日

这篇 "how-to" 文章将解释如何在 Java™ 应用程序和 J2EE™ 应用程序中使用 SQLJ。文中将介绍 SQLJ 语法，使用 SQLJ 访问数据源，建立 WebSphere® Application Developer 项目以支持 SQLJ，以及创建和调用 DB2® 存储过程。

SQLJ 概述

SQL 语句包括查询（SELECT）、插入（INSERT）、更改（UPDATE）、删除（DELETE）语句以及其他对存储在关系数据库表中的数据进行操作的语句。SQLJ 是在 Java 中嵌入这些 SQL 语句的一种约定，它是以某种允许编程工具对 Java 中 SQL 进行编译时分析的方式实现嵌入的，在编译时会对 SQL 语句进行语法检查以保证语法的正确性，进行类型检查以确定 Java 和 SQL 之间交换的数据具有兼容的类型和适当的类型转换，以及进行模式检查以确保 SQL 结构在它们执行时所在的数据库模式中是格式良好的、合法的。嵌入式 SQL 语句被称为是 "静态的（static）"，因为这些语句在 Java 程序中一目了然，因而嵌入式 SQL 语句随着包含它们的 Java 程序的编译而编译（通常的术语是"预编译"）。我们提议将 SQLJ 作为用于紧密集成 Java/SQL 程序的一种方便有效的标准。

SQLJ 简史

正如 Connie Tsui 在她的文章（后面有引用）中解释的那样，一个非正式的、开放的数据库供应商组织在 1997 年 4 月开始定期的会面，以便交换关于如何在 Java 编程语言中使用静态 SQL 语句和结构的思想。主要参与者包括 IBM®、Oracle、Compaq、Informix®、Sybase、Cloudscape™ 和 Sun Microsystems。该组织将他们为之努力的规范命名为 JSQL。在发现 JSQL 已经是商标术语后，JSQL 被更名为 SQLJ。在 1997 年 12 月，Oracle 向其他成员提供了 Java 中嵌入式 SQL 的一个参考实现。该参考实现可以在任何支持 JDK 1.1 的平台上运行，并且是与供应商无关的。在 1998 年 12 月，用于在 Java 中嵌入 SQL 的规范被完全开发出来，并且被接受为 ANSI 标准 Database Language —— SQL, Part 10 Object Language Bindings (SQL/OLB) ANSI x3.135.10-1998。该规范已经被当作 SQLJ 规范的 Part 0 供大家引用。如今它被称作 SQL/OLB (Object Language Bindings)。

SQLJ 与 JDBC 的比较

SQLJ —— Java 数据库应用程序的开门咒语

SQLJ 标准现在为 Java 应用程序提供了基于 SQL 的数据库访问。SQLJ —— Java 数据库应用程序的开门咒语

下面是 SQLJ 相对于直接在 JDBC 中编写代码的优势：

SQLJ 程序需要的代码行数比 JDBC 程序更少。SQL 程序更简短，因而更易于调试。SQLJ 可以通过在编译时使用数据库连接，对代码执行语法和语义上的检查。SQLJ 提供了对查询结果及其他返回参数的强类型检查，而 JDBC 值则是直接从 SQL 返回，在编译时未进行任何检查。

SQLJ 为处理 SQL 语句提供了一种简化的方式。现在无需编写不同的方法调用来绑定每个输入参数和获取每个选择列表项，而只需编写一条使用 Java 宿主变量的 SQL 语句。SQLJ 会替您完成绑定。

然而，JDBC 提供了对 SQL 语句的执行的细粒度控制，并提供了真正的动态 SQL 能力。如果应用程序需要动态能力（在运行时发现数据库或实例元数据），那么应该使用 JDBC。

回页首

为 SQLJ 建立 WebSphere Studio Application Developer 项目

如果您计划将 SQLJ 代码包括到所有 WebSphere Studio Application Developer (Application Developer) 项目中，那么需要使您的项目支持 SQLJ。为此，可以右击项目并选择 Add SQLJ Support。这将弹出 SQLJ 向导，如下所示。

图 1. 使 Application Developer 项目支持 SQLJ

回页首

SQLJ 和 Java 应用程序

从 Application Developer 主菜单中，选择 File -> New -> Other ，然后选择 Java 和 Java Project。单击 Next。

图 2. 创建 Java 项目

输入项目名，单击 Next。

图 3. 输入 Java 项目名

选择 Finish 创建该项目。

图 4. 输入 Java 项目设置

为了让 Java 应用程序能够成功运行，还需添加 DB2 JDBC 驱动程序 db2java.zip。右击 Java 项目，选择 Properties。

图 5. 编辑 Java 项目属性

接下来，选择 Java Build path，然后选择 Libraries 标签页。然后选择 Add External JARs。

图 6. 添加外部 JAR —— db2java.zip

完成这些设置后，库路径应该如下所示：

图 7. 添加外部 JAR —— db2java.zip

接下来的步骤是创建有关 Java 类，用于容纳主方法。为此，需要右击 Java 项目，然后选择 New -> Class。填入包名和类名。另外，确保勾选了关于创建主方法的复选框。单击 Finish。

图 8. 创建 Java 主类

最后，需要创建 SQLJ 文件。从 Application Developer 主菜单中，选择 File -> New -> Other，然后选择 Data -> SQLJ 和 SQLJ File。最后单击 Next。Application Developer 将保证 SQLJ 文件被转换成一个 Java 文件。

图 9. 选择 SQLJ 文件向导

填入包名和文件名。然后单击 Finish。

图 10. 创建 SQLJ 文件

至此，还需要将代码添加到 Java 主方法中，另外必须创建一个 SQLJ 方法。首先让我们明确要完成什么。我们将创建一个 SQLJ 方法，该方法从 DB2 SAMPLE 数据库中根据给定的雇员号读取一个雇员记录。这个 SQLJ 方法以雇员号（一个 Java String）作为输入，并将其作为参数传递给一条 SQLJ Select 语句。Java 主方法将调用这个 SQLJ 方法。

清单 1. 包含主方法的 Java 类

<![CDATA[
/*
* Created on Nov 27, 2004
*
*/
package com.ibm.sqlj.main;
import com.ibm.sqlj.Select;
/**
* @author Owen Cline
*
*/
public class SQLJJave {
public static void main(String[] args) {
Select select = new Select();
select.selectEmployee("000110");
}
}
]]>

清单 2. 包含 SQLJ 方法的 SQLJ 类

<![CDATA[
/*
* Created on Nov 27, 2004
*
*/
package com.ibm.sqlj;
import java.sql.*;
import sqlj.runtime.ref.*;
/**
* @author Owen Cline
*
*/
public class Select {
// First, load the JDBC driver
static
{ try
{ Class.forName ("COM.ibm.db2.jdbc.app.DB2Driver").newInstance ();
} catch (Exception e)
{ System.out.println ("\n Error loading DB2 Driver...\n");
System.out.println (e);
System.exit(1);
}
}
public void selectEmployee(String empNo) {
Connection con = null; DefaultContext ctx = null; try {
String firstName = null;
String lastName = null;
// use the DB2 SAMPLE database
String url = "jdbc:db2:SAMPLE";
// Get the connection
con = DriverManager.getConnection(url); // Set the default context
ctx = new DefaultContext(con); DefaultContext.setDefaultContext(ctx);
// Lookup the employee given the employee number
#sql { SELECT FIRSTNME, LASTNAME INTO :firstName, :lastName
FROM EMPLOYEE
WHERE EMPNO = :empNo } ;
System.out.println ("Employee " + firstName + " " + lastName);
ctx.close();
con.close();
}
catch( Exception e )
{
System.out.println (e);
}
}
}
]]>

现在便可以运行这个 Java 应用程序了。选中您的 Java 项目，然后从 Application Developer 主菜单中选择 Run -> Run As -> Java Application。您应该可以看到在控制台 "Employee VINCENZO LUCCHESSI" 中打印出如下消息。

回页首

SQLJ 和 J2EE 应用程序

您可能想到，还可以在 J2EE 应用程序、servlet、会话 bean、BMP 实体 bean 和 MDB bean 中使用 SQLJ。现在我们要做的就是将我们创建的在 Java 应用程序中运行的上述代码移植，使之在一个会话 bean 中运行。

首先，需要创建一个 EJB 项目。从 Application Developer 主菜单中，选择 File- > New -> Project。 然后选择 EJB and EJB Project。单击 Next。

图 11. 创建 EJB Project

确保选择了 Create 2.0 EJB Project ，然后单击 Next。

图 12. 选择一个 EJB 版本

现在，输入 SQLJSession 作为 EJB 项目名。EAR 项目应该是 DefaultEAR。单击 Next。

图 13. 输入 EJB 项目名

在 Module Dependencies 对话框中，选择 Finish 创建 EJB 项目和 EAR 项目。

图 14. 输入 EJB 模块依赖

在这里，我们还想创建一个会话 Bean。 选择 Application Developer 主菜单中的 File -> New -> Enterprise Bean。然后单击 Next。

图 15. 创建一个会话 Bean —— 步骤 1

确保选择了 Session bean 单选按钮，并输入了一个 Bean 名称。然后单击 Next。

图 16. 创建一个会话 Bean —— 步骤 2

确保选中 Local client view 复选框，以得到本地接口（如果 EJB 容器部署在本地，那么这样做会更快一些），然后单击 Finish 创建会话 Bean。

图 17. 创建一个会话 Bean - 步骤 3

现在我们来创建一个 SQLJ 文件，该文件将包含我们的业务逻辑。右击 EJB 项目 SQLJSession 并选择 New -> Other，然后选择 Data -> SQLJ 和 SQLJ File。最后单击 Next。

图 18. 创建 SQLJ 文件 —— 步骤 1

输入包名和文件名，然后选择 Finish 创建 SQLJ 文件。还应注意的是，由于是在一个项目中创建这个 SQLJ 文件，而这个项目还没有添加 SQLJ 支持，因此这一次需添加该支持。

接着，使用上述步骤创建第二个 SQLJ 文件，文件名为 SessionBeanSelectUsingDefaultDatasource，以便以后演示如何使用 defaultDataSource。现在，我们可以在创建的 SQLJ 文件中添加自己的业务逻辑，如下所示：

图 19. 创建 SQLJ File —— 步骤 2

清单 3. SessionBeanSelect.sqlj

<![CDATA[
package com.ibm.sqlj;
import java.sql.*;
import sqlj.runtime.ref.*;
import javax.sql.DataSource;
/**
* @author Owen Cline
*
*/
public class SessionBeanSelect {
// Setup datasource to use. Notice that I am not using a global JNDI name // but instead using a Resource Reference which points to the global JNDI name. // This is a best practice.
#sql public static context Ctx with (dataSource="java:comp/env/sqljDS");
public void selectEmployee(String empNo) {
String firstName = null;
String lastName = null;
try {
// Create context
Ctx conCtx = new Ctx();
// Lookup the employee given the employee number
#sql [conCtx] { SELECT FIRSTNME, LASTNAME INTO :firstName, :lastName
FROM EMPLOYEE
WHERE EMPNO = :empNo } ;
System.out.println ("SessionBeanSelect-Employee " + firstName + " " + lastName);
conCtx.close();
} catch (Exception e) {
System.out.println(e);
}
}
}
]]>

清单 4. SessionBeanSelectUsingDefaultDatasource.sqlj

<![CDATA[
package com.ibm.sqlj;
import java.sql.*;
import sqlj.runtime.ref.*;
import javax.sql.DataSource;
/**
* @author Owen Cline
*
*/
public class SessionBeanSelectUsingDefaultDatasource {
public void selectEmployee(String empNo) {
String firstName = null;
String lastName = null;
try {
// Lookup the employee given the employee number
#sql { SELECT FIRSTNME, LASTNAME INTO :firstName, :lastName
FROM EMPLOYEE
WHERE EMPNO = :empNo } ;
System.out.println ("SessionBeanSelectUsingDefaultDatasource-Employee " + firstName + " " + lastName);
} catch (Exception e) {
System.out.println(e);
}
}
}
]]>

现在，我们要添加 bean 模块，以便调用 SQLJ 文件中的业务逻辑。编辑 SQLJSessionBeanBean.java 文件，添加两个方法：selectEmployee 和 selectEmployeeUsingDefaultDatasource，如以下清单所示。然后，别忘了使这两个方法成为本地接口。最后，在进入下一步之前，确保生成了部署和 RMIC 代码。

清单 4. SQLJSessionBeanBean.java

<![CDATA[
package com.ibm.sqlj.ejb.session;
import com.ibm.sqlj.SessionBeanSelect;
import com.ibm.sqlj.SessionBeanSelectUsingDefaultDatasource;
/**
* Bean implementation class for Enterprise Bean: SQLJSessionBean
*/
public class SQLJSessionBeanBean implements javax.ejb.SessionBean {
private javax.ejb.SessionContext mySessionCtx;
/**
* getSessionContext
*/
public javax.ejb.SessionContext getSessionContext() {
return mySessionCtx;
}
/**
* setSessionContext
*/
public void setSessionContext(javax.ejb.SessionContext ctx) {
mySessionCtx = ctx;
}
/**
* ejbCreate
*/
public void ejbCreate() throws javax.ejb.CreateException {
}
/**
* ejbActivate
*/
public void ejbActivate() {
}
/**
* ejbPassivate
*/
public void ejbPassivate() {
}
/**
* ejbRemove
*/
public void ejbRemove() {
}
/**
* selectEmployee
*/
public void selectEmployee(String empNo) {
SessionBeanSelect sbs = new SessionBeanSelect();
sbs.selectEmployee(empNo);
}
/**
* selectEmployee
*/
public void selectEmployeeUsingDefaultDatasource(String empNo) {
SessionBeanSelectUsingDefaultDatasource sbs = new SessionBeanSelectUsingDefaultDatasource();
sbs.selectEmployee(empNo);
}
}
]]>

为最终测试我们的会话 Bean，必须创建一个 Server Configuration。切换到 Server Perspective，并在 Server Configuration 视图中单击右键。选择 New -> Server and Server Configuration。输入服务器名 TestServer ，然后单击 Finish 创建该服务器。

图 20. 创建一个 Server Configuration

创建好服务器后，在服务器上单击右键（同样也是在 "Server Configuration" 视图中），然后选择 Add and Remove Projects。 在 "Add and Remove Projects" 对话框中（这里没有显示出来），添加 DefaultEAR 项目并单击 Finish。

最后要做的是创建我们的会话 Bean 将要使用的 DB2 数据源。在 Server Configuration 视图中右击 Test Server，这将弹出服务器配置编辑器。选择 Security 标签页，然后选择下面显示的 JAAS Authentication Entries 对话框旁边的 Add 按钮。为该条目输入一个名称，然后输入一个用于访问数据库的合法用户名和密码。最后单击 OK。

图 21. 添加 JAAS 认证条目

现在，选择 Data source 标签页。在 JDBC Provider 列表中选择 Default DB2 JDBC Provider 条目。单击在上面所选 JDBC 提供者中定义的数据源旁边的 Add 按钮。确保选中了 DB2 JDBC Provider 和 Version 5.0 data source 单选按钮。然后单击 Next。

图 22. 选择要创建的数据源的类型

输入 sqljDS 作为数据源名称，输入 jdbc/sqljDS 作为 JNDI 名称。对于 "Component-managed authentication alias" 和 "Container-managed authentication alias"，都选择前面创建的 JAAS Authentication Entry。然后单击 Finish。

图 23. 输入 sqljDS 的数据源参数

重复这些步骤，创建另一个名为 defaultDataSource 的数据源，数据源的 JNDI 名称为 jdbc/defaultDataSource。最后，保存该服务器配置。

图 24. 输入 defaultDataSource 的数据源参数

现在，我们需要创建一个 Resource Reference，以便会话 bean 可以查找 sqljDS 数据源。因此，切换到 Application Developer 中的 J2EE Perspective。在 J2EE Hierarchy 视图中，右击 SQLJSession EJB 项目，以调用 EJB Deployment Descriptor 编辑器。选择 References 标签页。选择 SQLJSessionBean 并选择 Add 按钮。选择 Resource Reference 单选按钮，然后单击 Next。

图 25. 创建资源引用

输入 sqljDS 作为名称。选择 javax.sql.DataSource 作为类型。为 Authentication 选择 Container 。 保留 Sharing Scope 为 Shareable。然后单击 Finish。

图 26. 输入资源引用参数

选中刚创建的资源引用，然后输入 jdbc/sqljDS 作为 JNDI 名。保存该 EJB 部署描述文件。

图 27. 输入资源引用的 JNDI 名

至此，您应该可以测试会话 Bean 模块了。首先，在 Server Perspective 中，通过在 Servers 视图中右键单击 TestServer 并选择 Start 来启动该服务器。接着，通过在 Servers 视图中单击右键并选择 Run universal test client 调用 Universal Test Client。从这个 universal test client 中，选择 JNDI Explorer 并展开 "jdbc" 菜单，以显示出两个数据源：sqljDS 和 defaultDataSource。接下来，完全展开 Local EJB beans 菜单，直到能够选择 SQLJSessionBeanLocalHome。在 EJB reference 菜单中完全展开菜单项，直到能够选择 SQLJSessionBeanLocal.create() 模块，然后选择 Invoke followed by the Work with Object 按钮。

图 28. 调用 SQLJSessionBeanLocal.create() 方法

现在，您将看到有两个方法可供调用：selectEmployee 和 selectEmployeeUsingDefaultDatasource。选择 selectEmployee 方法。输入 000110 作为 empNo 值，并选择 Invoke 按钮。检查控制台窗口，以确信显示了 "[11/28/04 16:56:05:176 PST] 6d2f338b SystemOut O SessionBeanSelect-Employee VINCENZO LUCCHESSI"。最后，您自己尝试一下 selectEmployeeUsingDefaultDatasource 方法。

图 29. 调用 selectEmployee() 方法

回页首

结束语

总之，对于不需要动态 SQL 的 Java 和 J2EE 应用程序，SQLJ 是提供持久性框架的一种非常有用的方式。虽然本文没有提到，但使用 SQLJ 开发存储过程也是可行的。

回页首

下载

描述 名字 大小 下载方法

code samples

SQLJArticle_sourcecode.zip

3443 KB

FTP

|

HTTP

关于下载方法的信息

Get Adobe® Reader®

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文 。
• 下载本文中用到的源代码。
• "考虑将 SQLJ 用于 DB2 V8 Java 应用程序" (developerWorks, February 2003)
• "Building DB2 Stored Procedure Using WSAD V5" (Bibhas Bhattacharya)
• DB2 Java Stored Procedures Learning by Example (IBM Redbook, September 2000)

关于作者

Owen Cline 是位于加州圣地亚哥市的 IBM Software Services for Websphere 小组的一名成员。他有 20 多年软件开发领域的开发经验。他拥有 4 项软件专利，编写了大量 IBM 红皮书，并曾多次出席各种技术会议。在过去的 5 年当中，Owen 专门从事 J2EE 架构、应用开发和部署，重点研究了 WebSphere 平台。此外，这几年来，他还参与了许多高知名度的 Web 站点的开发。

源文档 <http://www.ibm.com/developerworks/cn/db2/library/techarticles/dm-0412cline/index.html>

This section will cover the nuts and bolts of developing a Java UDR with embedded SQL. Our topics will include:

• Software Requirements
• Server Configuration
• Development Environment
• Runtime Environment
• Embedded SQL Syntax
• Compiling Embedded SQL Java Programs

Software Requirements

1. To develop Java UDRs that employ embedded SQL, the first thing you'll need is version 9.21 or later of Informix Foundation. Foundation consists of the Informix database engine, plus a suite of supporting software that includes "Krakatoa", which permits Java routines to run inside the server. Note that 9.20 and earlier versions will not support embedded SQL.
2. Next, you'll need the Informix JDBC Driver, version 2.1+ . The JDBC Driver can be downloaded free from the Informix download web site. Versions of the JDBC Driver prior to 2.1 will not support embedded SQL.

Server Configuration

Your Informix server configuration file (typically, $INFORMIXDIR/etc/onconfig on Unix, or %INFORMIXDIR%\etc\ONCONFIG.<servername> on NT) includes a number of parameters for setting the server's environment to support Krakatoa (a. k. a., "Java-in-the-server"). Most are pre-set in the default configuration file, and most of the information needed to set the rest can be found in the release notes for your platform.

One setting, which is specific to using embedded SQL in Java UDRs, may not be documented in your version of the server: JVPCLASSPATH must include the ifxsqlj.jar (or ifxsqlj-g.jar) file in your JDBC installation, and it must also include the full path to the directory where the .class file for your Java UDR will reside.

On NT, your Krakatoa-related ONCONFIG settings should look something like this:

VPCLASS      jvp,num=1                       # Number of JVPs to start with
            JVPJAVAHOME  D:\informix\extend\krakatoa\jre # JDK installation root directory
            JVPHOME      D:\informix\extend\krakatoa     # Krakatoa installation directory
            JVPLOGFILE   D:\informix\extend\krakatoa\jvp.log    # VP log file
            JVPPROPFILE  D:\informix\extend\krakatoa\.jvpprops  # JVP property file
            JDKVERSION   1.2                  # JDK version supported by this server
            JVMTHREAD    native               # Java VM thread type (green or native)
            # The path to the JRE libraries relative to JVPJAVAHOME
            JVPJAVALIB   \bin\
            # The JRE libraries to use for the Java VM
            JVPJAVAVM    hpi;jvm;java;net;math;zip;jpeg
            # Classpath to use upon Java VM start-up (use _g version for debugging)
            # IMPORTANT: In this sample, the line is broken to fit on a page. In a live
            # ONCONFIG file, your JVPCLASSPATH entry MUST be a single, unbroken line.
            JVPCLASSPATH d:/informix/extend/krakatoa/jdbc.jar;d:/informix/extend/krakatoa/
            krakatoa.jar;d:/java/jdbc211jc1/lib/ifxsqlj.jar;d:/informix/extend/SQLjDemo.1.0

Note that in this example, the Informix installation directory is D:\informix.

Most of the values here were inserted automatically when Foundation was installed. However, it's worth reiterating a couple of comments about JVPCLASSPATH:

• In any installation where Krakatoa is enabled, JVPCLASSPATH will include the path to the jdbc.jar and krakatoa.jar (or their debugging equivalents) in $INFORMIXDIR/extend/krakatoa. If you are going to use embedded SQL, however, you must add the full path to the ifxsqlj.jar file in your JDBC installation.
• SQLj standards call for your Java routines to be bundled in .jar files, and for those .jar files to be stored in the database by means of the install_jar() SQL routine. The corresponding SQL routine is then mapped to the stored .jar file.
  
  For any Java UDR, an alternative to this approach is to map your SQL routine directly to the .class file for your Java implementation, and enable the server to find your .class file by naming its directory in your server's JVPCLASSPATH variable.
  
  At the time of this writing, Java UDRs that include embedded SQL must use the latter method.
• JVPCLASSPATH is (at the time of this writing) limited to 256 characters. If you include a large number of directories where .class files will be stored, then you may overrun this limit, and your UDR will fail at runtime.
  
  An alternative syntax allows you to specify JVPCLASSPATH as the name of a file, for instance:
  
  JVPCLASSPATH file:d:/informix/extend/krakatoa/classpath.txt
  
  The content of classpath.txt takes exactly the same format as the text in your server configuration file would: full pathnames separated by semicolons on NT, or colons on Unix, all on a single line. In this case, however, the length of the line is not limited to 256 characters.

Development Environment

Developing a Java UDR that uses embedded SQL is not much different from developing any other Java UDR:

• You'll need access to JDK 1.2.x (1.2.x is compatible with the Java Runtime Environment (JRE) that is included with Krakatoa), so you'll need to set your PATH environment variable to include the "bin" directory of your JDK installation.
• You'll want to have access to your Informix installation, so that you can test your UDR-in-progress. This means having INFORMIXDIR set to point to the root of your Informix installation, and including $INFORMIXDIR/bin in your PATH.

However, there's one additional requirement:

• Set CLASSPATH to include each of the .jar files in the lib directory of your JDBC installation. You can use either the debug versions, whose names end with "-g.jar", or the optimized versions.

Runtime Environment

Other than configuring your server as described above, there are no special runtime requirements for using Java UDRs with embedded SQL.

Embedded SQL Syntax

This paper can present only the barest minimum of information about embedded SQL syntax, but it does seem appropriate to take a quick look at it here. Much more information about SQLj syntax can be found in the demo programs included with the Informix JDBC Driver distribution. Remember, however, when reviewing those demos, that they are client applications, and are not server-side Java routines.

In this section, we'll look at:

• Filenames
• SQLj import files
• Establishing a database connection
• Embedded SQL syntax

Filenames

As with other Java programs, the names of those using embedded SQL are case sensitive. The precompiler will generate a .java file with the same name prefix, and the compiler will generate a .class file with the same name prefix.

The filename extension used for Java embedded SQL programs is ".sqlj".

SQLj import files

Your "import" list must include:

1. java.sql.* (Since you will be using SQL to access a database.)
2. com.informix.jdbc.* (The precompiler translates your SQL statements into JDBC calls.)
3. sqlj.runtime.* (To provide runtime support for sqlj.)
4. sqlj.runtime.ref.DefaultContext (For access to the underlying routines that establish your database connection.)

Establishing a Database Connection

In a client application using Java embedded SQL, there are a lot of options for establishing database connections, including multiple concurrent connections to several databases or server installations. To support this flexibility, SQLj uses the concept of a "context" to extend the simpler idea of a "connection", and it provides a whole range of classes and methods for managing "contexts".

Since a UDR runs inside the server, it only needs a "DefaultContext". You get a DefaultContext from a database connection that is obtained by using the JDBC DriverManager.getConnection() call, and supplying a "direct connection" database URL:

public static Connection conn = null;
            public static String DRIVER = "com.informix.jdbc.IfxDriver";
            public static String DBURL = "jdbc:informix-direct";
            ...
            public static Connection newConnection() throws SQLException {
            // Load the JDBC driver
            try {
            Class.forName( DRIVER );
            }
            ...
            // Get a database connection
            try {
            conn = DriverManager.getConnection (DBURL);
            }
            ...
            // Use the connection to get a connection context
            DefaultContext ctx = DefaultContext.getDefaultContext();
            try {
            ctx = new DefaultContext(newConnection());
            }
            ...
            }   

Please refer to the downloadable demo for a complete example.

Embedded SQL syntax

Once you have established a database connection, and obtained a DefaultContext, accessing information stored in a database is simple. You'll need a program variable of the appropriate type to receive the data, and an SQL statement to retrieve it.

If you have a table like this:

          CREATE TABLE excuses (id integer, words lvarchar);
            INSERT INTO excuses VALUES (1, "Dog ate my homework");
            INSERT INTO excuses VALUES (2, "Missed the bus");
            INSERT INTO excuses VALUES (3, "I Forgot!"); 

Then you could retrieve the text of an excuse into a program variable like this:

          ...
            String excuse = new String();
            #sql {
            SELECT words
            INTO :excuse
            FROM excuses
            WHERE id = 3
            }; 

Note that the program variable "excuse" is preceeded by a colon when used in the SQL statement. It's important to note, too, the placement of the semicolon that terminates the SQL statement: It follows the closing bracket.

Complete information about mapping Informix data types to JDBC data types can be found in the Informix JDBC Driver Programmer's Guide, which is included with your JDBC distribution.

Compiling Embedded SQL Java Programs

Compiling a Java UDR containing embedded SQL is simple, and is identical to compiling a client application that contains embedded SQL. If your source file is "Foo.sqlj", then compile it like this:

java ifxsqlj Foo.sqlj

ifxsqlj will precompile Foo.sqlj into Foo.java, then will call javac to compile Foo.java into Foo.class.

Along the way, two additional files are generated:

• Foo_SJProfile0.ser
• Foo_SJProfileKeys.class

These files contain hooks for vendor-specific customizations, as provided by the SQLj standards. In this way, vendors can optimize the implementation of embedded SQL statements for their own database products, and still retain a vendor-neutral, portable compiled object.

Tip: In the current release of the SQLj package, ifxsqlj may hang and produce no feedback at all if it encounters certain syntax errors in your code. If this happens, break out with ^C, then try to compile the generated .java file manually: javac Foo.java . The javac compiler will flag the errors in the .java file, and you can trace them back to your .sqlj code.

All three of the files generated by a successful compile will need to be made available to the server at runtime, by placing them in a directory named in your server's JVPCLASSPATH entry.

The hard part is done now: You've written your UDR and successfully compiled it. Now all you need to do is "register it to a database", which amounts to mapping it to an SQL routine.

Let's assume we have a "bladelet" with a single routine, "Foo()". Let's also assume we're going to follow the convention that most DataBlades do, and store our "Foo" files in "$INFORMIXDIR/extend/Foo". We'll call the script that maps our "Foo" Java routine to an SQL "Foo" routine -- that "registers the UDR to the database" -- "register.sql".

Following this convention, $INFORMIXDIR/extend/Foo will contain:

• register.sql
• Foo.class
• Foo_SJProfileKeys.class
• Foo_SJProfile0.ser

Your register.sql script looks like this:

create procedure testmain()
            external name 'Foo.Foo()'
            language java; 

The first "Foo" in the "external name" identifies the Java class, and the second "Foo" refers to the method name within that class.

How does the server find the class? It looks in each of the directories named in its JVPCLASSPATH variable until it finds the one with the name "Foo.class". If we've remembered to include d:\informix\extend\Foo in our JVPCLASSPATH entry, the server will find it.

IBM, DB2, Informix, and WebSphere are trademarks or registered trademarks of IBM Corporation in the United States, other countries, or both.

Windows and Windows NT are registered trademarks of Microsoft Corporation in the United States, other countries, or both.

Java and all Java-based trademarks and logos are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.

Other company, product, and service names may be trademarks or service marks of others.

利用 DB2 UDB 来使用 Java CachedRowSet 实现

断开连接

将此页作为电子邮件发送

未显示需要 JavaScript 的文档选项

样例代码

级别: 初级

Kulvir Singh Bhogal (kbhogal@us.ibm.com), IBM Software Services for WebSphere, IBM Corporation

2004 年 8 月 01 日

高速缓存行集（Cached Row Set）是 Java™ 1.5 提供的一项新功能，源自 JSR114 的努力。这一新功能使您可以拥有一个可串行化的断开连接的对象。这意味着您可以连接到数据库，以结果集的形式取得数据，释放连接并在本地操纵这些数据，然后恢复连接以完成事务，这样可以大大减少对连接和服务器资源的使用。本文展示这一切是如何利用 DB2® Universal Database™ 来实现的，并包含示例代码。

简介

应该把数据库连接看作是一种被应用程序广泛使用的宝贵资源。尤其是在高流量的 Web 站点中，客户机应该使用由应用程序服务器（例如，IBM WebSphere® Application Server）管理的数据库连接池中的数据库连接，并在其必要的事务发生之后释放数据库连接，这一点很重要。

在许多情况下，事务会话会持续较长一段时间，占用着数据库连接，直到完成。过去，Java 程序员一直使用没有高速缓存解决方案的 JDBC API。高速缓存解决方案允许用户在本地高速缓存结果集，释放连接，操纵结果集数据，并在稍后的时间点与数据库同步。在本文中，我将介绍 javax.sql.RowSet 接口的实现，该实现允许我们实现高速缓存解决方案。

回页首

获得 RowSet 实现

javax.sql.RowSet 接口是在 J2SE Version 1.4 中引入到 Java 语言的。随着 Java 2 Standard Edition version 1.5 的发布，我们将会看到该接口的增强和绑定到语言的接口实现。 RowSet 接口是 JSR 114的结果，JSR 114 勾勒了一个方案，也就是“将表格数据与数据源分隔开……”，从而增加“应用程序的可扩展性和编程模型的灵活性”。我使用 beta 版本的 Tiger (Java 1.5) 来进行开发。如果您使用的是以前版本的 Java，应该尝试 RowSet 的参考实现，可以 从 Sun Microsystems 下载参考实现。对于我们的例子，我们将利用 CachedRowSet 实现。

回页首

您以前看到过 RowSet 实现

本文中突出展示的 CachedRowSetImpl 类是 javax.sql.Rowset 接口的一个实现。 javax.sql.Rowset 扩展了 java.sql.ResultSet 接口。因此，如果您熟悉 javax.sql.ResultSet 接口，我是这样假设的，那么您会认出 CachedRowSetImpl 提供的许多方法。 java.sql.RowSet 接口提供您在标准 JDBC 2.0 ResultSet 中看到过的所有方法；附加价值是，我们不需要连续使用数据库连接。就相当于我们可以走进商店，取走商品目录之后进行挑选，然后再带着填好的订单回到商店。

回页首

使用 CachedRowSet

CachedRowSet 是一个 JavaBean。您可以通过使用现有的 ResultSet 对象，或者通过指定连接连接信息和 SQL 查询，来填充 CachedRowSet 。我们采用后一种方法。但是，首先为我们的沙箱创建一个小的 DB2 数据库。

db2 => create database cachedex

我假设在您的机器上具有一个叫做 db2admin 的用户，口令为 db2admin：

db2=> connect to cachedex user db2admin using db2admin

创建一个名为 cachetbl 的表：

db2=> create table cachetbl (id int primary key not null, firstname varchar(40) not null, lastname varchar(40) not null)

然后用以下行填充该表：

insert into cachetbl values (12345,’Kulvir’,’Bhogal’)
insert into cachetbl values (23456,’Meet’,’Feona’)
insert into cachetbl values (34567,’Bicky’,’Singh’)

我提供的示例代码建立一个到 DB2 的直接连接。如果您是通过由应用程序服务器（比如 IBM WebSphere Application Server）管理的池获得数据库连接，那么可以使用 execute 方法的另一种形式，该方法利用 java.sql.Connection 对象作为参数。通过阅读我的相关主题的文章 Using Data Sources the Right Way，可以更多地了解使用数据源 —— 一种 J2EE 最佳实践。

回页首

可串行化

javax.sql.RowSet 的实现可以被串行化。对于处理 Enterprise Java Beans 的程序员来说，这是一个比较好的消息。标准 JDBC 2.0 ResultSets 是不可串行化的，这使得是否需要使用定制对象，以便 ResultSet 数据可以被发送回 EJB 设置中的客户机以进行操纵或查询，成了一个争论。有了 RowSet 实现的出现，我们就可以串行化 ResultSets ，将它们发送到我们的客户机，然后我们的客户机可以读取和更新 ResultSet ，并将它发送回服务器。

回页首

可滚动

CachedRowSetImpl 实现是可滚动的，所以允许您在 RowSet 给出的记录集中向前和向后滚动。这在 JDBC 2.0 ResultSet 中是允许的。但是以前，在滚动发生期间必须维护一个会话。现在，我们可以在离线数据中滚动了。

回页首

作一个数据完整性的乐天派

您可能会想，如果在客户机 A 将更改与数据库服务器进行同步之前，客户机 A 上缓存的数据被另一个客户机（客户机 B）操纵，那将会发生什么事情。 CachedRowSet 的默认实现不对数据库服务器维护锁。参考实现使用乐观的同步。具体地说就是，如果客户机 A 试图操纵的数据在数据库服务器上没有更改，那么更新将会被数据库接受。但是，如果在次期间目标数据被更改，就会抛出一个同步异常。注意，这种乐观方法也是参考实现处理并发性的方式。其他实现可能采取不同的并发策略；规范并不强制要求使用某个特定的并发模型。

回页首

查看起作用的东西

我提供了一个 示例程序，该程序演示了 CachedRowSetImpl 提供的一些功能。这些代码都可以在文件 DisconnectedExample.java 中找到。我将解释该程序的一些部分，以便您可以理解我想要传达的内容。注意，要运行示例应用程序，需要在运行时类路径中包含 DB2 Universal JDBC 驱动程序 (db2jcc.jar)。还需要包含 db2jcc_license_cu.jar 文件。关于设置环境的更多信息，请参考我的文章： Hooking Up with DB2 Universal Database Version 8 using Java。

Class.forName("com.ibm.db2.jcc.DB2Driver");
CachedRowSet crs = new CachedRowSetImpl();
crs.setUsername("db2admin"); crs.setPassword("db2admin"); crs.setUrl("jdbc:db2://localhost:50000/cachedex"); crs.setCommand("SELECT id,firstname,lastname from cachetbl");
crs.execute();
System.out.println("---------------------------");
// display size of cached row set
System.out.println("Size: " + crs.size() + " records");
// display records in cachedrowset
while (crs.next())
{
System.out.println(crs.getRow() + " - " + crs.getString("firstname") + " " + crs.getString("lastname"));
}
System.out.println("---------------------------");

在上面的代码中，我创建了一个 com.sun.rowset.CachedRowSetImpl 对象。注意我是如何为 CachedRowsetImpl 对象指定数据库连接信息的。我用 setCommand 方法来指定想要执行的查询。当发出 execute 方法时，就会填充 CachedRowSetImpl 对象。就是在该方法调用中，我们获得然后再关闭数据库连接。然后我可以在对象中迭代，并使用 getter 方法来抽取和报告其中包含的数据。

正如前面所提到的， CachedRowSetImpl 对象是可滚动的。下面的代码例示了这项功能，我在该代码中使用 last() 和 previous() 方法在数据间前后滚动。

System.out.println("Showcase scrollability");
// move backwards through rowset
// scroll to last row
crs.last();
// iterate to next row
while (crs.previous())
{
// report current row contents
System.out.println(crs.getRow() + " - " + crs.getString("lastname"));
}

方法 first() 和 next() 也可用于在数据间滚动。

为了演示从数据库断开连接的能力，示例程序设计为暂停，并让您实际地执行生动的操作，即停止 DB2，以真正了解 CachedRowSet 功能的优势。在继续操作（由完成 BufferedReader 对象的一个简单 readLine 而推动）之前，应用程序等待按下任意键。当示例程序提示您停止 DB2 时，可以在一个新的 DB2 命令行处理器窗口中使用下面的命令：

db2 force applications all

然后再使用

db2stop

来强迫 DB2 的停止。

尽管数据库已经停止，但是下面的代码必须执行：

System.out.println("Demonstration of how to update cached row set"); crs.updateString("lastname","Kaur");
// commit changes to cached portion of rowset
crs.updateRow();
System.out.println(crs.getRow() + " - " + crs.getString("lastname"));

在上面的代码中，我们更改了当前行条目的 last name 字段。注意，对 CachedRowSetImpl 对象使用了 updateRow() 方法，以记录对该对象的更改。在这一时间点，数据库还没有被更新。正如您可以回想起的，数据库 甚至没有运行。应用程序将提示您启动 DB2。为此，可以从 DB2 命令行处理器发出下面的命令：

db2start

在 DB2 启动之后，按任意键继续示例应用程序。

此时，下面的代码将会运行，这将有效地在数据库中同步更改。

crs.acceptChanges();

通过对 cachetbl 执行一个选择查询，可以确认数据库实际上已经更新，如 图 1所示：

图 1. 确认更新更改已经与数据库同步

为了结束我们对 CachedRowSet 的动手研究，示例应用程序还演示了如何插入和删除行。要执行插入，必须将光标移动到一个叫做“插入行”的特殊位置。在这里，我们使用更新方法来填充新行。当我们使用 insertRow() 方法时， CachedRowSetImpl 对象就会被更新。当执行 acceptChanges() 方法时，更改就被持久地存储到数据库中。

以下代码演示了这一点：

// move the cursor to a blank row crs.moveToInsertRow();
// populate the new row
crs.updateInt(1,01234);
crs.updateString(2,"Judith");
crs.updateString(3,"Smith");
// insert the new row
crs.insertRow();
// move cursor back to previous position
crs.moveToCurrentRow();
// synchronize changes to database
crs.acceptChanges();

在插入完成之后程序将会暂停，以允许您在数据库中查询插入。

从对象删除行相当直观。只需要将光标定位到想要删除的地方，然后使用 deleteRow 方法即可。跟前面一样，需要一个后续的同步，以将更改持久存储到数据库中：

// delete row (where the cursor is currently positioned)
crs.deleteRow();
// synchronize changes to database
crs.acceptChanges();

回页首

只是一种实现

读者应该注意， javax.sql.RowSet 接口的 CachedRowSetImpl 实现只是一种实现（更确切地说是参考实现）。其他供应商也拥有 RowSet 的实现，这些实现与参考实现处理问题（比如数据完整性）的方式可能会不同（例如，第三方实现可能会对服务器进行锁维护）。

回页首

普遍含义

可更新的“断开连接的” ResultSets 在普遍世界中具有各种含义，其中，网络连接可以是断断续续的。使用 CachedRowSet 可以允许客户机在连接可用时将数据缓存在本地，然后重新连接，以同步对数据执行的更改。

回页首

谨慎使用

断开连接具有其优点。但是用户必须理解，断开连接的对象是保存在内存中。因此，不应该使用具有大型结果集的方法。大型结果集的相应更新和滚动会是耗资源的操作。

回页首

结束语

与标准 JDBC 2.0 ResultSet 不一样，利用 CachedRowSet 不再需要连续使用数据库连接。因为数据库连接池中的数据库连接是宝贵的资源，所以连接数据库、断开连接，然后重新连接以便同步数据库，这种能力无疑是非常受欢迎的。

回页首

致谢

作者感谢 IBM Life Sciences Development 的 Richard Dettinger 对本文的审稿。

回页首

下载

名字 大小 下载方法

DisconnectedExample.java

4.03 KB

HTTP

关于下载方法的信息

Get Adobe® Reader®

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文.
• 下载本文中使用的 源代码。
• 文章 Using Data Sources the Right Way（ Java Pro，2004 年 2 月），告诉您如何通过 IBM WebSphere Application Server 设置 5.0 版本数据源。
• 文章 Hooking Up with DB2 Universal Database Version 8 using Java（ InformIT，2004 年 4 月），告诉您 DB2 UDB 和 JDBC 如何入门。
• 了解更多的 JSR 114 JDBC rowset 实现。
• 从 Sun Microsystems 下载 JDBC 参考实现。
• 检查 developerWorks Java 技术，了解关于开发 Java 应用程序的更多信息和资源。
• 检查 developerWorks DB2 Java 技术页面，了解关于开发特定于 DB2 的 Java 应用程序的信息和资源。

关于作者

Kulvir Singh Bhogal 是一名 IBM 顾问，他为全国性的客户网站设计和实现以 Java 为中心的解决方案。 .

源文档 <http://www.ibm.com/developerworks/cn/db2/library/techarticles/dm-0406bhogal/index.html>