1.概念介绍
1.1 数据源：顾名思义，数据的来源，它包含了数据库类型信息，位置和数据等信息，一个数据源对应一个数据库。
1.2 连接池：在做持久化操作时，需要通过数据库连接对象来连接数据库，而连接池就是数据库连接对象的缓冲池，需要的时候可以从这个缓冲池中直接取出。
1.3 数据源的分类：UnpooledDataSource，PooledDataSource和JndiDataSourceFactory，采用的是工厂模式来生成这些对象的，如下如所示：
2.DataSource的创建过程
数据源DataSource是在mybatis初始化加载配置文件的时候进行创建的，配置文件信息如下：
<environments default="development"> <environment id="development"> <transactionManager type="JDBC" />
// type="POOLED" 表示创建有连接池的数据源 PooledDataSource对象
// type="UNPOOLED" 表示创建没有连接池的数据源 UnpooledDataSource对象
// type="JNDI" 表示会从JNDI服务器上查找数据源 <dataSource type="POOLED"> <property name="driver" value="${driver}" /> <property name="url" value="${url}" /> <property name="username" value="${username}" /> <property name="password" value="${password}" /> </dataSource> </environment> </environments>
创建过程，看源码，进入XMLConfigBuilder类的dataSourceElement方法：
private DataSourceFactory dataSourceElement(XNode context) throws Exception { if (context != null) {
// 获取type的属性值 String type = context.getStringAttribute("type"); Properties props = context.getChildrenAsProperties();
// 根据type的属性值，获取DataSourceFactory的class对象，然后根据DataSourceFactory的class对象创建一个DataSourceFactory实例对象。 DataSourceFactory factory = (DataSourceFactory) resolveClass(type).newInstance();
// 设置DataSource的相关属性 进入该方法 factory.setProperties(props); return factory; } throw new BuilderException("Environment declaration requires a DataSourceFactory."); }
当DataSourceFactory实例对象创建完成以后，此时对应的DataSource也就创建完成了，通过源码可知，DataSource的创建是在DataSourceFactory的构造器中执行的。比如，看下UnpooledDataSourceFactory的构造方法：
public UnpooledDataSourceFactory() { this.dataSource = new UnpooledDataSource(); }
进入 factory.setProperties(props);方法：
public void setProperties(Properties properties) { Properties driverProperties = new Properties();
// 创建DataSource对应的MetaObject对象 MetaObject metaDataSource = SystemMetaObject.forObject(dataSource);
// 遍历Properties集合，该集合中配置了数据源需要的信息 for (Object key : properties.keySet()) { String propertyName = (String) key; if (propertyName.startsWith(DRIVER_PROPERTY_PREFIX)) { String value = properties.getProperty(propertyName); driverProperties.setProperty(propertyName.substring(DRIVER_PROPERTY_PREFIX_LENGTH), value); } else if (metaDataSource.hasSetter(propertyName)) { String value = (String) properties.get(propertyName);
// 进入该方法可知：对属性类型进行类型转换，主要是Integer，Long，Boolean的类型转换 Object convertedValue = convertValue(metaDataSource, propertyName, value);
// 设置DataSource的相关属性 metaDataSource.setValue(propertyName, convertedValue); } else { throw new DataSourceException("Unknown DataSource property: " + propertyName); } } if (driverProperties.size() > 0) { metaDataSource.setValue("driverProperties", driverProperties); } }
这就是DataSouece对象的创建及其属性配置的过程。
3.UnpooledDataSource的解析
UnpooledDataSource实现了DataSource接口，每次调用它的getConnection方法时，都会创建一个新的连接。接下来对这个类进行分析：
在该类中有一个静态代码块如下所示，就是在加载UnpooledDataSource类时，会加载该静态代码块，将已经在DriverManager中注册的JDBC Driver复制一份到UnpooledDataSource.registeredDrivers集合中。
static { Enumeration<Driver> drivers = DriverManager.getDrivers(); while (drivers.hasMoreElements()) { Driver driver = drivers.nextElement(); registeredDrivers.put(driver.getClass().getName(), driver); } }
3.1 属性:
private ClassLoader driverClassLoader; // 加载Driver类的类加载器 private Properties driverProperties; // 数据库连接驱动的相关配置
// 缓存所有已经注册的数据库连接驱动 private static Map<String, Driver> registeredDrivers = new ConcurrentHashMap<String, Driver>(); private String driver; //数据库连接的驱动名称 private String url; private String username; private String password; private Boolean autoCommit; // 是否自动提交 private Integer defaultTransactionIsolationLevel; //事务的隔离级别
3.2 获取连接对象Connection的过程：
private Connection doGetConnection(Properties properties) throws SQLException {
// 初始化数据库驱动 initializeDriver();
// 创建数据库连接对象 Connection connection = DriverManager.getConnection(url, properties); // 配置连接对象的隔离级别和是否自动提交
configureConnection(connection); return connection; }
进入initializeDriver方法：
private synchronized void initializeDriver() throws SQLException {
// 判断数据库驱动是否已经被加载，如果没有则动态加载 if (!registeredDrivers.containsKey(driver)) { Class<?> driverType; try { if (driverClassLoader != null) { driverType = Class.forName(driver, true, driverClassLoader); } else { driverType = Resources.classForName(driver); } // DriverManager requires the driver to be loaded via the system ClassLoader. // http://www.kfu.com/~nsayer/Java/dyn-jdbc.html
// 获取Driver类的实例对象，然后注册到DriverManager中
Driver driverInstance = (Driver)driverType.newInstance(); DriverManager.registerDriver(new DriverProxy(driverInstance));
// 将driver添加到registeredDriver集合中
registeredDrivers.put(driver, driverInstance); } catch (Exception e) { throw new SQLException("Error setting driver on UnpooledDataSource. Cause: " + e); } } }
每调用一次getConnection方法，上面的流程都会重新走一次，所以每次都是获取的新的Connection连接对象。
4.PooledDataSource的解析
在进行PooledDataSource的讲解前，先分析PooledConnection和PoolState这两个类，因为它们两个对PooledDataSource而言很重要。
4.1 PooledConnection
PooledDataSource并不会直接管理java.sql.Connection对象，而是管理PooledConnection对象，该对象封装了真正的数据库连接对象java.sql.Connection和它自己的代理对象。
// 实现了InvocationHandler接口，所以连接对象的代理对象proxyConnection调用某个方法时，真正执行的逻辑是在invoke方法
class PooledConnection implements InvocationHandler { private static final String CLOSE = "close"; private static final Class<?>[] IFACES = new Class<?>[] { Connection.class }; private int hashCode = 0; private PooledDataSource dataSource; private Connection realConnection; //真正的数据库连接 private Connection proxyConnection; // 数据库连接的代理对象 private long checkoutTimestamp; // 从连接池中取出该连接的时间戳 private long createdTimestamp; // 创建该连接的时间戳 private long lastUsedTimestamp; //最后一次被使用的时间戳 private int connectionTypeCode; // 根据数据库连接的URL，用户名和密码生成的hash值，用于标识该连接所在的连接池 private boolean valid; //检测当前连接是否有效
/* * Required for InvocationHandler implementation. * * @param proxy - not used * @param method - the method to be executed * @param args - the parameters to be passed to the method * @see java.lang.reflect.InvocationHandler#invoke(Object, java.lang.reflect.Method, Object[]) */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { String methodName = method.getName();
// 如果调用的是close方法，那么把该连接对象放到连接池中 if (CLOSE.hashCode() == methodName.hashCode() && CLOSE.equals(methodName)) { dataSource.pushConnection(this); return null; } else { try { if (!Object.class.equals(method.getDeclaringClass())) { // issue #579 toString() should never fail // throw an SQLException instead of a Runtime checkConnection(); }
// 调用真正的连接对象对应的方法 return method.invoke(realConnection, args); } catch (Throwable t) { throw ExceptionUtil.unwrapThrowable(t); } } } }
4.2 PoolState
PoolState是用于管理PooledConnection对象状态的组件，它有两个属性集合，来管理空闲状态的连接和活跃状态的连接，看源码：
protected final List<PooledConnection> idleConnections = new ArrayList<PooledConnection>(); // 空闲的PooledConnection集合 protected final List<PooledConnection> activeConnections = new ArrayList<PooledConnection>(); // 活跃的PooledConnection集合 protected long requestCount = 0; // 请求数据库连接的次数 protected long accumulatedRequestTime = 0; // 获取连接的积累时间 protected long accumulatedCheckoutTime = 0; // 所有连接积累的checkoutTime时长 CheckoutTime 是指从连接池中取出连接到归还连接着段时长 protected long claimedOverdueConnectionCount = 0; // 当连接长时间未归还给连接池时，会被认为连接超时，这个字段就是表示连接超时的个数 protected long accumulatedCheckoutTimeOfOverdueConnections = 0;// 累计超时时间 protected long accumulatedWaitTime = 0;// 累计等待时间 protected long hadToWaitCount = 0;// 累计等待次数 protected long badConnectionCount = 0;// 无效的连接数
4.3 PooledDataSource 是一个实现了简单连接池的数据源，我们通过源码来对它进行学习：
4.3.1 属性
// 用于管理连接池的状态并记录统计信息 稍后会对它进行分析
private final PoolState state = new PoolState(this); // 用于生成真实的数据库连接对象，在构造函数中初始化该字段 private final UnpooledDataSource dataSource; // OPTIONAL CONFIGURATION FIELDS protected int poolMaximumActiveConnections = 10; // 最大活跃连接数 protected int poolMaximumIdleConnections = 5; // 最大空闲连接数 protected int poolMaximumCheckoutTime = 20000; // 从连接池中取出该连接的最大时长 protected int poolTimeToWait = 20000; // 在无法获取连接时，线程需要等待的时间 protected String poolPingQuery = "NO PING QUERY SET"; // 在检测一个数据库连接是否可用时，会给数据库发送一个测试SQL语句 protected boolean poolPingEnabled = false; // 是否允许发送测试SQL语句 protected int poolPingConnectionsNotUsedFor = 0; // 根据数据库的URL，用户名和密码生成的一个hash值，标识着当前的连接池，在构造函数中初始化 private int expectedConnectionTypeCode;
4.2 获取连接的过程：
先思考一个问题：下面这个方法什么时候执行呢？其实在调用查询语句goodsMapper.selectGoodsById("1");时，才会去获取连接的。
private PooledConnection popConnection(String username, String password) throws SQLException { boolean countedWait = false; PooledConnection conn = null; long t = System.currentTimeMillis(); int localBadConnectionCount = 0; while (conn == null) {
// 获取连接的过程要同步 synchronized (state) {
// 判断是否还有空闲的连接对象，如果有则直接取出 if (state.idleConnections.size() > 0) { // Pool has available connection conn = state.idleConnections.remove(0); if (log.isDebugEnabled()) { log.debug("Checked out connection " + conn.getRealHashCode() + " from pool."); } } else {
// 如果没有，那么判断活跃的连接对象的个数是否超过允许的最大值 // Pool does not have available connection if (state.activeConnections.size() < poolMaximumActiveConnections) { // Can create new connection // 如果没有，则创建一个PooledConnection，它是对真实的Connection对象的包装，后面会介绍这个类
conn = new PooledConnection(dataSource.getConnection(), this); @SuppressWarnings("unused") //used in logging, if enabled // 获取真实的连接对象
Connection realConn = conn.getRealConnection(); if (log.isDebugEnabled()) { log.debug("Created connection " + conn.getRealHashCode() + "."); } } else { // Cannot create new connection // 活跃连接数已经达到最大值，则不能创建新的连接
// 获取最先创建的活跃连接
PooledConnection oldestActiveConnection = state.activeConnections.get(0); long longestCheckoutTime = oldestActiveConnection.getCheckoutTime(); if (longestCheckoutTime > poolMaximumCheckoutTime) { //检测该连接是否超时 // Can claim overdue connection 对超时的连接信息进行统计 state.claimedOverdueConnectionCount++; state.accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime; state.accumulatedCheckoutTime += longestCheckoutTime; // 将超时连接移除activeCollections集合
state.activeConnections.remove(oldestActiveConnection); if (!oldestActiveConnection.getRealConnection().getAutoCommit()) { oldestActiveConnection.getRealConnection().rollback(); }
// 创建新的PooledCOnnection，但是真实的连接对象并未创建新的，是刚才移除的那个真实的连接对象 conn = new PooledConnection(oldestActiveConnection.getRealConnection(), this); oldestActiveConnection.invalidate();// 将超时的连接对象设置为无效 if (log.isDebugEnabled()) { log.debug("Claimed overdue connection " + conn.getRealHashCode() + "."); } } else { // Must wait
// 无空闲连接，无法创建新的连接对象，并且没有超时的连接，就只能阻塞等待
try { if (!countedWait) { state.hadToWaitCount++; //统计等待次数 countedWait = true; } if (log.isDebugEnabled()) { log.debug("Waiting as long as " + poolTimeToWait + " milliseconds for connection."); } long wt = System.currentTimeMillis();
// 阻塞等待 state.wait(poolTimeToWait);
// 统计累计的等待时间 state.accumulatedWaitTime += System.currentTimeMillis() - wt; } catch (InterruptedException e) { break; } } } }
// 如果获取到了PooledConnection对象 if (conn != null) { if (conn.isValid()) { // 判断PooledCOnnection是否有效 if (!conn.getRealConnection().getAutoCommit()) { conn.getRealConnection().rollback(); }
// 设置PooledConnection的相关属性 conn.setConnectionTypeCode(assembleConnectionTypeCode(dataSource.getUrl(), username, password)); conn.setCheckoutTimestamp(System.currentTimeMillis()); conn.setLastUsedTimestamp(System.currentTimeMillis());
// 将该PooledCollection放到activeConnections集合中 state.activeConnections.add(conn); state.requestCount++; state.accumulatedRequestTime += System.currentTimeMillis() - t; } else { if (log.isDebugEnabled()) { log.debug("A bad connection (" + conn.getRealHashCode() + ") was returned from the pool, getting another connection."); } state.badConnectionCount++; localBadConnectionCount++; conn = null; if (localBadConnectionCount > (poolMaximumIdleConnections + 3)) { if (log.isDebugEnabled()) { log.debug("PooledDataSource: Could not get a good connection to the database."); } throw new SQLException("PooledDataSource: Could not get a good connection to the database."); } } } } } if (conn == null) { if (log.isDebugEnabled()) { log.debug("PooledDataSource: Unknown severe error condition. The connection pool returned a null connection."); } throw new SQLException("PooledDataSource: Unknown severe error condition. The connection pool returned a null connection."); } return conn; }
4.3.3 把连接放回到连接池的过程：
protected void pushConnection(PooledConnection conn) throws SQLException { synchronized (state) { //同步 state.activeConnections.remove(conn); // 从activeConnections中移除该连接对象 if (conn.isValid()) { // 验证该连接是否有效 // 判断空闲连接数是否达到上限，以及该连接是否属于该连接池
if (state.idleConnections.size() < poolMaximumIdleConnections && conn.getConnectionTypeCode() == expectedConnectionTypeCode) { state.accumulatedCheckoutTime += conn.getCheckoutTime(); // 累计连接时长 if (!conn.getRealConnection().getAutoCommit()) { conn.getRealConnection().rollback(); }
// 创建一个连接对象，真正的连接不是新建的 PooledConnection newConn = new PooledConnection(conn.getRealConnection(), this); // 把新建的连接放到空闲连接集合中
state.idleConnections.add(newConn);
// 给新建的连接设置属性 newConn.setCreatedTimestamp(conn.getCreatedTimestamp()); newConn.setLastUsedTimestamp(conn.getLastUsedTimestamp()); // 将原来的连接设置无效
conn.invalidate(); if (log.isDebugEnabled()) { log.debug("Returned connection " + newConn.getRealHashCode() + " to pool."); } state.notifyAll();// 唤醒阻塞等待的线程 } else {
// 如果空闲连接数达到上限，或者 该连接对象不属于该连接池 state.accumulatedCheckoutTime += conn.getCheckoutTime(); // 增加累计连接时长 if (!conn.getRealConnection().getAutoCommit()) { conn.getRealConnection().rollback(); }
// 关闭真正的连接 conn.getRealConnection().close(); if (log.isDebugEnabled()) { log.debug("Closed connection " + conn.getRealHashCode() + "."); }
// 将该连接对象设置为无效 conn.invalidate(); } } else { if (log.isDebugEnabled()) { log.debug("A bad connection (" + conn.getRealHashCode() + ") attempted to return to the pool, discarding connection."); } state.badConnectionCount++; } } }