《深入理解Mybatis原理》 02-Mybatis数据源与连接池
对于ORM框架而言，数据源的组织是一个非常重要的一部分，这直接影响到框架的性能问题。本文将通过对MyBatis框架的数据源结构进行详尽的分析，并且深入解析MyBatis的连接池。
本文首先会讲述MyBatis的数据源的分类，然后会介绍数据源是如何加载和使用的。紧接着将分类介绍UNPOOLED、POOLED和JNDI类型的数据源组织；期间我们会重点讲解POOLED类型的数据源和其实现的连接池原理。
本文结构如下：
- 一、MyBatis数据源DataSource分类
- 二、数据源DataSource的创建过程
- 三、 DataSource什么时候创建Connection对象
- 四、不使用连接池的UnpooledDataSource
- 五、为什么要使用连接池？
- 六、使用了连接池的PooledDataSource
一、Mybatis数据源分类
mybatis数据源实现类在mybatis的dataSource包中：
Mybatis将数据源分为三种：
JNDI 数据源 ： 使用JNDI方式数据源
POOLED数据眼： 使用连接池数据源
UNPOOLED 数据源 ： 不使用连接池数据源
即：
相应的Mybatis内部分别以实现 javax.sql.DataSource 接口的 PooledDataSource和 UnPooledDataSource 实现 POOLED和UNPOOLED数据源。(关于数据源创建细节请看下面章节)
JNDI数据源则通过 javax.naming.Context 上下文生成数据源。
二、数据源DataSource创建过程
数据源配置如下：
Mybatis数据源的创建过程：
Mybatis初始化阶段 就会创建好数据源，具体创建数据源的时机发生在解析mybatis XML配置文件
//context ：dataSource节点数据
private DataSourceFactory dataSourceElement(XNode context) throws Exception {
if (context != null) {
//获取dataSource配置的类型 （POOLED、UNPOOLED、JNDI）
String type = context.getStringAttribute("type");
//将dataSource下的username、password等信息解析为Properties
Properties props = context.getChildrenAsProperties();
//根据dataSource的type类型（别名机制）获取到对应的DateSource实现类，并实例化该类
DataSourceFactory factory = (DataSourceFactory) resolveClass(type).newInstance();
factory.setProperties(props);
return factory;
}
throw new BuilderException("Environment declaration requires a DataSourceFactory.");
}创建DataSource最关键的一步在: DataSourceFactory factory = (DataSourceFactory) resolveClass(type).newInstance();
打开该方法resolveClass方法实现，看它到底做了什么：
public Class resolveAlias(String string) {
try {
if (string == null) {
return null;
}
String key = string.toLowerCase(Locale.ENGLISH);
Class value;
if (TYPE_ALIASES.containsKey(key)) {
value = (Class) TYPE_ALIASES.get(key);
} else {
value = (Class) Resources.classForName(string);
}
return value;
} catch (ClassNotFoundException e) {
throw new TypeException("Could not resolve type alias '" + string + "'. Cause: " + e, e);
}
} resolveClass方法核心功能就是根据XML dataSource节点配置的type属性找到对应的实现类：
如上图所示：
根据配置的type别名找到Factory,然后创建出对应的DataSource
- JNDI ： JndiDataSourceFactory
- POOLED： PooledDataSourceFactory
- UNPOOLED: UnpooledDataSourceFactory
Mybatis创建DataSource之后会将其放在Configuration的Environment中，供以后使用。
三、DataSource什么时候创建Connection对象
InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
User user = (User) sqlSession.selectOne("selectByPrimaryKey", 1);如上图所示，前三行代码都不会去创建javax.sql.Connection,当执行到 selectOne("selectByPrimaryKey", 1);时，才会去真正创建Connection对象：
@Override
public List doQuery(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
throws SQLException {
Statement stmt = null;
try {
flushStatements();
Configuration configuration = ms.getConfiguration();
StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameterObject, rowBounds, resultHandler, boundSql);
Connection connection = getConnection(ms.getStatementLog());
stmt = handler.prepare(connection, transaction.getTimeout());
handler.parameterize(stmt);
return handler.query(stmt, resultHandler);
} finally {
closeStatement(stmt);
}
} 那对于UNPOOLED类型DataSource的实现UnpooledDataSource是怎么样实现getConnection方法呢？请看一下节。
四、不使用连接池的UnpooledDataSource
//UnpoolDataSource 创建Connection对象
private Connection doGetConnection(Properties properties) throws SQLException {
//1. 初始化驱动
initializeDriver();
//2. 创建Connection对象
Connection connection = DriverManager.getConnection(url, properties);
//3. 配置Connection
configureConnection(connection);
return connection;
}如上代码所示，流程如下：
- 1. 初始化驱动 ： 判断驱动是否加载到内存中，若有则直接取出，否则创建驱动
- 2. 创建Connecion : 调用DriverManager创建相应的Connection对象
- 3. 配置Connection: 配置Connection对象一些默认配置项
- 4. 返回DataSource对象： 返回创建好的Connection对象供以使用
总结：从上述的代码中可以看到，我们每调用一次getConnection()方法，都会通过DriverManager.getConnection()返回新的java.sql.Connection实例。
五、为什么要使用连接池？
public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {
long start = System.currentTimeMillis();
Class.forName("com.mysql.jdbc.Driver");
Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mall", "root", "123456");
System.out.println("创建Connection对象耗时 ： " + String.valueOf(System.currentTimeMillis() - start));
String sql = "select * from mmall_user where id = 1";
start = System.currentTimeMillis();
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery(sql);
System.out.println("查询语句耗时：" + String.valueOf(System.currentTimeMillis() - start));
while(resultSet.next()){
System.out.println("id = " + resultSet.getInt(1) + " username = " + resultSet.getString(2));
}
resultSet.close();
statement.close();
connection.close();
} 
创建Connection对象耗时 789ms, 而查询语句才耗时7ms.(不排除数据库数据少的原因，但是查询耗时一般不会超过789ms)
一次查询请求创建Connection对象耗时789ms。要知道100ms对于Java来说都是很奢侈的。（一个Connection对象耗时 700ms，10000 * 700 = 116分钟，10000次请求只创建对象就耗时116分钟，这是根本不能接受的）
所以使用连接池是非常有必要的。
六、使用了连接池的PooledDataSource
了解连接池之前，先了解两个参数概念：
idleConnections ： 空闲Connection对象，当其他请求需要创建Connection时，直接到ideaConnection取出一个连接，可以减少资源、耗时。
activeConnections ： 活动Connection对象，记录当前正在被请求所使用的Connection对象，当一次请求使用完一个Connection时，不将其立即销毁，而是放到idleConnection缓存池里面。
对于UnpooledDataSource每次请求都会创建一个新的Connection对象，当请求结束后会执行Connection.cloes()方法关闭该Connection.
PooledDataSource是如何创建的Connection的呢？
@Override
public Connection getConnection() throws SQLException {
return popConnection(dataSource.getUsername(), dataSource.getPassword()).getProxyConnection();
}
@Override
public Connection getConnection(String username, String password) throws SQLException {
return popConnection(username, password).getProxyConnection();
}数据源type设置为 POOLED，当实例化DataSource时会根据别名实例化出 PooledDataSource对象。
当调用getConnection方法创建Connection时，最终会调用 popConnecion方法并返回一个代理对象。
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) {
//判断连接池中是否还有空闲Connection对象，若有则直接返回一个Connection
if (!state.idleConnections.isEmpty()) {
// Pool has available connection
conn = state.idleConnections.remove(0);
if (log.isDebugEnabled()) {
log.debug("Checked out connection " + conn.getRealHashCode() + " from pool.");
}
} else {//没有空闲Connection对象
//当前活动对象个数是小于最大活动数量 则会生成一个新的Connection对象
if (state.activeConnections.size() < poolMaximumActiveConnections) {
// Can create new connection
conn = new PooledConnection(dataSource.getConnection(), this);
if (log.isDebugEnabled()) {
log.debug("Created connection " + conn.getRealHashCode() + ".");
}
} else {//判断老的活动对象是否超过poolMaximumCheckoutTime时间
PooledConnection oldestActiveConnection = state.activeConnections.get(0);
long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
//超过poolMaximumCheckoutTime时间，则尝试结束该Connection对象线程，并返回重用Connection
if (longestCheckoutTime > poolMaximumCheckoutTime) {
// Can claim overdue connection
state.claimedOverdueConnectionCount++;
state.accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;
state.accumulatedCheckoutTime += longestCheckoutTime;
state.activeConnections.remove(oldestActiveConnection);
if (!oldestActiveConnection.getRealConnection().getAutoCommit()) {
try {
oldestActiveConnection.getRealConnection().rollback();
} catch (SQLException e) {
/*
Just log a message for debug and continue to execute the following
statement like nothing happend.
Wrap the bad connection with a new PooledConnection, this will help
to not intterupt current executing thread and give current thread a
chance to join the next competion for another valid/good database
connection. At the end of this loop, bad {@link @conn} will be set as null.
*/
log.debug("Bad connection. Could not roll back");
}
}
conn = new PooledConnection(oldestActiveConnection.getRealConnection(), this);
conn.setCreatedTimestamp(oldestActiveConnection.getCreatedTimestamp());
conn.setLastUsedTimestamp(oldestActiveConnection.getLastUsedTimestamp());
oldestActiveConnection.invalidate();
if (log.isDebugEnabled()) {
log.debug("Claimed overdue connection " + conn.getRealHashCode() + ".");
}
} else {//没有超时，则等待该Connection线程结束
// 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;
}
}
}
}
if (conn != null) {
// ping to server and check the connection is valid or not
if (conn.isValid()) {
if (!conn.getRealConnection().getAutoCommit()) {
conn.getRealConnection().rollback();
}
conn.setConnectionTypeCode(assembleConnectionTypeCode(dataSource.getUrl(), username, password));
conn.setCheckoutTimestamp(System.currentTimeMillis());
conn.setLastUsedTimestamp(System.currentTimeMillis());
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 + poolMaximumLocalBadConnectionTolerance)) {
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;
}综上所述，大致流程如下：
- 1. 若IdleConnection中是否有空闲的连接对象，则直接返回Connection
- 2. 判断当前activeConnection数量是否小于poolMaximumActiveConnections（活动连接最大数量），若小于，则和Unpooled方式一样创建新的Connection对象并返回。若大于，则会判断当前所有活动连接的占用时间是否超时，若超时则停止该Connection,并直接返回供其他请求使用。若没有超时，则等待Connection使用完毕后再返回。
连接池对Connection.close()的处理：
PooledDataSource中除了popConnection方法，还有一个pushConnection方法
pushConnection方法会将使用完毕的Connection放入idleConnections缓存池中，供其他请求继续使用。
传统的jdbc连接使用完Connection之后，会手动执行Connection.cloes()方法关闭连接。
Pooled连接池为了重复利用Connection减少不必要的开销，对Connection.cloes做了动态代理。
也就是说，在Pooled模式下，若我们手动执行connecion.cloes()，实际上并不会执行原生Connection.close方法。而是通过PooledConnection对原生Connection做动态代理，把close方法映射到 pushConnection方法上：
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
//若执行close方法，实际上会代理执行pushConnection方法
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);
}
}
}
以上就是本文 《深入理解Mybatis原理》 02-Mybatis数据源与连接池 的全部内容，
上述内容如有不妥之处，还请读者指出，共同探讨，共同进步！
@author : [email protected]