DBCP数据连接池

maxActive：一个时间最大的活跃连接数，负数代表没有上限
maxIdle：池中最大的空闲对象保持数，其他的将会释放，负数代表没有上限
minIdle：池中最小的空闲对象保持数，其他的将会被创建，0代表不保持
maxWait：当池耗尽时等待空闲对象的最长时间
maxWaitMillis：获取连接最大等待时间,-1代表一直等
timeBetweenEvictionRunsMillis：空闲对象被清除的时间间隔
poolPreparedStatements：Statement pool true时包含PreparedStatements和CallableStatements
numTestsPerEvictionRun：每次运行清除空闲对象线程时要检查的对象数
minEvictableIdleTimeMillis：空闲对象在可被清除之前的最小的停留时间
testWhileIdle：指示对象是否由空闲对象（如果有的话）验证。 如果一个对象无法验证，它将从池中删除。默认false
maxOpenPreparedStatements = GenericKeyedObjectPool.DEFAULT_MAX_TOTAL （-1）:
最大开放语句数声明池。 一个连接通常每次只使用一个或两个语句，这是主要用于帮助检测资源泄漏
removeAbandonedTimeout:超时多少秒删除连接

<!-- datasource setting -->
    <bean id="basicDataSource" class="org.apache.commons.dbcp.BasicDataSource" abstract="true"
          init-method="createDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <!-- 一个时间最大的活跃连接数，负数代表没有上限 -->
        <property name="maxActive" value="10"/>
        <!-- 池中空闲对象的最大数量 -->
        <property name="maxIdle" value="10"/>
        <!-- 池中空闲对象的最小数量 -->
        <property name="minIdle" value="5"/>
        <!-- 当池耗尽时等待空闲对象的最长时间 -->
        <property name="maxWait" value="3000"/>
        <!-- 池启动时创建的初始连接数 -->
        <property name="initialSize" value="20"/>
        <!-- 空闲时间：空闲对象被清除的时间间隔-->
        <property name="timeBetweenEvictionRunsMillis" value="60000"/>
        <!-- Statement pool true时包含PreparedStatements和CallableStatements -->
        <property name="poolPreparedStatements" value="true"/>
        <!-- 最大开放语句数声明池 -->
        <property name="maxOpenPreparedStatements" value="50"/>
        <!-- 超时多少秒删除连接 -->
        <property name="removeAbandonedTimeout" value="180"/>
        <!-- 申请连接时执行validationQuery检测连接是否有效，配置为true会降低性能 -->
        <property name="testOnBorrow" value="false"/>
        <!-- 归还连接时执行validationQuery检测连接是否有效，配置为true会降低性能  -->
        <property name="testOnReturn" value="false"/>
        <!-- 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于
             timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。  -->
        <property name="testWhileIdle" value="true"/>
        <!-- 用来检测连接是否有效的sql，要求是一个查询语句,如果validationQuery为
             null，testOnBorrow、testOnReturn、testWhileIdle都不起其作用。 -->
        <property name="validationQuery" value="select 1;"/>
    </bean>

解释：
配置timeBetweenEvictionRunsMillis = "30000"后，每30秒运行一次空闲连接回收器（独立线程）。并每次检查3个连接，如果连接空闲时间超过30分钟就销毁。销毁连接后，连接数量就少了，如果小于minIdle数量，就新建连接，维护数量不少于minIdle，过行了新老更替。
testWhileIdle = "true" 表示每30秒，取出3条连接，使用validationQuery = "SELECT 1" 中的SQL进行测试 ，测试不成功就销毁连接。销毁连接后，连接数量就少了，如果小于minIdle数量，就新建连接。
testOnBorrow = "false" 一定要配置，因为它的默认值是true。false表示每次从连接池中取出连接时，不需要执行validationQuery = "SELECT 1" 中的SQL进行测试。若配置为true,对性能有非常大的影响，性能会下降7-10倍。所在一定要配置为false.
每30秒，取出numTestsPerEvictionRun条连接（本例是3，也是默认值），发出"SELECT 1" SQL语句进行测试 ，测试过的连接不算是“被使用”了，还算是空闲的。连接空闲30分钟后会被销毁。

a.创建drive工厂：createConnectionFactory
b.创建GenericObjectPool connectionPool;
c.statementPoolFactory:GenericKeyedObjectPoolFactory
d.创建DataSource实例:
PoolingDataSource pds = new PoolingDataSource(connectionPool);

