Caused by: java.io.FileNotFoundException: /home/jboss/jboss-5.1.0.GA/server/default/deploy/card.war/WEB-INF/web.xml (Too many open files)
 at java.io.FileInputStream.open(Native Method)
 at java.io.FileInputStream.<init>(FileInputStream.java:120)
 at org.jboss.net.protocol.file.FileURLConnection.getInputStream(FileURLConnection.java:128)
 at org.jboss.virtual.plugins.context.AbstractURLHandler.openStream(AbstractURLHandler.java:203)
 at org.jboss.virtual.VirtualFile.openStream(VirtualFile.java:230)
 at org.jboss.virtual.VFSInputSource.getByteStream(VFSInputSource.java:66)
 ... 44 more

这是因为linux限制了打开文件的最大句柄数量。

linux默认的打开文件数量是1024，我们可以用ulimit -a 来查看系统资源，例如：

[root@redhat ~]# ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
file size               (blocks, -f) unlimited
pending signals                 (-i) 1024
max locked memory       (kbytes, -l) 32
max memory size         (kbytes, -m) unlimited
open files                   (-n) 1024 --打开最大文件数量限制
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
stack size              (kbytes, -s) 10240
cpu time               (seconds, -t) unlimited
max user processes              (-u) 16384
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

解决该问题的宗旨是：增大打开文件最大句柄限制数，该数是1024的整数倍

1.临时增大open files的限制值

  可以用ulimit -n 来临时增大该限制值，但是一旦重启服务器后，该值又会恢复到1024。只能暂时性的解决问题。命令如下：

[root@redhat ~]# ulimit -n 65536
[root@redhat ~]# ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
file size               (blocks, -f) unlimited
pending signals                 (-i) 1024
max locked memory       (kbytes, -l) 32
max memory size         (kbytes, -m) unlimited
open files                      (-n) 65536
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
stack size              (kbytes, -s) 10240
cpu time               (seconds, -t) unlimited
max user processes              (-u) 16384
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

2.彻底增大open files的限制值

  一般情况下，我们都会通过修改系统限制文件来彻底增大open files的值。

2.1 通过VI打开/etc/security/limits.conf，在“# End of file”上面添加如下：

    *  -  nofile  65536

    该语句表示：每一个用户的默认打开文件数是65536

2.2 通过VI打开/etc/sysctl.conf,在最后一行添加如下： 
  
     fs.file-max = 65536 
  
2.3 重启ssh服务
修改ssh server配置文件：/etc/ssh/sshd_config
UseLogin yes

重启ssh 用/etc/init.d/sshd restart

此时再用ulimit -a来查看： 
[root@redhat ~]# ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
file size               (blocks, -f) unlimited
pending signals                 (-i) 1024
max locked memory       (kbytes, -l) 32
max memory size         (kbytes, -m) unlimited
open files                      (-n) 65536
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
stack size              (kbytes, -s) 10240
cpu time               (seconds, -t) unlimited
max user processes              (-u) 16384
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

（如果还不行可以重启下服务器试试）

本文分两部分：FLASH编程 和 Java编程，此文记录的仅仅是我在探索中的一些收获，其中用了很多个人化的描述语言，并不是业界标准的用语。 ：）

探索笔记：

目前国内Flash应用大部分还是在制作精美的动画方面，但据我了解早在Flash4 的时代，国外一些人就已经开始将flash技术运用于开发动态网站（和php、asp、jsp结合）和开发应用程序（象网络游戏、远程管理等应用软件）的项目中了。而直到今日，这方面在国内发展还是比较缓慢（有一部分原因是少数人掌握了关键技术，但不愿意共享出来）。因此，我将致力于推动国内flash技术在开发动态网站和开发应用程序方面的发展，并将自己亲手写的代码公布到网络中，以便于大家共享、交流。

涉及到的知识范畴：

1. socket概念
2. java编程语言
3. Flash MX ActionScript中的XMLSocket

实时网络游戏也属于大型应用程序范畴，一个关键环节就是建立实时主动通信环境（相对的，有个称为被动通。信的方式，最好的例子就是你正在用IE浏览器浏览一个网站，此时浏览器和服务器之间就是被动通信方式：如果你不点击一个连接，发送一个WEB页面请求到WEB服务器，WEB服务器是不会主动向你的浏览器发送任何页面的）。在此Socekt API就成为了首选。限于篇幅，这里不再过多解释socket的含义，只希望大家能记住一点，只要建立能够实时通信的应用程序就需要建立socket连接。

【客户端FLASH编程部分】

从mx自带的as字典中可以看出，Flash在网络通信方面得到了非常大的加强。"The XMLSocket object is useful for client-server applications that require low latency, such as real-time chat systems"注意最后的一小段话：such as real-time chat systems（译文：例如实时聊天系统）

通过调用XMLSocket方法FLASH就可以和一些由强大语言编写的服务器应用程序进行通信，进而开发出各种实时信息交流系统。所以我们的目标锁定在XMLSocket！

另外值得注意的是：有很多人一看到XMLSocket前面的XML三个字母，就觉得头疼，以为必须先熟悉甚至精通XML才能使用这个对象及其方法，但我要说的是在你不太了解XML的阶段，只要把XML信息看成是一个随意长度（>0）的字符串，把XMLSocket看成是一个只是用来发送字符串数据的对象就好办多了。

我们还是从分析代码着手，来跨进开发FLASH实时网络游戏的大门吧：

//建立XMLSocket对象
var mySocket = new XMLSocket();
mySocket.connect("127.0.0.1",3000);
//测试建立socket连接是否成功
mySocket.onConnect = function(success) {
  if(success) {
    trace("connect ok"); 
  } else {
    trace("connect failed");
  }
}
//End for 测试是否连接成功 

成功建立连接后 向服务器端发送一个测试用的字符串，以便服务器端能显示出信息。

mySocket.send("this is a testing String !!!");

FLASH中的程序就先到此，因为是基础篇，所以不会涉及太多的其他东西，呵呵。

【服务器端java程序部分】

import java.io.*;
import java.net.*;
public class LocalServer {
  protected int listenPort = 3000;
  public void acceptConnections() {
  try {
    ServerSocket server = new ServerSocket(this.listenPort);
    //在服务器端,我们需要ServerSocket对象以便建立服务,参数是兼听的端口号
    Socket incomingConnection = null;//创建一个客户端的Socket变量,以接收从客户端监听到的Socket
    handleConnection处理
    System.out.println("Server端正在等待一个socket连接......");
    incomingConnection = server.accept();//调用该 ServerSocket 的 accept()来告诉它开始侦听
    System.out.println("一个socket客户端已经连接过来......");
    handleConnection(incomingConnection);
    } catch (BindException e) {
      System.out.println("Unable to bind to port " + listenPort);
      }
  catch (IOException e) {
    System.out.println("Unable to instantiate a ServerSocket on port: " + listenPort);
    }
  }
  public void handleConnection(Socket incomingConnection) {
    System.out.println("\r\n正在对此连接进行处理......");
    try {//首先获取同Socket相关联的流outputToSocket和InputStream
//其中outputToSocket是要返回给客户端Socket的流
//InputStream是客户端发来的请求
      otputStream outputToSocket = incomingConnection.getOutputStream();
      InputStream inputFromSocket = incomingConnection.getInputStream();
      BufferedReader streamReader = new BufferedReader(new InputStreamReader(inputFromSocket));
//首先要将InputStream转换到BufferedReader中
      String line = null;
      while ((line = streamReader.readLine()) != null) {
        System.out.println(line); 
        //从streamReader中读出信息，直接输出到默认输出设备中(本例中是指dos窗口)
      }
    System.out.println("\r\n\r\n接受信息完毕！");
//完成之后关闭所有流,注意关闭Socket流的顺序
    streamReader.close();
    } catch (Exception e) {
      System.out.println("Error handling a client: " + e);
    }
  }
//主程序，建立sever实例对象，然后运行对象的acceptConnections()方法
  public static void main(String[] args) {
    LocalServer server = new LocalServer();
    server.acceptConnections();
  }
}

java服务端程序就到此为止了，此时已经能够建立起一个最简单的C/S结构通信体系。

在此基础上再增加适当的东西 就能够开发出任何应用程序或者网络游戏。

   
       附注：发现又有上一篇的错误，中文版的Eclipse在新建项目时，比较容易有“由于类路径错误（不完整或涉及循环），所以未构建项目。”这类的错误。好办，因为中文包只是一些文本文件，对开发没用，用前面一篇所说的方法删除那些对中文包的引用（前面字符为ECLIPSE_HOME_LANGUAGE_LINK…….），如下图：  

  
二、插件开发的几个关注点。 
　　a) 库引用。如上附注所说库引用是在建立插件初期要设置好的地方，不过一经设置基本不需要再改变。功能类似于JDK的classpath或者Jbuilder里的库引用。 
　　b) 插件JAVA源代码。今后主要的工作，狂写代码吧。主要都是一些*.JAVA文件。 
　　c) 项目根目录下的plugin.xml文件。这个文件是插件的入口文件，Eclipse根据这个文件中的设置来加载插件。代码写完了，要让Eclipse加载你的代码就要在这里面做些手脚了，这些手脚有个术语叫“设置扩展点”。象在Eclipse的加个主菜单、视图、按钮，都在这个文件里面做不同的扩展点，后面的教程会看到这个文件的使用。要人会说那我开发一个系统会有很多的菜单和按钮，那是不是都要设置这个文件呢？回答：不必，这里面只设置主要和Eclipse接壤的扩展点，其它系统里的菜单按钮就没必要了，今后会讲到。 
  
三、设置库引用。 
　　在删除了上面附注所说的无用且出错的引用，接下来我们要加入一些开发插件要用到的库。是那些呢？呵呵，前面我们还是用向导建立了一个helloword插件吗，参考它的就行了。如下图： 

  
　　手工加可真累，这里有个好办法。把目录C:\eclipse2.1.3\eclipse\workspace\myplugin\下的.classpath文件拷贝到C:\eclipse2.1.3\eclipse\workspace\myplugin2目录就行了。所有关于库引用的设置全保存在这个文件中。最后别忘记刷新一下项目，如下图所示： 

附注说明：

　　有些文章在这里是用“文件>导入...>外部插件和段”来提供插件开发支持库的引用，本文不采用这种方法，因为这种会将支持库（也是一种插件项目）会新建很多相应项目，让开发界面显得很乱。还不如本文所用的建立库引用变量的方法方便简洁。  
  

四、写源代码。 
　　a) 新建一个包。方法如下图所示。 
　　　

　　包名如下： 

　　　
  
　　结果如下： 

　　　

  
　　b) 然后将上一章的myplugin的SampleAction直接移动本项目myplugin2中就可以了（Eclipse支持鼠标拖拉操做）。 
　　c)  本文SampleAction做了一些小修改（删除了注释和构造函数）。代码如下：  

五、在plugin.xml文件中加入扩展点的代码。 
　　库将本项目plugin.xml文件打开，并转到其源代码视图。将如下代码加入到“</runtime>”之后。（这些xml还是从上一章的项目搬过来的  

当然，我还看到别人考虑的几种方法：
1.生成计算题，比如20+34*(23-12)=?，用户必须输入正确的答案才能通过验证，这个想法挺好，但是用户必须打开计算器进行计算，增加了用户的难度
2.问一些常见的问题，比如“人”这个字由几笔组成。这也是不错的想法，关键是必须有上万条的题库，而且题库的答案必须是明确的，简单易比较的，这个难度也较大。

下面是彩色汉字验证码的代码。

<%@ page contentType="image/jpeg" import="java.awt.*,java.awt.image.*,java.util.*,javax.imageio.*" %>
<%!

//生成随机颜色
Color getRandColor(Random random,int fc,int bc)
{
        if(fc>255) fc=255;
        if(bc>255) bc=255;
        int r=fc+random.nextInt(bc-fc);
        int g=fc+random.nextInt(bc-fc);
        int b=fc+random.nextInt(bc-fc);
        return new Color(r,g,b);
}
%>
<%
//设置页面不缓存
response.setHeader("Pragma","No-cache");
response.setHeader("Cache-Control","no-cache");
response.setDateHeader("Expires", 0);

