持久层设计与资源管理模式笔记

 持久层设计与资源管理模式 
无论是怎样的应用系统，都无法脱离对资源的管理和使用。而对于持久层而言，资源的合理管理和调度则显得尤为重要。 

在大多数应用系统中，80%以上的应用逻辑并不需要特别复杂的数据库访问逻辑(可能只是几条简单的Select或作者Insert/Update语句)。对于这些占到多数的简单逻辑而言，如果SQL语句和数据库本身的设计不是太糟糕(合适的关联，字段索引以及数据库分区策略)，在特定的硬件环境下，我们认为数据库的性能基本稳定。 
此时，导致持久层性能地下的罪魁祸首可能并不是数据库本身，而是在于失败的资源管理调度机制。 

Connection Pool 
即使对于我们而言，通过JDBC获取数据库连接实在是件再简单不过的事情，但对于JDBC Driver来说，连接数据库却并非一件轻松差事。数据库连接不仅仅是在应用服务器与数据库服务器之间建立一个Socket Connection(对于Type4 的JDBC Driver而言)，连接建立之后，应用服务器和数据库服务器之间还需要交换若干次数据（验证用户密码，权限等），然后，数据库开始初始化连接会话句柄，记录联机日志，为此连接分配相应得处理进程和系统资源。 

系统如此忙碌，如果我们只是简单地仍过去两个SQL语句，然后就将此连接抛弃，实在可惜，而数据库连接池技术正是为了解决这个问题。 
数据库连接池的基本原理是在内部对象池中维护一定数量的数据库连接，并对外暴露数据库连接获取或返回方法。如图 

   数据库连接池基本原理示意 
外部使用者可以通过getConnection方法获取连接，使用完毕后再通过releaseConnection方法将连接返回，注意此时连接并没有关闭，而是由连接池管理器回收，并为下一次使用做好准备。 
数据连接池技术带来下面的优势： 
1. 资源重用 
由于数据库连接得以重用，避免了频繁创建，释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增进了系统运行环境的平稳性（减少内存碎片以及数据库临时进程/线程的数量）。 
2. 更快的系统响应速度 
数据库连接池仔初始化过程中，往往已经创建了若干数据库连接池置于池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而缩减了系统整体响应时间。 
3. 新的资源分配手段 
对于应用共享同一个数据库的系统而言，可在应用曾通过数据库连接池的配置，实现某一应用最大可用数据库连接数的限制，避免某一应用独占所有数据库资源。 
4. 统一的连接管理，避免数据库连接泄露 
在较为完备的数据库连接池实现中，可根据预先的连接占用超时设定，强制收回被占用连接。从而避免了常规数据库连接操作中可能出现的资源泄露。 
一个最小化的数据库连接池实现： 

Java代码  

1. package net.wanjin.lab.utils;  
2.   
3. import java.sql.Connection;  
4. import java.sql.DriverManager;  
5. import java.sql.SQLException;  
6. import java.util.Vector;  
7.   
8. public class ConnectionPool {  
9.       
10.     private static Vector pool;  
11.     private final int POOL_MAX_SIZE =20;  
12.     /** 
13.      * 获取数据库连接 
14.      * 如果当前池中有可用连接，则将池中最后一个返回，如果没有，则新建一个返回 
15.      * @return 
16.      * @throws DBException 
17.      */  
18.     public synchronized Connection getConnection() throws DBException{  
19.           
20.         if(pool ==null){  
21.             pool = new Vector();  
22.         }  
23.         Connection conn;  
24.         if(pool.isEmpty()){  
25.             conn = createConnection();  
26.         }else{  
27.             int last_idx = pool.size() -1;  
28.             conn =(Connection)pool.get(last_idx);  
29.             pool.remove(pool.get(last_idx));  
30.               
31.         }  
32.         return conn;  
33.     }  
34.     /** 
35.      * 将使用完毕的数据库连接放回备用池 
36.      *  
37.      * 判断当前池中连接数是否已经超过阀值 
38.      * 如果超过，则关闭该连接 
39.      * 否则放回池中以备下次重用 
40.      * @param conn 
41.      */  
42.     public synchronized void releaseConnection(Connection conn){  
43.           
44.         if(pool.size()>POOL_MAX_SIZE){  
45.             try{  
46.                 conn.close();  
47.             }catch(SQLException e){  
48.                 e.printStackTrace();  
49.             }  
50.         }else{  
51.             pool.add(conn);  
52.         }  
53.     }  
54.     /** 
55.      * 读取数据库配置信息，并从数据库连接池中获得数据库连接 
56.      * @return 
57.      * @throws DBException 
58.      */  
59.     private static Connection createConnection() throws DBException{  
60.         Connection conn;  
61.         try{  
62.             Class.forName("oracle.jdbc.driver.OracleDriver");  
63.             conn = DriverManager.getConnection("jdbc:oracle:thin:@1521:oracle","personal","personal");  
64.             return conn;  
65.         }catch(ClassNotFoundException e){  
66.             throw new DBException("ClassNotFoundException when loading JDBC Driver");  
67.         }catch(SQLException e){  
68.             throw new DBexception("SQLException when loading JDBC Driver");  
69.         }  
70.     }  
71.   
72. }  

