[关闭]
@yulongsun 2017-03-25T07:27:20.000000Z 字数 9335 阅读 1176

数据库连接池实现原理

java

1. 目的

为了实现对`对象Connection`的重用。

2. 实现

2.1 创建自定义的连接池

  1. //创建自定义的连接池
  2. 1、以下是类的源代码,使用的是MySql数据库，代码较多，请注意阅读。
  3. package cn.itcast.connectionpool;
  4. import java.sql.Array;
  5. import java.sql.Blob;
  6. import java.sql.CallableStatement;
  7. import java.sql.Clob;
  8. import java.sql.Connection;
  9. import java.sql.DatabaseMetaData;
  10. import java.sql.DriverManager;
  11. import java.sql.NClob;
  12. import java.sql.PreparedStatement;
  13. import java.sql.SQLClientInfoException;
  14. import java.sql.SQLException;
  15. import java.sql.SQLWarning;
  16. import java.sql.SQLXML;
  17. import java.sql.Savepoint;
  18. import java.sql.Statement;
  19. import java.sql.Struct;
  20. import java.util.LinkedList;
  21. import java.util.Map;
  22. import java.util.Properties;
  23. /**
  24.  * 我的连接池
  25.  * 通过此连接池的实现，用户只能通过 -  包装代理。
  26.  * MyConnectionPool.getConnection()来获取连接
  27.  * 且当用户关闭连接时并没有真的关闭，而是将此对连接又放回到LinkedList中。
  28.  * @author <a href="wangjian_me@126.com">王健</a>
  29.  */
  30. public class MyConnectionPool {
  31.     private MyConnectionPool(){}//声明一个私有的构造不允许别人创建
  32.     //声明连接的字符串，可以使用动态加载，即从资源文件加载
  33.     private static String url="jdbc:mysql://127.0.0.1:3306/itcast";
  34.     //声明用户存放连接类
  35.     private static LinkedList<Connection> connections = new LinkedList<Connection>();
  36.     //仍然是在static中初始化
  37.     static{
  38.         try{
  39.             Class.forName("com.mysql.jdbc.Driver");
  40.             for(int i=0;i<5;i++){//声明初始化有5个连接
  41.                 Connection con = DriverManager.getConnection(url,"root","root");
  42.                 connections.addLast(new ItcastConnection(con));//退加到最后
  43.             }
  44.             System.err.println("共有几个连接："+connections.size());
  45.         }catch(Exception e){
  46.             e.printStackTrace();
  47.         }
  48.     }
  49.     /**
  50.      * 获取一个连接
  51.      */
  52.     public static Connection getConnection(){
  53.         if(connections.size()<=0){
  54.             throw new RuntimeException("已经没有可用的连接，或用户使用了连接后没有关闭。");
  55.         }
  56.         return connections.removeFirst();//返回第一个
  57.     }
  61.     /**
  62.      * 声明成内部私有类，外部的任何人不可以访问
  63.      * 以下使用了个"假"代理来完成Connection的功能
  64.      * 请注意实现的close方法，并没有关闭连接。
  65.      * @author <a href="wangjian_me@126.com">王健</a>
  66.      */
  67.     static private class ItcastConnection implements Connection {
  68.         private Connection realConnection; // 直接的连接
  69.         /**
  70.          * 私有的方法
  71.          */
  72.         private ItcastConnection(Connection con){
  73.             this.realConnection = con;
  74.         }
  75.         //下面的方法只是简单的调用realConnection的实现而已
  76.         public void clearWarnings() throws SQLException {
  77.             realConnection.clearWarnings();
  78.         }
  80.         @Override
  81.         public void close() throws SQLException {
  82.             System.err.println("连接关闭了......");
  83.             connections.addLast(this);              //再次自己加回去
  84.             //realConnection.close();              
  85.  //为了不影响以用户习惯的代码编写所以一个简单的类包裹实现代理，当用户关闭连接时，其实是将此连接更追加到链表的尾部。
  86. //此功能可以一步步的引导学生完成，从最基本的强制用户调用一个方法将连接追加到尾部到实现自动的追加到尾部。
  87.         }
  88.         @Override
  89.         public void commit() throws SQLException {
  90.             realConnection.commit();
  91.         }
  93.         @Override
  94.         public Array createArrayOf(String typeName, Object[] elements)
  95.                 throws SQLException {
  96.             return realConnection.createArrayOf(typeName, elements);
  97.         }
  99.         @Override
  100.         public Blob createBlob() throws SQLException {
  101.             return realConnection.createBlob();
  102.         }
  104.         @Override
  105.         public Clob createClob() throws SQLException {
  106.             return realConnection.createClob();
  107.         }
  109.         @Override
  110.         public NClob createNClob() throws SQLException {
  111.             return realConnection.createNClob();
  112.         }
  114.         @Override
  115.         public SQLXML createSQLXML() throws SQLException {
  116.             return realConnection.createSQLXML();
  117.         }
  118.         public Statement createStatement() throws SQLException {
  119.             return realConnection.createStatement();
  120.         }
  122.         @Override
  123.         public Statement createStatement(int resultSetType, int resultSetConcurrency)
  124.                 throws SQLException {
  125.             return realConnection.createStatement(resultSetType, resultSetConcurrency);
  126.         }
  128.         @Override
  129.         public Statement createStatement(int resultSetType,
  130.                 int resultSetConcurrency, int resultSetHoldability)
  131.                 throws SQLException {
  132.             return realConnection.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);
  133.         }
  134.         public Struct createStruct(String typeName, Object[] attributes)
  135.                 throws SQLException {
  136.             return realConnection.createStruct(typeName, attributes);
  137.         }
  139.         @Override
  140.         public boolean getAutoCommit() throws SQLException {
  141.             return realConnection.getAutoCommit();
  142.         }
  144.         @Override
  145.         public String getCatalog() throws SQLException {
  146.             return realConnection.getCatalog();
  147.         }
  148.         @Override
  149.         public Properties getClientInfo() throws SQLException {
  150.             return realConnection.getClientInfo();
  151.         }
  153.         @Override
  154.         public String getClientInfo(String name) throws SQLException {
  155.             return realConnection.getClientInfo(name);
  156.         }
  157.         public int getHoldability() throws SQLException {
  158.             return realConnection.getHoldability();
  159.         }
  161.         @Override
  162.         public DatabaseMetaData getMetaData() throws SQLException {
  163.             return realConnection.getMetaData();
  164.         }
  166.         @Override
  167.         public int getTransactionIsolation() throws SQLException {
  168.             return realConnection.getTransactionIsolation();
  169.         }
  171.         @Override
  172.         public Map<String, Class<?>> getTypeMap() throws SQLException {
  173.             return realConnection.getTypeMap();
  174.         }
  176.         @Override
  177.         public SQLWarning getWarnings() throws SQLException {
  178.             return realConnection.getWarnings();
  179.         }
  181.         @Override
  182.         public boolean isClosed() throws SQLException {
  183.             return realConnection.isClosed();
  184.         }
  186.         @Override
  187.         public boolean isReadOnly() throws SQLException {
  188.             return realConnection.isReadOnly();
  189.         }
  191.         @Override
  192.         public boolean isValid(int timeout) throws SQLException {
  193.             return realConnection.isValid(timeout);
  194.         }
  196.         @Override
  197.         public String nativeSQL(String sql) throws SQLException {
  198.             return realConnection.nativeSQL(sql);
  199.         }
  201.         @Override
  202.         public CallableStatement prepareCall(String sql) throws SQLException {
  203.             return realConnection.prepareCall(sql);
  204.         }
  206.         @Override
  207.         public CallableStatement prepareCall(String sql, int resultSetType,
  208.                 int resultSetConcurrency) throws SQLException {
  209.             return realConnection.prepareCall(sql);
  210.         }
  212.         @Override
  213.         public CallableStatement prepareCall(String sql, int resultSetType,
  214.                 int resultSetConcurrency, int resultSetHoldability)
  215.                 throws SQLException {
  216.             return realConnection.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
  217.         }
  219.         @Override
  220.         public PreparedStatement prepareStatement(String sql) throws SQLException {
  221.             return realConnection.prepareStatement(sql);
  222.         }
  224.         @Override
  225.         public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
  226.                 throws SQLException {
  227.             return realConnection.prepareStatement(sql, autoGeneratedKeys);
  228.         }
  230.         @Override
  231.         public PreparedStatement prepareStatement(String sql, int[] columnIndexes)
  232.                 throws SQLException {
  233.             return realConnection.prepareStatement(sql, columnIndexes);
  234.         }
  236.         @Override
  237.         public PreparedStatement prepareStatement(String sql, String[] columnNames)
  238.                 throws SQLException {
  239.             return realConnection.prepareStatement(sql, columnNames);
  240.         }
  242.         @Override
  243.         public PreparedStatement prepareStatement(String sql, int resultSetType,
  244.                 int resultSetConcurrency) throws SQLException {
  245.             return realConnection.prepareStatement(sql, resultSetType, resultSetConcurrency);
  246.         }
  248.         @Override
  249.         public PreparedStatement prepareStatement(String sql, int resultSetType,
  250.                 int resultSetConcurrency, int resultSetHoldability)
  251.                 throws SQLException {
  252.             return realConnection.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
  253.         }
  255.         @Override
  256.         public void releaseSavepoint(Savepoint savepoint) throws SQLException {
  257.             realConnection.releaseSavepoint(savepoint);
  258.         }
  260.         @Override
  261.         public void rollback() throws SQLException {
  262.             realConnection.rollback();
  263.         }
  265.         @Override
  266.         public void rollback(Savepoint savepoint) throws SQLException {
  267.             realConnection.rollback(savepoint);
  268.         }
  270.         @Override
  271.         public void setAutoCommit(boolean autoCommit) throws SQLException {
  272.             realConnection.setAutoCommit(autoCommit);
  273.         }
  275.         @Override
  276.         public void setCatalog(String catalog) throws SQLException {
  277.             realConnection.setCatalog(catalog);
  278.         }
  280.         @Override
  281.         public void setClientInfo(Properties properties)
  282.                 throws SQLClientInfoException {
  283.             realConnection.setClientInfo(properties);
  284.         }
  286.         @Override
  287.         public void setClientInfo(String name, String value)
  288.                 throws SQLClientInfoException {
  289.             realConnection.setClientInfo(name, value);
  290.         }
  292.         @Override
  293.         public void setHoldability(int holdability) throws SQLException {
  294.             realConnection.setHoldability(holdability);
  295.         }
  297.         @Override
  298.         public void setReadOnly(boolean readOnly) throws SQLException {
  299.             realConnection.setReadOnly(readOnly);
  300.         }
  302.         @Override
  303.         public Savepoint setSavepoint() throws SQLException {
  304.             return realConnection.setSavepoint();
  305.         }
  307.         @Override
  308.         public Savepoint setSavepoint(String name) throws SQLException {
  309.             return realConnection.setSavepoint(name);
  310.         }
  312.         @Override
  313.         public void setTransactionIsolation(int level) throws SQLException {
  314.             realConnection.setTransactionIsolation(level);
  315.         }
  317.         @Override
  318.         public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
  319.             realConnection.setTypeMap(map);
  320.         }
  322.         @Override
  323.         public boolean isWrapperFor(Class<?> iface) throws SQLException {
  324.             return realConnection.isWrapperFor(iface);
  325.         }
  327.         @Override
  328.         public <T> T unwrap(Class<T> iface) throws SQLException {
  329.             return realConnection.unwrap(iface);
  330.         }
  331.     }
  332. }