// 设置图片的长宽
int width=176, height=30;
//设置备选汉字，剔除一些不雅的汉字
String base = "\u7684\u4e00\u4e86\u662f\u6211\u4e0d\u5728\u4eba\u4eec\u6709\u6765\u4ed6\u8fd9\u4e0a\u7740\u4e2a\u5730\u5230\u5927\u91cc\u8bf4\u5c31\u53bb\u5b50\u5f97\u4e5f\u548c\u90a3\u8981\u4e0b\u770b\u5929\u65f6\u8fc7\u51fa\u5c0f\u4e48\u8d77\u4f60\u90fd\u628a\u597d\u8fd8\u591a\u6ca1\u4e3a\u53c8\u53ef\u5bb6\u5b66\u53ea\u4ee5\u4e3b\u4f1a\u6837\u5e74\u60f3\u751f\u540c\u8001\u4e2d\u5341\u4ece\u81ea\u9762\u524d\u5934\u9053\u5b83\u540e\u7136\u8d70\u5f88\u50cf\u89c1\u4e24\u7528\u5979\u56fd\u52a8\u8fdb\u6210\u56de\u4ec0\u8fb9\u4f5c\u5bf9\u5f00\u800c\u5df1\u4e9b\u73b0\u5c71\u6c11\u5019\u7ecf\u53d1\u5de5\u5411\u4e8b\u547d\u7ed9\u957f\u6c34\u51e0\u4e49\u4e09\u58f0\u4e8e\u9ad8\u624b\u77e5\u7406\u773c\u5fd7\u70b9\u5fc3\u6218\u4e8c\u95ee\u4f46\u8eab\u65b9\u5b9e\u5403\u505a\u53eb\u5f53\u4f4f\u542c\u9769\u6253\u5462\u771f\u5168\u624d\u56db\u5df2\u6240\u654c\u4e4b\u6700\u5149\u4ea7\u60c5\u8def\u5206\u603b\u6761\u767d\u8bdd\u4e1c\u5e2d\u6b21\u4eb2\u5982\u88ab\u82b1\u53e3\u653e\u513f\u5e38\u6c14\u4e94\u7b2c\u4f7f\u5199\u519b\u5427\u6587\u8fd0\u518d\u679c\u600e\u5b9a\u8bb8\u5feb\u660e\u884c\u56e0\u522b\u98de\u5916\u6811\u7269\u6d3b\u90e8\u95e8\u65e0\u5f80\u8239\u671b\u65b0\u5e26\u961f\u5148\u529b\u5b8c\u5374\u7ad9\u4ee3\u5458\u673a\u66f4\u4e5d\u60a8\u6bcf\u98ce\u7ea7\u8ddf\u7b11\u554a\u5b69\u4e07\u5c11\u76f4\u610f\u591c\u6bd4\u9636\u8fde\u8f66\u91cd\u4fbf\u6597\u9a6c\u54ea\u5316\u592a\u6307\u53d8\u793e\u4f3c\u58eb\u8005\u5e72\u77f3\u6ee1\u65e5\u51b3\u767e\u539f\u62ff\u7fa4\u7a76\u5404\u516d\u672c\u601d\u89e3\u7acb\u6cb3\u6751\u516b\u96be\u65e9\u8bba\u5417\u6839\u5171\u8ba9\u76f8\u7814\u4eca\u5176\u4e66\u5750\u63a5\u5e94\u5173\u4fe1\u89c9\u6b65\u53cd\u5904\u8bb0\u5c06\u5343\u627e\u4e89\u9886\u6216\u5e08\u7ed3\u5757\u8dd1\u8c01\u8349\u8d8a\u5b57\u52a0\u811a\u7d27\u7231\u7b49\u4e60\u9635\u6015\u6708\u9752\u534a\u706b\u6cd5\u9898\u5efa\u8d76\u4f4d\u5531\u6d77\u4e03\u5973\u4efb\u4ef6\u611f\u51c6\u5f20\u56e2\u5c4b\u79bb\u8272\u8138\u7247\u79d1\u5012\u775b\u5229\u4e16\u521a\u4e14\u7531\u9001\u5207\u661f\u5bfc\u665a\u8868\u591f\u6574\u8ba4\u54cd\u96ea\u6d41\u672a\u573a\u8be5\u5e76\u5e95\u6df1\u523b\u5e73\u4f1f\u5fd9\u63d0\u786e\u8fd1\u4eae\u8f7b\u8bb2\u519c\u53e4\u9ed1\u544a\u754c\u62c9\u540d\u5440\u571f\u6e05\u9633\u7167\u529e\u53f2\u6539\u5386\u8f6c\u753b\u9020\u5634\u6b64\u6cbb\u5317\u5fc5\u670d\u96e8\u7a7f\u5185\u8bc6\u9a8c\u4f20\u4e1a\u83dc\u722c\u7761\u5174\u5f62\u91cf\u54b1\u89c2\u82e6\u4f53\u4f17\u901a\u51b2\u5408\u7834\u53cb\u5ea6\u672f\u996d\u516c\u65c1\u623f\u6781\u5357\u67aa\u8bfb\u6c99\u5c81\u7ebf\u91ce\u575a\u7a7a\u6536\u7b97\u81f3\u653f\u57ce\u52b3\u843d\u94b1\u7279\u56f4\u5f1f\u80dc\u6559\u70ed\u5c55\u5305\u6b4c\u7c7b\u6e10\u5f3a\u6570\u4e61\u547c\u6027\u97f3\u7b54\u54e5\u9645\u65e7\u795e\u5ea7\u7ae0\u5e2e\u5566\u53d7\u7cfb\u4ee4\u8df3\u975e\u4f55\u725b\u53d6\u5165\u5cb8\u6562\u6389\u5ffd\u79cd\u88c5\u9876\u6025\u6797\u505c\u606f\u53e5\u533a\u8863\u822c\u62a5\u53f6\u538b\u6162\u53d4\u80cc\u7ec6";
//备选汉字的长度
int length = base.length();

//创建内存图像
BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
// 获取图形上下文
Graphics g = image.getGraphics();

//创建随机类的实例
Random random = new Random();

// 设定图像背景色(因为是做背景，所以偏淡)
g.setColor(getRandColor(random,200,250));
g.fillRect(0, 0, width, height);

//备选字体
String[] fontTypes = {"\u5b8b\u4f53","\u65b0\u5b8b\u4f53","\u9ed1\u4f53","\u6977\u4f53","\u96b6\u4e66"};
int fontTypesLength = fontTypes.length;

//在图片背景上增加噪点
g.setColor(getRandColor(random,160,200));
g.setFont(new Font("Times New Roman",Font.PLAIN,14));
for (int i=0;i<6;i++)
{
    g.drawString("*********************************************",0,5*(i+2));
}

//取随机产生的认证码(6个汉字)

//保存生成的汉字字符串
String sRand="";
for (int i=0;i<6;i++)
{
    int start = random.nextInt(length);
    String rand=base.substring(start,start+1);
    sRand+=rand;
    
    //设置字体的颜色
    g.setColor(getRandColor(random,10,150));
    //设置字体
    g.setFont(new Font(fontTypes[random.nextInt(fontTypesLength)],Font.BOLD,18 + random.nextInt(6)));
    //将此汉字画到图片上
    g.drawString(rand,24*i+ 10 + random.nextInt(8),24);
}

//将认证码存入session
session.setAttribute("rand",sRand);

g.dispose();

//输出图象到页面
ImageIO.write(image, "JPEG", response.getOutputStream());
%> 

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<!-- saved from url=(0057) http://localhost:8080/jspsmartfile/jsp/uploadTemplate.jsp -->
<HTML><HEAD>
<META content="text/html; charset=gb2312" http-equiv=Content-Type>
<META content="MSHTML 5.00.2920.0" name=GENERATOR></HEAD>
<BODY bgColor=#e6e6e6><BR>
<FORM action="upload.jsp"  encType=multipart/form-data method=post>
<TABLE>
  <TBODY>
  <TR>
    <TD><FONT color=#000000 face=helv,helvetica size=1>&nbsp;&nbsp;File 
      :&nbsp;</FONT>&nbsp;&nbsp;<INPUT  size=60 type=file  name="file"></TD></TR>
        <TR>
    <TR>
    <TD><FONT color=#000000 face=helv,helvetica size=1>&nbsp;&nbsp;File 
      :&nbsp;</FONT>&nbsp;&nbsp;<INPUT  size=60 type=file  name="file1"></TD></TR>
        <TR> 
    <TD><FONT color=#000000 face=helv,helvetica size=1>&nbsp;&nbsp;File 
      :&nbsp;</FONT>&nbsp;&nbsp;<INPUT  size=60 type=text  name="text"></TD></TR>
  <TR>
    <TD
align=right><INPUT type=submit value=Send name="send"></TD></TR></TBODY></TABLE></FORM></BODY></HTML>

  再来看一下接收的页面 ，我们把文件上传到服务器以后就直接把它再存入数据库中：upload.jsp

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<%@ page import="com.jspsmart.upload.*" %>
<%@ page import="DBstep.iDBManager2000.*"%>
<%
    //实 例化上载bean
    com.jspsmart.upload.SmartUpload mySmartUpload=new com.jspsmart.upload.SmartUpload();
    //初 始化
    mySmartUpload.initialize(pageContext);
    //设 置上载的最大值
    mySmartUpload.setMaxFileSize(500 * 1024*1024);
    //上 载文件
    mySmartUpload.upload();
   //循 环取得所有上载的文件
   for (int i=0;i<mySmartUpload.getFiles().getCount();i++){
   //取 得上载的文件
   com.jspsmart.upload.File myFile = mySmartUpload.getFiles().getFile(i);
   if (!myFile.isMissing())
    {
   //取 得上载的文件的文件名
    String myFileName=myFile.getFileName();
    //取 得不带后缀的文件名
    String  suffix=myFileName.substring(0,myFileName.lastIndexOf('.'));
    //取 得后缀名
    String  ext= mySmartUpload.getFiles().getFile(0).getFileExt(); 
    //取 得文件的大小 
    int fileSize=myFile.getSize();
    //保 存路径
    String aa=getServletContext().getRealPath("/")+"jsp\\";
    String trace=aa+myFileName;
    //取 得别的参数
    String explain=(String)mySmartUpload.getRequest().getParameter("text");
    String send=(String)mySmartUpload.getRequest().getParameter("send");
    //将 文件保存在服务器端
    myFile.saveAs(trace,mySmartUpload.SAVE_PHYSICAL);
    //下 面的是将上载的文件保存到数据库中
    //将 文件读到流中
    java.io.File file = new java.io.File(trace);
    java.io.FileInputStream fis = new java.io.FileInputStream(file);
  out.println(file.length());
   //打 开数据库
   ResultSet result=null;
   String mSql=null;
   PreparedStatement prestmt=null;
   DBstep.iDBManager2000 DbaObj=new DBstep.iDBManager2000();
   DbaObj.OpenConnection();
   //将 文件写到数据库中
   mSql="insert into marklist (markname,password,marksize,markdate,MarkBody) values (?,?,?,?,?)";
   prestmt =DbaObj.Conn.prepareStatement(mSql);
   prestmt.setString(1, "aaa1");
   prestmt.setString(2, "0000");
   prestmt.setInt(3, fileSize);
   prestmt.setString(4, DbaObj.GetDateTime());
   prestmt.setBinaryStream(5,fis,(int)file.length());
   DbaObj.Conn.setAutoCommit(true) ;
   prestmt.executeUpdate();
   DbaObj.Conn.commit();
   out.println(("上载成功！！！").toString());
   }
   else
   { out.println(("上载失败！！！").toString()); }
   }//与前面的if对应
%>

   再说一下下载，下载分两种情况1。从数据库直接下载2。从服务器上下载

  先说从数据库直接下载的情形：就是把输入流从数据库里读出来，然后转存为文件

<%@ page contentType="text/html; charset=gb2312" %>
<%@ page import="java.sql.*"%>
<%@ page import="java.io.*" %>
<%@ page import="DBstep.iDBManager2000.*"%>
<%
    int bytesum=0;
    int byteread=0;
  //打 开数据库
  ResultSet result=null;
  String Sql=null;
  PreparedStatement prestmt=null;
  DBstep.iDBManager2000 DbaObj=new DBstep.iDBManager2000();
  DbaObj.OpenConnection();
  //取 得数据库中的数据
 Sql="select  *  from  t_local_zhongzhuan ";
 result=DbaObj.ExecuteQuery(Sql);
 result.next();

  //将 数据库中的数据读到流中
InputStream inStream=result.getBinaryStream("content");
FileOutputStream fs=new FileOutputStream( "c:/dffdsafd.doc");

  byte[]  buffer =new  byte[1444];
int length;
    while ((byteread=inStream.read(buffer))!=-1)
    {
       out.println("<DT><B>"+byteread+"</B></DT>");
       bytesum+=byteread;
       System.out.println(bytesum);
   
   
       fs.write(buffer,0,byteread);
     }
%>

再说从服务器上下载的情形：

<%@ page contentType="text/html; charset=gb2312" %>
<%@ page import="java.io.*" %>
<%
  String fileName = "zsc104.swf".toString();
f//读 到流中
InputStream inStream=new FileInputStream("c:/zsc104.swf");
  //设置 置输出的格式
  response.reset();
  response.setContentType("bin");
  response.addHeader("Content-Disposition","attachment; filename=\"" + fileName + "\"");
  //循 环取出流中的数据
  byte[] b = new byte[100];
  int len;
  while((len=inStream.read(b)) >0)
  response.getOutputStream().write(b,0,len); 
  inStream.close();
%>

   好了，到这里只要不是太大的文件的上传下载的操作都可以完成了。

第一：改变了用户使用习惯，增加了用户的使用难度。