完备的连接池实现固然错综复杂，但就其根本而言，还是源自同样的思想。 

先脱离连接池本身的具体实现，我们看看这段代码在实际应用中可能产生的问题，注意到，由于getConnection方法返回的是一个标准的JDBC Connection,程序员由于编成习惯，可能会习惯性的调用其close方法关闭连接。如此一来，连接无法得到重用，数据库连接池机制形同虚设。为了解决这个问题，比较好的途径有： 
1. Decorator 模式 
2. Dynamic Proxy 模式 
下面我们就这两种模式进行一些探讨： 
“Decorator模式的主要目的是利用一个对象，透明地为另一个对象添加新的功能”。 
这句话是从GOF关于设计模式的经典著作《设计模式-可复用面向对象软件的基础》一书中关于Decorator模式的描述直译而来，可能比较难以理解。简单来讲，就是通过一个Decorator对原有对象进行封装，同时实现与原有对象相同的接口，从而得到一个基于原有对象的，对既有接口的增强性实现。 


对于前面所讨论的Connection释放的问题，理所当然，我们首先想到的是，如果能让JDBC Connection在执行close操作时自动返回到数据库连接池中，那么所有问题都将迎刃而解，但是，JDBC Connection自己显然无法根据实际情况判断何去何从。此时，引入Decorator模式来解决我们所面对的问题就非常合适。 

首先，我们引入一个ConnectionDecorator类： 

Java代码  

1. import java.sql.Connection;  
2. import java.sql.SQLException;  
3.   
4.   
5.   
6. public class ConnectionDecorator implements Connection {  
7.     Connection dbconn;  
8.       
9.     public ConnectionDecorator(Connection conn){  
10.         this.dbconn = conn; //实际从数据库获得的Connection引用  
11.     }  
12.       
13.     /** 
14.      * 此方法将被子类覆盖，以实现数据库连接池的连接返回操作 
15.      * @see java.sql.Connection#close() 
16.      */  
17.     public void close() throws SQLException{  
18.         this.dbconn.close();  
19.     }  
20.     /** 
21.      * (non-Javadoc) 
22.      * @see java.sql.Connectionn#commit() 
23.      */  
24.     public void commit() throws SQLException{  
25.         this.dbconn.commit(); //调用实际连接的commit方法  
26.     }  
27.     //以下各个方法类似,均调用dbconn.xxx方法作为Connection接口中方法的简单实现.  
28.   
29. }  

可以看到，ConnectionDecorator类实际上的对传入的数据库连接加上一个外壳，他实现了java.slq.Connection接口，不过本身并没有实现任何实际内容，只是简单的把方法的实现委托给运行期实际获得的Connection实例，，而从外部来看，ConnctionDecorator与普通Connection实例并没有什么区别，因为他们实现了同样的接口，对外提供了同样的功能调用。 

目标很清楚，通过这样的封装，我们的ConnectionDecorator对于外部的程序员而言，调用方法与普通的JDBC Connection完全相同，而在内部通过对ConnectionDecorator的修改，我们就可以透明地改变现有实现，为了增加新的特性： 

Java代码  

1. package net.wanjin.lab.persistence.Decorator;  
2.   
3. import java.sql.Connection;  
4.   
5. import net.wanjin.lab.utils.ConnectionPool;  
6.   
7. public class PooledConnection extends ConnectionDecorator implements Connection{  
8.       
9.     private ConnectionPool connPool;  
10.       
11.     public PooledConnection(ConnectionPool pool,Connection conn){  
12.         super(conn);  
13.         connPool = pool;      
14.     }  
15.     /** 
16.      * 覆盖Close方法，将数据库连接返回连接池，而不是直接关闭连接 
17.      */  
18.     public void close() throws SQLException{  
19.         connPool.releaseConnection(this.dbconn);  
20.     }  
21. }  
22. 为了应用新的PooledConnection ,我们需要对原本的DBConnectionPool.getConnection和releaseConnection方法稍做改造：  
23.   
24.     /** 
25.      * 获取数据库连接 
26.      * 如果当前池中有可用连接，则将池中最后一个返回，如果没有，则新建一个返回 
27.      * @return 
28.      * @throws DBException 
29.      */  
30.     public synchronized Connection getConnection() throws DBException{  
31.           
32.         if(pool ==null){  
33.             pool = new Vector();  
34.         }  
35.         Connection conn;  
36.         if(pool.isEmpty()){  
37.             conn = createConnection();  
38.         }else{  
39.             int last_idx = pool.size() -1;  
40.             conn =(Connection)pool.get(last_idx);  
41.             pool.remove(pool.get(last_idx));  
42.               
43.         }  
44.         //return conn;  
45.         return new PooledConnection(this,conn);  
46.     }  
47.     /* 
48.      * 将使用完毕的数据库连接放回备用池 
49.      *  
50.      * 判断当前池中连接数是否已经超过阀值 
51.      * 如果超过，则关闭该连接 
52.      * 否则放回池中以备下次重用 
53.      * @param conn 
54.      */  
55.     public synchronized void releaseConnection(Connection conn){  
56.           
57.         if(conn instanceof PooledConnection||pool.size()>POOL_MAX_SIZE){  
58.             try{  
59.                 conn.close();  
60.             }catch(SQLException e){  
61.                 e.printStackTrace();  
62.             }  
63.         }else{  
64.             pool.add(conn);  
65.         }  
66.     }  

