java之使用动态代理实现数据库连接的回收

package cn.mycast.bank.db; 2 3 import java.sql.Connection; 4 import java.sql.SQLException; 5 import java.util.LinkedList; 6 import cn.mycast.bank.util.JdbcUtil; 7 public class MyDatabasePool { 8 LinkedList<Connection> connPool= new LinkedList<Connection>(); // 存放连接 9 private int Maxsize=10 ; 10 private int Initsize=6 ; 11 int Currentsize=0 ; 12 public MyDatabasePool(){ 13 for ( int i=0;i<Initsize;i++) // 连接池中存放10个连接 14 { 15 this .connPool.addLast( this .CreateConnection()); // 每次添加到集合最后面 16 this .Currentsize++ ; 17 } 18 } 19 public Connection CreateConnection(){ // 获得连接 20 Connection realconn= JdbcUtil.getConnection(); 21 MyDatabaseHandler handler= new MyDatabaseHandler( this ); // 代理类 22 return handler.bind(realconn); 23 } 24 public Connection GetConnection() throws SQLException{ 25 synchronized (connPool){ 26 if ( this .connPool.size()>0 ){ 27 return connPool.removeFirst(); // 取出最上面的一个连接 28 } 29 if ( this .Currentsize< Maxsize){ 30 this .Currentsize++ ; 31 return this .CreateConnection(); 32 } 33 throw new SQLException("" ); 34 } 35 } 36 public void FreeConnection(Connection conn){ // 将用完后的连接放回到集合中 37 this .connPool.addLast(conn); 38 } 39 }

2.编写一个代理类，这里主要是实现一个InvocationHandler的接口

  1   package   cn.mycast.bank.db;
   2  
  3   import   java.lang.reflect.InvocationHandler;
   4   import   java.lang.reflect.Method;
   5   import   java.lang.reflect.Proxy;
   6   import   java.sql.Connection;
   7   public   class  MyDatabaseHandler  implements   InvocationHandler{
   8       private   Connection realConnection;
   9       private   Connection WrapperConn;
  10       private   MyDatabasePool databasesource;
  11       private   int  Maxsize=10 ;
  12       int  Currentsize=0 ;
  13       public   MyDatabaseHandler(MyDatabasePool databasesource){
  14           this .databasesource= databasesource;
  15       }
  16       /* 
 17        * Proxy类动态根据这里我们制定的接口生成一个class byte，然后通过classloader将class byte生成一个类对象，再将该对象委派给当前代理类的实例
  18        */ 
 19       Connection bind(Connection realConn){
  20           this .realConnection=realConn; //  需要代理的原始的对象 
 21           this .WrapperConn=(Connection)Proxy.newProxyInstance( this .getClass().getClassLoader(),  new  Class[]{Connection. class },  this  );
  22           return   WrapperConn;
  23           //  这步是创建代理对象了，第一个参数指定类加载器:使得这个代理类能访问被代理对象，
  24           //  第二个参数指定代理类应该具有哪些接口：要不然怎么去代理被代理对象，
  25           //  第二个参数就是指定，代理对象额外完成的业务逻辑了：如前面所述的获取被代理类的执行时间。 
 26       }
  27       @Override
  28       public   Object invoke(Object proxy, Method method, Object[] args)
  29               throws   Throwable {
  30           if ("close".equals(method.getName())){ //  这里代理原始类的close方法 
 31               this .Currentsize++ ;
  32               if ( this .Currentsize< this  .Maxsize){
  33                   this .databasesource.connPool.addLast( this  .WrapperConn);
  34              } else  {
  35                   this  .realConnection.close();
  36                   this .databasesource.Currentsize-- ;
  37               }
  38           }
  39           return  method.invoke( this  .realConnection, args);
  40       }
  41      
 42  }

3.编写一个测试类

  1   package   cn.mycast.bank.db;
   2  
  3   import   java.sql.Connection;
   4   import   java.sql.SQLException;
   5  
  6   public   class   Main {
   7       /** 
  8        *   @param   args
   9        *   @throws   SQLException 
  10        */ 
 11       public   static   void   main(String[] args) {
  12          System.out.println("创建连接.........." );
  13          MyDatabasePool databasepool= new   MyDatabasePool();
  14          
 15          System.out.println("客户端连接.........." );
  16          Connection conn= null  ;
  17           try   {
  18              conn= databasepool.GetConnection();
  19              System.out.println("連接池中的連接個數"+ databasepool.connPool.size());
  20          }  catch   (SQLException e) {
  21               //   TODO Auto-generated catch block 
 22               e.printStackTrace();
  23          } finally  {
  24               if (conn!= null  ){
  25                   try   {
  26                       conn.close();
  27                      System.out.println("客户端關閉連接.........." );
  28                  }  catch   (SQLException e) {
  29                       e.printStackTrace();
  30                   }
  31               }
  32           }
  33          System.out.println("連接池中的連接個數"+ databasepool.connPool.size());
  34       }
  35  
 36  }

创建连接..........
客户端连接..........
連接池中的連接個數5
客户端關閉連接..........
連接池中的連接個數6

动态代理工作原理图如下：

      动态代理就是对被代理的类进行一次封装包裹，以便加上我们自己需要加的一些业务逻辑。

java之使用动态代理实现数据库连接的回收

标签：

查看更多关于java之使用动态代理实现数据库连接的回收的详细内容...