mybaits源码分析（四）mybaits数据源详解

mybaits源码分析（四） 数据源

前言：对于ORM框架，数据源都是不可或少的组件，虽然mybaits框架整合spring时，可以由外部指定数据源对象，构建到SqlSessionFactoryBean中，但是对于mybaits自身对数据源的实现原理还是值得探究的，本文将通过对MyBatis框架的数据源 结构进行详尽的分析，并且深入解析MyBatis的连接池。

本文内容初步分为下面几个部分
        
    mybaits数据源的概述
        
    mybaits数据源的构建和使用
                
    UnpooledDataSource的剖析
        
    PooledDataSource的剖析
        
    简易数据源案例演示

 一、Mybaits数据源的概述

1、数据源分类
       MyBatis把数据源DataSource分为三种
        UnpooledDataSource ：不使用连接池的数据源
        PooledDataSource ：使用连接池的数据源
        JndiDataSource：使用JNDI实现的数据源

2、数据源类结构

数据源由DatasourceFacotry创建，UnpooledDataSourceFacotry创建UnpooledDataSource ，PooledDataSourceFacotry创建PooledDataSource ，并且UnpooledDataSourceFacotry继承UnpooledDataSourceFacotry用于通用设置属性用途，PooledDataSource 内部维护了UnpooledDataSource 的实例，用于真实创建数据库链接， PooledDataSource 内部连接池缓存的是用于增强并包装真实连接对象和代理连接对象的PooledConnection。

类结构如下：

 3、数据源的创建

    我们主要讲解UnpooledDataSource和PooledDataSource，其中UnpooledDataSource是没有使用连接池的数据源,PooledDataSource包装了UnpooledDataSource，并且扩展了连接池功能，用UnpooledDataSource依据创建连接，内部用列表容器实现连接池功能。
    数据源的创建，采用了工厂模式，UnpooledDataSource和PooledDataSource的创建，分别交于不同的实现了DataSourceFactory的工厂类创建，并且设置了一些配置属性。下面是UnpooledDataSourceFactory创建数据源的过程。

public UnpooledDataSourceFactory() { // 构造函数创建对应工厂的数据源
this.dataSource = new UnpooledDataSource();
}
public void setProperties(Properties properties) { // 设置属性
Properties driverProperties = new Properties();
MetaObject metaDataSource = SystemMetaObject.forObject(dataSource);
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)) { // 其他常规数据，依据有无set方法进行设置
String value = (String) properties.get(propertyName);
Object cOnvertedValue= convertValue(metaDataSource, propertyName, value);
metaDataSource.setValue(propertyName, convertedValue);
} else {
throw new DataSourceException("Unknown DataSource property: " + propertyName);
}
}
if (driverProperties.size() > 0) {
metaDataSource.setValue("driverProperties", driverProperties);
}
}

  二、mybaits数据源的构建

 上面对数据源的分类，类图结构，以及工厂类创建数据源的过程进行了简单的介绍，知道框架会根据不同的工厂类创建不同的数据源，那么在mybaits中如何创建数据源工厂类的呢

 1、数据源的构建

  下面是xml配置文件

      数据源创建的时候，会根据dataSource节点的type属性，实例化对应的工厂类，进行数据源的创建，并且把子节点的props属性对添加到数据源的set方法中，POOLED表示会创建PooledDataSource数据源，Unpooled表示会创建UnpooledDataSource数据源。

        private DataSourceFactory dataSourceElement(XNode context) throws Exception {
          if (context != null) { // context是解析dataSource节点的内容
              String type = context.getStringAttribute("type"); // type属性
              Properties props = context.getChildrenAsProperties(); // 子属性键值对
              DataSourceFactory factory = (DataSourceFactory) resolveClass(type).newInstance();
              factory.setProperties(props);
              return factory;
          }
          throw new BuilderException("Environment declaration requires a DataSourceFactory.");
        }

    2、数据源的使用

    数据源的作用就是获取连接对象connection，那么在执行过程中，我们是哪个时候从数据源中获取连接对象的呢？从上篇事务我们了解到，连接是包装到Transaction对象中，当我们创建了SQLSession之后，通过SqlSession执行sql语句的时候，Mybatis才会调用DataSource数据源去创建Connection对象。

