前言
前面两章我们构建了SqlSessionFactory,并通过SqlSessionFactory创建了我们需要的SqlSession，并通过这个SqlSession获取了我们需要的代理mapper。而SqlSession中最重要的则是用来处理请求的Executor,在上一章中我们创建了SimpleExecutor，并使用CachingExecutor代理了一下，我们最终得到了CachingEecutor.本章我们主要研究代理mapper的执行过程。这里再贴一下之前的测试代码
@Autowired private SqlSessionFactory sqlSessionFactory; @GetMapping("/get") public List<AssetInfo> get(){ SqlSession sqlSession = sqlSessionFactory.openSession(); AssetInfoMapper mapper = sqlSession.getMapper(AssetInfoMapper.class); List<AssetInfo> test = mapper.get("测试删除" , "123123123"); System.out.println(test); return test; }
public interface AssetInfoMapper { List<AssetInfo> get(@Param("name") String name, @Param("id")String id); }
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mapper.AssetInfoMapper">
<select id="get" resultType="com.entity.AssetInfo">
select * from asset_info where id =#{id} and `name` = #{name}
</select>
</mapper>
正文
1.MethodProxy
我们知道代理类最终执行的是我们实现了InvocationHandler接口里面的方法，而我们的创建mapper代理类传入的参数是MethodProxy,所以最终执行的也是这个类里面的invoke方法
//构建的SqlSession private final SqlSession sqlSession; //本mapper对应的接口 private final Class<T> mapperInterface; //方法缓存 里面存储的是方法的签名识别信息等 private final Map<Method, MapperMethod> methodCache; @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { try { //判断下是不是代理的Object类 if (Object.class.equals(method.getDeclaringClass())) { return method.invoke(this, args); } //如果是接口中的default方法 else if (method.isDefault()) { if (privateLookupInMethod == null) { return invokeDefaultMethodJava8(proxy, method, args); } else { return invokeDefaultMethodJava9(proxy, method, args); } } } catch (Throwable t) { throw ExceptionUtil.unwrapThrowable(t); } //如果是普通方法 我们主要分析这儿 这儿的主要目的是将方法的信息存起来 final MapperMethod mapperMethod = cachedMapperMethod(method); //执行其方法 return mapperMethod.execute(sqlSession, args); } //设置方法标志签名 private MapperMethod cachedMapperMethod(Method method) { return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration())); }
上面的invoke方法中做了一些判断，这儿我们主要分析下常规的方法调用。这儿有两步，第一步是创建我们调用的方法的签名mapperMethod并存储，第二部是调用mapperMethod的execute即执行方法。所以我们先看下是如何创建的方法签名。根据代码可以知道 如果method对应的mapperMethod不存在就调用其有参构造创建一个，所以我们主要看有参构造
public class MapperMethod { private final SqlCommand command; private final MethodSignature method; public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) { //创建该方法的command this.command = new SqlCommand(config, mapperInterface, method); //创建该方法的MethodSignature this.method = new MethodSignature(config, mapperInterface, method); } ........... }
通过上面可以看到，该方法主要创建了两个属性，SqlCommand,MethodSignature。我可以得知后面的execute方法肯定也是围绕这两个属性展开的。我们逐个分析就可以知道它们的作用了
SqlCommand
public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) { //获得方法名 例如get final String methodName = method.getName(); //获得方法声明的接口类型 final Class<?> declaringClass = method.getDeclaringClass(); //根据这个获取mybatis初始化时为xml中的每个方法构建的MappedStatement 里面主要存储该sql的信息 MappedStatement ms = resolveMappedStatement(mapperInterface, methodName, declaringClass, configuration); //如果未找到 if (ms == null) { //查看是否为有 @Flush注解 if (method.getAnnotation(Flush.class) != null) { name = null; //说明该方法只是用来刷新的 type = SqlCommandType.FLUSH; } else { throw new BindingException("Invalid bound statement (not found): " + mapperInterface.getName() + "." + methodName); } } else { //获取到该 MappedStatement的id 一般为接口名+'.'+方法名 name = ms.getId(); //获取到方法类型 select|update |delete type = ms.getSqlCommandType(); //如果未知直接抛异常 if (type == SqlCommandType.UNKNOWN) { throw new BindingException("Unknown execution method for: " + name); } } } private MappedStatement resolveMappedStatement(Class<?> mapperInterface, String methodName, Class<?> declaringClass, Configuration configuration) { //获取到该 MappedStatement的id 一般为接口名+'.'+方法名 String statementId = mapperInterface.getName() + "." + methodName; //如果有旧直接返回 if (configuration.hasStatement(statementId)) { return configuration.getMappedStatement(statementId); } //如果没有 但我们传入的接口和方法声明的接口是一个接口 就返回null else if (mapperInterface.equals(declaringClass)) { return null; } //否则有可能是我们的自己的接口继承了mapper的接口，所以找到其父接口(如果有)继续递归调用 for (Class<?> superInterface : mapperInterface.getInterfaces()) { if (declaringClass.isAssignableFrom(superInterface)) { MappedStatement ms = resolveMappedStatement(superInterface, methodName, declaringClass, configuration); if (ms != null) { return ms; } } } return null; }
通过上述代码可以得知SqlCommand主要存储了该方法的类型 | update |delete |select ,以及方法的全名，即声明的接口名+方法名，可能有同学发现了其信息来自于MappedStatment，而这个是根据我们构造的方法全名查到的。其实在第一张解析mapper.xml的过程即介绍xmlMapperBuilder中有提到在构建过程中最后一步为mapper中的每个sql方法构建了一个MappedStatment。这个类将会在后面频繁的用到，所以我们详细讲一下，希望大家仔细看。当时没有详细的讲构建过程，这儿就顺带说一下，我们回顾下那个方法
private void configurationElement(XNode context) { try { //获取该mapper的namespace的值 一般为接口地址 String namespace = context.getStringAttribute("namespace"); //判空 if (namespace == null || namespace.equals("")) { throw new BuilderException("Mapper's namespace cannot be empty"); } //设置当前处理的namespace builderAssistant.setCurrentNamespace(namespace); //设置当前nameSpace的缓存引用 cacheRefElement(context.evalNode("cache-ref")); //设置当前nameSpace的缓存 cacheElement(context.evalNode("cache")); //设置当前nameSpace的所有parameterMap parameterMapElement(context.evalNodes("/mapper/parameterMap")); //设置当前nameSpace的所有resultMap resultMapElements(context.evalNodes("/mapper/resultMap")); //设置当前nameSpace的所有sql语句 sqlElement(context.evalNodes("/mapper/sql")); //设置当前nameSpace 每个sql方法的方法类型 buildStatementFromContext(context.evalNodes("select|insert|update|delete")); } catch (Exception e) { throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e); } }
最后一步的buildStatementFromContext方法即是构建方法
private void buildStatementFromContext(List<XNode> list) { if (configuration.getDatabaseId() != null) { buildStatementFromContext(list, configuration.getDatabaseId()); } buildStatementFromContext(list, null); } private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) { for (XNode context : list) { final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId); try { statementParser.parseStatementNode(); } catch (IncompleteElementException e) { configuration.addIncompleteStatement(statementParser); } } }
上面又是很熟悉的创建构建器，然后调用构建器的parsexx方法，我们还是主要看parseStatementNode方法。 注意 该方法中的XNode属性就已经是我们每个方法的sql了。
public void parseStatementNode() { //获取到sql方法定义的id 一般对应接口中的方法名 String id = context.getStringAttribute("id"); //获取到sql方法定义的数据库id 多数据源时会用到 String databaseId = context.getStringAttribute("databaseId"); //如果这儿判断下如果有指定id 那当前数据源是否为指定id if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) { return; } //获取到该sql方法的名字即类型 |select | delete |update |insert String nodeName = context.getNode().getNodeName(); SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH)); //设置是查询操作还是更新操作 boolean isSelect = sqlCommandType == SqlCommandType.SELECT; //是否刷新缓存 boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect); //是否使用二级缓存 boolean useCache = context.getBooleanAttribute("useCache", isSelect); //返回结果是否排序 boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false); // 解析sql方法中包含的节点 例如<if></if>等 XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant); includeParser.applyIncludes(context.getNode()); //获得参数类型 String parameterType = context.getStringAttribute("parameterType"); //获得参数类型对应的class信息 Class<?> parameterTypeClass = resolveClass(parameterType); //获取语言 String lang = context.getStringAttribute("lang"); LanguageDriver langDriver = getLanguageDriver(lang); //暂时不明确这句的作用 processSelectKeyNodes(id, parameterTypeClass, langDriver); // Parse the SQL (pre: <selectKey> and <include> were parsed and removed) KeyGenerator keyGenerator; // id +'!selectKey' String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX; //namespace + id + '!selectKey' keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true); //获取到该方法的key即主键生成器 if (configuration.hasKeyGenerator(keyStatementId)) { keyGenerator = configuration.getKeyGenerator(keyStatementId); } else { keyGenerator = context.getBooleanAttribute("useGeneratedKeys", configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType)) ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE; } //解析sql语句 这里面会将sql语句解析出来 并将#{xx} 替换为 ? 占位符 SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass); //获得statementType 默认为PREPARED 即预编译类型 StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString())); //影响期望值 Integer fetchSize = context.getIntAttribute("fetchSize"); //超时时间 Integer timeout = context.getIntAttribute("timeout"); //自定义的parameterMap String parameterMap = context.getStringAttribute("parameterMap"); //返回类型 String resultType = context.getStringAttribute("resultType"); //返回类型的class属性 Class<?> resultTypeClass = resolveClass(resultType); //自定义的返回resultMap String resultMap = context.getStringAttribute("resultMap"); //自定义的resultSetType String resultSetType = context.getStringAttribute("resultSetType"); ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType); if (resultSetTypeEnum == null) { resultSetTypeEnum = configuration.getDefaultResultSetType(); } //标记唯一属性 String keyProperty = context.getStringAttribute("keyProperty"); //生成的键值 设置列名 String keyColumn = context.getStringAttribute("keyColumn"); //多结果集时使用 String resultSets = context.getStringAttribute("resultSets"); //构建MappedStatement builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType, fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass, resultSetTypeEnum, flushCache, useCache, resultOrdered, keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets); }
这个方法就是把sql方法所有的元素解析出来，然后使用builderAssistant.addMappedStatement方法把参数全部传进去 然后构建值，我们接着看
public MappedStatement addMappedStatement() { if (unresolvedCacheRef) { throw new IncompleteElementException("Cache-ref not yet resolved"); } //获取到该MappedStatement的id 这儿为namespace+'.'+id id = applyCurrentNamespace(id, false); //获得方法SqlCommandType boolean isSelect = sqlCommandType == SqlCommandType.SELECT; //构建者模式传入参数 MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType) .resource(resource) .fetchSize(fetchSize) .timeout(timeout) .statementType(statementType) .keyGenerator(keyGenerator) .keyProperty(keyProperty) .keyColumn(keyColumn) .databaseId(databaseId) .lang(lang) .resultOrdered(resultOrdered) .resultSets(resultSets) .resultMaps(getStatementResultMaps(resultMap, resultType, id)) .resultSetType(resultSetType) .flushCacheRequired(valueOrDefault(flushCache, !isSelect)) .useCache(valueOrDefault(useCache, isSelect)) .cache(currentCache); ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id); if (statementParameterMap != null) { //添加ParameterMap statementBuilder.parameterMap(statementParameterMap); } MappedStatement statement = statementBuilder.build(); //添加 configuration.addMappedStatement(statement); return statement; } protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection") .conflictMessageProducer((savedValue, targetValue) -> ". please check " + savedValue.getResource() + " and " + targetValue.getResource()); public void addMappedStatement(MappedStatement ms) { mappedStatements.put(ms.getId(), ms); }
这个方法就获取到mappedStatment的id以及使用构建者模式构建系列参数，最终创建好后存储到Configuration中的mappedStatements 存储，key则为mappedStatment的id
到此 mappedStatment就创建好了并且成功存储
分析完了SqlCommand顺带分析了mappedStatment后我们接着分析MapperMethod中另一个属性 即MethodSignature的创建过程
MethodSignature
public MethodSignature(Configuration configuration, Class<?> mapperInterface, Method method) { //该方法返回类型 Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, mapperInterface); if (resolvedReturnType instanceof Class<?>) { this.returnType = (Class<?>) resolvedReturnType; } else if (resolvedReturnType instanceof ParameterizedType) { this.returnType = (Class<?>) ((ParameterizedType) resolvedReturnType).getRawType(); } else { this.returnType = method.getReturnType(); } //是否返回空 this.returnsVoid = void.class.equals(this.returnType); //是否返回多个数据 this.returnsMany = configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray(); //是否返回的是Cursor类型 this.returnsCursor = Cursor.class.equals(this.returnType); //是否返回的是Optional类型 this.returnsOptional = Optional.class.equals(this.returnType); //获取到mapKey 即@MapKey值 this.mapKey = getMapKey(method); //是否返回map this.returnsMap = this.mapKey != null; //参数中是否有RowBounds 即mybatis的分页工具类 this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class); //是否有ResultHandler类 this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class); //获取到参数值 即@Param的值，如果有则为里面的value值 如果没有 则为'0','1','2'之类的 this.paramNameResolver = new ParamNameResolver(configuration, method); }
这个比较容易理解，就是解析了下该方法的参数信息之类的。
到此mapperMethod就创建完毕了。接下来就是执行其execute方法了
2.MapperMethod.execute()
该方法就是我们创建好mapperMethod后的重头戏方法了，也是我们调用代理类后最终要调用的方法
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: //如果返回为void 又有结果处理类 那就走这个方法 if (method.returnsVoid() && method.hasResultHandler()) { executeWithResultHandler(sqlSession, args); result = null; //返回多条数据 } else if (method.returnsMany()) { result = executeForMany(sqlSession, args); //返回map } else if (method.returnsMap()) { result = executeForMap(sqlSession, args); //返回多条数据Cursor } else if (method.returnsCursor()) { result = executeForCursor(sqlSession, args); } //返回单条普通数据 else { Object param = method.convertArgsToSqlCommandParam(args); //查询单条数据 result = sqlSession.selectOne(command.getName(), param); //如果返回Optional则包装一下 if (method.returnsOptional() && (result == null || !method.getReturnType().equals(result.getClass()))) { result = Optional.ofNullable(result); } } break; //刷新缓存类型 case FLUSH: result = sqlSession.flushStatements(); break; default: //直接抛异常 throw new BindingException("Unknown execution method for: " + command.getName()); } //如果返回null 而接收值时初始化数据类型 并且接收值不为void 那就抛异常 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; }
本案例中中是select方法，并返回list，所以我们解析executeForMany(sqlSession, args); 其他查询操作大同小异，至于更新操作本文最后会讲解到。
3.executeForMany(sqlSession, args);
这儿主要是参数转换一下，然后调用SqlSession中的selectList方法 主要传入sqlCommand的id ，包装参数，分页信息。可见最终还是交由我们的SqlSession去执行了。所以又回到了我们上一章构建的DefaultSqlSession中去查询了
private <E> Object executeForMany(SqlSession sqlSession, Object[] args) { List<E> result; //参数转换一下 Object param = method.convertArgsToSqlCommandParam(args); //如果方法有分页类RowBounds if (method.hasRowBounds()) { RowBounds rowBounds = method.extractRowBounds(args); //分页查询 result = sqlSession.selectList(command.getName(), param, rowBounds); } else { //非分页查询 result = sqlSession.selectList(command.getName(), param); } // 由于结果都是Object 所以这儿需要转换下 增加数组支持 if (!method.getReturnType().isAssignableFrom(result.getClass())) { if (method.getReturnType().isArray()) { return convertToArray(result); } else { return convertToDeclaredCollection(sqlSession.getConfiguration(), result); } } return result; }
4.DefaultSqlSession.selectList()
这儿我们通过statementId拿到了我们上面构建的MappedStatement ，也就是标红了让大家注意看的地方。然后调用执行器查询，由于默认打开了二级缓存，所以根据上一章的步骤，这儿使用的是CachingExecutor，并且里面封装了SimpleExecutor
@Override public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { try { //根据statementId拿到我们构建的MappedStatement 里面包含了该方法的所有xml解析出来的信息 MappedStatement ms = configuration.getMappedStatement(statement); //使用执行器 即CachingExecutor执行查询 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(); } }
5.CachingExecutor.query()
@Override public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException { //拿到sql内容以及有关信息 BoundSql boundSql = ms.getBoundSql(parameterObject); //得到该方法缓存的key 这个key涉及到mybatis的一二级缓存 ，我们下一章讲缓存的时候将会着重讲 CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql); //继续执行重载方法 return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); }
上面的代码主要通过我们的参数拿到对应的BoundSql，里面包含了sql信息，参数信息等。然后通过一系列的参数创建了一个缓存key，这个在mybatis的缓存中起着非常重要的作用。我们下一章讲一二级缓存时将会着重讲。现在我们接着看重载方法
//这儿是SimpleExecutor private final Executor delegate; private final TransactionalCacheManager tcm = new TransactionalCacheManager(); @Override public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { //获取到该方法所在mapper的二级缓存 Cache cache = ms.getCache(); //如果缓存不为null if (cache != null) { //如果该方法需要刷新缓存则刷新二级缓存 flushCacheIfRequired(ms); //如果该方法使用缓存 且没有结果处理器 if (ms.isUseCache() && resultHandler == null) { //确定下参数类型 ensureNoOutParams(ms, boundSql); @SuppressWarnings("unchecked") //根据缓存获取数据 List<E> list = (List<E>) tcm.getObject(cache, key); //如果结果为空 则会调用实际的SimpleExecutor的query方法 //所以如果真实结果为空，那么二级缓存会失效 if (list == null) { list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); //二级缓存存入进去 tcm.putObject(cache, key, list); // issue #578 and #116 } //返回结果 return list; } } //SimpleExecutor的query方法 return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); }
这个方法则体现出了该代理执行器的作用，就是为了二级缓存。我们先接着看具体的查询方法即deletegate.query。这儿的delegate则是我们传入的SimpleExecutor。
6.BaseExecutor.query()方法
我们看下SimpleExecutor的结构，其继承了抽象类BaseExecutor。我们用的query方法则是在BaseExecutor中。
@SuppressWarnings("unchecked")
@Override
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());
//检查该Executor即SqlSession是否关闭。
if (closed) {
throw new ExecutorException("Executor was closed.");
}
//如果查询的栈深度为0 并且该方法有刷新标志
if (queryStack == 0 && ms.isFlushCacheRequired()) {
//清除本地缓存 即一级缓存
clearLocalCache();
}
List<E> list;
try {
//查询栈深度+1
queryStack++;
//一级缓存查找结果 并且需要结果处理器为空
list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
if (list != null) {
//不为null 但是该select为存储过程的话 执行下存储过程
handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
} else {
//缓存为空，或者有结果处理器 则从数据库拿 并且数据存入一级缓存中
list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
} finally {
//查询栈深度-1
queryStack--;
}
//如果查询栈深度为0
if (queryStack == 0) {
//将队列中的 延迟重新加载任务加载
for (DeferredLoad deferredLoad : deferredLoads) {
deferredLoad.load();
}
//清除队列
deferredLoads.clear();
//如果缓存配置是STATEMENT 即一次查询过程 那这个时候清空缓存
if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
// issue #482
clearLocalCache();
}
}
return list;
}
该方法则主要涉及到了一级缓存，由此可以看出二级缓存优先度高于一级缓存。我们接着看从数据库查询数据的逻辑。
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; }
该方法也主要处理一些缓存，实际的调用由doQuery执行，doQuery是BaseExecutor的一个抽象方法，所以具体的实现是在SimpleExecutor中
7.SimpleExecutor.doQuery方法
@Override public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException { Statement stmt = null; try { //获取到该方法的Configuration Configuration configuration = ms.getConfiguration(); //生成一个声明处理器 StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql); //根据这个声明处理器和日志实现类型 来获取jdbc的处理器 stmt = prepareStatement(handler, ms.getStatementLog()); //调用我们创建的预编译处理器执行查询方法 return handler.query(stmt, resultHandler); } finally { closeStatement(stmt); } }
里面创建了两个比较重要的东西，声明处理器和jdbc标准的sql处理器。 我们分别看两个的创建逻辑，先看StatementHandler
public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) { //创建一个RoutingStatementHandler StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql); //执行一次拦截器的方法 statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler); return statementHandler; } private final StatementHandler delegate; public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) { switch (ms.getStatementType()) { case STATEMENT: delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql); break; case PREPARED: delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql); break; case CALLABLE: delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql); break; default: throw new ExecutorException("Unknown statement type: " + ms.getStatementType()); } }
通过上面的结果不难发现，虽然我们创建的是RoutingStatementHandler，但是通过其构造函数发现，这个statment只是一个路由的作用，最终的处理器肯定还是根据MappedStatement.getStatementType()决定的。这儿有三个类型从上到下分别是普通处理器，预编译处理器，存储过程处理器。这儿我们使用的则是预编译处理器，也是mybatis默认
还有一个需要注意的地方是这儿又执行了一个拦截器的方法，第一次是在我们创建SqlSession时构建Executor的地方执行过一次。并且都是执行的plugin方法
接下来我们看生成jdbc标准的处理器的逻辑prepareStatement(handler, ms.getStatementLog());
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException { Statement stmt; //获取到jdbc连接 这儿是通过的SpringDataSourceManager Connection connection = getConnection(statementLog); //预编译 最终由BaseStatementHandler执行 (PreparedStatementHandler未实现该方法) stmt = handler.prepare(connection, transaction.getTimeout()); //设置参数 最终由PreparedStatementHandler中的parameterHandler执行 handler.parameterize(stmt); return stmt; }
这段代码相信熟悉jdbc的同学都了解，是在进行java的原生sql连接步骤，即加载驱动获取连接，预编译，设置参数，还有执行，获取结果与释放连接，由于本案例使用的是连接池，所以我们主要关注后面的执行方法了。前面三个步骤也不细讲了，感兴趣的可以去了解下jdbc原生开发步骤即可
8.PreparedStatementHandler.query方法
由于RoutingStatementHandler最终会选择到我们的预执行处理器，所以最终处理器的也就是PreparedStatementHandler.query方法。我们就来分析这个方法
@Override public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException { PreparedStatement ps = (PreparedStatement) statement; ps.execute(); return resultSetHandler.handleResultSets(ps); }
在7中我们已经执行了jdbc中前几个步骤，到这儿直接执行execute方法，jdbc会将sql发送到数据库上，我们则只需要获取返回结果即可，到这儿其实我们的sql就已经执行完毕了，接下来需要做的就是处理返回结果。在看结果前我们先这个resultSetHandler是如何生成的。在该类的构造函数中有这样的逻辑
this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
可见这个结果处理器是根据我们这个方法的一系列标识来创建的。
public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler, ResultHandler resultHandler, BoundSql boundSql) { //创建默认的结果处理器 ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds); //执行一次拦截器方法 resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler); return resultSetHandler; }
创建了一个默认的结果处理器，并且第三次执行了拦截器的plugin方法。我们接着看最后的方法，即结果封装
9.DefaultResultSetHandler.handleResultSets()
@Override public List<Object> handleResultSets(Statement stmt) throws SQLException { ErrorContext.instance().activity("handling results").object(mappedStatement.getId()); //创建集合搜集 final List<Object> multipleResults = new ArrayList<>(); int resultSetCount = 0; //获取到第一个返回结果并包装返回 ResultSetWrapper rsw = getFirstResultSet(stmt); //获取到所有的resultMap List<ResultMap> resultMaps = mappedStatement.getResultMaps(); //获取到ResultMap的数量 int resultMapCount = resultMaps.size(); //验证下有效的数量 即 不能小于1 validateResultMapsCount(rsw, resultMapCount); // while (rsw != null && resultMapCount > resultSetCount) { //获取到当前的resultMap ResultMap resultMap = resultMaps.get(resultSetCount); //将结果存入multipleResults 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); }
上面则是做了一些判断，然后根据我们定义的ResultMap，或者ResultType 和ResultSet分情况进行封装，由于具体的结果集封装过程非常的长以及篇幅有限，本系列文主要讲解mybatis的原理和流程，所以对具体的封装过程就不详细分析了。
10 有关更新操作
由于delete，update,insert都属于更新操作，最后都会调用相同的方法，所以这儿一并讲解，其实更新操作相比查询操作去掉了结果封装的一步，增加了清空缓存，以及标记修改的功能。其他的步骤一致，所以我只分析几个特别的地方。
10.1 DefaultSqlSession.update 增加修改操作标记
@Override public int update(String statement, Object parameter) { try { //本次SqlSession已出现过修改操作 dirty = true; MappedStatement ms = configuration.getMappedStatement(statement); return executor.update(ms, wrapCollection(parameter)); } catch (Exception e) { throw ExceptionFactory.wrapException("Error updating database. Cause: " + e, e); } finally { ErrorContext.instance().reset(); } }
10.2CachingExecutor.update()清空二级缓存
@Override public int update(MappedStatement ms, Object parameterObject) throws SQLException { flushCacheIfRequired(ms); return delegate.update(ms, parameterObject); } private void flushCacheIfRequired(MappedStatement ms) { Cache cache = ms.getCache(); //更新操作isFlushCacheRequired 即sql方法中的flushCache默认标记为true if (cache != null && ms.isFlushCacheRequired()) { //清空二级缓存 tcm.clear(cache); } }
10.3BaseExecutor.update 清空一级缓存
@Override public int update(MappedStatement ms, Object parameter) throws SQLException { ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId()); if (closed) { throw new ExecutorException("Executor was closed."); } //清除一级缓存 clearLocalCache(); return doUpdate(ms, parameter); } @Override public void clearLocalCache() { if (!closed) { localCache.clear(); localOutputParameterCache.clear(); } }
特殊步骤已做说明，其他的和查询操作一致，相信查询操作理解了修改操作很快也就能理解。不过由于我们创建的DefaultSqlSession的autocommit默认为false，所以有更新操作，需要手动提交事务。我们可以看下事务代码即SqlSession.commit()方法
@Override public void commit(boolean force) { try {
//判断下是否有改动 或者强制提交 然后再commit executor.commit(isCommitOrRollbackRequired(force)); dirty = false; } catch (Exception e) { throw ExceptionFactory.wrapException("Error committing transaction. Cause: " + e, e); } finally { ErrorContext.instance().reset(); } }
提交后本次SqlSession的修改操作又置为false，使用Executor进行提交
@Override public void commit(boolean required) throws SQLException { //清空缓存并提交事务 delegate.commit(required); //清空二级缓存 tcm.commit(); }
我们看最后调用的是BaseExecutor.commit()方法
@Override public void commit(boolean required) throws SQLException { if (closed) { throw new ExecutorException("Cannot commit, transaction is already closed"); } //清空一级缓存 clearLocalCache(); //刷新 flushStatements(); //如果本次操作有必要提交(有改动 或者自动提交设置为true) 或者强制提交再提交事务 if (required) { //我们使用的是SpringManagedTransaction 进行事务提交 transaction.commit(); } }
系统会先判断是否有必要提交(有改动 或者自动提交设置为true) 或者强制提交再提交事务，
完结
现在我们已经成功的通过代理类的方法调用SqlSession中的查找方法，而SqlSession在拿到方法对应的MappedStatment后交由其Executor执行具体的查询方法，中间会涉及到拦截器已即缓存，这个我会在后面专门的章节分析。
提供一张我整理的查询操作的图作为流程思路参考，有完整的从代理类开始调用的逻辑。修改操作原理类