此时获取数据库连接后，调用这只需要按照JDBC Connection的标准用法进行调用即可，从而实现了数据库连接的透明化。同样的道理，我们甚至可以利用Decorator模式对DriverManager类进行同样的改造，从而最小化数据库连接池实现对传统JDBC编码方式的影响。 

Dynamic Proxy 模式 
DynamicProxy是JDK1.3版本中新引入的一种代理机制。严格来讲，DynamicProxy本身并非一种模式，只能算是Proxy模式的一种动态实现方式，不过为了与传统Proxy模式相区分，这里暂且将其称为“Dynamic Proxy模式”，来泛指通过Dynamic Proxy机制实现的Proxy模式。 
回到上面的问题，我们的目标是在引入数据库连接池机制的同时，保持JDBCConnection对外接口不变。前面通过Decorator接口中定义的方法众多，我们也只是能照单全收，在ConnecionDecorator中逐一实现这些方法，虽然只是简单的委托实现，也实在是件恼人的工作。 
Dynamic Proxy模式则良好地解决了这一问题。通过实现一个邦定到Connection对象的InvocationHandler接口实现，我们可以在Connection.close方法被调用时将其截获，并以我们自己实现的Close方法将其代替，使连接返回到数据库连接池等待下次重用，而不是直接关闭。 

下面是ConnectionHandler类，它实现了InvocationHandler接口，按照DynamicProxy机制的定义，Invoke方法将截获所有代理对象的方法调用操作，这里我们通过invoke方法截获close方法进行处理。 

Java代码  

1. package net.wanjin.lab.utils;  
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.   
8.   
9.   
10. public class ConnectionHandler implements InvocationHandler {  
11.       
12.     Connection dbconn;  
13.     ConnectionPool pool;  
14.       
15.     public ConnectionHandler(ConnectionPool connPool){  
16.         this.pool = connPool;  
17.     }  
18.     /** 
19.      *  
20.      */  
21.     public Connection bind(Connection conn){  
22.         this.dbconn = conn;  
23.           
24.         Connection proxyConn =(Connection)Proxy.newProxyInstance(  
25.                 conn.getClass().getClassLoader(),conn.getClass().getInterfaces(),this);  
26.           
27.         return proxyConn;  
28.     }  
29.       
30.     public Object invoke(Object proxy,Method method,Object[] args)  
31.     throws Throwable{  
32.         Object obj =null;  
33.         //如果调用的是close方法，则用pool.releaseConnection方法将其替换  
34.         if("close".equals(method.getName())){  
35.             pool.releaseConnection(dbconn);  
36.         }else{  
37.             obj = method.invoke(dbconn, args);  
38.         }  
39.         return obj;  
40.           
41.     }  
42.   
43. }  

配合Dynamic Proxy模式，我们的DBConnectionPool.getConnection方法也做了一点小的修改： 

Java代码  

1. /** 
2.  * 获取数据库连接 
3.  * 如果当前池中有可用连接，则将池中最后一个返回，如果没有，则新建一个返回 
4.  * @return 
5.  * @throws DBException 
6.  */  
7. public synchronized Connection getConnection() throws DBException{  
8.       
9.     if(pool ==null){  
10.         pool = new Vector();  
11.     }  
12.     Connection conn;  
13.     if(pool.isEmpty()){  
14.         conn = createConnection();  
15.     }else{  
16.         int last_idx = pool.size() -1;  
17.         conn =(Connection)pool.get(last_idx);  
18.         pool.remove(pool.get(last_idx));  
19.           
20.     }  
21.     //return conn;  
22.     //return new PooledConnection(this,conn);  
23.     ConnectionHandler connHandler = new ConnectionHandler(this);  
24.     return connHandler.bind(conn);  
25. }  

可以看到，基于Dynamic Proxy 模式的实现相对Decorator更加简洁明了。