首先我们来看看一个正常的数据库操作过程：

												
int executeSQL(String sql) throws SQLException
{
	Connection conn = getConnection();	//通过某种方式获取数据库连接
	PreparedStatement ps = null;
	int res = 0;
	try{
		ps = conn.prepareStatement(sql);
		res = ps.executeUpdate();
}finally{
try{
ps.close();
}catch(Exception e){}
try{
	conn.close();//
}catch(Exception e){}
}
return res;
}

										

使用者在用完数据库连接后通常是直接调用连接的方法close来释放数据库资源，如果用我们前面提到的连接池的实现方法，那语句conn.close()将被某些特定的语句所替代。

第二：使连接池无法对之中的所有连接进行独占控制。由于连接池不允许用户直接调用连接的close方法，一旦使用者在使用的过程中由于习惯问题直接关闭了数据库连接，那么连接池将无法正常维护所有连接的状态，考虑连接池和应用由不同开发人员实现时这种问题更容易出现。

综合上面提到的两个问题，我们来讨论一下如何解决这两个要命的问题。

首先我们先设身处地的考虑一下用户是想怎么样来使用这个数据库连接池的。用户可以通过特定的方法来获取数据库的连接，同时这个连接的类型应该是标准的java.sql.Connection。用户在获取到这个数据库连接后可以对这个连接进行任意的操作，包括关闭连接等。

通过对用户使用的描述，怎样可以接管Connection.close方法就成了我们这篇文章的主题。

为了接管数据库连接的close方法，我们应该有一种类似于钩子的机制。例如在Windows编程中我们可以利用Hook API来实现对某个Windows API的接管。在JAVA中同样也有这样一个机制。JAVA提供了一个Proxy类和一个InvocationHandler，这两个类都在java.lang.reflect包中。我们先来看看SUN公司提供的文档是怎么描述这两个类的。

												
public interface InvocationHandler

InvocationHandler is the interface implemented by the invocation handler of a proxy instance. 

Each proxy instance has an associated invocation handler. 
When a method is invoked on a proxy instance, 
the method invocation is encoded and dispatched to the invoke method of its invocation handler.

										

SUN的API文档中关于Proxy的描述很多，这里就不罗列出来。通过文档对接口InvocationHandler的描述我们可以看到当调用一个Proxy实例的方法时会触发Invocationhanlder的invoke方法。从JAVA的文档中我们也同时了解到这种动态代理机制只能接管接口的方法，而对一般的类无效，考虑到java.sql.Connection本身也是一个接口由此就找到了解决如何接管close方法的出路。

首先，我们先定义一个数据库连接池参数的类，定义了数据库的JDBC驱动程序类名，连接的URL以及用户名口令等等一些信息，该类是用于初始化连接池的参数，具体定义如下：

												
public class ConnectionParam implements Serializable
{
	private String driver;				//数据库驱动程序
	private String url;					//数据连接的URL
	private String user;					//数据库用户名
	private String password;				//数据库密码
	private int minConnection = 0;		//初始化连接数
	private int maxConnection = 50;		//最大连接数
	private long timeoutValue = 600000;//连接的最大空闲时间
	private long waitTime = 30000;		//取连接的时候如果没有可用连接最大的等待时间

										

其次是连接池的工厂类ConnectionFactory，通过该类来将一个连接池对象与一个名称对应起来，使用者通过该名称就可以获取指定的连接池对象，具体代码如下：

												
/**
 * 连接池类厂，该类常用来保存多个数据源名称合数据库连接池对应的哈希
 * @author liusoft
 */
public class ConnectionFactory
{
	//该哈希表用来保存数据源名和连接池对象的关系表
	static Hashtable connectionPools = null;
	static{
		connectionPools = new Hashtable(2,0.75F);
	} 
	/**
	 * 从连接池工厂中获取指定名称对应的连接池对象
	 * @param dataSource	连接池对象对应的名称
	 * @return DataSource	返回名称对应的连接池对象
	 * @throws NameNotFoundException	无法找到指定的连接池
	 */
	public static DataSource lookup(String dataSource) 
		throws NameNotFoundException
	{
		Object ds = null;
		ds = connectionPools.get(dataSource);
		if(ds == null || !(ds instanceof DataSource))
			throw new NameNotFoundException(dataSource);
		return (DataSource)ds;
	}

	/**
	 * 将指定的名字和数据库连接配置绑定在一起并初始化数据库连接池
	 * @param name		对应连接池的名称
	 * @param param	连接池的配置参数，具体请见类ConnectionParam
	 * @return DataSource	如果绑定成功后返回连接池对象
	 * @throws NameAlreadyBoundException	一定名字name已经绑定则抛出该异常
	 * @throws ClassNotFoundException		无法找到连接池的配置中的驱动程序类
	 * @throws IllegalAccessException		连接池配置中的驱动程序类有误
	 * @throws InstantiationException		无法实例化驱动程序类
	 * @throws SQLException				无法正常连接指定的数据库
	 */
	public static DataSource bind(String name, ConnectionParam param)
		throws NameAlreadyBoundException,ClassNotFoundException,
				IllegalAccessException,InstantiationException,SQLException
	{
		DataSourceImpl source = null;
		try{
			lookup(name);
			throw new NameAlreadyBoundException(name);
		}catch(NameNotFoundException e){
			source = new DataSourceImpl(param);
			source.initConnection();
			connectionPools.put(name, source);
		}
		return source;
	}
	/**
	 * 重新绑定数据库连接池
	 * @param name		对应连接池的名称
	 * @param param	连接池的配置参数，具体请见类ConnectionParam
	 * @return DataSource	如果绑定成功后返回连接池对象
	 * @throws NameAlreadyBoundException	一定名字name已经绑定则抛出该异常
	 * @throws ClassNotFoundException		无法找到连接池的配置中的驱动程序类
	 * @throws IllegalAccessException		连接池配置中的驱动程序类有误
	 * @throws InstantiationException		无法实例化驱动程序类
	 * @throws SQLException				无法正常连接指定的数据库
	 */
	public static DataSource rebind(String name, ConnectionParam param)
		throws NameAlreadyBoundException,ClassNotFoundException,
				IllegalAccessException,InstantiationException,SQLException
	{
		try{
			unbind(name);
		}catch(Exception e){}
		return bind(name, param);
	}
	/**
	 * 删除一个数据库连接池对象
	 * @param name
	 * @throws NameNotFoundException
	 */
	public static void unbind(String name) throws NameNotFoundException
	{
		DataSource dataSource = lookup(name);
		if(dataSource instanceof DataSourceImpl){
			DataSourceImpl dsi = (DataSourceImpl)dataSource;
			try{
				dsi.stop();
				dsi.close();
			}catch(Exception e){
			}finally{
				dsi = null;
			}
		}
		connectionPools.remove(name);
	}
	
}

										

ConnectionFactory主要提供了用户将将连接池绑定到一个具体的名称上以及取消绑定的操作。使用者只需要关心这两个类即可使用数据库连接池的功能。下面我们给出一段如何使用连接池的代码：

												
	String name = "pool";
	String driver = " sun.jdbc.odbc.JdbcOdbcDriver ";
	String url = "jdbc:odbc:datasource";
	ConnectionParam param = new ConnectionParam(driver,url,null,null);
	param.setMinConnection(1);
	param.setMaxConnection(5);
	param.setTimeoutValue(20000);
	ConnectionFactory.bind(name, param);
	System.out.println("bind datasource ok.");
	//以上代码是用来登记一个连接池对象，该操作可以在程序初始化只做一次即可
	//以下开始就是使用者真正需要写的代码
	DataSource ds = ConnectionFactory.lookup(name);
	try{
		for(int i=0;i<10;i++){
			Connection conn = ds.getConnection();
			try{
				testSQL(conn, sql);
			}finally{
				try{
					conn.close();
				}catch(Exception e){}
			}
		}
	}catch(Exception e){
		e.printStackTrace();
	}finally{
		ConnectionFactory.unbind(name);
		System.out.println("unbind datasource ok.");
		System.exit(0);
	}

										

从使用者的示例代码就可以看出，我们已经解决了常规连接池产生的两个问题。但是我们最最关心的是如何解决接管close方法的办法。接管工作主要在ConnectionFactory中的两句代码：

												
source = new DataSourceImpl(param);
source.initConnection();

										

DataSourceImpl是一个实现了接口javax.sql.DataSource的类，该类维护着一个连接池的对象。由于该类是一个受保护的类，因此它暴露给使用者的方法只有接口DataSource中定义的方法，其他的所有方法对使用者来说都是不可视的。我们先来关心用户可访问的一个方法getConnection

												
/**
 * @see javax.sql.DataSource#getConnection(String,String)
 */
	public Connection getConnection(String user, String password) throws SQLException 
	{
		//首先从连接池中找出空闲的对象
		Connection conn = getFreeConnection(0);
		if(conn == null){
			//判断是否超过最大连接数,如果超过最大连接数
			//则等待一定时间查看是否有空闲连接,否则抛出异常告诉用户无可用连接
			if(getConnectionCount() >= connParam.getMaxConnection())
				conn = getFreeConnection(connParam.getWaitTime());
			else{//没有超过连接数，重新获取一个数据库的连接
				connParam.setUser(user);
				connParam.setPassword(password);
				Connection conn2 = DriverManager.getConnection(connParam.getUrl(), 
				user, password);
				//代理将要返回的连接对象
				_Connection _conn = new _Connection(conn2,true);
				synchronized(conns){
					conns.add(_conn);
				}
				conn = _conn.getConnection();
			}
		}
		return conn;
	}
	/**
	 * 从连接池中取一个空闲的连接
	 * @param nTimeout	如果该参数值为0则没有连接时只是返回一个null
	 * 否则的话等待nTimeout毫秒看是否还有空闲连接，如果没有抛出异常
	 * @return Connection
	 * @throws SQLException
	 */
	protected synchronized Connection getFreeConnection(long nTimeout) 
		throws SQLException
	{
		Connection conn = null;
		Iterator iter = conns.iterator();
		while(iter.hasNext()){
			_Connection _conn = (_Connection)iter.next();
			if(!_conn.isInUse()){
				conn = _conn.getConnection();
				_conn.setInUse(true);				
				break;
			}
		}
		if(conn == null && nTimeout > 0){
			//等待nTimeout毫秒以便看是否有空闲连接
			try{
				Thread.sleep(nTimeout);
			}catch(Exception e){}
			conn = getFreeConnection(0);
			if(conn == null)
				throw new SQLException("没有可用的数据库连接");
		}
		return conn;
	}

										

DataSourceImpl类中实现getConnection方法的跟正常的数据库连接池的逻辑是一致的，首先判断是否有空闲的连接，如果没有的话判断连接数是否已经超过最大连接数等等的一些逻辑。但是有一点不同的是通过DriverManager得到的数据库连接并不是及时返回的，而是通过一个叫_Connection的类中介一下，然后调用_Connection.getConnection返回的。如果我们没有通过一个中介也就是JAVA中的Proxy来接管要返回的接口对象，那么我们就没有办法截住Connection.close方法。

终于到了核心所在，我们先来看看_Connection是如何实现的，然后再介绍是客户端调用Connection.close方法时走的是怎样一个流程，为什么并没有真正的关闭连接。

												
/**
 * 数据连接的自封装，屏蔽了close方法
 * @author Liudong
 */
class _Connection implements InvocationHandler
{
	private final static String CLOSE_METHOD_NAME = "close";
	private Connection conn = null;
	//数据库的忙状态
	private boolean inUse = false;
	//用户最后一次访问该连接方法的时间
	private long lastAccessTime = System.currentTimeMillis();
	
	_Connection(Connection conn, boolean inUse){
		this.conn = conn;
		this.inUse = inUse;
	}
	/**
	 * Returns the conn.
	 * @return Connection
	 */
	public Connection getConnection() {
		//返回数据库连接conn的接管类，以便截住close方法
		Connection conn2 = (Connection)Proxy.newProxyInstance(
			conn.getClass().getClassLoader(),
			conn.getClass().getInterfaces(),this);
		return conn2;
	}
	/**
	 * 该方法真正的关闭了数据库的连接
	 * @throws SQLException
	 */
	void close() throws SQLException{
		//由于类属性conn是没有被接管的连接，因此一旦调用close方法后就直接关闭连接
		conn.close();
	}
	/**
	 * Returns the inUse.
	 * @return boolean
	 */
	public boolean isInUse() {
		return inUse;
	}

	/**
	 * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object)
	 */
	public Object invoke(Object proxy, Method m, Object[] args) 
		throws Throwable 
	{
		Object obj = null;
		//判断是否调用了close的方法，如果调用close方法则把连接置为无用状态
		if(CLOSE_METHOD_NAME.equals(m.getName()))
			setInUse(false);		
		else
			obj = m.invoke(conn, args);	
		//设置最后一次访问时间，以便及时清除超时的连接
		lastAccessTime = System.currentTimeMillis();
		return obj;
	}
		
