数据库连接池DBCP框架的研究以及源代码分析二：寻找真正的DataSource

从DataSourceFactory中，我们看到DataSourceFactory创建了一个DataBaseSource，如下代码

 
    public static DataSource createDataSource(Properties properties) throws Exception {
        BasicDataSource dataSource = new BasicDataSource();
      //省略设置属性若干

     retrun  dataSource ;

}

那么BasicDatasource是什么东东？请看代码

public class BasicDataSource implements DataSource {//从这里看，好像这个类就是传说中的DataSource，但是看看下面的红色属性部分
    
    static {
        DriverManager.getDrivers();//注册驱动
    }

//这里省略SET\GET方法一堆，以免耽误代价时间，直接看属性
     protected volatile DataSource dataSource = null;//这里又定义了一个Datasource，看来BasicDataSource只是一个烟雾弹，在里面的属性，才是真正的DataSource，我们知道,DataSource接口主要是用于创建连接，那么我们看一下getConnection（）就可以确认我们的猜测是否正确？，继续往下看红色部分

    protected volatile boolean defaultAutoCommit = true;
    protected transient Boolean defaultReadOnly = null;
    protected volatile int defaultTransactionIsolation =
        PoolableConnectionFactory.UNKNOWN_TRANSACTIONISOLATION;
    protected volatile String defaultCatalog = null;
    protected String driverClassName = null;
    protected ClassLoader driverClassLoader = null;
    protected int maxActive = GenericObjectPool.DEFAULT_MAX_ACTIVE;
    protected int maxIdle = GenericObjectPool.DEFAULT_MAX_IDLE;
    protected int minIdle = GenericObjectPool.DEFAULT_MIN_IDLE;
    protected int initialSize = 0;
    protected long maxWait = GenericObjectPool.DEFAULT_MAX_WAIT;
    protected boolean poolPreparedStatements = false;
    protected int maxOpenPreparedStatements = GenericKeyedObjectPool.DEFAULT_MAX_TOTAL;
    protected boolean testOnBorrow = true;
    protected boolean testOnReturn = false;
    protected long timeBetweenEvictionRunsMillis =
        GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS;
    protected int numTestsPerEvictionRun =
        GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN;
    protected long minEvictableIdleTimeMillis =
        GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS;
    protected boolean testWhileIdle = false;
    protected volatile String password = null;
    protected String url = null;
    protected String username = null;
    protected volatile String validationQuery = null;//验证连接有效性的SQL
    protected volatile int validationQueryTimeout = -1;
    protected volatile List connectionInitSqls;
    private boolean accessToUnderlyingConnectionAllowed = false; //是否可以操作底层连接
    private volatile boolean restartNeeded = false;
     protected volatile GenericObjectPool connectionPool = null; //连接池
    protected Properties connectionProperties = new Properties();

    protected PrintWriter logWriter = new PrintWriter(System.out);
    private AbandonedConfig abandonedConfig;
    protected boolean closed;
 
    public Connection getConnection() throws SQLException {
        return createDataSource().getConnection();//看来，这个类很狡猾，跟我们玩了一个花样，createDataSource里面创建的才是真正创造连接的DataSource接口
    }

//创建真正DataSource的类
    protected synchronized DataSource createDataSource()//核心方法
        throws SQLException {
        if (closed) {
            throw new SQLException("Data source is closed");
        }


        // 如果已经创建过一次了，就返回已经创建的，这个合情合理
        if (dataSource != null) {
            return (dataSource);
        }


        // 创建一个工厂，用于生成真正物理的Connection
        ConnectionFactory driverConnectionFactory = createConnectionFactory();


        // 创建我们的连接池
        createConnectionPool();


 
        GenericKeyedObjectPoolFactory statementPoolFactory = null;
        if (isPoolPreparedStatements()) {//如果需要缓存PrepareStatement，生成带KEY的对象池
            statementPoolFactory = new GenericKeyedObjectPoolFactory(null,
                        -1, // unlimited maxActive (per key)
                        GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL,
                        0, // maxWait
                        1, // maxIdle (per key)
                        maxOpenPreparedStatements);
        }


        // 创建对象状态维护工厂类
        createPoolableConnectionFactory(driverConnectionFactory, statementPoolFactory, abandonedConfig);


        // 创建真正的DataSource来管理连接
        createDataSourceInstance();
        
        try {//初始化对象
            for (int i = 0 ; i < initialSize ; i++) {
                connectionPool.addObject();
            }
        } catch (Exception e) {
            throw new SQLNestedException("Error preloading the connection pool", e);
        }
        
        return dataSource;
    } 