三、UnpooledDataSource详解

    UnpooledDataSource数据源是由UnpooledDataSourceFactory创建的，这个数据源就是直接实例化connection对象，然后供调用方使用，即使用UnpooledDataSource数据源的getConnection方法，每一次调用都会产生一个Connection对象。

public UnpooledDataSource(String driver, String url, String username, String password) {
this.driver = driver;
this.url = url;
this.username = username;
this.password = password;
}
public Connection getConnection() throws SQLException {
return doGetConnection(username, password);
}
private Connection doGetConnection(String username, String password) throws SQLException {
Properties props = new Properties();
if (driverProperties != null) {
props.putAll(driverProperties); // 其他参数
}
if (username != null) { // username参数
props.setProperty("user", username);
}
if (password != null) { // password参数
props.setProperty("password", password);
}
return doGetConnection(props);
}
private Connection doGetConnection(Properties properties) throws SQLException {
initializeDriver(); // 初始化驱动
Connection cOnnection= DriverManager.getConnection(url, properties); // 获得连接
configureConnection(connection);
return connection;
}

从上面我们知道，    UnpooledDataSource的getConnection就是直接创建jdbc连接Connection对象的过程。

四、PooledDataSource详解

    PooledDataSource数据源在上面我就介绍了它拥有连接池的数据源。现在我们看一下PooledDataSource的基本原理：PooledDataSource数据源将Connection对象包裹成了PooledConnection对象放到PoolState容器中进行维护。MyBatis将连接池中的PooledConnection分为两种状态： 空闲状态（idle）和活动状态(active)，这两种状态的PooledConnection对象分别被存储到PoolState容器内的idleConnections和activeConnections两个List集合中。
    而PooledDataSource内部包装UnpooledDataSource的主要作用就是，在自身需要创建数据源的时候，可以调用UnpooledDataSource进行创建数据源。

1、PoolState和PooledDataSource的主要属性

public class PoolState {
protected PooledDataSource dataSource;
// 空闲连接
protected final List idleCOnnections= new ArrayList();
// 活跃连接
protected final List activeCOnnections= new ArrayList();

public class PooledDataSource implements DataSource {
private final PoolState state = new PoolState(this); // 封装空闲连接和活跃连接的集合
private final UnpooledDataSource dataSource; // unpooledDataSource用于真实获取连接用途
protected int poolMaximumActiveCOnnections= 10; // 最大活跃个数
protected int poolMaximumIdleCOnnections= 5; // 最大空闲个数
protected int poolMaximumCheckoutTime = 20000; // 最大工作超时时间
protected int poolTimeToWait = 20000; // 未获得连接的等待时间
protected String poolPingQuery = "NO PING QUERY SET"; // 心跳查询
protected boolean poolPingEnabled = false;
protected int poolPingCOnnectionsNotUsedFor= 0;
private int expectedConnectionTypeCode;
public PooledDataSource() {
dataSource = new UnpooledDataSource();
}

    2、核心执行逻辑

   类的属性结构讲完，连接池的工作流程也就清晰了，既然是连接池，我们从连接池的更新角度看，就存在打开连接和用完放回连接池的过程，这个过程分别对应popConnection和pushConnection方法。

