今天来继续学习Mybatis的源码，首先在这里需要补充一点：就是执行XMLStatementBuilder的parseStatementNode方法时有一段代码自己没有仔细看：
builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
resultSetTypeEnum, flushCache, useCache, resultOrdered,
keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
该方法中会MappedStatement.Builder构造方法，当然创建MappedStatement.Builder的目的主要是其内部维护了一个MappedStatement对象，MappedStatement对象相当与就是xml文件中的一个sql节点，它维护了这个sql节点的所有相关信息。之后所有MappedStatement都会被存储到Configuration的成员变量mappedStatements，存储的key就是对应的xml的namespace + id(sql节点id)，或者说是对应的mapper中相应方法的全路径，即：xxx.xxx.xxxMapper + 方法名。
一、创建SSqlSessionTemplate的bean
这个方法其实没有什么特别的内容，代码如下：
public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
ExecutorType executorType = this.properties.getExecutorType();
if (executorType != null) {
return new SqlSessionTemplate(sqlSessionFactory, executorType);
} else {
return new SqlSessionTemplate(sqlSessionFactory);
}
}
也就是执行SqlSessionTemplate的构造函数
public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
PersistenceExceptionTranslator exceptionTranslator) {
notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
notNull(executorType, "Property 'executorType' is required");
this.sqlSessionFactory = sqlSessionFactory;
this.executorType = executorType;
this.exceptionTranslator = exceptionTranslator;
this.sqlSessionProxy = (SqlSession) newProxyInstance(
SqlSessionFactory.class.getClassLoader(),
new Class[] { SqlSession.class },
new SqlSessionInterceptor());
}
主要就是一些成员变量初始化的内容，另外其内部有一个代理对象。到这里基本就算完成了，感觉没啥内容，相比SqlSessionFactory简单了很多，当然它也是以来于SqlSessionFactory的。
二、Mapper代理对象创建
上次学习SqlSessionFactory的时候，我们知道会在MapperRegistry的addMapper方法中，会将相应的Mapper类对象作为key、该Mapper的MapperProxyFactory对象为value存储到MapperRegistry的成员变量knownMappers中。spring容器启动会通过注解方式注入相关的mapper对象（代理对象），具体的代码这里先不去管它，创建mapper代理对象的和时候由MapperFactoryBean（这个工厂只能注入接口）执行getObject方法完成的，代码如下：
public T getObject() throws Exception {
return getSqlSession().getMapper(this.mapperInterface);
}
这个方法会先去执行getSqlSession方法，这个方法其实返回的是其父类SqlSessionDaoSupport的成员变量sqlSession（一个SqlSessionTemplate对象），也就是说实际调用的是SqlSessionTemplate的getMapper方法，代码如下：
public <T> T getMapper(Class<T> type) {
return getConfiguration().getMapper(type, this);
}
执行的Configuration的getMapper方法，这个方法就是从其成员变量mapperRegistry中获取具体的代理对象，代码如下：
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
return mapperRegistry.getMapper(type, sqlSession);
}
然后继续向下看MapperRegistry的方法：
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
if (mapperProxyFactory == null) {
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
}
try {
return mapperProxyFactory.newInstance(sqlSession);
} catch (Exception e) {
throw new BindingException("Error getting mapper instance. Cause: " + e, e);
}
}
这个方法中先根据具体的接口类对象从knownMappers变量拿到对应的MapperProxyFactory对象，调用MapperProxyFactory的newInstance方法，代码如下：
public T newInstance(SqlSession sqlSession) {
final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
return newInstance(mapperProxy);
}
protected T newInstance(MapperProxy<T> mapperProxy) {
return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}
通过以上代码最终完成了mapper接口代理类的创建，并将其返回，也就是说我们执行mapper的相关方法时实际上执行的MapperProxy的invoke方法。好了到这里mapper代理对象就创建完成了，然后这个bean会被注入到spring的容器中。
三、mapper执行过程
接下来通过一个简单的查询操作，看一下mybatis实际是如何帮我们完成和数据库的交互的，从一个最简单的查询开始吧，这个查询有两个参数，下面是我service的代码：
public User findByUserId(Integer id) {
int age = 22;
String userName = "testUser";
List<User> userList = userMapper.selectByNameAndAge(age,userName);
// MapperProxyFactory<UserMapper> userMapperMapperProxyFactory = new MapperProxyFactory<>(UserMapper.class);
// UserMapper userMapperInstance = userMapperMapperProxyFactory.newInstance(sqlSession);
// List<User> userList = userMapperInstance.selectByNameAndAge(age,userName);
return userList.size() != 0 ? userList.get(0) : null;
}
为了方便我直接在代码里写死了，下面跟踪一下userMapper是如何根据userName和age完成查询的。
图-1.png
根据上图也可以看出来这时候的userMapper其实就是一个MapperProxy对象。
执行selectByNameAndAge方法实际上执行的是MapperProxy方法，我们看下invoke方法：
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, args);
} else if (isDefaultMethod(method)) {
return invokeDefaultMethod(proxy, method, args);
}
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
final MapperMethod mapperMethod = cachedMapperMethod(method);
return mapperMethod.execute(sqlSession, args);
}
这个方法中会对Method进行一些判断，从而执行不同的方法。当然一般情况下是不会执行if-else代码快里面代码的。执行cachedMapperMethod方法，代码如下：
private MapperMethod cachedMapperMethod(Method method) {
MapperMethod mapperMethod = methodCache.get(method);
if (mapperMethod == null) {
mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
methodCache.put(method, mapperMethod);
}
return mapperMethod;
}
也就是说先根据Method对象从methodCache中获取相应的MapperMethod对象，如果没有获取则新建一个并防护methodCache中，然后返回该MapperMethod对象。
接着执行MapperMethod的execute方法，代码如下：
public Object execute(SqlSession sqlSession, Object[] args) {
Object result;
switch (command.getType()) {
case INSERT: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.insert(command.getName(), param));
break;
}
case UPDATE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.update(command.getName(), param));
break;
}
case DELETE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.delete(command.getName(), param));
break;
}
case SELECT:
if (method.returnsVoid() && method.hasResultHandler()) {
executeWithResultHandler(sqlSession, args);
result = null;
} else if (method.returnsMany()) {
result = executeForMany(sqlSession, args);
} else if (method.returnsMap()) {
result = executeForMap(sqlSession, args);
} else if (method.returnsCursor()) {
result = executeForCursor(sqlSession, args);
} else {
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
}
break;
case FLUSH:
result = sqlSession.flushStatements();
break;
default:
throw new BindingException("Unknown execution method for: " + command.getName());
}
if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
throw new BindingException("Mapper method '" + command.getName()
+ " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
}
return result;
}
首先根据sql的类型决定执行哪种操作比如insert、update、select、delete等，这里以select举例（毕竟查询才使用最多）。然后根据method的返回结果类型执行不同分支，这里执行的executeForMany方法，完成之后返回结果。
1部分、MapperMethod的executeForMany方法
private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
List<E> result;
Object param = method.convertArgsToSqlCommandParam(args);
if (method.hasRowBounds()) {
RowBounds rowBounds = method.extractRowBounds(args);
result = sqlSession.<E>selectList(command.getName(), param, rowBounds);
} else {
result = sqlSession.<E>selectList(command.getName(), param);
}
// issue #510 Collections & arrays support
if (!method.getReturnType().isAssignableFrom(result.getClass())) {
if (method.getReturnType().isArray()) {
return convertToArray(result);
} else {
return convertToDeclaredCollection(sqlSession.getConfiguration(), result);
}
}
return result;
}
根据代码可以看出，首先会将查询传入的所有参数转为一个对象；然后执行sqlSession（一个DefaultSqlSession的实例）的selectList方法（返回多个结果），这时候代码跳转到2
2部分、DefaultSqlSession的selectList方法
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
try {
MappedStatement ms = configuration.getMappedStatement(statement);
return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
根据代码可以看出，先从configuration中获取具体执行的MappedStatement对象，key是具体是mapper + 方法名称（xml的namespace + 具体sql的id值）；接着执行executor的query方法，此executor是一个CachingExecutor实例，代码继续到3部分。
3部分、CachingExecutor的query方法
因为方法签名不同，所以有多个query方法，一起看下
// 方法1
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
BoundSql boundSql = ms.getBoundSql(parameterObject);
CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
// 方法2
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
throws SQLException {
Cache cache = ms.getCache();
if (cache != null) {
flushCacheIfRequired(ms);
if (ms.isUseCache() && resultHandler == null) {
ensureNoOutParams(ms, boundSql);
@SuppressWarnings("unchecked")
List<E> list = (List<E>) tcm.getObject(cache, key);
if (list == null) {
list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
tcm.putObject(cache, key, list); // issue #578 and #116
}
return list;
}
}
return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
return delegate.createCacheKey(ms, parameterObject, rowBounds, boundSql);
}
1、在第一个query方法中，首先执行MappedStatement的getBoundSql方法，该方法参数是一个封装的MapperMethod的ParamMap的对象，其中封装了查询参数的名字和其对应的值，这部分代码看4部分，完成后执行下一步。
2、执行createCacheKey方法，这个方法实际执行的是BaseExecutor的createCacheKey方法，代码跳转到6部分，执行完成后，继续执行第二个query方法。
3、第二个query方法中先从MappedStatement获取缓存，也就是mybatis的一级缓存，缓存不为空的话，判断是否需要刷新缓存，需要就刷新。然后判断当前MappedStatement是否开启缓存，以及对应的resultHandler书否为null，执行ensureNoOutParams方法，即保证都是入参。然后从tcm成员变量中获取缓存，该成员变量是一个TransactionalCacheManager对象，入参是CacheKey和Cache，执行7部分的代码，获取具体的结果。判断返回的具体缓存列表是否为空，不为空直接返回结果值，本部分方法结束；为空则执行8部分的代码，即BaseExecutor的query方法，这个方法获取从数据库的查询结果，然后将查询结果添加到缓存，执行的是TransactionalCacheManager的putObject方法，完成后返回查询结果，本部分代码结束。
4部分：MappedStatement的getBoundSql方法
public BoundSql getBoundSql(Object parameterObject) {
BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
if (parameterMappings == null || parameterMappings.isEmpty()) {
boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
}
// check for nested result maps in parameter mappings (issue #30)
for (ParameterMapping pm : boundSql.getParameterMappings()) {
String rmId = pm.getResultMapId();
if (rmId != null) {
ResultMap rm = configuration.getResultMap(rmId);
if (rm != null) {
hasNestedResultMaps |= rm.hasNestedResultMaps();
}
}
}
return boundSql;
}
1、先调用sqlSource的getBoundSql方法，同样一封装的MapperMethod的ParamMap的对象为参数，执行5部分代码。
2、判断返回的BoundSql中parameterMappings成员变量是否为空，即封装请求参数的对象的List是否存在或是否为空，满足条件执行3，否则执行4.
3、执行BoundSql的构造函数，执行BoundSql的构造函数，它的构造函数只是将MappedStatement的parameterMap中获取请求参数相关列表，并赋值给BoundSql的成员变量，完成BoundSql初始化，接着执行下一步。
4、遍历BoundSql的parameterMappings，获取到ParameterMapping对象（这个对象封装了请求参数的相关信息，如jdbcType、javaType、resultMapId等等）。如果resultMapId不为空，从configuration中获取具体对应的sql的resultMap。再判断这个resultMap是否为嵌套的结果集。MappedStatement的getBoundSql执行完成，返回BoundSql，到这里4部分代码执行完成。
5部分：SqlSource的getBoundSql方法
// 1、RawSqlSource
public BoundSql getBoundSql(Object parameterObject) {
return sqlSource.getBoundSql(parameterObject);
}
// 2、StaticSqlSource
public BoundSql getBoundSql(Object parameterObject) {
return new BoundSql(configuration, sql, parameterMappings, parameterObject);
}
getBoundSql方法，内部执行的是StaticSqlSource的getBoundSql方法，该方法执行的是BoundSql的构造函数，参数为StaticSqlSource的Configuration、parameterMappings、具体的sql语句（还没赋值）以及封装请求参数的ParamMap。BoundSql构造完成，成员变量完成赋值，创建BoundSql对象完成后返回结果。
6部分：BaseExecutor的createCacheKey方法
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
if (closed) {
throw new ExecutorException("Executor was closed.");
}
CacheKey cacheKey = new CacheKey();
cacheKey.update(ms.getId());
cacheKey.update(rowBounds.getOffset());
cacheKey.update(rowBounds.getLimit());
cacheKey.update(boundSql.getSql());
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
// mimic DefaultParameterHandler logic
for (ParameterMapping parameterMapping : parameterMappings) {
if (parameterMapping.getMode() != ParameterMode.OUT) {
Object value;
String propertyName = parameterMapping.getProperty();
if (boundSql.hasAdditionalParameter(propertyName)) {
value = boundSql.getAdditionalParameter(propertyName);
} else if (parameterObject == null) {
value = null;
} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
value = parameterObject;
} else {
MetaObject metaObject = configuration.newMetaObject(parameterObject);
value = metaObject.getValue(propertyName);
}
cacheKey.update(value);
}
}
if (configuration.getEnvironment() != null) {
// issue #176
cacheKey.update(configuration.getEnvironment().getId());
}
return cacheKey;
}
1、创建出新的CacheKey对象，然后执行其update方法，这个方法的参数是传入的相关参数的一些属性，这个update方法的作用主要我觉得是将这些相关属性添加到CacheKey的updateList中，另外就是更新该CacheKey的hashcode。
2、遍历boundSql的parameterMappings。获取每个参数的属性名称，即查询数据库字段的名称；然后根据字段名称从parameterObject的转译对象（MetaObject对象）中获取对应的查询条件值。对每个值执行CacheKey的update方法，主要是mybatis的缓存会用到CacheKey，上面的所有update方法其实都是查询缓存需要用到的。执行完成后返回创建的CacheKey对象到3部分。
7部分、TransactionalCacheManager的getObject方法：
public Object getObject(Cache cache, CacheKey key) {
return getTransactionalCache(cache).getObject(key);
}
private TransactionalCache getTransactionalCache(Cache cache) {
TransactionalCache txCache = transactionalCaches.get(cache);
if (txCache == null) {
txCache = new TransactionalCache(cache);
transactionalCaches.put(cache, txCache);
}
return txCache;
}
这部分实际执行的是先执行getTransactionalCache方法，其入参是Cache，返回一个TransactionalCache对象，然后执行TransactionalCache对象的getObject方法，入参是CacheKey。如果结果为null则新建TransactionalCache对象，并放入transactionalCaches。方法执行完成，返回具体的缓存结果到3部分。
8部分：BaseExecutor的query方法
// 方法1
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
BoundSql boundSql = ms.getBoundSql(parameter);
CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
// 方法2
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
if (closed) {
throw new ExecutorException("Executor was closed.");
}
if (queryStack == 0 && ms.isFlushCacheRequired()) {
clearLocalCache();
}
List<E> list;
try {
queryStack++;
list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
if (list != null) {
handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
} else {
list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
} finally {
queryStack--;
}
if (queryStack == 0) {
for (DeferredLoad deferredLoad : deferredLoads) {
deferredLoad.load();
}
// issue #601
deferredLoads.clear();
if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
// issue #482
clearLocalCache();
}
}
return list;
}
1、BaseExecutor维护了几个成员变量，一个就是closed，判断当前执行器是否关闭，另一个是queryStack，查询栈数量。查询时会先从localCache中查询，如果有结果，直接对结果进行处理，执行handleLocallyCachedOutputParameters方法；否则执行queryFromDatabase方法， 即从数据库查询，代码执行下一步。
2、queryFromDatabase方法中执行的doQuery方法，该方法返回查询结果。并将结果添加到localCache中。而doQuery方法，实际执行的是SimpleExecutor的doQuery方法，代码跳转到9部分。
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
List<E> list;
localCache.putObject(key, EXECUTION_PLACEHOLDER);
try {
list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
} finally {
localCache.removeObject(key);
}
localCache.putObject(key, list);
if (ms.getStatementType() == StatementType.CALLABLE) {
localOutputParameterCache.putObject(key, parameter);
}
return list;
}
9部分、SimpleExecutor的doQuery方法：
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
Statement stmt = null;
try {
Configuration configuration = ms.getConfiguration();
StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
stmt = prepareStatement(handler, ms.getStatementLog());
return handler.<E>query(stmt, resultHandler);
} finally {
closeStatement(stmt);
}
}
这个方法首先是获取configuration、StatementHandler（RoutingStatementHandler对象），接着执行prepareStatement方法（这个方法要细看下，sql会在这里完成赋值，即将参数值写到sql语句中），这个方法返回一个Statement对象，具体类型要根据不同的数据库确定，比我用的pgsql，返回的是PgPreparedStatement，当然也可能是PgCallableStatement。然后执行StatementHandler（一个RoutingStatementHandler对象）的query方法，当然本质执行的是PreparedStatementHandler的query方法，代码跳转到10部分。
10部分：PreparedStatementHandler的query方法：
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
PreparedStatement ps = (PreparedStatement) statement;
ps.execute();
return resultSetHandler.<E> handleResultSets(ps);
}
执行PreparedStatement的execute方法，这部分代码我就不再细看了，感兴趣的可以继续深挖。然后执行resultSetHandler（DefaultResultSetHandler）的handleResultSets方法，代码见11部分。
11部分：DefaultResultSetHandler的handleResultSets方法
public List<Object> handleResultSets(Statement stmt) throws SQLException {
ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
final List<Object> multipleResults = new ArrayList<Object>();
int resultSetCount = 0;
ResultSetWrapper rsw = getFirstResultSet(stmt);
List<ResultMap> resultMaps = mappedStatement.getResultMaps();
int resultMapCount = resultMaps.size();
validateResultMapsCount(rsw, resultMapCount);
while (rsw != null && resultMapCount > resultSetCount) {
ResultMap resultMap = resultMaps.get(resultSetCount);
handleResultSet(rsw, resultMap, multipleResults, null);
rsw = getNextResultSet(stmt);
cleanUpAfterHandlingResultSet();
resultSetCount++;
}
String[] resultSets = mappedStatement.getResultSets();
if (resultSets != null) {
while (rsw != null && resultSetCount < resultSets.length) {
ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
if (parentMapping != null) {
String nestedResultMapId = parentMapping.getNestedResultMapId();
ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
handleResultSet(rsw, resultMap, null, parentMapping);
}
rsw = getNextResultSet(stmt);
cleanUpAfterHandlingResultSet();
resultSetCount++;
}
}
return collapseSingleResultList(multipleResults);
}
这个方法会将查询的结果集进行处理，即将数据库返回的结果转换成具体的范型对象，然后添加到multipleResults中，然后转成List范型返回，其实这里的方法也挺多的，但是感觉意义不是特别的大，感兴趣的话也可以看看。返回最后的结果，该部分执行完成，整个查询过程也就结束了。
三、总结
因为时间和篇幅问题，很多代码也没有很详细的去看，但是整个流程基本上是走完了的，如果有兴趣可以再继续往下深挖一下。整体上代码是看的懂，但是有些方法以及一些参数的意义并不清楚具体的作用，可能还不是很理解作者的用意。到这里mybatis源码部分也就结束了，比我预想的要快不少，主要原因是SqlSessionTemplate创建简化了不少，当然有部分代码自己也没有去深究的原因，接下来我觉得可能还是要多再理解消化，有的代码还是应该再看看。
网友评论