    /**
     * 创建Connection工厂
     */
    protected ConnectionFactory createConnectionFactory() throws SQLException {
        // 注册驱动
        Class driverFromCCL = null;
        if (driverClassName != null) {
            try {
                try {
                    if (driverClassLoader == null) {
                        Class.forName(driverClassName);
                    } else {
                        Class.forName(driverClassName, true, driverClassLoader);
                    }
                } catch (ClassNotFoundException cnfe) {
                    driverFromCCL = Thread.currentThread(
                            ).getContextClassLoader().loadClass(
                                    driverClassName);
                }
            } catch (Throwable t) {
                String message = "Cannot load JDBC driver class '" +
                    driverClassName + "'";
                logWriter.println(message);
                t.printStackTrace(logWriter);
                throw new SQLNestedException(message, t);
            }
        }


        // 创建Driver实例
        Driver driver = null;
        try {
            if (driverFromCCL == null) {
                driver = DriverManager.getDriver(url);
            } else {
                // Usage of DriverManager is not possible, as it does not
                // respect the ContextClassLoader
                driver = (Driver) driverFromCCL.newInstance();
                if (!driver.acceptsURL(url)) {
                    throw new SQLException("No suitable driver", "08001"); 
                }
            }
        } catch (Throwable t) {
            String message = "Cannot create JDBC driver of class '" +
                (driverClassName != null ? driverClassName : "") +
                "' for connect URL '" + url + "'";
            logWriter.println(message);
            t.printStackTrace(logWriter);
            throw new SQLNestedException(message, t);
        }


        // 根据验证的SQL语句判断是否需要验证连接有效性
        if (validationQuery == null) {
            setTestOnBorrow(false);
            setTestOnReturn(false);
            setTestWhileIdle(false);
        }


        // Set up the driver connection factory we will use
        String user = username;
        if (user != null) {
            connectionProperties.put("user", user);
        } else {
            log("DBCP DataSource configured without a 'username'");
        }


        String pwd = password;
        if (pwd != null) {
            connectionProperties.put("password", pwd);
        } else {
            log("DBCP DataSource configured without a 'password'");
        }


        ConnectionFactory driverConnectionFactory = new DriverConnectionFactory(driver, url, connectionProperties);
        return driverConnectionFactory;
    }

 /**
     *创建连接池
     */
    protected void createConnectionPool() {
    
        GenericObjectPool gop;
        if ((abandonedConfig != null) && (abandonedConfig.getRemoveAbandoned())) {//如果有配置以及设置收回没有使用的连接
            gop = new AbandonedObjectPool(null,abandonedConfig);//生成我们带回收连接的连接池
        }
        else {
            gop = new GenericObjectPool();//生成普通连接池
        }
        gop.setMaxActive(maxActive);
        gop.setMaxIdle(maxIdle);
        gop.setMinIdle(minIdle);
        gop.setMaxWait(maxWait);
        gop.setTestOnBorrow(testOnBorrow);
        gop.setTestOnReturn(testOnReturn);
        gop.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        gop.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
        gop.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        gop.setTestWhileIdle(testWhileIdle);
        connectionPool = gop;
    }

/**
     创建可池化连接工厂（对象状态维护工厂）
     */
    protected void createPoolableConnectionFactory(ConnectionFactory driverConnectionFactory,
            KeyedObjectPoolFactory statementPoolFactory, AbandonedConfig configuration) throws SQLException {
        PoolableConnectionFactory connectionFactory = null;
        try {

//由此我们可以看到，对象状态维护工厂为PoolableConnectionFactory，提供了makeObject，Destory等方法对对象进行维护。
            connectionFactory =
                new PoolableConnectionFactory(driverConnectionFactory,/
                                              connectionPool,
                                              statementPoolFactory,
                                              validationQuery,
                                              validationQueryTimeout,
                                              connectionInitSqls,
                                              defaultReadOnly,
                                              defaultAutoCommit,
                                              defaultTransactionIsolation,
                                              defaultCatalog,
                                              configuration);
            validateConnectionFactory(connectionFactory);
        } catch (RuntimeException e) {
            throw e;
        } catch (Exception e) {
            throw new SQLNestedException("Cannot create PoolableConnectionFactory (" + e.getMessage() + ")", e);
        }
    }
 
    protected void createDataSourceInstance() throws SQLException {
        PoolingDataSource pds = new PoolingDataSource(connectionPool);//真正的Datasource对象，看来我们找到了,值得庆祝一下，慢慢抽丝剥茧读代码
        pds.setAccessToUnderlyingConnectionAllowed(isAccessToUnderlyingConnectionAllowed());
        pds.setLogWriter(logWriter);
        dataSource = pds;
    }

--------------------------------------------------------核心代码到此完，下面的方法，即使不用脑子，用脚趾也能猜出是干嘛的--------------------------