         1) 取出连接popConnection

取出连接的过程，基本上就是如果idle有，就从idle取，否则，判断active的尺寸是否大于最大acitve尺寸，如果小于，那么就可以创建一个新的链接，如果大于等于，那就不能创建了，就取出最先使用的链接,判断是否过期，如果过期就rollback，更新成一个链接，如果没有过期，就等待，然后继续执行获取。

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.isEmpty()) {
cOnn= state.idleConnections.remove(0); // 从空闲中取
} else {
// 如果活跃尺寸少于最大活跃
if (state.activeConnections.size() 创建一个新的--这个datasource 是UnpooledDataSource，即获取真实连接。
cOnn= new PooledConnection(dataSource.getConnection(), this);
} else {
// 否则从旧的中取
PooledConnection oldestActiveCOnnection= state.activeConnections.get(0);
long lOngestCheckoutTime= oldestActiveConnection.getCheckoutTime();
// 判断最先用的是否超时
if (longestCheckoutTime > poolMaximumCheckoutTime) {
// 是超时就移除旧的
state.activeConnections.remove(oldestActiveConnection);
if (!oldestActiveConnection.getRealConnection().getAutoCommit()) {
try { // 并且旧的要回滚
oldestActiveConnection.getRealConnection().rollback();
} catch (SQLException e) {
}
}
// 把旧的真实连接取出，包装成一个新的PooledConnection
cOnn= new PooledConnection(oldestActiveConnection.getRealConnection(), this);
oldestActiveConnection.invalidate();
} else {
try {
// 如果没法获得连接就等待，等待恢复后，从新执行while下面的流程判断。
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); // 等待
} catch (InterruptedException e) {
break;
}
}
}
}
if (conn != null) {
if (conn.isValid()) {
if (!conn.getRealConnection().getAutoCommit()) {
conn.getRealConnection().rollback(); // 再次保证全部进行了rollBack，才可以使用
}
state.activeConnections.add(conn); // 添加到activeConnections
} else {
cOnn= null;
}
}
}
}
return conn;
}

流程图如下图所示  

2) 归还连接oushConnection

从上面的分析我们知道，我们active集合，在没有超容时，会创建，那么我们的第一层判断idle容器的数量怎么来的呢？这个就要下面的归还连接的过程进行分析。
       归还连接的过程就比上面的简单多了，就是如果idel容器少于acitve最大限制，那么就是放到空闲容器中，如果超过了，就直接close（注意，这个是真实连接调用关闭连接）

protected void pushConnection(PooledConnection conn) throws SQLException {
synchronized (state) {
state.activeConnections.remove(conn); // 活跃池移除
if (conn.isValid()) {
// 如果空闲池少于最大空闲连接，就直接将活跃池中移除的添加到空闲池
if (state.idleConnections.size() 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();
state.notifyAll();
// 否则直接关闭
} else {
state.accumulatedCheckoutTime += conn.getCheckoutTime();
if (!conn.getRealConnection().getAutoCommit()) {
conn.getRealConnection().rollback();
}
conn.getRealConnection().close();
conn.invalidate();
}
} else {
// ....
}
}
}

 3、PooledConnection分析

上面我们分析的是对连接池直接操作的pushConnection和popConnection方法，那么我们外部是如何调用这2个方法的呢？首先popConnection方法很简单，就是被连接池接口方法getConnection调用的。而pushConnection方法呢？，难道我们每次使用完连接就要手动调用这个方法。
       肯定不能这样操作，我们希望的是，每次connection进行close的使用，实际上不进行close，而调用pushConnection方法，这种功能想都不要想，肯定是使用动态代理。具体实现是，我们PooledDataSource获取连接的是PooledConnection包装的ProxyConnection。

下面就是PooledConnection的主要属性和构造函数。

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 boolean valid;

public PooledConnection(Connection connection, PooledDataSource dataSource) {
this.hashCode = connection.hashCode();
this.realCOnnection= connection;
this.dataSource = dataSource;
this.valid = true;
this.proxyCOnnection= (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), IFACES, this);
}

如上所示，PooledConnection是实现InvocationHandler类的代理增强，并且构造函数中，创建了一个代理连接对象。我们只要看这个类的invoke方法是如何增强的即可。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
if (CLOSE.hashCode() == methodName.hashCode() && CLOSE.equals(methodName)) {
dataSource.pushConnection(this); // 核心 -- 如果Colse方法就返回池中
return null;
} else {
try {
if (!Object.class.equals(method.getDeclaringClass())) {
checkConnection();
}
// 普通方法直接执行
return method.invoke(realConnection, args);
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
}
}

  五、简易数据源案例演示

1、MyPoolConnection 数据连接包装及代理增强和实例化