	/**
	 * Returns the lastAccessTime.
	 * @return long
	 */
	public long getLastAccessTime() {
		return lastAccessTime;
	}

	/**
	 * Sets the inUse.
	 * @param inUse The inUse to set
	 */
	public void setInUse(boolean inUse) {
		this.inUse = inUse;
	}
}

										

一旦使用者调用所得到连接的close方法，由于用户的连接对象是经过接管后的对象，因此JAVA虚拟机会首先调用_Connection.invoke方法，在该方法中首先判断是否为close方法，如果不是则将代码转给真正的没有被接管的连接对象conn。否则的话只是简单的将该连接的状态设置为可用。到此您可能就明白了整个接管的过程，但是同时也有一个疑问：这样的话是不是这些已建立的连接就始终没有办法真正关闭？答案是可以的。我们来看看ConnectionFactory.unbind方法，该方法首先找到名字对应的连接池对象，然后关闭该连接池中的所有连接并删除掉连接池。在DataSourceImpl类中定义了一个close方法用来关闭所有的连接，详细代码如下：

												
	/**
	 * 关闭该连接池中的所有数据库连接
	 * @return int 返回被关闭连接的个数
	 * @throws SQLException
	 */
	public int close() throws SQLException
	{
		int cc = 0;
		SQLException excp = null;
		Iterator iter = conns.iterator();
		while(iter.hasNext()){
			try{
				((_Connection)iter.next()).close();
				cc ++;
			}catch(Exception e){
				if(e instanceof SQLException)
					excp = (SQLException)e;
			}
		}
		if(excp != null)
			throw excp;
		return cc;
	}

										

该方法一一调用连接池中每个对象的close方法，这个close方法对应的是_Connection中对close的实现，在_Connection定义中关闭数据库连接的时候是直接调用没有经过接管的对象的关闭方法，因此该close方法真正的释放了数据库资源。

以上文字只是描述了接口方法的接管，具体一个实用的连接池模块还需要对空闲连接的监控并及时释放连接，详细的代码请参照附件。

						
								
										
												
package screensaver;
												
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.*;
import com.sun.image.codec.jpeg.*;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.awt.image.MemoryImageSource;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;
												
public class ScreenPicSaver
{
  MediaTracker tracker = new MediaTracker(new Component()
  {});
												
  public ScreenPicSaver()
  {}
												
  public Image loadbitmap(String sdir, String sfile) //读取8位或24位的位图文件
  {
    Image image;
    System.out.println("loading:" + sdir + sfile);
    try
    {
      FileInputStream fs = new FileInputStream(sdir + sfile);
      int bflen = 14; // 14 字节 BITMAPFILEHEADER
      byte bf[] = new byte[bflen];
      fs.read(bf, 0, bflen);
      int bilen = 40; // 40 字节 BITMAPINFOHEADER
      byte bi[] = new byte[bilen];
      fs.read(bi, 0, bilen);
												
      // 解释数据。
      int nsize = ( ( (int) bf[5] & 0xff) << 24)
          | ( ( (int) bf[4] & 0xff) << 16)
          | ( ( (int) bf[3] & 0xff) << 8)
          | (int) bf[2] & 0xff;
      System.out.println("File type is :" + (char) bf[0] + (char) bf[1]);
      System.out.println("Size of file is :" + nsize);
												
      int nbisize = ( ( (int) bi[3] & 0xff) << 24)
          | ( ( (int) bi[2] & 0xff) << 16)
          | ( ( (int) bi[1] & 0xff) << 8)
          | (int) bi[0] & 0xff;
      System.out.println("Size of bitmapinfoheader is :" + nbisize);
												
      int nwidth = ( ( (int) bi[7] & 0xff) << 24)
          | ( ( (int) bi[6] & 0xff) << 16)
          | ( ( (int) bi[5] & 0xff) << 8)
          | (int) bi[4] & 0xff;
      System.out.println("Width is :" + nwidth);
												
      int nheight = ( ( (int) bi[11] & 0xff) << 24)
          | ( ( (int) bi[10] & 0xff) << 16)
          | ( ( (int) bi[9] & 0xff) << 8)
          | (int) bi[8] & 0xff;
      System.out.println("Height is :" + nheight);
												
      int nplanes = ( ( (int) bi[13] & 0xff) << 8) | (int) bi[12] & 0xff;
      System.out.println("Planes is :" + nplanes);
												
      int nbitcount = ( ( (int) bi[15] & 0xff) << 8) | (int) bi[14] & 0xff;
      System.out.println("BitCount is :" + nbitcount);
												
      // 查找表明压缩的非零值
      int ncompression = ( ( (int) bi[19]) << 24)
          | ( ( (int) bi[18]) << 16)
          | ( ( (int) bi[17]) << 8)
          | (int) bi[16];
      System.out.println("Compression is :" + ncompression);
												
      int nsizeimage = ( ( (int) bi[23] & 0xff) << 24)
          | ( ( (int) bi[22] & 0xff) << 16)
          | ( ( (int) bi[21] & 0xff) << 8)
          | (int) bi[20] & 0xff;
      System.out.println("SizeImage is :" + nsizeimage);
												
      int nxpm = ( ( (int) bi[27] & 0xff) << 24)
          | ( ( (int) bi[26] & 0xff) << 16)
          | ( ( (int) bi[25] & 0xff) << 8)
          | (int) bi[24] & 0xff;
      System.out.println("X-Pixels per meter is :" + nxpm);
												
      int nypm = ( ( (int) bi[31] & 0xff) << 24)
          | ( ( (int) bi[30] & 0xff) << 16)
          | ( ( (int) bi[29] & 0xff) << 8)
          | (int) bi[28] & 0xff;
      System.out.println("Y-Pixels per meter is :" + nypm);
												
      int nclrused = ( ( (int) bi[35] & 0xff) << 24)
          | ( ( (int) bi[34] & 0xff) << 16)
          | ( ( (int) bi[33] & 0xff) << 8)
          | (int) bi[32] & 0xff;
      System.out.println("Colors used are :" + nclrused);
												
      int nclrimp = ( ( (int) bi[39] & 0xff) << 24)
          | ( ( (int) bi[38] & 0xff) << 16)
          | ( ( (int) bi[37] & 0xff) << 8)
          | (int) bi[36] & 0xff;
      System.out.println("Colors important are :" + nclrimp);
												
      if (nbitcount == 24)
      {
        // 24 位格式不包含调色板数据，但扫描行被补足到
        // 4 个字节。
        int npad = (nsizeimage / nheight) - nwidth * 3;
        int ndata[] = new int[nheight * nwidth];
        byte brgb[] = new byte[ (nwidth + npad) * 3 * nheight];
        fs.read(brgb, 0, (nwidth + npad) * 3 * nheight);
        int nindex = 0;
        for (int j = 0; j < nheight; j++)
        {
          for (int i = 0; i < nwidth; i++)
          {
            ndata[nwidth * (nheight - j - 1) + i] =
                (255 & 0xff) << 24
                | ( ( (int) brgb[nindex + 2] & 0xff) << 16)
                | ( ( (int) brgb[nindex + 1] & 0xff) << 8)
                | (int) brgb[nindex] & 0xff;
            /**   System.out.println("Encoded Color at ("
               +i + "," + j + ")is:" + nrgb + " (R,G,B)= ("
                   + ( (int) (brgb[2]) & 0xff) + ","
                   + ( (int) brgb[1] & 0xff) + ","
                   + ( (int) brgb[0] & 0xff) + ")");
             }*/
            nindex += 3;
          }
          nindex += npad;
        }
												
        image = Toolkit.getDefaultToolkit().createImage
            (new MemoryImageSource(nwidth, nheight,
                                   ndata, 0, nwidth));
      }
      else if (nbitcount == 8)
      {
        // 必须确定颜色数。如果 clrsused 参数大于 0，
        // 则颜色数由它决定。如果它等于 0，则根据
        // bitsperpixel 计算颜色数。
        int nNumColors = 0;
        if (nclrused > 0)
        {
          nNumColors = nclrused;
        }
        else
        {
          nNumColors = (1 & 0xff) << nbitcount;
        }
        System.out.println("The number of Colors is" + nNumColors);
												
        // 某些位图不计算 sizeimage 域，请找出
        // 这些情况并对它们进行修正。
        if (nsizeimage == 0)
        {
          nsizeimage = ( ( ( (nwidth * nbitcount) + 31) & ~31) >> 3);
          nsizeimage *= nheight;
          System.out.println("nsizeimage (backup) is" + nsizeimage);
        }
												
        // 读取调色板颜色。
        int npalette[] = new int[nNumColors];
        byte bpalette[] = new byte[nNumColors * 4];
        fs.read(bpalette, 0, nNumColors * 4);
        int nindex8 = 0;
        for (int n = 0; n < nNumColors; n++)
        {
          npalette[n] = (255 & 0xff) << 24
              | ( ( (int) bpalette[nindex8 + 2] & 0xff) << 16)
              | ( ( (int) bpalette[nindex8 + 1] & 0xff) << 8)
              | (int) bpalette[nindex8] & 0xff;
          /**System.out.println ("Palette Color "+n
                     +" is:" + npalette[n] + " (res,R,G,B)= ("
              + ( (int) (bpalette[nindex8 + 3]) & 0xff) + ","
              + ( (int) (bpalette[nindex8 + 2]) & 0xff) + ","
              + ( (int) bpalette[nindex8 + 1] & 0xff) + ","
              + ( (int) bpalette[nindex8] & 0xff) + ")");
           */
          nindex8 += 4;
        }
												
        // 读取图像数据（实际上是调色板的索引）
        // 扫描行仍被补足到 4 个字节。
        int npad8 = (nsizeimage / nheight) - nwidth;
        System.out.println("nPad is:" + npad8);
												
        int ndata8[] = new int[nwidth * nheight];
        byte bdata[] = new byte[ (nwidth + npad8) * nheight];
        fs.read(bdata, 0, (nwidth + npad8) * nheight);
        nindex8 = 0;
        for (int j8 = 0; j8 < nheight; j8++)
        {
          for (int i8 = 0; i8 < nwidth; i8++)
          {
            ndata8[nwidth * (nheight - j8 - 1) + i8] =
                npalette[ ( (int) bdata[nindex8] & 0xff)];
            nindex8++;
          }
          nindex8 += npad8;
        }
												
        image = Toolkit.getDefaultToolkit().createImage
            (new MemoryImageSource(nwidth, nheight,
                                   ndata8, 0, nwidth));
      }
      else
      {
        System.out.println("Not a 24-bit or 8-bit Windows Bitmap, aborting...");
        image = (Image)null;
      }
												
      fs.close();
      return image;
    }
    catch (Exception e)
    {
      System.out.println("Caught exception in loadbitmap!");
    }
    return (Image)null;
  }
												
  public void waitForImage(Image image)
  {
    //tracker = new MediaTracker(this);
    try
    {
      tracker.addImage(image, 0); //public void addImage(Image image,int id)
      //tracker.waitForAll();
      tracker.waitForID(0);
      tracker.checkAll(true);
      /** while(!tracker.checkID(0))
       {
         tracker.waitForID(0);
       }*/
      if (tracker.isErrorAny())
      {
        // System.out.println(tracker.getErrorsAny().toString());
        System.out.println("加载图像出现错误！");
        System.exit(0);
      }
												
      // loadStatus = tracker.statusID( 0, false );
      // tracker.removeImage(image, 0);
    }
    catch (InterruptedException e)
    {
      e.printStackTrace();
    }
  } // waitForImage
												
  public void checkImage(Image image)
  {
    waitForImage(image);
												
    int imageWidth = image.getWidth(null);
    if (imageWidth < 1)
    {
      throw new IllegalArgumentException("image width " + imageWidth +
                                         " is out of range");
    }
    int imageHeight = image.getHeight(null);
    if (imageHeight < 1)
    {
      throw new IllegalArgumentException("image height " + imageHeight +
                                         " is out of range");
    }
    // System.out.println( "Image size=" + imageWidth + "x" + imageHeight );
  } // checkImage
												
  public void encodeJPEG(OutputStream outputStream, Image outputImage,
                         float outputQuality) throws java.io.IOException
  {
    int outputWidth = outputImage.getWidth(null);
    if (outputWidth < 1)
    {
      throw new IllegalArgumentException("output image width " + outputWidth +
                                         " is out of range");
    }
    int outputHeight = outputImage.getHeight(null);
    if (outputHeight < 1)
    {
      throw new IllegalArgumentException("output image height " + outputHeight +
                                         " is out of range");
    }
												
    // Get a buffered image from the image.
    BufferedImage bi = new BufferedImage(outputWidth, outputHeight,
                                         BufferedImage.TYPE_INT_RGB);
    Graphics2D biContext = bi.createGraphics();
    biContext.drawImage(outputImage, 0, 0, null);
    // Note that additional drawing such as watermarks or logos can be placed here.
												
    // com.sun.image.codec.jpeg package is included in sun and ibm sdk 1.3
    JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(outputStream);
    // The default quality is 0.75.
    JPEGEncodeParam jep = JPEGCodec.getDefaultJPEGEncodeParam(bi);
    jep.setQuality(outputQuality, true);
    encoder.encode(bi, jep);
    // encoder.encode( bi );
    outputStream.flush();
  } // encodeImage
												
