JDBC 连接池代码列子.docx

1、JDBC 连接池代码列子Java代码 import java.sql.*; import java.lang.reflect.*; import org.omg.CORBA.portable.InvokeHandler; import freemarker.template.utility.ObjectConstructor; /* * 定义数据库连接的代理类 * * author mark * */ public class ConnectionProxy implements InvocationHandler / 定义连接 private Connection conn = null;

2、/ 定义监控连接创建的语句 private Statement statRef = null; private PreparedStatement preStatRef = null; / 是否支持事务标志 private boolean supportTransaction = false; / 数据库的忙状态 private boolean isFree = false; / 最后一次访问时间 long lastAccessTime = 0; / 定义要接管的函数的名字 String CREATESTATE = createStatement; String CLOSE = close;

3、String PREPARESTATEMENT = prepareStatement; String COMMIT = commit; String ROLLBACK = rollbakc; /* * 构造函数，采用私有，防止被直接创建 * * param param * 连接参数 */ private ConnectionProxy(ConnectionParam param) / 记录日志 try / 创建连接 Class.forName(oracle.jdbc.driver.OracleDriver); conn = DriverManager.getConnection(jdbc:or

4、acle:thin:10.8.1.234:1521:WF4PPDB,PP42, PP42); DatabaseMetaData dm = null; dm = conn.getMetaData(); / 判断是否支持事务 supportTransaction = dm.supportsTransactions(); catch (Exception ex) ex.printStackTrace(); public Object invoke(Object proxy, Method method, Object args) throws Throwable Object obj = null;