public class MyPoolConnection implements InvocationHandler {
private static final Class[] IFACES = new Class[] { Connection.class };
private MyPoolDataSource dataSource; // 保持数据源的链接
private Connection realConnection; // 真实连接
private Connection proxyConnection; // 代理连接
private long checkoutTimestamp; // 检测使用时间
public MyPoolConnection(Connection connection, MyPoolDataSource dataSource) {
this.realCOnnection= connection;
this.dataSource = dataSource;
this.proxyCOnnection= (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), IFACES, this);
}
public MyPoolDataSource getDataSource() {
return dataSource;
}
public void setDataSource(MyPoolDataSource dataSource) {
this.dataSource = dataSource;
}
public Connection getRealConnection() {
return realConnection;
}
public void setRealConnection(Connection realConnection) {
this.realCOnnection= realConnection;
}
public Connection getProxyConnection() {
return proxyConnection;
}
public void setProxyConnection(Connection proxyConnection) {
this.proxyCOnnection= proxyConnection;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
if ("close".equals(methodName)) {
dataSource.pushConnection(this);
} else {
if (!Object.class.equals(method.getDeclaringClass())) {
// 检测链接是否有效
}
return method.invoke(realConnection, args);
}
return null;
}
public long getCheckoutTime() {
return System.currentTimeMillis() - checkoutTimestamp;
}
public void setCheckoutTimestamp(long checkoutTimestamp) {
this.checkoutTimestamp = checkoutTimestamp;
}
}

2、MyPoolDataSource数据源