  /** Adjusts the size of the image to the given coordinates.
   * If width or height is -1, the image aspect ration is maintained.
   * <p>
   * Hints are one of SCALE_DEFAULT, SCALE_FAST, SCALE_SMOOTH,
   * SCALE_REPLICATE, SCALE_AREA_AVERAGING as defined in java.awt.Image.
   */
  public Image setSize(Image image, int width, int height, int hints)
  {
    return image.getScaledInstance(width, height, hints);
  } // setSize
												
  public Image setSize(Image image, int width, int height)
  {
    return setSize(image, width, height, java.awt.Image.SCALE_DEFAULT); //setSize调用的是上一个方法.
  } // setSize
												
  //Component initialization
  public static void main(String[] args)
  {
    ScreenPicSaver sps = new ScreenPicSaver();
    // String sdir = new String("d:\\");
    // String sfile = new String("desktop.bmp");
    String outputFileName = new String("d:\\desktop.jpg");
												
    //Image inputImage = Toolkit.getDefaultToolkit().getImage(inputFileName);
    //Image inputImage = sps.loadbitmap(sdir, sfile);
    //===============================================================
    BufferedImage bufferedImage = null;
    Robot robot;
    Image inputImage = null;
    try
    {
      robot = new Robot();
      bufferedImage = robot.createScreenCapture(new Rectangle(Toolkit.
          getDefaultToolkit().getScreenSize())); //得到桌面图像的bufferedImage对象
												
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
    int width = bufferedImage.getWidth();
    int height = bufferedImage.getHeight();
    inputImage = bufferedImage.getScaledInstance(width, height,
                                                 BufferedImage.TYPE_INT_RGB); //将bufferedImage对象转化位Image对象
												
    MediaTracker tracker = new MediaTracker(new Component()
    {});
												
    int outputWidth = inputImage.getWidth(null); //使得新图像和原图像的宽度一样
    float outputQuality = 0.80f;
    Image outputImage = sps.setSize(inputImage, outputWidth, -1); //-1表示在宽度确定的情况下，高度在原图像的基础上成比例缩放
												
    try
    {
      tracker.addImage(inputImage, 0);
      //sps.tracker.waitForAll();
      tracker.waitForID(0);
      tracker.checkAll(true);
    }
    catch (InterruptedException e)
    {
      e.printStackTrace();
    }
												
    int imageWidth = inputImage.getWidth(null);
    if (imageWidth < 1)
    {
      throw new IllegalArgumentException("image width " + imageWidth +
                                         " is out of range");
    }
    int imageHeight = inputImage.getHeight(null);
    if (imageHeight < 1)
    {
      throw new IllegalArgumentException("image height " + imageHeight +
                                         " is out of range");
    }
    try
    {
      FileOutputStream fos = new FileOutputStream(outputFileName);
      sps.encodeJPEG(fos, outputImage, outputQuality);
      fos.flush();
      fos.close();
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
												
    System.exit(0);
												
  }
												
}
										
								
						
				

IBM已经有一篇文章介绍动态图文结合输出的文章， 由于此篇文章中使用了SUN的JPEG特殊类：com.sun.image.codec.jpeg.*;我个人认为通用性不好，利用jdk1.4的新特点，也完全可以作到：

现将本人实践的动态图文结合javabeans的核心公布如下:

 1import java.io.*;
 2import java.util.*;
 3import java.awt.image.BufferedImage;
 4import java.awt.Image;
 5import java.awt.image.AffineTransformOp;
 6import javax.imageio.ImageIO;
 7import java.awt.geom.AffineTransform;
 8import java.awt.Graphics2D;
 9import java.awt.Color;
10import java.awt.Font;
11
12..
13
14//生成BufferedImage实例,这是不需要真正显示时经常使用的类
15BufferedImage Bi = ImageIO.read(F);
16
17
18// 利用Graphics2D的新特性.
19Graphics2D g2D = Bi.createGraphics(); 
20
21
22//定义字体(楷体或宋体等) 及其大小
23Font myfont=new Font("\u5b8b\u4f53",Font.PLAIN,20);
24g2D.setFont(myfont);
25//字体颜色为黑
26g2D.setColor(Color.BLACK);
27
28
29//需要写在图片上文字 注意:中文需要操作系统支持中文 如中文window,
30// linux下要安装中文字库,并使jdk1.4支持这个中文
31String strs="hello everyone 中 文";
32
33
34//在离顶部 和左边各为20处 写入文字,该处使用了对中文处理的getBytes功能.
35g2D.drawString(new String(strs.getBytes("ISO8859_1")),20,20);
36
37//必须使用,表示完成 
38g2D.dispose(); 
39
40try {
41//使用ImageIO写入图片 
42ImageIO.write(Bi, ext, ThF);
43
44//原来是使用com.sun.image.codec.jpeg.*的功能,如下.需要下载com.sun.image.codec.jpeg
45// FileOutputStream out = new FileOutputStream(ThF);
46// JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
47// encoder.encode(Bi);
48// out.close();
49
50}catch (Exception ex) {
51throw new Exception(" ImageIo.write error in CreatThum.: "+ex.getMessage()); 
52}
53

只要jsp将相关参数通知这个bean,就会轻松产生自己的图文,下图我自己在linux上调试的结果,由于linux没有安装字库,所以下图中文不正常显示,不过该程序我在中文win2000下调试正常通过:

原图:

效果图

关于使用Servlet/Jsp输出图片或图像，见网址：

http://www.mullassery.com/

相关文章：

软件最大的追求是什么？

初学者如何开发出一个高质量的J2EE系统？

数据库时代的终结

状态对象：数据库的替代者

Java/J2EE中文问题终极解决之道

为了保证示例程序的运行，必须安装Java 2 sdk1.4.0 和Jakarta POI，Jakarta POI的Web站点是: http://jakarta.apache.org/poi/

操作Excel的原理大体是这样:
1.创建一个Excel文件
2.读取Excel文件
3.进行读出和写入操作
应该就这么简单!

网上有此类文档,不过没有我的完全,可以将示例:CreateXL.java 直接放在工程下即可运行!
也可以根据自己需要更改.

示例中有关于表名设置为中文的问题迟迟没有解决,望大虾们指点.
这是本人第一次在网上发布文档,很希望朋友们多意见!
也希望站长指正后发布!

可能表述有些问题,如有不明白的朋友,请联系我!

示例: CreateXL.java

/** 

* Copyright by 2006 A&D. 

* writer: hike. 

*/

package comm;

//如需设置字体,请导入以下两个包
//import org.apache.poi.hssf.usermodel.HSSFCellStyle;
//import org.apache.poi.hssf.usermodel.HSSFFont;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFCell;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class CreateXL {
	
	/**
	 * 
	 *解决中文问题
	 */
	
	public static String getUnicode(String toEncoded,String encoding){
	  String retString="";
	  if(toEncoded.equals("")||toEncoded.trim().equals(""))
	  {
	    return toEncoded;
	  }
	  try
	  {
	  byte[] b=toEncoded.getBytes(encoding);
	  sun.io.ByteToCharConverter  convertor=sun.io.ByteToCharConverter.getConverter(encoding);
	  char [] c=convertor.convertAll(b);
	  for(int i=0;i< c.length;i++)
	  {
	    retString+=String.valueOf(c[i]);
	  }
	  }catch(java.io.UnsupportedEncodingException usee)
	  {
	   System.out.println("不支持"+encoding+"编码方式");
	   usee.printStackTrace();
	  }catch(sun.io.MalformedInputException mfie)
	  {
	   System.out.println("输入参数无效!!!");
	   mfie.printStackTrace();
	  }
	  return retString;
	}
	
	/**
	 * 写入EXCEL
	 */
	
	//Excel 文件要存放的位置，假定在D盘JTest目录下
	public static String UPath="D:\\JTest";
	//工作簿名称,可以取中文(就是另存为名称).
	public static String outputFile="D:/JTest/test.xls";
	
	public static void main(String argv[]){
		try{
			//	如果UPath不存在,则创建路径
			if(!new java.io.File(UPath).isDirectory()){
				new java.io.File(UPath).mkdirs();
				}
			
			File objFile = new File(outputFile);
			
			HSSFWorkbook workbook = null;
			
			HSSFSheet sheet = null;
			
			String table_name = "sheet1";
			
			//创建文件
			if(!objFile.exists()){   //文件不存在
				//创建新的Excel 工作簿
				System.out.println("检测到文件不存在,正在创建文件...");
				workbook = new HSSFWorkbook();
				//在Excel工作簿中建一工作表，其名为缺省值
				//如要新建一名为"效益指标"的工作表，其语句为：
				//HSSFSheet sheet = workbook.createSheet("效益指标");
				//上一句是来自网上,其实表名并不支持中文,转换后也不行!
				//如有人已解决,请给出,谢谢!
				sheet = workbook.createSheet(table_name);
				
				//新建一输出文件流
				FileOutputStream fOut = new FileOutputStream(outputFile);
				
				//把相应的Excel 工作簿存盘
				workbook.write(fOut);
				fOut.flush();
				
				//操作结束，关闭文件
				fOut.close();
				}
			
			//如果文件存在,将直接插入数据.
			//创建对Excel工作簿文件的引用
			workbook = new HSSFWorkbook(new FileInputStream(outputFile));
			
			//创建对工作表的引用。
			//本例是按名引用（让我们假定那张表有着缺省名"Sheet1"）
			sheet = workbook.getSheet(table_name);
			
			//也可用getSheetAt(int index)按索引引用，
			//在Excel文档中，第一张工作表的缺省索引是0，
			//其语句为：HSSFSheet sheet = workbook.getSheetAt(0);
			//读取左上端单元
			//行和列都是以'0'开头,比如A1为'00'
			for(int i=0; i< 2; i++){
				for(int j=0; j< 5; j++){
					
					//这儿,你可以测试读出一个已存在文件
					//HSSFRow row = sheet.getRow(i);
					//HSSFCell cell = row.getCell((short)j);
					//输出单元内容，cell.getStringCellValue()就是取所在单元的值
					//System.out.println("左上端单元是： " + cell.getStringCellValue());
					
					//在索引0的位置创建行（最顶端的行）
					//这儿,测试插入数据
					//插入之前必需先创建
					HSSFRow row = sheet.createRow((short)i);
					//在索引0的位置创建单元格（左上端)
					HSSFCell cell = row.createCell((short)j);
					
					//在创建之后可以设置单元格格式
					//具体用法将附于文档后面.
					//记得要导入包
					
					//定义单元格为字符串类型
					//这两名非常重要,缺少,则不能显示中文,
					//即使你调用编码转换方法,也不行.
					cell.setCellType(HSSFCell.CELL_TYPE_STRING);
					//指定编码格式
					cell.setEncoding(HSSFCell.ENCODING_UTF_16);
					
					//在单元格中输入一些内容
					String text = ""+i+j+"";
					//调用编码转换方法,只针对中文
					text = getUnicode(text,"gb2312");
					cell.setCellValue(text);
					
					//新建一输出文件流
					FileOutputStream fOut = new FileOutputStream(outputFile);
					
					//把相应的Excel 工作簿存盘
					workbook.write(fOut);
					fOut.flush();
					
					// 操作结束，关闭文件
					fOut.close();
					}
				}
			
			System.out.println("文件已生成!");
			}
		catch(Exception e) {
			System.out.println("已运行 xlCreate() : " + e );
			}
		}
	}


设置单元格格式

在这里，我们将只介绍一些和格式设置有关的语句，
我们假定workbook就是对一个工作簿的引用。在Java中，
第一步要做的就是创建和设置字体和单元格的格式，然后再应用这些格式：

例用开发工具追踪器,可以查看更多参数,自己慢慢去研究!

1、创建字体，设置其为红色、粗体：

HSSFFont font = workbook.createFont();

font.setColor(HSSFFont.COLOR_RED);

font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);

2、创建格式

HSSFCellStyle cellStyle= workbook.createCellStyle();

cellStyle.setFont(font);

3、应用格式

HSSFCell cell = row.createCell((short) 0);

cell.setCellStyle(cellStyle);

cell.setCellType(HSSFCell.CELL_TYPE_STRING);

cell.setCellValue("标题");

　　到sun的主页 http://java.sun.com/j2se/1.5.0/download.jsp 下载jdk安装文件jdk-1_5_0_05-linux-i586.bin

二. 解压安装jdk

　　在shell终端下进入jdk-1_5_0_05-linux-i586.bin文件所在目录，执行命令 ./jdk-1_5_0_05-linux-i586.bin 这时会出现一段协议，连继敲回车，当询问是否同意的时候，输入yes，回车。之后会在当前目录下生成一个jdk-1.5.0_05目录，你可以将它复制到任何一个目录下。

三. 需要配置的环境变量

　　1. PATH环境变量。作用是指定命令搜索路径，在shell下面执行命令时，它会到PATH变量所指定的路径中查找看是否能找到相应的命令程序。我们需要把jdk安装目录下的bin目录增加到现有的PATH变量中，bin目录中包含经常要用到的可执行文件如javac/java/javadoc等待，设置好PATH变量后，就可以在任何目录下执行javac/java等工具了。

　　2. CLASSPATH环境变量。作用是指定类搜索路径，要使用已经编写好的类，前提当然是能够找到它们了，JVM就是通过CLASSPTH来寻找类的。我们需要把jdk安装目录下的lib子目录中的dt.jar和tools.jar设置到CLASSPATH中，当然，当前目录“.”也必须加入到该变量中。

　　3. JAVA_HOME环境变量。它指向jdk的安装目录，Eclipse/NetBeans/Tomcat等软件就是通过搜索JAVA_HOME变量来找到并使用安装好的jdk。

四. 三种配置环境变量的方法

　　1. 修改/etc/profile文件

　　　　如果你的计算机仅仅作为开发使用时推荐使用这种方法，因为所有用户的shell都有权使用这些环境变量，可能会给系统带来安全性问题。

　　　　·用文本编辑器打开/etc/profile
　　　　·在profile文件末尾加入：

　　　　　　JAVA_HOME=/usr/share/jdk1.5.0_05
　　　　　　PATH=$JAVA_HOME/bin:$PATH
　　　　　　CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
　　　　　　export JAVA_HOME
　　　　　　export PATH
　　　　　　export CLASSPATH

　　　　·重新登录
　　　　·注解
　　　　　　a. 你要将 /usr/share/jdk1.5.0_05jdk 改为你的jdk安装目录
　　　　　　b. linux下用冒号“:”来分隔路径
　　　　　　c. $PATH / $CLASSPATH / $JAVA_HOME 是用来引用原来的环境变量的值
　　　　　　　 在设置环境变量时特别要注意不能把原来的值给覆盖掉了，这是一种
　　　　　　　 常见的错误。
　　　　　　d. CLASSPATH中当前目录“.”不能丢,把当前目录丢掉也是常见的错误。
　　　　　　e. export是把这三个变量导出为全局变量。
　　　　　　f. 大小写必须严格区分。

　　2. 修改.bashrc文件
　　　　
　　　　这种方法更为安全，它可以把使用这些环境变量的权限控制到用户级别，如果你需要给某个用户权限使用这些环境变量，你只需要修改其个人用户主目录下的.bashrc文件就可以了。

　　　　·用文本编辑器打开用户目录下的.bashrc文件
　　　　·在.bashrc文件末尾加入：
　　　　　　
　　　　　　set JAVA_HOME=/usr/share/jdk1.5.0_05
　　　　　　export JAVA_HOME
　　　　　　set PATH=$JAVA_HOME/bin:$PATH
            　　　export PATH
            　　　set CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
            　　　export CLASSPATH

　　　　·重新登录

　　3. 直接在shell下设置变量

　　　　不赞成使用这种方法，因为换个shell，你的设置就无效了，因此这种方法仅仅是临时使用，以后要使用的时候又要重新设置，比较麻烦。

　　　　只需在shell终端执行下列命令：

　　　　export JAVA_HOME=/usr/share/jdk1.5.0_05
　　　　export PATH=$JAVA_HOME/bin:$PATH
　　　　export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

五. 测试jdk

　　1. 用文本编辑器新建一个Test.java文件，在其中输入以下代码并保存：

　　　　public class test {
　　　　　　public static void main(String args[]) {
　　　　　　　　System.out.println("A new jdk test !");
　　　　　　}
　　　　}

　　2. 编译：在shell终端执行命令 javac Test.java

　　3. 运行：在shell终端执行命令 java Test

　　　　当shell下出现“A new jdk test !”字样则jdk运行正常。

六. 卸载jdk

　　·找到jdk安装目录的_uninst子目录
　　·在shell终端执行命令./uninstall.sh即可卸载jdk。

import java.rmi.*;

public interface RmiHelloRemoteIntfc extends Remote
{
   String helloRemoteObj(String client) throws RemoteException;
}

远程接口的实现类RmiHelloRemoteObj.java

import java.rmi.server.*;
import java.rmi.*;

public class RmiHelloRemoteObj extends UnicastRemoteObject implements RmiHelloRemoteIntfc
{