2.2 使用动态代理实现

代理示意图

  1. // 1、真实的代理实现应该使用InvocationHandler和Proxy两个类。
  2. // 2、代理的简单实现：见cn.itcast.proxy.a包。
  3. // 3、使用Proxy代理Connection类见：cn.itcast.proxy.b包
  4. // 以下是使用动态代理的源代码：
  5. package cn.itcast.pool;
  6. import java.lang.reflect.InvocationHandler;
  7. import java.lang.reflect.Method;
  8. import java.lang.reflect.Proxy;
  9. import java.sql.Connection;
  10. import java.sql.DriverManager;
  11. import java.util.LinkedList;
  13. /**
  14.  * 数据库连接池
  15.  * 使用动态代理实现
  16.  * @author wangjianme
  17.  */
  18. public class MyConnPool {
  19.     private static String driver = "com.mysql.jdbc.Driver";
  20.     private static String url= "jdbc:mysql://127.0.0.1:3306/wj?useUincode=true&characterEncoding=utf8";
  21.     //使用LinkedList保存有限的连接
  22.     private static LinkedList<Connection> list = new LinkedList<Connection>();
  23.     static{
  24.         try{
  25.             Class.forName(driver);
  26.             for(int i=0;i<5;i++){
  27.                 Connection con = DriverManager.getConnection(url,"root","root");
  28.                 con = MyProxy.getConn(con);//对已经生成的Connection进行代理
  29.                 list.addLast(con);
  30.             }
  31.         }catch(Exception e){
  32.             throw new RuntimeException(e.getMessage(),e);
  33.         }
  34.     }
  35.     /**
  36.      * 获取一个连接
  37.      * @return
  38.      */
  39.     public static Connection getConn(){
  40.         if(list.size()>0){
  41.             Connection con = list.removeFirst();
  42.             return con;
  43.         }else{
  44.             throw new RuntimeException("已经没有可用的连接...");
  45.         }
  46.     }
  47.     /**
  48.      * 以下是动态代理类，实现执行句柄的接口
  49.      * @author wangjianme
  50.      */
  51.     static class MyProxy implements InvocationHandler{
  52.         private Object o;
  53.         private MyProxy(Object o){
  54.             this.o = o;
  55.         }
  56.         public static Connection getConn(Object o){//对传过来的对像进行代理
  57.             Connection c = (Connection)Proxy.newProxyInstance(
  58.                         o.getClass().getClassLoader(),
  59.                         new Class[]{Connection.class},
  60.                         new MyProxy(o));//注意这个new
  61.             return c;
  62.         }
  63.         @Override
  64.         public Object invoke(Object proxy, Method method, Object[] args)
  65.                 throws Throwable {
  66.             if(method.getName().equals("close")){
  67.                 System.err.println("有人在关闭连接，现在将它放回去："+proxy);
  68.                 list.addLast((Connection)proxy);
  69.                 return null;
  70.             }else{
  71.                 return method.invoke(o, args);
  72.             }
  73.         }
  74.     }
  75. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注