您的位置：首页 >> 编程开发 >> Java >> J2SE >> 正文
J2SE RSS
 

一个基本成熟的数据库连接池(part 2)<修正后>

http://www.rdxx.com 05年07月24日 21:13 JR 我要投稿

关键词： 修正 , 基本 , 数据库连接池 , 数据 , 连接

//===================这部分是数据库连接和造作类的封装================


  2. /**
  3.  * 数据连接类Connection的自封装，屏蔽了close方法和createStatement，prepareStatement 方法以返回自己的接管类
  4.  * @author zxg
  5.  */
  6. package com.dbaccess.dbpool;
  8. import java.sql.*;
  10. import java.util.Date;
  11. import java.lang.reflect.*;
  13. public class ConnectionObject implements InvocationHandler{
  15.     private final static String CLOSE_METHOD_NAME = "close";
  16.     private final static String CREATSTATMENT_METHOD_NAME = "createStatement";
  17.     private final static String PREPARESTATEMENT_METHOD_NAME = "prepareStatement";
  20.     private Connection conn_proxy=null;
  21.     private PreparedStatementObject pso=null;
  22.     private StatementObject stmo=null;
  24.     public Connection conn = null;
  25.     public String poolName=null;
  26.     //数据库的忙状态
  27.     private boolean inUse = false;
  29.     //用户最后一次访问该连接方法的时间
  30.     private long lastAccessTime = new Date().getTime();
  33.     public ConnectionObject(Connection conn, boolean inUse){
  34.         this.conn = conn;
  35.         this.inUse = inUse;
  36.     }
  38.     /**
  39.      * Returns the conn.
  40.      * @return Connection
  41.      */
  42.     //返回数据库连接conn的接管类，以便截住Connection 的各个方法
  43.     public Connection getConnection(boolean bNewConn) {
  44.         if (bNewConn)
  45.         {
  46.             ClassLoader classloader=conn.getClass().getClassLoader();
  47.             Class[] interfaces = conn.getClass().getInterfaces();
  49.             if(interfaces==null||interfaces.length==0){
  50.                 interfaces = new Class[1];
  51.                 interfaces[0] = Connection.class;
  52.             }
  54.             conn_proxy=null;
  56.             try{
  58.                 conn_proxy= (Connection)Proxy.newProxyInstance(classloader,interfaces,this);
  60.             }catch(NullPointerException e){
  61.                 log(e,"ConnectionObject getConnection()--error");
  62.             }
  63.             if(conn_proxy!=null)
  64.                 log("ConnectionObject getConnection()--success");
  65.         }
  67.         return conn_proxy;
  69.     }
  71.     /**
  72.      * 该方法真正的关闭了数据库的连接
  73.      * @throws SQLException
  74.      */
  75.     synchronized void  close() throws SQLException{
  76.         //由于类属性conn是没有被接管的连接，因此一旦调用close方法后就直接关闭连接
  77.         conn.close();
  78.         conn=null;
  79.     }
  80.     /**
  81.      * Returns the inUse.
  82.      * @return boolean
  83.      */
  84.     public boolean isInUse() {
  85.         return inUse;
  86.     }
  88.     public boolean isClosed() {
  89.         boolean bClosed=false;
  90.         try{
  91.             bClosed=conn.isClosed();
  92.         }catch(SQLException e){
  93.             log(e,"ConnectionObject--isClosed");
  94.             bClosed=false;
  95.         }
  96.         return bClosed;
  97.     }
  98.     /**
  99.      * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object)
  100.      */
  101.     public Object invoke(Object proxy, Method m, Object[] args)
  102.         throws Throwable
  103.     {
  104.         Object obj = null;
  105.         log("ConnectionObject--invoke:Method: \""+m.getName()+"\"");
  107.         //判断是否调用了close的方法，如果调用close方法则把连接置为无用状态
  109.         if(CLOSE_METHOD_NAME.equals(m.getName())){
  110.             setInUse(false);
  112.         }else if(CREATSTATMENT_METHOD_NAME.equals(m.getName())){
  114.         //如果调用了 createStatment 的方法，封装 Statement 类接受管理
  115.             try{
  116.                 Statement stm=(Statement) m.invoke(conn, args);
  118.                 stmo=new StatementObject(stm);
  119.                 stmo.setConnectionObject(this);
  120.                 obj=stmo.getStatement();
  122.             }catch(Exception e){
  123.                 obj = m.invoke(conn, args);
  124.                 log(e,"ConnectionObject--invoke:Method: \""+m.getName()+"\"--失败");
  125.             }
  127.         }else if(PREPARESTATEMENT_METHOD_NAME.equals(m.getName())){
  129.         //如果调用了 createStatment 的方法，封装 PreparedStatement 类接受管理
  130.             try{
  131.                 PreparedStatement ps=(PreparedStatement) m.invoke(conn, args);
  133.                 pso=new PreparedStatementObject(ps);
  134.                 pso.setConnectionObject(this);
  135.                 obj=pso.getPreparedStatement();
  136.             }catch(Exception e){
  137.                 obj = m.invoke(conn, args);
  138.                 log(e,"ConnectionObject--invoke:Method: \""+m.getName()+"\"--失败");
  139.             }
  141.         }else
  142.             obj = m.invoke(conn, args);
  144.         //设置最后一次访问时间，以便及时清除超时的连接
  145.         lastAccessTime = new Date().getTime();
  146.         return obj;
  147.     }
  149.     /**
  150.      * Returns the lastAccessTime.
  151.      * @return long
  152.      */
  153.     public long getLastAccessTime() {
  154.         return lastAccessTime;
  155.     }
  156.     /**
  157.      * set the lastAccessTime.
  158.      * @param latimelong
  159.      */
  161.     public void setLastAccessTime(long latime) {
  162.         lastAccessTime=latime;
  163.     }
  165.     /**
  166.      * Sets the inUse.
  167.      * @param inUse The inUse to set
  168.      */
  169.     public void setInUse(boolean inUse) {
  170.         this.inUse = inUse;
  171.     }
  173.     public synchronized void release() {
  174.         try{
  175.             close();
  176.         }catch(SQLException e){
  177.             log(e,"ConnectionObject--release 调用 close 失败");
  178.         }
  179.     }
  180.         /**
  181.     * 将文本信息写入日志文件
  182.     */
  183.     private void log(String msg) {
  184.         msg="POOLMSG:Name:["+poolName+"];Msg:"+msg;
  185.         ConnectionManager.log(msg);
  186.     }
  188.     /**
  189.     * 将文本信息与异常写入日志文件
  190.     */
  191.     private void log(Throwable e, String msg) {
  192.         msg="POOLERR:Name:["+poolName+"];Msg:"+msg;
  193.         ConnectionManager.log(e,msg);
  194.     }
  195.     public void setPoolName(String pn){
  196.         poolName=pn;
  197.     }
  198.     public String getPoolName(){
  199.         return poolName;
  200.     }
  201. }
  202. /**
  203.  * Statement的自封装，屏蔽了getResultSet，executeQuery，getGeneratedKeys方法 返回自己的接管类
  204.  * 目的适记录SQl的动作和设置相应连接最后活动时间。
  205.  * @author Liudong
  206.  */
  210. package com.dbaccess.dbpool;
  213. import java.sql.*;
  215. import java.util.Date;
  216. import java.lang.reflect.*;
  218. public class StatementObject implements InvocationHandler{
  219.     
  220.     private Statement stm=null;
  221.     private Statement stm_proxy=null;
  222.     
  223.     private ConnectionObject connoj=null;
  224.     
  225.     private final static String GETRESULTSET_METHOD_NAME = "getResultSet";
  226.     private final static String EXECUTEQUERY_METHOD_NAME = "executeQuery";
  227.     private final static String GETGENERATEDKEYS_METHOD_NAME = "getGeneratedKeys";
  228.     
  229.     private ResultSetObject rso=null;
  231.     public StatementObject(Statement stm){
  232.         this.stm=stm;
  233.     }
  234.     
  235.     public Statement getStatement(){
  237.         ClassLoader classloader=stm.getClass().getClassLoader();
  238.         Class[] interfaces = stm.getClass().getInterfaces(); 
  239.         
  240.         if(interfaces==null||interfaces.length==0){ 
  241.             interfaces = new Class[1]; 
  242.             interfaces[0] = Statement.class; 
  243.         }
  244.         if (stm_proxy!=null)  stm_proxy=null;
  245.         try{
  246.              
  247.             stm_proxy= (Statement)Proxy.newProxyInstance(classloader,interfaces,this);
  248.             
  249.         }catch(NullPointerException e){
  250.             log(e,"StatementObject getStatement()--error");
  251.         }
  252.         if(stm_proxy!=null)
  253.             log("StatementObject getStatement()--success");
  255.         return stm_proxy;
  256.     }
  257.     
  258.     public Object invoke(Object proxy, Method m, Object[] args)    throws Throwable 
  259.     {
  260.         Object obj = null;
  261.         log("StatementObject--invoke:Method: \""+m.getName()+"\"");
  262.          
  263.         //判断是否调用了getResultSet or executeQuery or getGeneratedKeys
  264.         //是就截获
  265.         if(GETRESULTSET_METHOD_NAME.equals(m.getName()) 
  266.             || EXECUTEQUERY_METHOD_NAME.equals(m.getName())
  267.                 || GETGENERATEDKEYS_METHOD_NAME.equals(m.getName())){
  268.             try{
  269.                 ResultSet rs=(ResultSet)m.invoke(stm, args);
  271.                 rso=new ResultSetObject(rs);
  272.                 rso.setConnectionObject(connoj);
  273.                 obj=rso.getResultSet();
  274.                 
  275.             }catch(Exception e){
  276.                 obj = m.invoke(stm, args);
  277.                 log(e,"StatementObject--invoke:Method: \""+m.getName()+"\"--失败");
  278.             
  279.             }
  280.         }else{
  281.             obj = m.invoke(stm, args);    
  282.         }
  283.         
  284.         
  285.         //设置最后一次访问时间，以便及时清除超时的连接
  286.         setLastAccessTime( new Date().getTime());
  287.         return obj;
  288.     }
  289.     /**
  290.     * 将文本信息写入日志文件
  291.     */
  292.     private void log(String msg) {
  293.         msg="POOLMSG:Name:["+connoj.getPoolName()+"];Msg:"+msg;
  294.         ConnectionManager.log(msg);
  295.     }
  296.     
  297.     /**
  298.     * 将文本信息与异常写入日志文件
  299.     */
  300.     private void log(Throwable e, String msg) {
  301.         msg="POOLERR:Name:["+connoj.getPoolName()+"];Msg:"+msg;
  302.         ConnectionManager.log(e,msg);
  303.     }
  304.     
  305.     //设置最后一次访问时间
  306.     private void setLastAccessTime(long ltime){
  307.         connoj.setLastAccessTime(ltime);
  308.     }
  309.     public void setConnectionObject(ConnectionObject cnoj){
  310.         connoj=cnoj;
  311.     }
  312. }
  314. /**
  315.  * PreparedStatement 的自封装，屏蔽了executeQuery方法 返回自己的接管类
  316.  * 目的适记录SQl的动作和设置相应连接最后活动时间。
  317.  * @author Liudong
  318.  */
  320. package com.dbaccess.dbpool;
  323. import java.sql.*;
  325. import java.util.Date;
  326. import java.lang.reflect.*;
  328. public class PreparedStatementObject implements InvocationHandler{
  329.     
  330.     private PreparedStatement ps=null;
  331.     private    PreparedStatement ps_proxy =null;
  332.     private ConnectionObject connoj=null;    
  333.     private final static String EXECUTEQUERY_METHOD_NAME = "executeQuery";
  334.     private ResultSetObject rso=null;
  336.     
  337.     PreparedStatementObject(PreparedStatement ps){
  338.         this.ps=ps;
  339.     }
  340.     public PreparedStatement getPreparedStatement(){
  342.         ClassLoader classloader=ps.getClass().getClassLoader();
  343.         Class[] interfaces = ps.getClass().getInterfaces(); 
  344.         
  345.         if(interfaces==null||interfaces.length==0){ 
  346.             interfaces = new Class[1]; 
  347.             interfaces[0] = PreparedStatement.class; 
  348.         } 
  349.         if (ps_proxy!=null)  ps_proxy=null;        
  350.         try{
  352.             ps_proxy= (PreparedStatement) Proxy.newProxyInstance(classloader,interfaces,this);
  353.             
  354.         }catch(NullPointerException e){
  355.             log(e,"PreparedStatementObject getPreparedStatement()--error");
  356.         }
  357.         if(ps_proxy!=null)
  358.             log("PreparedStatementObject getPreparedStatement()--success");
  360.         return ps_proxy;
  361.     }
  363.     public Object invoke(Object proxy, Method m, Object[] args)    throws Throwable 
  364.     {
  365.         Object obj = null;
  366.         log("PreparedStatementObject--invoke:Method: \""+m.getName()+"\"");
  367.         
  368.         //是否调用了executeQuery 如果是 则接管
  369.         if(EXECUTEQUERY_METHOD_NAME.equals(m.getName())){
  370.             try{
  371.                 ResultSet rs=(ResultSet)m.invoke(ps, args);
  372.                 rso=new ResultSetObject(rs);
  373.                 rso.setConnectionObject(connoj);
  374.                 obj=rso.getResultSet();
  375.             }catch(Exception e){
  376.                 obj = m.invoke(ps, args);
  377.                 log(e,"PreparedStatementObject--invoke:Method: \""+m.getName()+"\"--失败");
  378.             }
  379.         }else{
  380.             obj = m.invoke(ps, args);
  381.         }
  382.         
  383.         obj = m.invoke(ps, args);    
  384.         //设置最后一次访问时间，以便及时清除超时的连接
  385.         setLastAccessTime( new Date().getTime());
  386.         return obj;
  387.     }
  388.     /**
  389.     * 将文本信息写入日志文件
  390.     */
  391.     private void log(String msg) {
  392.         msg="POOLMSG:Name:["+connoj.getPoolName()+"];Msg:"+msg;
  393.         ConnectionManager.log(msg);
  394.     }
  395.     
  396.     /**
  397.     * 将文本信息与异常写入日志文件
  398.     */
  399.     private void log(Throwable e, String msg) {
  400.         msg="POOLERR:Name:["+connoj.getPoolName()+"];Msg:"+msg;
  401.         ConnectionManager.log(e,msg);
  402.     }
  403.     //设置最后一次访问时间
  404.     private void setLastAccessTime(long ltime){
  405.         connoj.setLastAccessTime(ltime);
  406.     }
  407.     public void setConnectionObject(ConnectionObject cnoj){
  408.         connoj=cnoj;
  409.     }
  410. }
  413. /**
  414.  *ResultSet 的自封装，屏蔽了getStatement,getMetaData,getString 方法 返回自己的接管类
  415.  * 目的适记录SQl的动作和设置相应连接最后活动时间。
  416.  * @author Liudong
  417.  */
  420. package com.dbaccess.dbpool;
  422. import java.sql.*;
  424. import java.util.Date;
  426. import java.lang.reflect.*;
  428. public class ResultSetObject implements InvocationHandler{
  430.     private ResultSet rs=null;
  431.     private ResultSet rs_proxy =null;
  432.     private ConnectionObject connoj=null;
  433.     private final static String GETSTATEMENT_METHOD_NAME = "getStatement";
  434.     private final static String GETMETADATA_METHOD_NAME = "getMetaData";
  436.     private StatementObject stmo=null;
  437.     private ResultSetMetaDataObject rsdmo=null;
  440.     public ResultSetObject(ResultSet rs){
  441.         this.rs=rs;
  442.     }
  443.     public ResultSet getResultSet(){
  445.         ClassLoader classloader=rs.getClass().getClassLoader();
  446.         Class[] interfaces = rs.getClass().getInterfaces();
  448.         if(interfaces==null||interfaces.length==0){
  449.             interfaces = new Class[1];
  450.             interfaces[0] = ResultSet.class;
  451.         }
  452.         if(rs_proxy!=null) rs_proxy =null;
  453.         try{
  455.             rs_proxy =(ResultSet)Proxy.newProxyInstance(classloader,interfaces,this);
  457.         }catch(NullPointerException e){
  458.             log(e,"ResultSetObject getResultSet()--error");
  459.         }
  460.         if(rs_proxy!=null)
  461.             log("ResultSet getResultSet()--success");
  462.         return rs_proxy;
  463.     }
  464.     public Object invoke(Object proxy, Method m, Object[] args)    throws Throwable
  465.     {
  466.         Object obj = null;
  468.         log("ResultSetObject--invoke:Method: \""+m.getName()+"\"");
  469.         //是否执行getStatement，返回Statement 的接管类
  470.         if(GETSTATEMENT_METHOD_NAME.equals(m.getName())){
  471.             try{
  472.                 Statement stm=(Statement)m.invoke(rs,args);
  473.                 if (stmo!=null) stmo=null;
  474.                 stmo=new StatementObject(stm);
  475.                 stmo.setConnectionObject(connoj);
  477.                 obj=stmo.getStatement();
  478.             }catch(Exception e){
  479.                 obj=m.invoke(rs,args);
  480.                 log(e,"ResultSetObject--invoke:Method: \""+m.getName()+"\"--失败");
  481.             }
  483.         }else if(GETMETADATA_METHOD_NAME.equals(m.getName())){
  484.             try{
  485.                 ResultSetMetaData rsdm=(ResultSetMetaData)m.invoke(rs, args);
  486.                 if (rsdmo!=null) rsdmo=null;
  487.                 rsdmo=new ResultSetMetaDataObject(rsdm);
  488.                 rsdmo.setConnectionObject(connoj);
  489.                 obj = rsdmo.getMetaData();
  490.             }catch(Exception e){
  491.                 obj=m.invoke(rs,args);
  492.                 log(e,"ResultSetObject--invoke:Method: \""+m.getName()+"\"--失败");
  493.             }
  495.         }else if(m.getName().equals("getString")){
  496.             try{
  498.                 Class paramTypes[]=m.getParameterTypes();
  499.                 Class paramType = paramTypes[0];
  500.                 String paramName=paramType.getName();
  501.                 //debug
  502.             //    log(paramName);
  504.                 if(paramName.indexOf("string")!=-1 ||
  505.                 paramName.indexOf("String")!=-1){
  508.                     String    parm=(String)args[0];
  509.                     //debug
  510.                 //    log(parm);
  511.                     String character=getCharacter(connoj.getPoolName());
  513.                     obj=new String(rs.getBytes(parm),character);
  514.                 }else{
  516.                     Object oi=args[0];
  518.                     String si=oi.toString();
  519.                     //debug
  520.                 //    log(si);
  522.                     int i=Integer.parseInt(si);
  523.                     String character=getCharacter(connoj.getPoolName());
  524.                     obj=new String(rs.getBytes(i),character);
  525.                 }
  526.             }catch(Exception e){
  528.                 obj=m.invoke(rs,args);
  529.                 log(e,"ResultSetObject--invoke:Method: \""+m.getName()+"\"--失败");
  531.             }
  532.         }else
  533.             obj=m.invoke(rs,args);
  535.         //设置最后一次访问时间，以便及时清除超时的连接
  536.         setLastAccessTime( new Date().getTime());
  538.         return obj;
  539.     }
  540.     /**
  541.     * 将文本信息写入日志文件
  542.     */
  543.     private void log(String msg) {
  544.         msg="POOLMSG:Name:["+connoj.getPoolName()+"];Msg:"+msg;
  545.         ConnectionManager.log(msg);
  546.     }
  548.     /**
  549.     * 将文本信息与异常写入日志文件
  550.     */
  552.     private void log(Throwable e, String msg) {
  553.         msg="POOLERR:Name:["+connoj.getPoolName()+"];Msg:"+msg;
  554.         ConnectionManager.log(e,msg);
  555.     }
  557.     private String getCharacter(String poolName) {
  559.         return ConnectionManager.getCharacter(poolName);
  560.     }
  561.     //设置最后一次访问时间
  562.     private void setLastAccessTime(long ltime){
  563.         connoj.setLastAccessTime(ltime);
  564.     }
  565.     //关联所使用得连接。
  566.     public void setConnectionObject(ConnectionObject cnoj){
  567.         connoj=cnoj;
  568.     }
  569. }
  571. /**
  572.  * ResultSetMetaData 的自封装，屏蔽了executeQuery方法 返回自己的接管类
  573.  * 目的适记录SQl的动作和设置相应连接最后活动时间。
  574.  * @author Liudong
  575.  */
  577. package com.dbaccess.dbpool;
  580. import java.sql.*;
  582. import java.util.Date;
  583. import java.lang.reflect.*;
  585. public class ResultSetMetaDataObject implements InvocationHandler{
  586.     
  587.     private ResultSetMetaData rsmd=null;
  588.     private    ResultSetMetaData rsmd_proxy =null;
  589.     //
  590.     private ConnectionObject connoj=null;
  591.     public ResultSetMetaDataObject(ResultSetMetaData rsmd){
  592.         this.rsmd=rsmd;
  593.     }
  594.     public ResultSetMetaData getMetaData(){
  596.         ClassLoader classloader=rsmd.getClass().getClassLoader();
  597.         Class[] interfaces = rsmd.getClass().getInterfaces(); 
  598.         
  599.         if(interfaces==null||interfaces.length==0){ 
  600.             interfaces = new Class[1]; 
  601.             interfaces[0] = ResultSetMetaData.class; 
  602.         } 
  603.         if (rsmd_proxy!=null)  rsmd_proxy=null;
  605.         try{
  607.             rsmd_proxy= (ResultSetMetaData) Proxy.newProxyInstance(classloader,interfaces,this);
  608.             
  609.         }catch(NullPointerException e){
  610.             log(e,"ResultSetMetaDataObject getPreparedStatement()--error");
  611.         }
  612.         if(rsmd_proxy!=null)
  613.             log("ResultSetMetaDataObject getPreparedStatement()--success");
  614.         
  615.         return rsmd_proxy;
  616.     }
  618.     public Object invoke(Object proxy, Method m, Object[] args)    throws Throwable 
  619.     {
  620.         Object obj = null;
  621.         
  622.         log("ResultSetMetaDataObject--invoke:Method: \""+m.getName()+"\"");
  623.                 
  624.         obj = m.invoke(rsmd, args);    
  625.         
  626.         //设置最后一次访问时间，以便及时清除超时的连接
  627.         
  628.         setLastAccessTime( new Date().getTime());
  629.         
  630.         return obj;
  631.     }
  632.         /**
  633.     * 将文本信息写入日志文件
  634.     */
  635.     private void log(String msg) {
  636.         msg="POOLMSG:Name:["+connoj.getPoolName()+"];Msg:"+msg;
  637.         ConnectionManager.log(msg);
  638.     }
  639.     
  640.     /**
  641.     * 将文本信息与异常写入日志文件
  642.     */
  643.     private void log(Throwable e, String msg) {
  644.         msg="POOLERR:Name:["+connoj.getPoolName()+"];Msg:"+msg;
  645.         ConnectionManager.log(e,msg);
  646.     }
  647.     //设置最后一次访问时间
  648.     private void setLastAccessTime(long ltime){
  649.         connoj.setLastAccessTime(ltime);
  650.     }
  651.     public void setConnectionObject(ConnectionObject cnoj){
  652.         connoj=cnoj;
  653.     }
  654. }
  656. /**
  657.  * CallableStatement 的自封装，屏蔽了executeQuery getGeneratedKeys getMetaData 方法 返回自己的接管类
  658.  * 目的是记录SQl的动作和设置相应连接最后活动时间。
  659.  * @author Liudong
  660.  */
  661. package com.dbaccess.dbpool;
  664. import java.sql.*;
  666. import java.util.Date;
  667. import java.lang.reflect.*;
  670. public class CallableStatementObject implements InvocationHandler{
  671.     
  672.     
  673.     private CallableStatement cs=null;
  674.     private CallableStatement cs_proxy =null;
  675.     private ConnectionObject connoj=null;
  676.     
  677.     private final static String EXECUTEQUERY_METHOD_NAME = "executeQuery";
  678.     private final static String GETRESULTSET_METHOD_NAME = "getResultSet";
  679.     private final static String GETGENERATEDKEYS_METHOD_NAME = "getGeneratedKeys";
  680.     private final static String GETMETADATA_METHOD_NAME = "getMetaData";
  681.     
  682.     private ResultSetObject rso=null;
  683.     private ResultSetMetaDataObject rsmdo=null;
  684.     
  685.     CallableStatementObject(CallableStatement cs){
  686.         this.cs=cs;
  687.     }
  688.     public CallableStatement getCallableStatement(){
  689.         ClassLoader classloader=cs.getClass().getClassLoader();
  690.         Class[] interfaces = cs.getClass().getInterfaces(); 
  691.         
  692.         if(interfaces==null||interfaces.length==0){ 
  693.             interfaces = new Class[1]; 
  694.             interfaces[0] = CallableStatement.class; 
  695.         } 
  697.         try{
  699.             cs_proxy= (CallableStatement) Proxy.newProxyInstance(classloader,interfaces,this);
  700.             
  701.         }catch(NullPointerException e){
  702.             log(e,"CallableStatementObject getCallableStatement()--error");
  703.         }
  704.         if(cs_proxy!=null)
  705.             log("CallableStatementObject getCallableStatement()--success");
  707.         return cs_proxy;
  708.     }
  710.     public Object invoke(Object proxy, Method m, Object[] args)    throws Throwable 
  711.     {
  712.         Object obj = null;
  713.         log("CallableStatementObject--invoke:Method: \""+m.getName()+"\"");
  714.         
  715.         //是否调用了executeQuery || getGeneratedKeys 如果是 则接管
  716.         if(EXECUTEQUERY_METHOD_NAME.equals(m.getName()) ||
  717.            GETGENERATEDKEYS_METHOD_NAME.equals(m.getName())||
  718.            GETRESULTSET_METHOD_NAME.equals(m.getName())){
  719.                try{
  720.                 ResultSet rs=(ResultSet)m.invoke(cs, args);
  721.                 rso=new ResultSetObject(rs);
  722.                 rso.setConnectionObject(connoj);
  723.                 obj=rso.getResultSet();
  724.                }catch(Exception e){
  725.                    obj=m.invoke(cs, args);
  726.                    log(e,"CallableStatementObject--invoke:Method: \""+m.getName()+"\"--失败");
  727.                }
  728.         }else if(GETMETADATA_METHOD_NAME.equals(m.getName())){
  729.             try{
  730.                 
  731.                 ResultSetMetaData rsmd=(ResultSetMetaData)m.invoke(cs, args);            
  732.                 rsmdo=new ResultSetMetaDataObject(rsmd);
  733.                 rsmdo.setConnectionObject(connoj);
  734.                 obj=rsmdo.getMetaData();
  735.                 
  736.             }catch(Exception e){
  737.                 obj=m.invoke(cs, args);
  738.                 log(e,"CallableStatementObject--invoke:Method: \""+m.getName()+"\"--失败");
  739.             }
  740.         }else if(m.getName().equals("getString")){
  741.             try{
  742.                 
  743.                 Class paramTypes[]=m.getParameterTypes();
  744.                 Class paramType = paramTypes[0];
  745.                 String paramName=paramType.getName();
  746.                 //debug
  747.             //    log(paramName);
  748.                 
  749.                 if(paramName.indexOf("string")!=-1 ||
  750.                 paramName.indexOf("String")!=-1){
  751.             
  752.                     
  753.                     String    parm=(String)args[0];
  754.                     //debug
  755.                 //    log(parm);
  756.                     String character=getCharacter(connoj.getPoolName());
  757.                     
  758.                     obj=new String(cs.getBytes(parm),character);
  759.                 }else{
  760.                     
  761.                     Object oi=args[0];
  762.                     
  763.                     String si=oi.toString();
  764.                     //debug
  765.                 //    log(si);
  766.                     
  767.                     int i=Integer.parseInt(si);
  768.                     String character=getCharacter(connoj.getPoolName());
  769.                     obj=new String(cs.getBytes(i),character);
  770.                 }                
  771.             }catch(Exception e){
  772.                 
  773.                 log(e,"CallableStatementObject--invoke:Method: \""+m.getName()+"\"--失败");
  774.                 
  775.                 obj=m.invoke(cs,args);
  776.             }
  777.         }else
  778.             obj = m.invoke(cs, args);    
  779.         //设置最后一次访问时间，以便及时清除超时的连接
  780.         setLastAccessTime( new Date().getTime());
  781.         return obj;
  782.     }
  783.         /**
  784.     * 将文本信息写入日志文件
  785.     */
  786.     private void log(String msg) {
  787.         msg="POOLMSG:Name:["+connoj.getPoolName()+"];Msg:"+msg;
  788.         ConnectionManager.log(msg);
  789.     }
  790.     
  791.     /**
  792.     * 将文本信息与异常写入日志文件
  793.     */
  794.     private void log(Throwable e, String msg) {
  795.         msg="POOLERR:Name:["+connoj.getPoolName()+"];Msg:"+msg;
  796.         ConnectionManager.log(e,msg);
  797.     }
  798.     //设置最后一次访问时间
  799.     private void setLastAccessTime(long ltime){
  800.         connoj.setLastAccessTime(ltime);
  801.     }
  802.     public void setConnectionObject(ConnectionObject cnoj){
  803.         connoj=cnoj;
  804.     }
  805.     private String getCharacter(String poolName) {
  806.         
  807.         return ConnectionManager.getCharacter(poolName);
  808.     }
  809. }

 
 
标签： 修正 , 基本 , 数据库连接池 , 数据 , 连接 打印本文
 
 
  相关资讯
RSS
 
 
 
  热点搜索
 
 
  热点导读
 
 
  热点文章
 
 
 
  最近更新
 
 


Valid XHTML 1.0 Transitional
Copyright ©2005 - 2008 Rdxx.Com，All Rights Reserved
收藏本页
收藏本站