  public RmiHelloRemoteObj() throws RemoteException
  {
    super();
  }

  public String helloRemoteObj(String client) throws RemoteException
  {
     return "Hello World"+client;
  }

}

服务器类RmiHelloServer.java

import java.io.*;
import java.rmi.*;
import java.rmi.server.*;
import sun.applet.*;
import java.rmi.registry.LocateRegistry;

public class RmiHelloServer
{

  public RmiHelloServer()
  {
  }
  public static void main(String[] args)
  {
    //创建并安装安全管理器
    if(System.getSecurityManager()==null)
    {
       System.setSecurityManager(new RMISecurityManager());
    }

    try{
         //创建远程对象
         RmiHelloRemoteObj ttt=new RmiHelloRemoteObj();
         //启动注册表
         LocateRegistry.createRegistry(2222);
         //奖名称绑定到对象
         Naming.rebind("//Fangm:2222/helloObj",ttt);

         System.out.println("RMI服务器正在运行。。。。。。");
      }
      catch(Exception e)
      {
         e.printStackTrace();
      }

  }
}

服务器端的权限文件RmiHelloServer.policy

grant codeBase
"file:/e:/download/rmitest/"
{
 permission java.net.SocketPermission
      "*:1000-9999","accept,connect,listen,resolve";
};

现在就看看Client端是如何连接服务器和进行远程方法的调用的吧

import java.rmi.*;
import java.rmi.server.*;

public class RmiHelloClient
{

  public RmiHelloClient()
  {
  }
  public static void main(String[] args)
  {
    //创建并安装安全管理器
    if(System.getSecurityManager()==null)
    {
       System.setSecurityManager(new RMISecurityManager());
    }

    try{
          RmiHelloRemoteIntfc c1=(RmiHelloRemoteIntfc)Naming.lookup("rmi://Fangm:2222/helloObj");
          System.out.println(c1.helloRemoteObj("Everyone"));
    }
    catch(Exception e)
    {
       e.printStackTrace();
    }
    System.exit(0);

  }
}

Client端的权限文件RmiHelloClient.policy

grant codeBase
"file:/e:/download/rmitest/"
{
  permission java.net.SocketPermission
      "*:1000-9999","accept,connect,listen,resolve";
};

好了，一个最简单的RMI例子就安无了，对了还少了最重要的一步，那就是编译和运行呢？我们就来了个Bat或Cmd的批处理来进行吧，

看看RmiHello.bat吧

javac RmiHelloRemoteIntfc.java

javac RmiHelloRemoteObj.java

rmic RmiHelloRemoteObj

javac RmiHelloServer.java

javac RmiHelloClient.java

echo 在另一个窗口启动服务器，请稍后。。。
start java  -Djava.security.policy=RmiHelloServer.policy RmiHelloServer

echo 运行客户程序。。。
java -Djava.security.policy=RmiHelloClient.policy RmiHelloClient

其实我们可以自己写一个JDBC 数据库连接池。写 JDBC connection pool 的注意事项有：

1. 有一个简单的函数从连接池中得到一个 Connection。
2. close 函数必须将 connection 放回 数据库连接池。
3. 当数据库连接池中没有空闲的 connection， 数据库连接池必须能够自动增加 connection 个数。
4. 当数据库连接池中的 connection 个数在某一个特别的时间变得很大，但是以后很长时间只用其中一小部分，应该可以自动将多余的 connection 关闭掉。
5. 如果可能，应该提供debug 信息报告没有关闭的 new Connection 。

如果要 new Connection 就可以直接从数据库连接池中返回 Connection， 可以这样写( Mediator pattern ) (以下代码中使用了中文全角空格)：

public class EasyConnection implements java.sql.Connection{
　　private Connection m_delegate = null;

　　public EasyConnection(){
　　　　m_delegate = getConnectionFromPool();
　　}

　　public void close(){
　　　　putConnectionBackToPool(m_delegate);
　　}

　　public PreparedStatement prepareStatement(String sql) throws SQLException{
　　　　m_delegate.prepareStatement(sql);
　　}

　　//...... other method

}

看来并不难。不过不建议这种写法，因为应该尽量避免使用 Java Interface, 关于 Java Interface 的缺点我另外再写文章讨论。大家关注的是 Connection Pool 的实现方法。下面给出一种实现方法。

import java.sql.*;
import java.lang.reflect.*;
import java.util.*;
import java.io.*;

public class SimpleConnetionPool {
　　private static LinkedList m_notUsedConnection = new LinkedList();
　　private static HashSet m_usedUsedConnection = new HashSet();
　　private static String m_url = "";
　　private static String m_user = "";
　　private static String m_password = "";
　　static final boolean DEBUG = true;
　　static private long m_lastClearClosedConnection = System.currentTimeMillis();
　　public static long CHECK_CLOSED_CONNECTION_TIME = 4 * 60 * 60 * 1000; //4 hours

　　static {
　　　　initDriver();
　　}

　　private SimpleConnetionPool() {
　　}

　　private static void initDriver() {
　　　　Driver driver = null;
　　　　//load mysql driver
　　　　try {
　　　　　　driver = (Driver) Class.forName("com.mysql.jdbc.Driver").newInstance();
　　　　　　installDriver(driver);
　　　　} catch (Exception e) {
　　　　}

　　　　//load postgresql driver
　　　　try {
　　　　　　driver = (Driver) Class.forName("org.postgresql.Driver").newInstance();
　　　　　　installDriver(driver);
　　　　} catch (Exception e) {
　　　　}
　　}

　　public static void installDriver(Driver driver) {
　　　　try {
　　　　　　DriverManager.registerDriver(driver);
　　　　} catch (Exception e) {
　　　　　　e.printStackTrace();
　　　　}
　　}

　　public static synchronized Connection getConnection() {
　　　　clearClosedConnection();
　　　　while (m_notUsedConnection.size() > 0) {
　　　　　　try {
　　　　　　　　ConnectionWrapper wrapper = (ConnectionWrapper) m_notUsedConnection.removeFirst();
　　　　　　　　if (wrapper.connection.isClosed()) {
　　　　　　　　　　continue;
　　　　　　　　}
　　　　　　　　m_usedUsedConnection.add(wrapper);
　　　　　　　　if (DEBUG) {
　　　　　　　　　　wrapper.debugInfo = new Throwable("Connection initial statement");
　　　　　　　　}
　　　　　　　　return wrapper.connection;
　　　　　　} catch (Exception e) {
　　　　　　}
　　　　}
　　　　int newCount = getIncreasingConnectionCount();
　　　　LinkedList list = new LinkedList();
　　　　ConnectionWrapper wrapper = null;
　　　　for (int i = 0; i < newCount; i++) {
　　　　　　wrapper = getNewConnection();
　　　　　　if (wrapper != null) {
　　　　　　　　list.add(wrapper);
　　　　　　}
　　　　}
　　　　if (list.size() == 0) {
　　　　　　return null;
　　　　}
　　　　wrapper = (ConnectionWrapper) list.removeFirst();
　　　　m_usedUsedConnection.add(wrapper);

　　　　m_notUsedConnection.addAll(list);
　　　　list.clear();

　　　　return wrapper.connection;
　　}

　　private static ConnectionWrapper getNewConnection() {
　　　　try {
　　　　　　Connection con = DriverManager.getConnection(m_url, m_user, m_password);
　　　　　　ConnectionWrapper wrapper = new ConnectionWrapper(con);
　　　　　　return wrapper;
　　　　} catch (Exception e) {
　　　　　　e.printStackTrace();
　　　　}
　　　　return null;
　　}

　　static synchronized void pushConnectionBackToPool(ConnectionWrapper con) {
　　　　boolean exist = m_usedUsedConnection.remove(con);
　　　　if (exist) {
　　　　　　m_notUsedConnection.addLast(con);
　　　　}
　　}

　　public static int close() {
　　　　int count = 0;

　　　　Iterator iterator = m_notUsedConnection.iterator();
　　　　while (iterator.hasNext()) {
　　　　　　try {
　　　　　　　　( (ConnectionWrapper) iterator.next()).close();
　　　　　　　　count++;
　　　　　　} catch (Exception e) {
　　　　　　}
　　　　}
　　　　m_notUsedConnection.clear();

　　　　iterator = m_usedUsedConnection.iterator();
　　　　while (iterator.hasNext()) {
　　　　　　try {
　　　　　　　　ConnectionWrapper wrapper = (ConnectionWrapper) iterator.next();
　　　　　　　　wrapper.close();
　　　　　　　　if (DEBUG) {
　　　　　　　　　　wrapper.debugInfo.printStackTrace();
　　　　　　　　}
　　　　　　　　count++;
　　　　　　} catch (Exception e) {
　　　　　　}
　　　　}
　　　　m_usedUsedConnection.clear();

　　　　return count;
　　}

　　private static void clearClosedConnection() {
　　　　long time = System.currentTimeMillis();
　　　　//sometimes user change system time,just return
　　　　if (time < m_lastClearClosedConnection) {
　　　　　　time = m_lastClearClosedConnection;
　　　　　　return;
　　　　}
　　　　//no need check very often
　　　　if (time - m_lastClearClosedConnection < CHECK_CLOSED_CONNECTION_TIME) {
　　　　　　return;
　　　　}
　　　　m_lastClearClosedConnection = time;

　　　　//begin check
　　　　Iterator iterator = m_notUsedConnection.iterator();
　　　　while (iterator.hasNext()) {
　　　　　　ConnectionWrapper wrapper = (ConnectionWrapper) iterator.next();
　　　　　　try {
　　　　　　　　if (wrapper.connection.isClosed()) {
　　　　　　　　　　iterator.remove();
　　　　　　　　}
　　　　　　} catch (Exception e) {
　　　　　　　　iterator.remove();
　　　　　　　　if (DEBUG) {
　　　　　　　　　　System.out.println("connection is closed, this connection initial StackTrace");
　　　　　　　　　　wrapper.debugInfo.printStackTrace();
　　　　　　　　}
　　　　　　}
　　　　}

　　　　//make connection pool size smaller if too big
　　　　int decrease = getDecreasingConnectionCount();
　　　　if (m_notUsedConnection.size() < decrease) {
　　　　　　return;
　　　　}

　　　　while (decrease-- > 0) {
　　　　　　ConnectionWrapper wrapper = (ConnectionWrapper) m_notUsedConnection.removeFirst();
　　　　　　try {
　　　　　　　　wrapper.connection.close();
　　　　　　} catch (Exception e) {
　　　　　　}
　　　　}
　　}

　　/**
　　 * get increasing connection count, not just add 1 connection
　　 * @return count
　　 */
　　public static int getIncreasingConnectionCount() {
　　　　int count = 1;
　　　　int current = getConnectionCount();
　　　　count = current / 4;
　　　　if (count < 1) {
　　　　　　count = 1;
　　　　}
　　　　return count;
　　}

　　/**
　　 * get decreasing connection count, not just remove 1 connection
　　 * @return count
　　 */
　　public static int getDecreasingConnectionCount() {
　　　　int count = 0;
　　　　int current = getConnectionCount();
　　　　if (current < 10) {
　　　　　　return 0;
　　　　}
　　　　return current / 3;
　　}

　　public synchronized static void printDebugMsg() {
　　　　printDebugMsg(System.out);
　　}

　　public synchronized static void printDebugMsg(PrintStream out) {
　　　　if (DEBUG == false) {
　　　　　　return;
　　　　}
　　　　StringBuffer msg = new StringBuffer();
　　　　msg.append("debug message in " + SimpleConnetionPool.class.getName());
　　　　msg.append("\r\n");
　　　　msg.append("total count is connection pool: " + getConnectionCount());
　　　　msg.append("\r\n");
　　　　msg.append("not used connection count: " + getNotUsedConnectionCount());
　　　　msg.append("\r\n");
　　　　msg.append("used connection, count: " + getUsedConnectionCount());
　　　　out.println(msg);
　　　　Iterator iterator = m_usedUsedConnection.iterator();
　　　　while (iterator.hasNext()) {
　　　　　　ConnectionWrapper wrapper = (ConnectionWrapper) iterator.next();
　　　　　　wrapper.debugInfo.printStackTrace(out);
　　　　}
　　　　out.println();
　　}

　　public static synchronized int getNotUsedConnectionCount() {
　　　　return m_notUsedConnection.size();
　　}

　　public static synchronized int getUsedConnectionCount() {
　　　　return m_usedUsedConnection.size();
　　}

　　public static synchronized int getConnectionCount() {
　　　　return m_notUsedConnection.size() + m_usedUsedConnection.size();
　　}

　　public static String getUrl() {
　　　　return m_url;
　　}

　　public static void setUrl(String url) {
　　　　if (url == null) {
　　　　　　return;
　　　　}
　　　　m_url = url.trim();
　　}

　　public static String getUser() {
　　　　return m_user;
　　}

　　public static void setUser(String user) {
　　　　if (user == null) {
　　　　　　return;
　　　　}
　　　　m_user = user.trim();
　　}

　　public static String getPassword() {
　　　　return m_password;
　　}

　　public static void setPassword(String password) {
　　　　if (password == null) {
　　　　　　return;
　　　　}
　　　　m_password = password.trim();
　　}

}

class ConnectionWrapper implements InvocationHandler {
　　private final static String CLOSE_METHOD_NAME = "close";
　　public Connection connection = null;
　　private Connection m_originConnection = null;
　　public long lastAccessTime = System.currentTimeMillis();
　　Throwable debugInfo = new Throwable("Connection initial statement");

　　ConnectionWrapper(Connection con) {
　　　　Class[] interfaces = {java.sql.Connection.class};
　　　　this.connection = (Connection) Proxy.newProxyInstance(
　　　　　　con.getClass().getClassLoader(),
　　　　　　interfaces, this);
　　　　m_originConnection = con;
　　}

　　void close() throws SQLException {
　　　　m_originConnection.close();
　　}

　　public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
　　　　Object obj = null;
　　　　if (CLOSE_METHOD_NAME.equals(m.getName())) {
　　　　　　SimpleConnetionPool.pushConnectionBackToPool(this);
　　　　}
　　　　else {
　　　　　　obj = m.invoke(m_originConnection, args);
　　　　}
　　　　lastAccessTime = System.currentTimeMillis();
　　　　return obj;
　　}
}