    public Connection getConnection(String user, String pass) throws SQLException {
 
        throw new UnsupportedOperationException("Not supported by BasicDataSource");
 
    }


 
    public int getLoginTimeout() throws SQLException {
 
        throw new UnsupportedOperationException("Not supported by BasicDataSource");
  
    }




 
    public PrintWriter getLogWriter() throws SQLException {
        return createDataSource().getLogWriter();
    }




 
    public void setLoginTimeout(int loginTimeout) throws SQLException {
 
        throw new UnsupportedOperationException("Not supported by BasicDataSource");
 
    }



 
    public void setLogWriter(PrintWriter logWriter) throws SQLException {
        createDataSource().setLogWriter(logWriter);
        this.logWriter = logWriter;
    }





                                                           
    public boolean getRemoveAbandoned() {   
        if (abandonedConfig != null) {
            return abandonedConfig.getRemoveAbandoned();
        }
        return false;
    }                                    
                                 
     
    public void setRemoveAbandoned(boolean removeAbandoned) {
        if (abandonedConfig == null) {
            abandonedConfig = new AbandonedConfig();
        }
        abandonedConfig.setRemoveAbandoned(removeAbandoned);
        this.restartNeeded = true;
    }                                                        
                                               
       
    public int getRemoveAbandonedTimeout() { 
        if (abandonedConfig != null) {
            return abandonedConfig.getRemoveAbandonedTimeout();
        }
        return 300;
    }                                        


     
    public void setRemoveAbandonedTimeout(int removeAbandonedTimeout) {
        if (abandonedConfig == null) {
            abandonedConfig = new AbandonedConfig();
        }
        abandonedConfig.setRemoveAbandonedTimeout(removeAbandonedTimeout);
        this.restartNeeded = true;
    }                                                                  
                                                             
                                                        
    public boolean getLogAbandoned() {   
        if (abandonedConfig != null) {
            return abandonedConfig.getLogAbandoned();
        }
        return false;
    }                                 

 
    public void setLogAbandoned(boolean logAbandoned) {
        if (abandonedConfig == null) {
            abandonedConfig = new AbandonedConfig();
        }
        abandonedConfig.setLogAbandoned(logAbandoned);
        this.restartNeeded = true;
    }


    //公用方法


 
    public void addConnectionProperty(String name, String value) {
        connectionProperties.put(name, value);
        this.restartNeeded = true;
    }


 
    public void removeConnectionProperty(String name) {
        connectionProperties.remove(name);
        this.restartNeeded = true;
    }

 
    public void setConnectionProperties(String connectionProperties) {
        if (connectionProperties == null) throw new NullPointerException("connectionProperties is null");


        String[] entries = connectionProperties.split(";");
        Properties properties = new Properties();
        for (int i = 0; i < entries.length; i++) {
            String entry = entries[i];
            if (entry.length() > 0) {
                int index = entry.indexOf('=');
                if (index > 0) {
                    String name = entry.substring(0, index);
                    String value = entry.substring(index + 1);
                    properties.setProperty(name, value);
                } else {
                    // no value is empty string which is how java.util.Properties works
                    properties.setProperty(entry, "");
                }
            }
        }
        this.connectionProperties = properties;
        this.restartNeeded = true;
    }





 //关闭连接池
    public synchronized void close() throws SQLException {
        closed = true;
        GenericObjectPool oldpool = connectionPool;
        connectionPool = null;
        dataSource = null;
        try {
            if (oldpool != null) {
                oldpool.close();
            }
        } catch(SQLException e) {
            throw e;
        } catch(RuntimeException e) {
            throw e;
        } catch(Exception e) {
            throw new SQLNestedException("Cannot close connection pool", e);
        }
    }


 
    public synchronized boolean isClosed() {
        return closed;
    }

 
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return false;
    }


    public <T> T unwrap(Class<T> iface) throws SQLException {
        throw new SQLException("BasicDataSource is not a wrapper.");
    }
 
 



    protected static void validateConnectionFactory(PoolableConnectionFactory connectionFactory) throws Exception {
        Connection conn = null;
        try {
            conn = (Connection) connectionFactory.makeObject();
            connectionFactory.activateObject(conn);
            connectionFactory.validateConnection(conn);
            connectionFactory.passivateObject(conn);
        }
        finally {
            connectionFactory.destroyObject(conn);
        }
    }


    /**
     * Not used currently
     */
    private void restart() {
        try {
            close();
        } catch (SQLException e) {
            log("Could not restart DataSource, cause: " + e.getMessage());
        }
    }


    protected void log(String message) {
        if (logWriter != null) {
            logWriter.println(message);
        }
    }
}