//创建数据源
protected synchronized DataSource createDataSource()
        throws SQLException {
        //如果closed标识为关闭，直接抛异常
        if (closed) {
            throw new SQLException("Data source is closed");
        }
        //不为空，直接返回
        if (dataSource != null) {
            return (dataSource);
        }

        // 创建返回driver原始物理连接的工厂，使用数据库驱动来创建最底层的JDBC连接
        ConnectionFactory driverConnectionFactory = createConnectionFactory();

        // 为我们的连接创建一个池，缓存JDBC连接
        createConnectionPool();

        // 设置statement pool，如果需要就设置statement的缓存池，这个一般不需要设置
        工厂创建的池使用KeyedPoolableObjectFactory。
              * @param maxActive一次可以从池中借用的最大对象数量。
              * @param whenExhaustedAction在池耗尽时采取的操作。
              * @param maxWait当池耗尽时等待空闲对象的最长时间。
              * @param maxIdle池中空闲对象的最大数量。
              * @param maxTotal一次可以存在的最大对象数量。
        GenericKeyedObjectPoolFactory statementPoolFactory = null;
        if (isPoolPreparedStatements()) {
            statementPoolFactory = new GenericKeyedObjectPoolFactory(null,
                        -1, // unlimited maxActive (per key)
                        GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL,
                        0, // maxWait：当池耗尽时等待空闲对象的最长时间
                        1, // maxIdle (per key)：池中空闲对象的最大数量。
                        maxOpenPreparedStatements);
        }

        /**
         * 创建连接池工厂
         * 这个工厂使用上述driverConnectionFactory来创建底层JDBC连接，然后包装出一个PoolableConnection，
         * 这个PoolableConnection与连接池设置了一对多的关系，也就是说，连接池中存在多个PoolableConnection，
         * 每个PoolableConnection都关联同一个连接池，这样的好处是便于该表PoolableConnection的close方法的行为，具体会在后面详细分析。
            并将PoolableConnectionFactory赋值到连接池GenericObjectPool：_pool.setFactory(this);
            后面就可以进行调addObject()
         */
        createPoolableConnectionFactory(driverConnectionFactory, statementPoolFactory, abandonedConfig);

        // 创建并返回数据源管理实例
        createDataSourceInstance();

        // 初始化 为连接池中添加PoolableConnection
        try {
            for (int i = 0 ; i < initialSize ; i++) {
                connectionPool.addObject();
            }
        } catch (Exception e) {
            throw new SQLNestedException("Error preloading the connection pool", e);
        }

        return dataSource;
    }

public void addObject() throws Exception {
        assertOpen();
        if (_factory == null) {
            throw new IllegalStateException("Cannot add objects without a factory.");
        }
        Object obj = _factory.makeObject();
        try {
            assertOpen();
            addObjectToPool(obj, false);
        } catch (IllegalStateException ex) { // Pool closed
            try {
                _factory.destroyObject(obj);
            } catch (Exception ex2) {
                // swallow
            }
            throw ex;
        }
    }

    public Object makeObject() throws Exception {
            Connection conn = _connFactory.createConnection();
            if (conn == null) {
                throw new IllegalStateException("Connection factory returned null from createConnection");
            }
            initializeConnection(conn);
            if(null != _stmtPoolFactory) {
                KeyedObjectPool stmtpool = _stmtPoolFactory.createPool();
                conn = new PoolingConnection(conn,stmtpool);
                stmtpool.setFactory((PoolingConnection)conn);
            }
            return new PoolableConnection(conn,_pool,_config);
        }

synchronized (this) {
               if (isClosed()) {
                   shouldDestroy = true;
               } else {
                   if((_maxIdle >= 0) && (_pool.size() >= _maxIdle)) {
                       shouldDestroy = true;
                   } else if(success) {
                       // borrowObject always takes the first element from the queue,
                       // so for LIFO, push on top, FIFO add to end
                       if (_lifo) {
                           _pool.addFirst(new ObjectTimestampPair(obj));
                       } else {
                           _pool.addLast(new ObjectTimestampPair(obj));
                       }
                       if (decrementNumActive) {
                           _numActive--;
                       }
                       allocate();
                   }
               }
           }

public Connection getConnection() throws SQLException {
        try {
            Connection conn = (Connection)(_pool.borrowObject());
            if (conn != null) {
                conn = new PoolGuardConnectionWrapper(conn);
            }
            return conn;
        } catch(SQLException e) {
            throw e;
        } catch(NoSuchElementException e) {
            throw new SQLNestedException("Cannot get a connection, pool error " + e.getMessage(), e);
        } catch(RuntimeException e) {
            throw e;
        } catch(Exception e) {
            throw new SQLNestedException("Cannot get a connection, general error", e);
        }
    }

protected volatile GenericObjectPool connectionPool = null;