使用方法

public class TestConnectionPool{
　　public static void main(String[] args) {
　　　　SimpleConnetionPool.setUrl(DBTools.getDatabaseUrl());
　　　　SimpleConnetionPool.setUser(DBTools.getDatabaseUserName());
　　　　SimpleConnetionPool.setPassword(DBTools.getDatabasePassword());

　　　　Connection con = SimpleConnetionPool.getConnection();
　　　　Connection con1 = SimpleConnetionPool.getConnection();
　　　　Connection con2 = SimpleConnetionPool.getConnection();

　　　　//do something with con ...

　　　　try {
　　　　　　con.close();
　　　　} catch (Exception e) {}

　　　　try {
　　　　　　con1.close();
　　　　} catch (Exception e) {}

　　　　try {
　　　　　　con2.close();
　　　　} catch (Exception e) {}

　　　　con = SimpleConnetionPool.getConnection();
　　　　con1 = SimpleConnetionPool.getConnection();
　　　　try {
　　　　　　con1.close();
　　　　} catch (Exception e) {}

　　　　con2 = SimpleConnetionPool.getConnection();
　　　　SimpleConnetionPool.printDebugMsg();

　　}
}

运行测试程序后打印连接池中 Connection 状态， 以及正在使用的没有关闭 Connection 信息。

 2.使用连接池  可以自己写一个连接池 这样程序的灵活性强,便于移植.
      apache项目开发了一套非常通用而表现非常稳定的对象池 http://jakarta.apache.org/commons/pool.htm
      设计了自己的连接池后 在客户端调用建立对象
                           public Object makeObject() throws Exception{
    Class.forName("oracle.jdbc.driver.OracalDriver");
    return DriverManager.getConnection("url","username","password");
      }
                  销毁对象时用
      public void destroyObject(Object obj) throws Exception{
         ((Connection)obj.close());
      }
        注意几点 对象池里有没有回收机制,对象池里有机有容量限制,对象池里有多少个闲置对象(可以释放)       
 
        3.控制事务的提交  最好手动提交事务,不但可以可以保证数据原子性,而且对新能提高留下余地.
                   try{
   connection.setAutoCommint(false);
                        // 代码 用PreparedStatement  性能比Statementh好.

                        connection.commit();
                        connection.setAutoCommit(true);
     }
            catch(SQLException e){
                   }
                   finally{
   //代码
   if(connection!=null){
      connection.close(); 
   }
       }

 4.适当的选择事务的隔离级别   TRANSACTION_READ_UNCOMMITED  性能最高
                                     TRANSACTION_READ_COMMITED    快
                                     TRANSACTION_REFEATABLE_READ  中等
            RANSACTION_SERIALIZABLE      慢
 
   (3)Statement 优化
      jdbc3个接口用来处理sql的执行,是Statement PreparedStatement CallableStatement
          提供适当的Statement接口
          批量执行sql
          从数据库批量获取数据
      PreparedStatement 比Statement性能要好 主要体现在一个sql语句多次重复执行的情况
      PreparedStatemnt只编译解析一次而Statement每次编译一次.
     
      批量修改数据库  
 Statement 提供了方法addBatch(String)和executeBatch()
        调用方法为stmt.addBatch("isnert....."); stmt.addBatch("update.....")
                  stmt.executeBatch();
        也可以用PreparedStatement从而更好的提高性能.
                pstmt=conn.preparedStatement("insert into test_table(......) values(....?)");
                pstmt.setString(1,"aaa");
                pstmt.addBatch();
                pstmt.setString(1,"bbb");
                pstmt.addBatch();
                .....
                pstmt.executeBatch();
 
      批量地从数据库中取数据.
          通过setFetchSize()和getFectchSize()方法来设定和查看这个参数.这个参数对体统的性能影响比较大.
          这个参数太小会严重地降低程序地性能.
   Connection Statement ResultSet都有这个参数,他们对性能地影响顺序是:
             ResultSet---------Statement---------Connection
  (4)优化ResultSet.
     体现在以下几个方面
        批量读取数据.合理设置ResultSet的getFetchSize()和setFetchSize()方法中的参数
        使用正确的get和set方法
             使用整数而不是字段名作为参数性能比较高,
             例如 setInt(1,100);
                  setString(2,"aaaa");
               比 setInt("id","100");
                  setString("name","aaaa");
               性能好
        设置适当的滚动方向.有3个方向FETCH_FORWORD,FETCH_REVERSE FETCH_UNKNOWN
             单向滚动性能比较高.
  其他方面的性能优化
      及时显示的关闭Connection Statement ResultSet
          其中Connection可以用Connetion Pool处理.
      使用数据库系统的强大查询功能去组织数据.这样程序运行是和数据库服务的交互次数少,数据库返回给
      程序的记录条数少的多,所以性能有很大的提高.

