JAVA中操作数据库方式与设计模式的应用

[url]http://www.iteye.com/topic/198175[/url]

一个最简单地数据库连接池实现：

public class ConnectionPool {    

       private static Vector pools;    
       private final int POOL_MAXSIZE = 25;    
       /**   
        * 获取数据库连接   
        * 如果当前池中有可用连接，则将池中最后一个返回；若没有，则创建一个新的返回   
        */    
       public synchronized Connection getConnection() {    
              Connection conn = null;    
              if (pools == null) {    
                     pools = new Vector();    
              }    

              if (pools.isEmpty()) {    
                     conn = createConnection();    
              } else {    
                     int last_idx = pools.size() - 1;    
                     conn = (Connection) pools.get(last_idx);    
                     pools.remove(last_idx);    
              }    

              return conn;    
       }    

       /**   
        * 将使用完毕的数据库连接放回池中   
        * 若池中连接已经超过阈值，则关闭该连接；否则放回池中下次再使用   
        */    
       public synchronized void releaseConnection(Connection conn) {    
              if (pools.size() >= POOL_MAXSIZE)    
                     try {    
                            conn.close();    
                     } catch (SQLException e) {    
                            // TODO自动生成 catch 块    
                            e.printStackTrace();    
                     } else    
                     pools.add(conn);    
       }    

       public static Connection createConnection() {    
              Connection conn = null;    
              try {    
                     Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();    
                     String url = "jdbc:oracle:thin:@localhost:1521:orcl";    
                     String user = "scott";    
                     String password = "tiger";    
                     conn = DriverManager.getConnection(url, user, password);    
              } catch (InstantiationException e) {    
                     // TODO自动生成 catch 块    
                     e.printStackTrace();    
              } catch (IllegalAccessException e) {    
                     // TODO自动生成 catch 块    
                     e.printStackTrace();    
              } catch (ClassNotFoundException e) {    
                     // TODO自动生成 catch 块    
                     e.printStackTrace();    
              } catch (SQLException e) {    
                     // TODO自动生成 catch 块    
                     e.printStackTrace();    
              }    
              return conn;    
       }    
}  

注意：利用getConnection()方法得到的Connection，程序员很习惯地调用conn.close()方法关闭了数据库连接，那么上述的数据库连接机制便形同虚设。 在调用conn.close()方法方法时如何调用releaseConnection()方法？这是关键。这里，我们使用Proxy模式和java反射机制。

public synchronized Connection getConnection() {    
              Connection conn = null;    
              if (pools == null) {    
                     pools = new Vector();    
              }    

              if (pools.isEmpty()) {    
                     conn = createConnection();    
              } else {    
                     int last_idx = pools.size() - 1;    
                     conn = (Connection) pools.get(last_idx);    
                     pools.remove(last_idx);    
              }    

        ConnectionHandler handler=new ConnectionHandler(this);    
              return handler.bind(con);    
       }    

public class ConnectionHandler implements InvocationHandler {    
     private Connection conn;    
     private ConnectionPool pool;    

     public ConnectionHandler(ConnectionPool pool){    
            this.pool=pool;    
     }    

     /**   
      * 将动态代理绑定到指定Connection   
      * @param conn   
      * @return   
      */    
     public Connection bind(Connection conn){    
            this.conn=conn;    
Connection proxyConn=(Connection)Proxy.newProxyInstance(    
conn.getClass().getClassLoader(), conn.getClass().getInterfaces(),this);    
          return proxyConn;    
     }    

       /* （非 Javadoc）   
        * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])   
        */    
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {    
              // TODO自动生成方法存根    
              Object obj=null;    
              if("close".equals(method.getName())){    
                     this.pool.releaseConnection(this.conn);    
              }    
              else{    
                     obj=method.invoke(this.conn, args);    
              }    

              return obj;    
       }    
}