public class MyPoolDataSource extends AbstractDataSource {
// 数据源基本属性
private String driver;
private String url;
private String username;
private String password;
// 链接池属性
protected int poolMaximumActiveCOnnections= 10;
protected int poolMaximumIdleCOnnections= 5;
protected int poolMaximumCheckoutTime = 20000;
protected int poolTimeToWait = 20000;
// 连接容器
protected final List idleCOnnections= new ArrayList();
protected final List activeCOnnections= new ArrayList();

public MyPoolDataSource(String driver, String url, String username, String password) {
super();
this.driver = driver;
this.url = url;
this.username = username;
this.password = password;
}
@Override
public Connection getConnection() throws SQLException {
return popConnection(username, password).getProxyConnection();
}
@Override
public Connection getConnection(String username, String password) throws SQLException {
return popConnection(username, password).getProxyConnection();
}
/**
* 真实创建链接
*/
public Connection doGetConnection() throws SQLException {
initDriver();
Properties props = new Properties();
if (username != null) {
props.setProperty("user", username);
}
if (password != null) {
props.setProperty("password", password);
}
Connection cOnnection= DriverManager.getConnection(url, props);
return connection;
}
/**
* 用于判断是否已经加载驱动
*/
private static Map registeredDrivers = new ConcurrentHashMap();
/**
* 初始化数据源驱动
*/
private void initDriver() {
if (registeredDrivers.containsKey(this.driver)) {
try {
Class driverType = Class.forName(this.driver);
Driver driverInstance = (Driver) driverType.newInstance();
registeredDrivers.put(this.driver, driverInstance);
} catch (Exception e) {
throw new ExceptionInInitializerError(e);
}
}
}
/**
* 重点方法： 返回池中
*/
public void pushConnection(MyPoolConnection conn) throws SQLException {
synchronized (this) {
activeConnections.remove(conn);
if (!conn.getRealConnection().getAutoCommit()) {
conn.getRealConnection().rollback();
}
// 空闲池有位置
if (idleConnections.size() MyPoolConnection newCOnn= new MyPoolConnection(conn.getRealConnection(), this);
idleConnections.add(newConn);
this.notifyAll(); // 通知有可能等待取连接的线程
} else {
// 直接真实释放
conn.getRealConnection().close();
}
}
}
/**
* 重点方法：从池中取连接
*/
public MyPoolConnection popConnection(String username, String password) throws SQLException {
MyPoolConnection cOnn= null;
while (cOnn== null) {
synchronized (this) {
// idel池有货
if (idleConnections.size() > 0) {
cOnn= idleConnections.remove(0);
} else {
// active池未满
if (activeConnections.size() Connection cOnnection= this.doGetConnection();
cOnn= new MyPoolConnection(connection, this);
activeConnections.add(conn);
} else {
MyPoolConnection oldCOnnection= this.activeConnections.get(0);
long lOngestCheckoutTime= oldConnection.getCheckoutTime();
// 旧的超时
if (longestCheckoutTime > poolMaximumCheckoutTime) {
Connection cOnnection= oldConnection.getRealConnection();
if (!connection.getAutoCommit()) {
connection.rollback();
}
cOnn= new MyPoolConnection(connection, this);
activeConnections.remove(oldConnection);
// 没取到
} else {
try {
wait(poolTimeToWait); // wait等待池等待poolTimeToWait时间，如果notifyAll就会提前取消等待
} catch (InterruptedException e) {
break;
}
}
}
}
}
}
// 取到连接了
if (conn != null) {
if (!conn.getRealConnection().getAutoCommit()) {
conn.getRealConnection().rollback();
}
conn.setCheckoutTimestamp(System.currentTimeMillis());
}
// 没取到报错
if (cOnn== null) {
throw new SQLException(
"PooledDataSource: Unknown severe error condition. The connection pool returned a null connection.");
}
return conn;
}
public String getDriver() {
return driver;
}
public void setDriver(String driver) {
this.driver = driver;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getPoolMaximumActiveConnections() {
return poolMaximumActiveConnections;
}
public void setPoolMaximumActiveConnections(int poolMaximumActiveConnections) {
this.poolMaximumActiveCOnnections= poolMaximumActiveConnections;
}
public int getPoolMaximumIdleConnections() {
return poolMaximumIdleConnections;
}
public void setPoolMaximumIdleConnections(int poolMaximumIdleConnections) {
this.poolMaximumIdleCOnnections= poolMaximumIdleConnections;
}
public int getPoolMaximumCheckoutTime() {
return poolMaximumCheckoutTime;
}
public void setPoolMaximumCheckoutTime(int poolMaximumCheckoutTime) {
this.poolMaximumCheckoutTime = poolMaximumCheckoutTime;
}
public int getPoolTimeToWait() {
return poolTimeToWait;
}
public void setPoolTimeToWait(int poolTimeToWait) {
this.poolTimeToWait = poolTimeToWait;
}
public static Map getRegisteredDrivers() {
return registeredDrivers;
}
public static void setRegisteredDrivers(Map registeredDrivers) {
MyPoolDataSource.registeredDrivers = registeredDrivers;
}

public String logSate() {
return "空闲池" + idleConnections.size() + "," + "活跃池" + activeConnections.size();
}
}

3、测试使用

/**
* 数据源案例的测试
*/
public class DataSourceDemo {
/**
* 测试逻辑：(空闲max参数5，活跃max参数10) 建立30个线程，执行一个sql，然后每个线程执行完，打印一次池状态，
* 并且10次再打印一次池状态。
*/
public static void main(String[] args) throws SQLException {
String driver = "com.mysql.jdbc.Driver";
String url = "jdbc:mysql://localhost:3306/java_base?characterEncoding=utf8";
String username = "root";
String password = "123456";
MyPoolDataSource pool = new MyPoolDataSource(driver, url, username, password);
excute(pool);
CyclicBarrier cb = new CyclicBarrier(10, () -> {
System.out.println("10个线程执行完：" + pool.logSate());
});
// 30个线程执行sql
for (int i = 0; i <30; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
excute(pool);
System.out.println("单个线程执行完：" + pool.logSate());
} catch (SQLException e) {
e.printStackTrace();
}
try {
cb.await();
} catch (Exception e1) {
e1.printStackTrace();
}
};
}, "thread" + i).start();
}
}
private static void excute(MyPoolDataSource pool) throws SQLException {
Connection cOnnection= pool.getConnection();
PreparedStatement prepareStatement = connection.prepareStatement("select * from blog");
ResultSet executeQuery = prepareStatement.executeQuery();
while (executeQuery.next()) {
// System.out.println(executeQuery.getObject("id"));
}
connection.close();
}
}

end！