对于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 开发存储过程也是可行的。