5、 / 判断是否调用了close的方法，如果调用close方法则把连接置为无用状态 if (CLOSE.equals(method.getName() / 设置不使用标志 setFree(false); if (statRef != null) statRef.close(); if (preStatRef != null) preStatRef.close(); return null; / 判断是使用了createStatement语句 if (CREATESTATE.equals(method.getName() try obj = method.invoke(conn, args); s

6、tatRef = (Statement) obj; return obj; catch (ClassCastException ex) ex.printStackTrace(); / 判断是使用了prepareStatement语句 if (PREPARESTATEMENT.equals(method.getName() obj = method.invoke(conn, args); preStatRef = (PreparedStatement) obj; return obj; / 如果不支持事务，就不执行该事物的代码 if (COMMIT.equals(method.getName()

7、 | ROLLBACK.equals(method .getName() & (!isSupportTransaction() return null; obj = method.invoke(conn, args); / 设置最后一次访问时间，以便及时清除超时的连接 lastAccessTime = System.currentTimeMillis(); return obj; /* * 创建连接的工厂，只能让工厂调用 * * param factory * 要调用工厂，并且一定被正确初始化 * param param * 连接参数 * return 连接 */ public static

8、ConnectionProxy getConnection(ConnectionFactory factory, ConnectionParam param) / 判断是否正确初始化的工厂 if (factory.isCreate() ConnectionProxy _conn = new ConnectionProxy(param); return _conn; else return null; public Connection getFreeConnection() / 返回数据库连接conn的接管类，以便截住close方法 Connection cn = (Connection) P

9、roxy.newProxyInstance(conn.getClass() .getClassLoader(), conn.getClass().getInterfaces(), this); return cn; /* * 该方法真正的关闭了数据库的连接 * * throws SQLException */ public void close() throws SQLException / 由于类属性conn是没有被接管的连接，因此一旦调用close方法后就直接关闭连接 conn.close(); public void setFree(boolean isFree) this.isFree

10、 = isFree; public boolean isFree() return isFree; /* * 判断是否支持事务 * * return boolean */ public boolean isSupportTransaction() return supportTransaction; import java.sql.Connection; import java.sql.SQLException; import java.util.*; public class ConnectionFactory private static ConnectionFactory m_insta

11、nce = null; / 在使用的连接池 private LinkedHashSet ConnectionPool = null; / 空闲连接池 private LinkedHashSet FreeConnectionPool = null; / 最大连接数 private int MaxConnectionCount = 10; / 最小连接数S private int MinConnectionCount = 2; / 当前连接数 private int current_conn_count = 0; / 连接参数 private ConnectionParam connparam =

12、 null; / 是否创建工厂的标志 private boolean isflag = false; / 是否支持事务 private boolean supportTransaction = false; / 定义管理策略 private int ManageType = 0; /* * 构造器 */ private ConnectionFactory() ConnectionPool = new LinkedHashSet(); FreeConnectionPool = new LinkedHashSet(); /* * 使用指定的参数创建一个连接池 * * throws SQLExcep

13、tion */ public ConnectionFactory(ConnectionParam param, FactoryParam fparam) throws SQLException if (param = null) | (fparam = null) throw new SQLException(ConnectionParam和FactoryParam不能为空); if (m_instance = null) synchronized (ConnectionFactory.class) if (m_instance = null) / 参数定制 m_instance = new

14、ConnectionFactory(); connparam = param; m_instance.MaxConnectionCount = fparam .getMaxConnectionCount(); m_instance.MinConnectionCount = fparam .getMinConnectionCount(); m_instance.ManageType = fparam.getManageType(); m_instance.isflag = true; / 初始化，创建MinConnectionCount个连接 System.out.println(connect

15、ion factory 创建！); try for (int i = 0; i m_instance.MinConnectionCount; i+) ConnectionProxy conn = ConnectionProxy .getConnection(m_instance,m_instance.connparam); if (conn = null) continue; System.out.println(connection创建); m_instance.FreeConnectionPool.add(conn); / 加入空闲连接池 m_instance.current_conn_c

16、ount+; / 标志是否支持事务 m_instance.supportTransaction = conn .isSupportTransaction(); catch (Exception ex) ex.printStackTrace(); / 根据策略判断是否需要查询 if (m_instance.ManageType != 0) Thread t = new Thread(new FactoryManageThread( m_instance); t.start(); /* * 标志工厂是否已经创建 * * return boolean */ public boolean isCrea

17、te() return m_instance.isflag; /* * 从连接池中取一个空闲的连接 * * return Connection * throws SQLException */ public synchronized Connection getFreeConnection() throws SQLException Connection cn = null; / 获取空闲连接 Iterator ir = m_instance.FreeConnectionPool.iterator(); while (ir.hasNext() ConnectionProxy conn = (C

18、onnectionProxy) ir.next(); / 找到未用的连接 if (!conn.isFree() cn = conn.getFreeConnection(); conn.setFree(true); / 移出空闲区 m_instance.FreeConnectionPool.remove(conn); / 加入连接池 m_instance.ConnectionPool.add(conn); break; / 检查空闲池是否为空 if (m_instance.FreeConnectionPool.isEmpty() / 再检查是否能够分配 if (m_instance.curren

19、t_conn_count = m_instance.MinConnectionCount) newCount = m_instance.MinConnectionCount; else newCount = m_instance.MaxConnectionCount - m_instance.current_conn_count; / 创建连接 for (int i = 0; i newCount; i+) ConnectionProxy _conn = ConnectionProxy.getConnection( m_instance, connparam); m_instance.Free

20、ConnectionPool.add(_conn); m_instance.current_conn_count+; else / 如果不能新建，检查是否有已经归还的连接 ir = m_instance.ConnectionPool.iterator(); while (ir.hasNext() ConnectionProxy _conn = (ConnectionProxy) ir.next(); if (!_conn.isFree() cn = _conn.getFreeConnection(); _conn.setFree(false); m_instance.ConnectionPoo

21、l.remove(_conn); m_instance.FreeConnectionPool.add(_conn); break; / 再次检查是否能分配连接 if (cn = null) ir = m_instance.FreeConnectionPool.iterator(); while (ir.hasNext() ConnectionProxy _conn = (ConnectionProxy) ir.next(); if (!_conn.isFree() cn = _conn.getFreeConnection(); _conn.setFree(true); m_instance.F

22、reeConnectionPool.remove(_conn); m_instance.ConnectionPool.add(_conn); break; if (cn = null) / 如果不能则说明无连接可用 throw new SQLException(没有可用的数据库连接); System.out.println(Get Connection); return cn; /* * 关闭该连接池中的所有数据库连接 * * throws SQLException */ public synchronized void close() throws SQLException this.isf

23、lag = false; SQLException sqlError = null; / 关闭空闲池 Iterator ir = m_instance.FreeConnectionPool.iterator(); while (ir.hasNext() try (ConnectionProxy) ir.next().close(); System.out.println(Close connection:Free); m_instance.current_conn_count-; catch (Exception ex) if (ex instanceof SQLException) sqlE

24、rror = (SQLException) ex; / 关闭在使用的连接池 ir = m_instance.ConnectionPool.iterator(); while (ir.hasNext() try (ConnectionProxy) ir.next().close(); System.out.println(Close connection:Using); catch (Exception ex) if (ex instanceof SQLException) sqlError = (SQLException) ex; if (sqlError != null) throw sql

25、Error; /* * 返回是否支持事务 * * return boolean */ public boolean isSupportTransaction() return m_instance.supportTransaction; /* * 连接池调度管理 * */ public void schedule() Connection cn = null; / 再检查是否能够分配 Iterator ir = null; / 检查是否有已经归还的连接 ir = m_instance.ConnectionPool.iterator(); while (ir.hasNext() Connecti

26、onProxy _conn = (ConnectionProxy) ir.next(); if (!_conn.isFree() cn = _conn.getFreeConnection(); _conn.setFree(false); m_instance.ConnectionPool.remove(_conn); m_instance.FreeConnectionPool.add(_conn); break; if (m_instance.current_conn_count = m_instance.MinConnectionCount) newCount = m_instance.MinConnectionCount; else newCount = m_instance.MaxConnectionCount - m_instance.current_conn_count; / 创建连接 for (int i = 0; i newCount; i+) ConnectionProxy _conn = ConnectionProxy.getConnection( m_instance, connparam); m_instance.