1Class.forName(“org.gjt.mm.mysql.Driver”);
2Connection conn=DriverManager.getConnection(“jdbc:mydql://localhost:3306/test”,”root’,””);
3Statement stmt=conn.createStatement();
4ResultSet rs=stamt.executeQuery(“select * from table1”);
5JdbcRowSet jrs=new JdbcRowSetImpl(rs);

这样就创建了一个对象（JdbcRowSetImpl是com.sun.rowset包里面的实现类，文中的五个接口在包中都对应有一个实现类），这个对象里面的数据就是和rs里面的数据是一样的。还有一种创建的方法是使用默认的构造方法，然后set属性得到数据，个人推荐使用第二种方法：

1JdbcRowSet jrs=new JdbcRowSetImpl();
2jrs.setUrl(“jdbc:mydql://localhost:3306/test”);
3jrs.setUsername(“root”);
4jrs.setPassword(“”);
5jrs.setCommand(“select * from table1”);
6jrs.execute();

这样创建的对象是和第一种方法是一样的结果。当然这种方法可以连接一个数据源，如果我们在上下文环境种绑定了一个数据源，JNDI名字是dataSource1，那么下面的代码就可以获得对象：

1JdbcRowSet jrs=new JdbcRowSetImpl();
2jrs.setDataSourceName(“dataSource1”)
3jrs.execute();

得到对象之后我们就可以使用相应的方法来对数据进行遍历，更新，插入或者删除。

我有2点要说明：第一，其它四个接口的对象中除了JoinRowSet创建方式基本都是一样的，只是接口名字和接口实现类的名字不同而已，后面我就不再说明创建对象的方法了。第二，虽然JdbcRowSet默认是可滚动和可更新的，但是这也是需要数据库驱动支持的，我使用的MySql驱动就不支持更新结果集，所以大家使用之前需要阅读驱动的说明文档。

CachedRowSet接口：

它继承于RowSet接口，而且他是无连接的RowSet的其他3个实现的父接口，也就是说其他3个接口都直接或者间接继承了它。从名字我们可以知道，它的原理就是读入数据保存在缓存进行相应的操作。
创建接口对象除了上面的两种创建方式，还有一个方法，就是在构造方法里面传递一个SyncProvider。之前我说过无连接的RowSet都是基于流读写的，那么这里所说的SyncProvider就是提供了特定的Reader和Writer。jdk1.5文档的Sample Coder有这样的实现：

1String provider= “com.fred.providers.HighAvailabilityProvider”
2CachedRowSet crs=new CachedRowSetImpl(provider);

这样我们就为RowSet设置了特定的Reader和Writer，但是这是需要第三方的包支持的。而我们使用无参的构造方法创建的对象是使用了默认的 SyncProvider，当然一般来说这对于我们就已经足够了。创建了对象之后就可以使用和JdbcRowSet一样的方法来进行就结果集的增删改操作了，但是唯一不同的就是在更新了结果集之后必须调用Writer将缓存中的数据写入数据库，而其方法就是crs.acceptChages();
CachedRowSet提供的最令人兴奋的功能就是分页功能。以前程序员很头疼的问题就是怎么处理数据分页而不影响性能，现在有了CachedRowSet一切都变得那么简单，请看下面的代码：

 1CachedRowSet crs=new CaehedRowSetImpl();
 2crs.setUrl(“jdbc:mydql://localhost:3306/test”);
 3crs.setUsername(“root”);
 4crs.setPassword(“”);
 5crs.setCommand(“select * from table1”);
 6crs.setPageSize(5);
 7crs.execute();
 8while(crs.nextPage())
 9while(crs.next())
10System.out.println(crs.getInt(“id”+”\t\t”+crs.getString(“name”));

我们在crs.execute()之前设置每页的数据行数，那么Reader读取数据的时候就只读指定的行数的数据，这样我们就避免了一次读取所有数据再进行分页操作。是不是很简单呢？

JoinRowSet接口：

这个接口可以提供我们在无连接的状态下直接对结果集进行Join。下面的代码提供了JoinRowSet的实现：

 1CachedRowSet crs1=new CaehedRowSetImpl();
 2crs1.setUrl(“jdbc:mydql://localhost:3306/test”);
 3crs1.setUsername(“root”);
 4crs1.setPassword(“”);
 5crs1.setCommand(“select * from table1”);
 6crs1.execute();
 7CachedRowSet crs2=new CaehedRowSetImpl();
 8crs2.setUrl(“jdbc:mydql://localhost:3306/test”);
 9crs2.setUsername(“root”);
10crs2.setPassword(“”);
11crs2.setCommand(“select * from table2”);
12crs2.execute();
13JoinRowSet jrs=new JoinRowSetImpl();
14jrs.addRowSet(crs1,”id”);
15jrs.addRowSet(crs2,”id”);
16while(jrs.next())
17System.out.println(jrs.getInt(“id”)+”\t\t”+jrs.getString(“name”)+”\t\t”+jrs.getString(“info”);

这段代码的作用和执行select * from table1 inner join table2 on table1.id=table2.id语句得到的结果集是一样的。但是我个人认为与其这样复杂地使用JoinRowSet，不如直接使用这条Join语句来得到CachedRowSet。
默认的Join是inner join的，接口还支持cross join,full join,left outer join和right outer join，我们通过setJoinType()方法来修改连接类型，当然这还是需要数据库的支持。还有一个值得注意的地方就是，在这个例子里我连接的列在两个表里面都叫id，那么我们取数据的时候就使用id这个名字，那如果两列的名字不一样呢？系统就会为这个连接列取一个默认的名字叫做” MergedCol”。

FilteredRowSet接口：

.NET的ADO.NET支持获取结果集使用一定的条件过滤从而得到不同的结果，那现在jdk1.5也能做到了，FilterRowSet接口让我们可以灵活地定义过滤条件达到不同的效果。Javax.sql.rowset包里面的Predicate接口就是这个过滤器，我们通过实现这个接口定义过滤条件，下面是示意代码：

 1public class Filter implements Predicate {
 2private int min;
 3private int max;
 4private String colName;
 5public Filter (int min ,int max ,String colName) {
 6this.min=min; this.max=max; this.colName=colName;
 7}
 8public boolean evaluate (RowSet rs) {
 9CachedRowSet crs=(CachedRowSet)rs;
10if((crs.getInt(colName)>min)&& (crs.getInt(colName){
11 
12    }
13  }
14}
15

Class.forName("oracle.jdbc.driver.OracleDriver").newInstance(); 
String url="jdbc:oracle:thin:@localhost:1521:orcl"; //orcl为数据库的SID 
String user="test"; 
String password="test"; 
Connection conn= DriverManager.getConnection(url,user,password);

Class.forName("com.ibm.db2.jdbc.app.DB2Driver ").newInstance(); 
String url="jdbc:db2://localhost:5000/sample"; //sample为你的数据库名 
String user="admin"; 
String password=""; 
Connection conn= DriverManager.getConnection(url,user,password);

Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance(); 
String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mydb"; 
//mydb为数据库 
String user="sa"; 
String password=""; 
Connection conn= DriverManager.getConnection(url,user,password);

Class.forName("com.sybase.jdbc.SybDriver").newInstance(); 
String url =" jdbc:sybase:Tds:localhost:5007/myDB";//myDB为你的数据库名 
Properties sysProps = System.getProperties(); 
SysProps.put("user","userid"); 
SysProps.put("password","user_password"); 
Connection conn= DriverManager.getConnection(url, SysProps);

Class.forName("com.informix.jdbc.IfxDriver").newInstance(); 
String url = "jdbc:informix-sqli://123.45.67.89:1533/myDB:INFORMIXSERVER=myserver; 
user=testuser;password=testpassword"; //myDB为数据库名 
Connection conn= DriverManager.getConnection(url);

Class.forName("org.gjt.mm.mysql.Driver").newInstance(); 
String url ="jdbc:mysql://localhost/myDB?user=soft&password=soft1234&useUnicode=true&characterEncoding=8859_1" 
//myDB为数据库名 
Connection conn= DriverManager.getConnection(url);

Class.forName("org.postgresql.Driver").newInstance(); 
String url ="jdbc:postgresql://localhost/myDB" //myDB为数据库名 
String user="myuser"; 
String password="mypassword"; 
Connection conn= DriverManager.getConnection(url,user,password);

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver") ;
String url="jdbc:odbc:Driver={MicroSoft Access Driver (*.mdb)};DBQ="+application.getRealPath("/Data/ReportDemo.mdb");
Connection conn = DriverManager.getConnection(url,"","");
Statement stmtNew=conn.createStatement() ;

*以下列出了在使用JDBC来连接Oracle数据库时可以使用的一些技巧

　　1、在客户端软件开发中使用Thin驱动程序

　　在开发Java软件方面，Oracle的数据库提供了四种类型的驱动程序，二种用于应用软件、applets、servlets等客户端软件，另外二种用于数据库中的Java存储过程等服务器端软件。在客户机端软件的开发中，我们可以选择OCI驱动程序或Thin驱动程序。OCI驱动程序利用Java本地化接口（JNI），通过Oracle客户端软件与数据库进行通讯。Thin驱动程序是纯Java驱动程序，它直接与数据库进行通讯。为了获得最高的性能，Oracle建议在客户端软件的开发中使用OCI驱动程序，这似乎是正确的。但我建议使用Thin驱动程序，因为通过多次测试发现，在通常情况下，Thin驱动程序的性能都超过了OCI驱动程序。

　　2、关闭自动提交功能，提高系统性能

　　在第一次建立与数据库的连接时，在缺省情况下，连接是在自动提交模式下的。为了获得更好的性能，可以通过调用带布尔值false参数的Connection类的setAutoCommit()方法关闭自动提交功能，如下所示：

conn.setAutoCommit(false);

　　值得注意的是，一旦关闭了自动提交功能，我们就需要通过调用Connection类的commit()和rollback()方法来人工的方式对事务进行管理。

　　3、在动态SQL或有时间限制的命令中使用Statement对象

　　在执行SQL命令时，我们有二种选择：可以使用PreparedStatement对象，也可以使用Statement对象。无论多少次地使用同一个SQL命令，PreparedStatement都只对它解析和编译一次。当使用Statement对象时，每次执行一个SQL命令时，都会对它进行解析和编译。这可能会使你认为，使用PreparedStatement对象比使用Statement对象的速度更快。然而，我进行的测试表明，在客户端软件中，情况并非如此。因此，在有时间限制的SQL操作中，除非成批地处理SQL命令，我们应当考虑使用Statement对象。

　　此外，使用Statement对象也使得编写动态SQL命令更加简单，因为我们可以将字符串连接在一起，建立一个有效的SQL命令。因此，我认为，Statement对象可以使动态SQL命令的创建和执行变得更加简单。

　　4、利用helper函数对动态SQL命令进行格式化

　　在创建使用Statement对象执行的动态SQL命令时，我们需要处理一些格式化方面的问题。例如，如果我们想创建一个将名字O'Reilly插入表中的SQL命令，则必须使用二个相连的“''”号替换O'Reilly中的“'”号。完成这些工作的最好的方法是创建一个完成替换操作的helper方法，然后在连接字符串心服用公式表达一个SQL命令时，使用创建的helper方法。与此类似的是，我们可以让helper方法接受一个Date型的值，然后让它输出基于Oracle的to_date()函数的字符串表达式。

　　5、利用PreparedStatement对象提高数据库的总体效率

　　在使用PreparedStatement对象执行SQL命令时，命令被数据库进行解析和编译，然后被放到命令缓冲区。然后，每当执行同一个PreparedStatement对象时，它就会被再解析一次，但不会被再次编译。在缓冲区中可以发现预编译的命令，并且可以重新使用。在有大量用户的企业级应用软件中，经常会重复执行相同的SQL命令，使用PreparedStatement对象带来的编译次数的减少能够提高数据库的总体性能。如果不是在客户端创建、预备、执行PreparedStatement任务需要的时间长于Statement任务，我会建议在除动态SQL命令之外的所有情况下使用PreparedStatement对象。

　　6、在成批处理重复的插入或更新操作中使用PreparedStatement对象

　　如果成批地处理插入和更新操作，就能够显著地减少它们所需要的时间。Oracle提供的Statement和 CallableStatement并不真正地支持批处理，只有PreparedStatement对象才真正地支持批处理。我们可以使用addBatch()和executeBatch()方法选择标准的JDBC批处理，或者通过利用PreparedStatement对象的setExecuteBatch()方法和标准的executeUpdate()方法选择速度更快的Oracle专有的方法。要使用Oracle专有的批处理机制，可以以如下所示的方式调用setExecuteBatch()：

PreparedStatement pstmt3D null;
try {
　((OraclePreparedStatement)pstmt).setExecuteBatch(30);
　
　pstmt.executeUpdate();
}

　　调用setExecuteBatch()时指定的值是一个上限，当达到该值时，就会自动地引发SQL命令执行，标准的executeUpdate()方法就会被作为批处理送到数据库中。我们可以通过调用PreparedStatement类的sendBatch()方法随时传输批处理任务。

　　7、使用Oracle locator方法插入、更新大对象（LOB）

　　Oracle的PreparedStatement类不完全支持BLOB和CLOB等大对象的处理，尤其是Thin驱动程序不支持利用PreparedStatement对象的setObject()和setBinaryStream()方法设置BLOB的值，也不支持利用setCharacterStream()方法设置CLOB的值。只有locator本身中的方法才能够从数据库中获取LOB类型的值。可以使用PreparedStatement对象插入或更新LOB，但需要使用locator才能获取LOB的值。由于存在这二个问题，因此，我建议使用locator的方法来插入、更新或获取LOB的值。

　　8、使用SQL92语法调用存储过程

　　在调用存储过程时，我们可以使用SQL92或Oracle PL/SQL，由于使用Oracle PL/SQL并没有什么实际的好处，而且会给以后维护你的应用程序的开发人员带来麻烦，因此，我建议在调用存储过程时使用SQL92。

　　9、使用Object SQL将对象模式转移到数据库中

　　既然可以将Oracle的数据库作为一种面向对象的数据库来使用，就可以考虑将应用程序中的面向对象模式转到数据库中。目前的方法是创建Java bean作为伪装的数据库对象，将它们的属性映射到关系表中，然后在这些bean中添加方法。尽管这样作在Java中没有什么问题，但由于操作都是在数据库之外进行的，因此其他访问数据库的应用软件无法利用对象模式。如果利用Oracle的面向对象的技术，可以通过创建一个新的数据库对象类型在数据库中模仿其数据和操作，然后使用JPublisher等工具生成自己的Java bean类。如果使用这种方式，不但Java应用程序可以使用应用软件的对象模式，其他需要共享你的应用中的数据和操作的应用软件也可以使用应用软件中的对象模式。

　　10、利用SQL完成数据库内的操作

　　我要向大家介绍的最重要的经验是充分利用SQL的面向集合的方法来解决数据库处理需求，而不是使用Java等过程化的编程语言。

　　如果编程人员要在一个表中查找许多行，结果中的每个行都会查找其他表中的数据，最后，编程人员创建了独立的UPDATE命令来成批地更新第一个表中的数据。与此类似的任务可以通过在set子句中使用多列子查询而在一个UPDATE命令中完成。当能够在单一的SQL命令中完成任务，何必要让数据在网上流来流去的？我建议用户认真学习如何最大限度地发挥SQL的功能。