1
2

ArticleMapper articleMapper = session.getMapper(ArticleMapper.class);
Article article = articleMapper.findOne(1);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// -☆- DefaultSqlSession
public <T> T getMapper(Class<T> type) {return configuration.<T>getMapper(type, this);
}// -☆- Configuration
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {return mapperRegistry.getMapper(type, sqlSession);
}// -☆- MapperRegistry
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {// 从 knownMappers 中获取与 type 对应的 MapperProxyFactoryfinal 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);}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// -☆- MapperProxyFactory
public T newInstance(SqlSession sqlSession) {/** 创建 MapperProxy 对象，MapperProxy 实现了 * InvocationHandler 接口，代理逻辑封装在此类中*/final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);return newInstance(mapperProxy);
}protected T newInstance(MapperProxy<T> mapperProxy) {// 通过 JDK 动态代理创建代理对象return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[]{mapperInterface}, mapperProxy);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {try {// 如果方法是定义在 Object 类中的，则直接调用if (Object.class.equals(method.getDeclaringClass())) {return method.invoke(this, args);/** 下面的代码最早出现在 mybatis-3.4.2 版本中，用于支持 JDK 1.8 中的* 新特性 - 默认方法。这段代码的逻辑就不分析了，有兴趣的同学可以* 去 Github 上看一下相关的相关的讨论（issue #709），链接如下：* *   https://github.com/mybatis/mybatis-3/issues/709*/  } else if (isDefaultMethod(method)) {return invokeDefaultMethod(proxy, method, args);}} catch (Throwable t) {throw ExceptionUtil.unwrapThrowable(t);}// 从缓存中获取 MapperMethod 对象，若缓存未命中，则创建 MapperMethod 对象final MapperMethod mapperMethod = cachedMapperMethod(method);// 调用 execute 方法执行 SQLreturn mapperMethod.execute(sqlSession, args);
}

1
2
3
4
5
6
7
8
9
10
11
12

public class MapperMethod {private final SqlCommand command;private final MethodSignature method;public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {// 创建 SqlCommand 对象，该对象包含一些和 SQL 相关的信息this.command = new SqlCommand(config, mapperInterface, method);// 创建 MethodSignature 对象，从类名中可知，该对象包含了被拦截方法的一些信息this.method = new MethodSignature(config, mapperInterface, method);}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

public static class SqlCommand {private final String name;private final SqlCommandType type;public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) {final String methodName = method.getName();final Class<?> declaringClass = method.getDeclaringClass();// 解析 MappedStatementMappedStatement ms = resolveMappedStatement(mapperInterface, methodName, declaringClass, configuration);// 检测当前方法是否有对应的 MappedStatementif (ms == null) {// 检测当前方法是否有 @Flush 注解if (method.getAnnotation(Flush.class) != null) {// 设置 name 和 type 遍历name = null;type = SqlCommandType.FLUSH;} else {/** 若 ms == null 且方法无 @Flush 注解，此时抛出异常。* 这个异常比较常见，大家应该眼熟吧*/ throw new BindingException("Invalid bound statement (not found): "+ mapperInterface.getName() + "." + methodName);}} else {// 设置 name 和 type 变量name = ms.getId();type = ms.getSqlCommandType();if (type == SqlCommandType.UNKNOWN) {throw new BindingException("Unknown execution method for: " + name);}}}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

public static class MethodSignature {private final boolean returnsMany;private final boolean returnsMap;private final boolean returnsVoid;private final boolean returnsCursor;private final Class<?> returnType;private final String mapKey;private final Integer resultHandlerIndex;private final Integer rowBoundsIndex;private final ParamNameResolver paramNameResolver;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();}// 检测返回值类型是否是 void、集合或数组、Cursor、Map 等this.returnsVoid = void.class.equals(this.returnType);this.returnsMany = configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray();this.returnsCursor = Cursor.class.equals(this.returnType);// 解析 @MapKey 注解，获取注解内容this.mapKey = getMapKey(method);this.returnsMap = this.mapKey != null;/** 获取 RowBounds 参数在参数列表中的位置，如果参数列表中* 包含多个 RowBounds 参数，此方法会抛出异常*/ this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);// 获取 ResultHandler 参数在参数列表中的位置this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);// 解析参数列表this.paramNameResolver = new ParamNameResolver(configuration, method);}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

public class ParamNameResolver {private static final String GENERIC_NAME_PREFIX = "param";private final SortedMap<Integer, String> names;public ParamNameResolver(Configuration config, Method method) {// 获取参数类型列表final Class<?>[] paramTypes = method.getParameterTypes();// 获取参数注解final Annotation[][] paramAnnotations = method.getParameterAnnotations();final SortedMap<Integer, String> map = new TreeMap<Integer, String>();int paramCount = paramAnnotations.length;for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {// 检测当前的参数类型是否为 RowBounds 或 ResultHandlerif (isSpecialParameter(paramTypes[paramIndex])) {continue;}String name = null;for (Annotation annotation : paramAnnotations[paramIndex]) {if (annotation instanceof Param) {hasParamAnnotation = true;// 获取 @Param 注解内容name = ((Param) annotation).value();break;}}// name 为空，表明未给参数配置 @Param 注解if (name == null) {// 检测是否设置了 useActualParamName 全局配置if (config.isUseActualParamName()) {/** 通过反射获取参数名称。此种方式要求 JDK 版本为 1.8+，* 且要求编译时加入 -parameters 参数，否则获取到的参数名* 仍然是 arg1, arg2, ..., argN*/name = getActualParamName(method, paramIndex);}if (name == null) {/** 使用 map.size() 返回值作为名称，思考一下为什么不这样写：*   name = String.valueOf(paramIndex);* 因为如果参数列表中包含 RowBounds 或 ResultHandler，这两个参数* 会被忽略掉，这样将导致名称不连续。** 比如参数列表 (int p1, int p2, RowBounds rb, int p3)*  - 期望得到名称列表为 ["0", "1", "2"]*  - 实际得到名称列表为 ["0", "1", "3"]*/name = String.valueOf(map.size());}}// 存储 paramIndex 到 name 的映射map.put(paramIndex, name);}names = Collections.unmodifiableSortedMap(map);}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class ParamNameResolverTest {@Testpublic void test() throws NoSuchMethodException, NoSuchFieldException, IllegalAccessException {Configuration config = new Configuration();config.setUseActualParamName(false);Method method = ArticleMapper.class.getMethod("select", Integer.class, String.class, RowBounds.class, Article.class);ParamNameResolver resolver = new ParamNameResolver(config, method);Field field = resolver.getClass().getDeclaredField("names");field.setAccessible(true);// 通过反射获取 ParamNameResolver 私有成员变量 namesObject names = field.get(resolver);System.out.println("names: " + names);}class ArticleMapper {public void select(@Param("id") Integer id, @Param("author") String author, RowBounds rb, Article article) {}}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

// -☆- MapperMethod
public Object execute(SqlSession sqlSession, Object[] args) {Object result;// 根据 SQL 类型执行相应的数据库操作switch (command.getType()) {case INSERT: {// 对用户传入的参数进行转换，下同Object param = method.convertArgsToSqlCommandParam(args);// 执行插入操作，rowCountResult 方法用于处理返回值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()) {/** 如果方法返回值为 void，但参数列表中包含 ResultHandler，表明使用者* 想通过 ResultHandler 的方式获取查询结果，而非通过返回值获取结果*/executeWithResultHandler(sqlSession, args);result = null;} else if (method.returnsMany()) {// 执行查询操作，并返回多个结果 result = executeForMany(sqlSession, args);} else if (method.returnsMap()) {// 执行查询操作，并将结果封装在 Map 中返回result = executeForMap(sqlSession, args);} else if (method.returnsCursor()) {// 执行查询操作，并返回一个 Cursor 对象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());}// 如果方法的返回值为基本类型，而返回值却为 null，此种情况下应抛出异常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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// -☆- MapperMethod
public Object convertArgsToSqlCommandParam(Object[] args) {return paramNameResolver.getNamedParams(args);
}public Object getNamedParams(Object[] args) {final int paramCount = names.size();if (args == null || paramCount == 0) {return null;} else if (!hasParamAnnotation && paramCount == 1) {/** 如果方法参数列表无 @Param 注解，且仅有一个非特别参数，则返回该参数的值。* 比如如下方法：*     List findList(RowBounds rb, String name)* names 如下：*     names = {1 : "0"}* 此种情况下，返回 args[names.firstKey()]，即 args[1] -> name*/return args[names.firstKey()];} else {final Map<String, Object> param = new ParamMap<Object>();int i = 0;for (Map.Entry<Integer, String> entry : names.entrySet()) {// 添加 <参数名, 参数值> 键值对到 param 中param.put(entry.getValue(), args[entry.getKey()]);// genericParamName = param + index。比如 param1, param2, ... paramNfinal String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);/** 检测 names 中是否包含 genericParamName，什么情况下会包含？答案如下：**   使用者显式将参数名称配置为 param1，即 @Param("param1")*/if (!names.containsValue(genericParamName)) {// 添加 <param*, value> 到 param 中param.put(genericParamName, args[entry.getKey()]);}i++;}return param;}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// -☆- DefaultSqlSession
public <T> T selectOne(String statement, Object parameter) {// 调用 selectList 获取结果List<T> list = this.<T>selectList(statement, parameter);if (list.size() == 1) {// 返回结果return list.get(0);} else if (list.size() > 1) {// 如果查询结果大于1则抛出异常，这个异常也是很常见的throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());} else {return null;}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// -☆- DefaultSqlSession
public <E> List<E> selectList(String statement, Object parameter) {// 调用重载方法return this.selectList(statement, parameter, RowBounds.DEFAULT);
}private final Executor executor;public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {try {// 获取 MappedStatementMappedStatement ms = configuration.getMappedStatement(statement);// 调用 Executor 实现类中的 query 方法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();}
}

1
2
3
4
5
6
7
8
9

// -☆- CachingExecutor
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {// 获取 BoundSqlBoundSql boundSql = ms.getBoundSql(parameterObject);// 创建 CacheKeyCacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);// 调用重载方法return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// -☆- CachingExecutor
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {// 从 MappedStatement 中获取缓存Cache cache = ms.getCache();// 若映射文件中未配置缓存或参照缓存，此时 cache = nullif (cache != null) {flushCacheIfRequired(ms);if (ms.isUseCache() && resultHandler == null) {ensureNoOutParams(ms, boundSql);List<E> list = (List<E>) tcm.getObject(cache, key);if (list == null) {// 若缓存未命中，则调用被装饰类的 query 方法list = delegate.<E>query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);tcm.putObject(cache, key, list); // issue #578 and #116}return list;}}// 调用被装饰类的 query 方法return delegate.<E>query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// -☆- BaseExecutor
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {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();}deferredLoads.clear();if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {clearLocalCache();}}return list;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// -☆- BaseExecutor
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 {// 调用 doQuery 进行查询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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// -☆- SimpleExecutor
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();// 创建 StatementHandlerStatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);// 创建 Statementstmt = prepareStatement(handler, ms.getStatementLog());// 执行查询操作return handler.<E>query(stmt, resultHandler);} finally {// 关闭 StatementcloseStatement(stmt);}
}

1
2
3
4
5
6
7
8

// -☆- PreparedStatementHandler
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {PreparedStatement ps = (PreparedStatement) statement;// 执行 SQLps.execute();// 处理执行结果return resultSetHandler.<E>handleResultSets(ps);
}

1
2
3
4
5

private final String sql;
private final List<ParameterMapping> parameterMappings;
private final Object parameterObject;
private final Map<String, Object> additionalParameters;
private final MetaObject metaParameters;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// -☆- MappedStatement
public BoundSql getBoundSql(Object parameterObject) {// 调用 sqlSource 的 getBoundSql 获取 BoundSqlBoundSql boundSql = sqlSource.getBoundSql(parameterObject);List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();if (parameterMappings == null || parameterMappings.isEmpty()) {/** 创建新的 BoundSql，这里的 parameterMap 是 ParameterMap 类型。* 由<ParameterMap> 节点进行配置，该节点已经废弃，不推荐使用。默认情况下，* parameterMap.getParameterMappings() 返回空集合*/ boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);}// 省略不重要的逻辑return boundSql;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// -☆- DynamicSqlSource
public BoundSql getBoundSql(Object parameterObject) {// 创建 DynamicContextDynamicContext context = new DynamicContext(configuration, parameterObject);// 解析 SQL 片段，并将解析结果存储到 DynamicContext 中rootSqlNode.apply(context);SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();/** 构建 StaticSqlSource，在此过程中将 sql 语句中的占位符 #{} 替换为问号 ?，* 并为每个占位符构建相应的 ParameterMapping*/SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());// 调用 StaticSqlSource 的 getBoundSql 获取 BoundSqlBoundSql boundSql = sqlSource.getBoundSql(parameterObject);// 将 DynamicContext 的 ContextMap 中的内容拷贝到 BoundSql 中for (Map.Entry<String, Object> entry : context.getBindings().entrySet()) {boundSql.setAdditionalParameter(entry.getKey(), entry.getValue());}return boundSql;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class DynamicContext {public static final String PARAMETER_OBJECT_KEY = "_parameter";public static final String DATABASE_ID_KEY = "_databaseId";private final ContextMap bindings;private final StringBuilder sqlBuilder = new StringBuilder();public DynamicContext(Configuration configuration, Object parameterObject) {// 创建 ContextMapif (parameterObject != null && !(parameterObject instanceof Map)) {MetaObject metaObject = configuration.newMetaObject(parameterObject);bindings = new ContextMap(metaObject);} else {bindings = new ContextMap(null);}// 存放运行时参数 parameterObject 以及 databaseIdbindings.put(PARAMETER_OBJECT_KEY, parameterObject);bindings.put(DATABASE_ID_KEY, configuration.getDatabaseId());}// 省略部分代码
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

static class ContextMap extends HashMap<String, Object> {private MetaObject parameterMetaObject;public ContextMap(MetaObject parameterMetaObject) {this.parameterMetaObject = parameterMetaObject;}@Overridepublic Object get(Object key) {String strKey = (String) key;// 检查是否包含 strKey，若包含则直接返回if (super.containsKey(strKey)) {return super.get(strKey);}if (parameterMetaObject != null) {// 从运行时参数中查找结果return parameterMetaObject.getValue(strKey);}return null;}
}

1
2
3
4
5
6
7
8

public void appendSql(String sql) {sqlBuilder.append(sql);sqlBuilder.append(" ");
}public String getSql() {return sqlBuilder.toString().trim();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class MixedSqlNode implements SqlNode {private final List<SqlNode> contents;public MixedSqlNode(List<SqlNode> contents) {this.contents = contents;}@Overridepublic boolean apply(DynamicContext context) {// 遍历 SqlNode 集合for (SqlNode sqlNode : contents) {// 调用 salNode 对象本身的 apply 方法解析 sqlsqlNode.apply(context);}return true;}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class StaticTextSqlNode implements SqlNode {private final String text;public StaticTextSqlNode(String text) {this.text = text;}@Overridepublic boolean apply(DynamicContext context) {context.appendSql(text);return true;}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

public class TextSqlNode implements SqlNode {private final String text;private final Pattern injectionFilter;@Overridepublic boolean apply(DynamicContext context) {// 创建 ${} 占位符解析器GenericTokenParser parser = createParser(new BindingTokenParser(context, injectionFilter));// 解析 ${} 占位符，并将解析结果添加到 DynamicContext 中context.appendSql(parser.parse(text));return true;}private GenericTokenParser createParser(TokenHandler handler) {// 创建占位符解析器，GenericTokenParser 是一个通用解析器，并非只能解析 ${}return new GenericTokenParser("${", "}", handler);}private static class BindingTokenParser implements TokenHandler {private DynamicContext context;private Pattern injectionFilter;public BindingTokenParser(DynamicContext context, Pattern injectionFilter) {this.context = context;this.injectionFilter = injectionFilter;}@Overridepublic String handleToken(String content) {Object parameter = context.getBindings().get("_parameter");if (parameter == null) {context.getBindings().put("value", null);} else if (SimpleTypeRegistry.isSimpleType(parameter.getClass())) {context.getBindings().put("value", parameter);}// 通过 ONGL 从用户传入的参数中获取结果Object value = OgnlCache.getValue(content, context.getBindings());String srtValue = (value == null ? "" : String.valueOf(value));// 通过正则表达式检测 srtValue 有效性checkInjection(srtValue);return srtValue;}}
}

1

SELECT * FROM article WHERE author = '${author}'

1

SELECT * FROM article WHERE author = 'tianxiaobo'

1

SELECT * FROM article WHERE author = 'tianxiaobo'; DELETE FROM article;#'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class IfSqlNode implements SqlNode {private final ExpressionEvaluator evaluator;private final String test;private final SqlNode contents;public IfSqlNode(SqlNode contents, String test) {this.test = test;this.contents = contents;this.evaluator = new ExpressionEvaluator();}@Overridepublic boolean apply(DynamicContext context) {// 通过 ONGL 评估 test 表达式的结果if (evaluator.evaluateBoolean(test, context.getBindings())) {// 若 test 表达式中的条件成立，则调用其他节点的 apply 方法进行解析contents.apply(context);return true;}return false;}
}

1
2
3
4
5
6
7
8
9
10

public class WhereSqlNode extends TrimSqlNode {/** 前缀列表 */private static List<String> prefixList = Arrays.asList("AND ", "OR ", "AND\n", "OR\n", "AND\r", "OR\r", "AND\t", "OR\t");public WhereSqlNode(Configuration configuration, SqlNode contents) {// 调用父类的构造方法super(configuration, contents, "WHERE", prefixList, null, null);}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class TrimSqlNode implements SqlNode {private final SqlNode contents;private final String prefix;private final String suffix;private final List<String> prefixesToOverride;private final List<String> suffixesToOverride;private final Configuration configuration;// 省略构造方法@Overridepublic boolean apply(DynamicContext context) {// 创建具有过滤功能的 DynamicContextFilteredDynamicContext filteredDynamicContext = new FilteredDynamicContext(context);// 解析节点内容boolean result = contents.apply(filteredDynamicContext);// 过滤掉前缀和后缀filteredDynamicContext.applyAll();return result;}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

private class FilteredDynamicContext extends DynamicContext {private DynamicContext delegate;/** 构造方法会将下面两个布尔值置为 false */private boolean prefixApplied;private boolean suffixApplied;private StringBuilder sqlBuffer;// 省略构造方法public void applyAll() {sqlBuffer = new StringBuilder(sqlBuffer.toString().trim());String trimmedUppercaseSql = sqlBuffer.toString().toUpperCase(Locale.ENGLISH);if (trimmedUppercaseSql.length() > 0) {// 引用前缀和后缀，也就是对 sql 进行过滤操作，移除掉前缀或后缀applyPrefix(sqlBuffer, trimmedUppercaseSql);applySuffix(sqlBuffer, trimmedUppercaseSql);}// 将当前对象的 sqlBuffer 内容添加到代理类中delegate.appendSql(sqlBuffer.toString());}// 省略部分方法private void applyPrefix(StringBuilder sql, String trimmedUppercaseSql) {if (!prefixApplied) {// 设置 prefixApplied 为 true，以下逻辑仅会被执行一次prefixApplied = true;if (prefixesToOverride != null) {for (String toRemove : prefixesToOverride) {// 检测当前 sql 字符串是否包含 toRemove 前缀，比如 'AND ', 'AND\t'if (trimmedUppercaseSql.startsWith(toRemove)) {// 移除前缀sql.delete(0, toRemove.trim().length());break;}}}// 插入前缀，比如 WHEREif (prefix != null) {sql.insert(0, " ");sql.insert(0, prefix);}}}// 该方法逻辑与 applyPrefix 大同小异，大家自行分析private void applySuffix(StringBuilder sql, String trimmedUppercaseSql) {...}
}

1
2
3
4
5
6
7
8
9
10
11
12
13

public class SqlNodeTest {@Testpublic void testWhereSqlNode() throws IOException {String sqlFragment = "AND id = #{id}";MixedSqlNode msn = new MixedSqlNode(Arrays.asList(new StaticTextSqlNode(sqlFragment)));WhereSqlNode wsn = new WhereSqlNode(new Configuration(), msn);DynamicContext dc = new DynamicContext(new Configuration(), new ParamMap<>());wsn.apply(dc);System.out.println("解析前：" + sqlFragment);System.out.println("解析后：" + dc.getSql());}
}

1
2
3
4
5
6
7
8
9
10
11

// -☆- SqlSourceBuilder
public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {// 创建 #{} 占位符处理器ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);// 创建 #{} 占位符解析器GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);// 解析 #{} 占位符，并返回解析结果String sql = parser.parse(originalSql);// 封装解析结果到 StaticSqlSource 中，并返回return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
}

1
2
3
4
5
6

public String handleToken(String content) {// 获取 content 的对应的 ParameterMappingparameterMappings.add(buildParameterMapping(content));// 返回 ?return "?";
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

private ParameterMapping buildParameterMapping(String content) {/** 将 #{xxx} 占位符中的内容解析成 Map。大家可能很好奇一个普通的字符串是怎么解析成 Map 的，* 举例说明一下。如下：* *    #{age,javaType=int,jdbcType=NUMERIC,typeHandler=MyTypeHandler}*    * 上面占位符中的内容最终会被解析成如下的结果：* *  {*      "property": "age",*      "typeHandler": "MyTypeHandler", *      "jdbcType": "NUMERIC", *      "javaType": "int"*  }* * parseParameterMapping 内部依赖 ParameterExpression 对字符串进行解析，ParameterExpression 的* 逻辑不是很复杂，这里就不分析了。大家若有兴趣，可自行分析*/Map<String, String> propertiesMap = parseParameterMapping(content);String property = propertiesMap.get("property");Class<?> propertyType;// metaParameters 为 DynamicContext 成员变量 bindings 的元信息对象if (metaParameters.hasGetter(property)) {propertyType = metaParameters.getGetterType(property);/** parameterType 是运行时参数的类型。如果用户传入的是单个参数，比如 Article 对象，此时 * parameterType 为 Article.class。如果用户传入的多个参数，比如 [id = 1, author = "coolblog"]，* MyBatis 会使用 ParamMap 封装这些参数，此时 parameterType 为 ParamMap.class。如果 * parameterType 有相应的 TypeHandler，这里则把 parameterType 设为 propertyType*/} else if (typeHandlerRegistry.hasTypeHandler(parameterType)) {propertyType = parameterType;} else if (JdbcType.CURSOR.name().equals(propertiesMap.get("jdbcType"))) {propertyType = java.sql.ResultSet.class;} else if (property == null || Map.class.isAssignableFrom(parameterType)) {// 如果 property 为空，或 parameterType 是 Map 类型，则将 propertyType 设为 Object.classpropertyType = Object.class;} else {/** 代码逻辑走到此分支中，表明 parameterType 是一个自定义的类，* 比如 Article，此时为该类创建一个元信息对象*/MetaClass metaClass = MetaClass.forClass(parameterType, configuration.getReflectorFactory());// 检测参数对象有没有与 property 想对应的 getter 方法if (metaClass.hasGetter(property)) {// 获取成员变量的类型propertyType = metaClass.getGetterType(property);} else {propertyType = Object.class;}}// -------------------------- 分割线 ---------------------------ParameterMapping.Builder builder = new ParameterMapping.Builder(configuration, property, propertyType);// 将 propertyType 赋值给 javaTypeClass<?> javaType = propertyType;String typeHandlerAlias = null;// 遍历 propertiesMapfor (Map.Entry<String, String> entry : propertiesMap.entrySet()) {String name = entry.getKey();String value = entry.getValue();if ("javaType".equals(name)) {// 如果用户明确配置了 javaType，则以用户的配置为准javaType = resolveClass(value);builder.javaType(javaType);} else if ("jdbcType".equals(name)) {// 解析 jdbcTypebuilder.jdbcType(resolveJdbcType(value));} else if ("mode".equals(name)) {...} else if ("numericScale".equals(name)) {...} else if ("resultMap".equals(name)) {...} else if ("typeHandler".equals(name)) {typeHandlerAlias = value;    } else if ("jdbcTypeName".equals(name)) {...} else if ("property".equals(name)) {...} else if ("expression".equals(name)) {throw new BuilderException("Expression based parameters are not supported yet");} else {throw new BuilderException("An invalid property '" + name + "' was found in mapping #{" + content+ "}.  Valid properties are " + parameterProperties);}}if (typeHandlerAlias != null) {// 解析 TypeHandlerbuilder.typeHandler(resolveTypeHandler(javaType, typeHandlerAlias));}// 构建 ParameterMapping 对象return builder.build();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class SqlSourceBuilderTest {@Testpublic void test() {// 带有复杂 #{} 占位符的参数，接下里会解析这个占位符String sql = "SELECT * FROM Author WHERE age = #{age,javaType=int,jdbcType=NUMERIC}";SqlSourceBuilder sqlSourceBuilder = new SqlSourceBuilder(new Configuration());SqlSource sqlSource = sqlSourceBuilder.parse(sql, Author.class, new HashMap<>());BoundSql boundSql = sqlSource.getBoundSql(new Author());System.out.println(String.format("SQL: %s\n", boundSql.getSql()));System.out.println(String.format("ParameterMappings: %s", boundSql.getParameterMappings()));}
}public class Author {private Integer id;private String name;private Integer age;// 省略 getter/setter
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class StaticSqlSource implements SqlSource {private final String sql;private final List<ParameterMapping> parameterMappings;private final Configuration configuration;public StaticSqlSource(Configuration configuration, String sql) {this(configuration, sql, null);}public StaticSqlSource(Configuration configuration, String sql, List<ParameterMapping> parameterMappings) {this.sql = sql;this.parameterMappings = parameterMappings;this.configuration = configuration;}@Overridepublic BoundSql getBoundSql(Object parameterObject) {// 创建 BoundSql 对象return new BoundSql(configuration, sql, parameterMappings, parameterObject);}
}

1
2
3
4
5
6
7
8
9

// -☆- Configuration
public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement,Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {// 创建具有路由功能的 StatementHandlerStatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);// 应用插件到 StatementHandler 上statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);return statementHandler;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class RoutingStatementHandler implements StatementHandler {private final StatementHandler delegate;public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds,ResultHandler resultHandler, BoundSql boundSql) {// 根据 StatementType 创建不同的 StatementHandler 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());}}// 其他方法逻辑均由别的 StatementHandler 代理完成，就不贴代码了
}

1
2
3
4
5
6
7
8
9
10
11

// -☆- SimpleExecutor
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {Statement stmt;// 获取数据库连接Connection connection = getConnection(statementLog);// 创建 Statement，stmt = handler.prepare(connection, transaction.getTimeout());// 为 Statement 设置 IN 参数handler.parameterize(stmt);return stmt;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// -☆- PreparedStatementHandler
public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {Statement statement = null;try {// 创建 Statementstatement = instantiateStatement(connection);// 设置超时和 FetchSizesetStatementTimeout(statement, transactionTimeout);setFetchSize(statement);return statement;} catch (SQLException e) {closeStatement(statement);throw e;} catch (Exception e) {closeStatement(statement);throw new ExecutorException("Error preparing statement.  Cause: " + e, e);}
}protected Statement instantiateStatement(Connection connection) throws SQLException {String sql = boundSql.getSql();// 根据条件调用不同的 prepareStatement 方法创建 PreparedStatementif (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) {String[] keyColumnNames = mappedStatement.getKeyColumns();if (keyColumnNames == null) {return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);} else {return connection.prepareStatement(sql, keyColumnNames);}} else if (mappedStatement.getResultSetType() != null) {return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);} else {return connection.prepareStatement(sql);}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

// -☆- PreparedStatementHandler
public void parameterize(Statement statement) throws SQLException {// 通过参数处理器 ParameterHandler 设置运行时参数到 PreparedStatement 中parameterHandler.setParameters((PreparedStatement) statement);
}public class DefaultParameterHandler implements ParameterHandler {private final TypeHandlerRegistry typeHandlerRegistry;private final MappedStatement mappedStatement;private final Object parameterObject;private final BoundSql boundSql;private final Configuration configuration;public void setParameters(PreparedStatement ps) {/** 从 BoundSql 中获取 ParameterMapping 列表，每个 ParameterMapping * 与原始 SQL 中的 #{xxx} 占位符一一对应*/List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();if (parameterMappings != null) {for (int i = 0; i < parameterMappings.size(); i++) {ParameterMapping parameterMapping = parameterMappings.get(i);// 检测参数类型，排除掉 mode 为 OUT 类型的 parameterMappingif (parameterMapping.getMode() != ParameterMode.OUT) {Object value;// 获取属性名String propertyName = parameterMapping.getProperty();// 检测 BoundSql 的 additionalParameters 是否包含 propertyNameif (boundSql.hasAdditionalParameter(propertyName)) {value = boundSql.getAdditionalParameter(propertyName);} else if (parameterObject == null) {value = null;// 检测运行时参数是否有相应的类型解析器} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {/** 若运行时参数的类型有相应的类型处理器 TypeHandler，则将 * parameterObject 设为当前属性的值。*/value = parameterObject;} else {// 为用户传入的参数 parameterObject 创建元信息对象MetaObject metaObject = configuration.newMetaObject(parameterObject);// 从用户传入的参数中获取 propertyName 对应的值value = metaObject.getValue(propertyName);}// ---------------------分割线---------------------TypeHandler typeHandler = parameterMapping.getTypeHandler();JdbcType jdbcType = parameterMapping.getJdbcType();if (value == null && jdbcType == null) {// 此处 jdbcType = JdbcType.OTHERjdbcType = configuration.getJdbcTypeForNull();}try {// 由类型处理器 typeHandler 向 ParameterHandler 设置参数typeHandler.setParameter(ps, i + 1, value, jdbcType);} catch (TypeException e) {throw new TypeException(...);} catch (SQLException e) {throw new TypeException(...);}}}}}
}

1

SELECT * FROM author WHERE name = #{name} AND age = #{age}

1

ParameterMapping{property='name', mode=IN, javaType=class java.lang.String, jdbcType=null, ...}

1

ParameterMapping{property='age', mode=IN, javaType=class java.lang.Integer, jdbcType=null, ...}

1

SELECT * FROM Author WHERE name = ? AND age = ?

1

Author findByNameAndAge(@Param("name") String name, @Param("age") Integer age)

1
2
3
4

{0: "name",1: "age"
}

1

findByNameAndAge("tianxiaobo", 20)    // 20岁，好年轻啊，但是回不去了呀 ?

1
2
3
4
5
6

{"name": "tianxiaobo","age": 20,"param1": "tianxiaobo","param2": 20
}

1

SELECT * FROM Author WHERE name = "tianxiaobo" AND age = 20

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

public List<Object> handleResultSets(Statement stmt) throws SQLException {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) {...}return collapseSingleResultList(multipleResults);
}private ResultSetWrapper getFirstResultSet(Statement stmt) throws SQLException {// 获取结果集ResultSet rs = stmt.getResultSet();while (rs == null) {/** 移动 ResultSet 指针到下一个上，有些数据库驱动可能需要使用者* 先调用 getMoreResults 方法，然后才能调用 getResultSet 方法* 获取到第一个 ResultSet*/if (stmt.getMoreResults()) {rs = stmt.getResultSet();} else {if (stmt.getUpdateCount() == -1) {break;}}}/** 这里并不直接返回 ResultSet，而是将其封装到 ResultSetWrapper 中。* ResultSetWrapper 中包含了 ResultSet 一些元信息，比如列名称、每列对应的 JdbcType、* 以及每列对应的 Java 类名（class name，譬如 java.lang.String）等。*/return rs != null ? new ResultSetWrapper(rs, configuration) : null;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {try {if (parentMapping != null) {// 多结果集相关逻辑，不分析了handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);} else {/** 检测 resultHandler 是否为空。ResultHandler 是一个接口，使用者可实现该接口，* 这样我们可以通过 ResultHandler 自定义接收查询结果的动作。比如我们可将结果存储到* List、Map 亦或是 Set，甚至丢弃，这完全取决于大家的实现逻辑。*/ if (resultHandler == null) {// 创建默认的结果处理器DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);// 处理结果集的行数据handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);multipleResults.add(defaultResultHandler.getResultList());} else {// 处理结果集的行数据handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);}}} finally {closeResultSet(rsw.getResultSet());}
}

1
2
3
4
5
6
7
8
9
10
11
12
13

public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler,RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {if (resultMap.hasNestedResultMaps()) {ensureNoRowBounds();checkResultHandler();// 处理嵌套映射，关于嵌套映射本文就不分析了handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);} else {// 处理简单映射handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap,ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {DefaultResultContext<Object> resultContext = new DefaultResultContext<Object>();// 根据 RowBounds 定位到指定行记录skipRows(rsw.getResultSet(), rowBounds);// 检测是否还有更多行的数据需要处理while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {// 获取经过鉴别器处理后的 ResultMapResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);// 从 resultSet 中获取结果Object rowValue = getRowValue(rsw, discriminatedResultMap);// 存储结果storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

private void skipRows(ResultSet rs, RowBounds rowBounds) throws SQLException {// 检测 rs 的类型，不同的类型行数据定位方式是不同的if (rs.getType() != ResultSet.TYPE_FORWARD_ONLY) {if (rowBounds.getOffset() != RowBounds.NO_ROW_OFFSET) {// 直接定位到 rowBounds.getOffset() 位置处rs.absolute(rowBounds.getOffset());}} else {for (int i = 0; i < rowBounds.getOffset(); i++) {/** 通过多次调用 rs.next() 方法实现行数据定位。* 当 Offset 数值很大时，这种效率很低下*/rs.next();}}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap) throws SQLException {final ResultLoaderMap lazyLoader = new ResultLoaderMap();// 创建实体类对象，比如 Article 对象Object rowValue = createResultObject(rsw, resultMap, lazyLoader, null);if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {final MetaObject metaObject = configuration.newMetaObject(rowValue);boolean foundValues = this.useConstructorMappings;// 检测是否应该自动映射结果集if (shouldApplyAutomaticMappings(resultMap, false)) {// 进行自动映射foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, null) || foundValues;}// 根据 <resultMap> 节点中配置的映射关系进行映射foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, null) || foundValues;foundValues = lazyLoader.size() > 0 || foundValues;rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;}return rowValue;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// -☆- DefaultResultSetHandler
private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, ResultLoaderMap lazyLoader, String columnPrefix) throws SQLException {this.useConstructorMappings = false;final List<Class<?>> constructorArgTypes = new ArrayList<Class<?>>();final List<Object> constructorArgs = new ArrayList<Object>();// 调用重载方法创建实体类对象Object resultObject = createResultObject(rsw, resultMap, constructorArgTypes, constructorArgs, columnPrefix);// 检测实体类是否有相应的类型处理器if (resultObject != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();for (ResultMapping propertyMapping : propertyMappings) {// 如果开启了延迟加载，则为 resultObject 生成代理类if (propertyMapping.getNestedQueryId() != null && propertyMapping.isLazy()) {/** 创建代理类，默认使用 Javassist 框架生成代理类。由于实体类通常不会实现接口，* 所以不能使用 JDK 动态代理 API 为实体类生成代理。*/resultObject = configuration.getProxyFactory().createProxy(resultObject, lazyLoader, configuration, objectFactory, constructorArgTypes, constructorArgs);break;}}}this.useConstructorMappings =resultObject != null && !constructorArgTypes.isEmpty();return resultObject;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

/** 作者类 */
public class Author {private Integer id;private String name;private Integer age;private Integer sex;// 省略 getter/setter
}/** 文章类 */
public class Article {private Integer id;private String title;// 一对一关系private Author author;private String content;// 省略 getter/setter
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, List<Class<?>> constructorArgTypes, List<Object> constructorArgs, String columnPrefix) throws SQLException {final Class<?> resultType = resultMap.getType();final MetaClass metaType = MetaClass.forClass(resultType, reflectorFactory);// 获取 <constructor> 节点对应的 ResultMappingfinal List<ResultMapping> constructorMappings = resultMap.getConstructorResultMappings();/** 检测是否有与返回值类型相对应的 TypeHandler，若有则直接从* 通过 TypeHandler 从结果集中提取数据，并生成返回值对象*/if (hasTypeHandlerForResultObject(rsw, resultType)) {// 通过 TypeHandler 获取提取，并生成返回值对象return createPrimitiveResultObject(rsw, resultMap, columnPrefix);} else if (!constructorMappings.isEmpty()) {/** 通过 <constructor> 节点配置的映射信息从 ResultSet 中提取数据，* 然后将这些数据传给指定构造方法，即可创建实体类对象*/return createParameterizedResultObject(rsw, resultType, constructorMappings, constructorArgTypes, constructorArgs, columnPrefix);} else if (resultType.isInterface() || metaType.hasDefaultConstructor()) {// 通过 ObjectFactory 调用目标类的默认构造方法创建实例return objectFactory.create(resultType);} else if (shouldApplyAutomaticMappings(resultMap, false)) {// 通过自动映射查找合适的构造方法创建实例return createByConstructorSignature(rsw, resultType, constructorArgTypes, constructorArgs, columnPrefix);}throw new ExecutorException("Do not know how to create an instance of " + resultType);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

private boolean shouldApplyAutomaticMappings(ResultMap resultMap, boolean isNested) {// 检测 <resultMap> 是否配置了 autoMapping 属性if (resultMap.getAutoMapping() != null) {// 返回 autoMapping 属性return resultMap.getAutoMapping();} else {if (isNested) {// 对于嵌套 resultMap，仅当全局的映射行为为 FULL 时，才进行自动映射return AutoMappingBehavior.FULL == configuration.getAutoMappingBehavior();} else {// 对于普通的 resultMap，只要全局的映射行为不为 NONE，即可进行自动映射return AutoMappingBehavior.NONE != configuration.getAutoMappingBehavior();}}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

private boolean applyAutomaticMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, String columnPrefix) throws SQLException {// 获取 UnMappedColumnAutoMapping 列表List<UnMappedColumnAutoMapping> autoMapping = createAutomaticMappings(rsw, resultMap, metaObject, columnPrefix);boolean foundValues = false;if (!autoMapping.isEmpty()) {for (UnMappedColumnAutoMapping mapping : autoMapping) {// 通过 TypeHandler 从结果集中获取指定列的数据final Object value = mapping.typeHandler.getResult(rsw.getResultSet(), mapping.column);if (value != null) {foundValues = true;}if (value != null || (configuration.isCallSettersOnNulls() && !mapping.primitive)) {// 通过元信息对象设置 value 到实体类对象的指定字段上metaObject.setValue(mapping.property, value);}}}return foundValues;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

private static class UnMappedColumnAutoMapping {private final String column;private final String property;private final TypeHandler<?> typeHandler;private final boolean primitive;public UnMappedColumnAutoMapping(String column, String property, TypeHandler<?> typeHandler, boolean primitive) {this.column = column;this.property = property;this.typeHandler = typeHandler;this.primitive = primitive;}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

// -☆- DefaultResultSetHandler
private List<UnMappedColumnAutoMapping> createAutomaticMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, String columnPrefix) throws SQLException {final String mapKey = resultMap.getId() + ":" + columnPrefix;// 从缓存中获取 UnMappedColumnAutoMapping 列表List<UnMappedColumnAutoMapping> autoMapping = autoMappingsCache.get(mapKey);// 缓存未命中if (autoMapping == null) {autoMapping = new ArrayList<UnMappedColumnAutoMapping>();// 从 ResultSetWrapper 中获取未配置在 <resultMap> 中的列名final List<String> unmappedColumnNames = rsw.getUnmappedColumnNames(resultMap, columnPrefix);for (String columnName : unmappedColumnNames) {String propertyName = columnName;if (columnPrefix != null && !columnPrefix.isEmpty()) {if (columnName.toUpperCase(Locale.ENGLISH).startsWith(columnPrefix)) {// 获取不包含列名前缀的属性名propertyName = columnName.substring(columnPrefix.length());} else {continue;}}// 将下划线形式的列名转成驼峰式，比如 AUTHOR_NAME -> authorNamefinal String property = metaObject.findProperty(propertyName, configuration.isMapUnderscoreToCamelCase());if (property != null && metaObject.hasSetter(property)) {// 检测当前属性是否存在于 resultMap 中if (resultMap.getMappedProperties().contains(property)) {continue;}// 获取属性对于的类型final Class<?> propertyType = metaObject.getSetterType(property);if (typeHandlerRegistry.hasTypeHandler(propertyType, rsw.getJdbcType(columnName))) {// 获取类型处理器final TypeHandler<?> typeHandler = rsw.getTypeHandler(propertyType, columnName);// 封装上面获取到的信息到 UnMappedColumnAutoMapping 对象中autoMapping.add(new UnMappedColumnAutoMapping(columnName, property, typeHandler, propertyType.isPrimitive()));} else {configuration.getAutoMappingUnknownColumnBehavior().doAction(mappedStatement, columnName, property, propertyType);}} else {/** 若 property 为空，或实体类中无 property 属性，此时无法完成* 列名与实体类属性建立映射关系。针对这种情况，有三种处理方式，*   1. 什么都不做*   2. 仅打印日志*   3. 抛出异常* 默认情况下，是什么都不做*/configuration.getAutoMappingUnknownColumnBehavior().doAction(mappedStatement, columnName, (property != null) ? property : propertyName, null);}}// 写入缓存autoMappingsCache.put(mapKey, autoMapping);}return autoMapping;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// -☆- ResultSetWrapper
public List<String> getUnmappedColumnNames(ResultMap resultMap, String columnPrefix) throws SQLException {List<String> unMappedColumnNames = unMappedColumnNamesMap.get(getMapKey(resultMap, columnPrefix));if (unMappedColumnNames == null) {// 加载已映射与未映射列名loadMappedAndUnmappedColumnNames(resultMap, columnPrefix);// 获取未映射列名unMappedColumnNames = unMappedColumnNamesMap.get(getMapKey(resultMap, columnPrefix));}return unMappedColumnNames;
}private void loadMappedAndUnmappedColumnNames(ResultMap resultMap, String columnPrefix) throws SQLException {List<String> mappedColumnNames = new ArrayList<String>();List<String> unmappedColumnNames = new ArrayList<String>();final String upperColumnPrefix = columnPrefix == null ? null : columnPrefix.toUpperCase(Locale.ENGLISH);// 为 <resultMap> 中的列名拼接前缀final Set<String> mappedColumns = prependPrefixes(resultMap.getMappedColumns(), upperColumnPrefix);/** 遍历 columnNames，columnNames 是 ResultSetWrapper 的成员变量，* 保存了当前结果集中的所有列名*/for (String columnName : columnNames) {final String upperColumnName = columnName.toUpperCase(Locale.ENGLISH);// 检测已映射列名集合中是否包含当前列名if (mappedColumns.contains(upperColumnName)) {mappedColumnNames.add(upperColumnName);} else {// 将列名存入 unmappedColumnNames 中unmappedColumnNames.add(columnName);}}// 缓存列名集合mappedColumnNamesMap.put(getMapKey(resultMap, columnPrefix), mappedColumnNames);unMappedColumnNamesMap.put(getMapKey(resultMap, columnPrefix), unmappedColumnNames);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

// -☆- DefaultResultSetHandler
private boolean applyPropertyMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject,ResultLoaderMap lazyLoader, String columnPrefix) throws SQLException {// 获取已映射的列名final List<String> mappedColumnNames = rsw.getMappedColumnNames(resultMap, columnPrefix);boolean foundValues = false;// 获取 ResultMappingfinal List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();for (ResultMapping propertyMapping : propertyMappings) {// 拼接列名前缀，得到完整列名String column = prependPrefix(propertyMapping.getColumn(), columnPrefix);if (propertyMapping.getNestedResultMapId() != null) {column = null;}/** 下面的 if 分支由三个或条件组合而成，三个条件的含义如下：*   条件一：检测 column 是否为 {prop1=col1, prop2=col2} 形式，该*          种形式的 column 一般用于关联查询*   条件二：检测当前列名是否被包含在已映射的列名集合中，若包含则可进行数据集映射操作*   条件三：多结果集相关，暂不分析*/if (propertyMapping.isCompositeResult()|| (column != null && mappedColumnNames.contains(column.toUpperCase(Locale.ENGLISH)))|| propertyMapping.getResultSet() != null) {// 从结果集中获取指定列的数据Object value = getPropertyMappingValue(rsw.getResultSet(), metaObject, propertyMapping, lazyLoader, columnPrefix);final String property = propertyMapping.getProperty();if (property == null) {continue;// 若获取到的值为 DEFERED，则延迟加载该值} else if (value == DEFERED) {foundValues = true;continue;}if (value != null) {foundValues = true;}if (value != null || (configuration.isCallSettersOnNulls() && !metaObject.getSetterType(property).isPrimitive())) {// 将获取到的值设置到实体类对象中metaObject.setValue(property, value);}}}return foundValues;
}private Object getPropertyMappingValue(ResultSet rs, MetaObject metaResultObject, ResultMapping propertyMapping,ResultLoaderMap lazyLoader, String columnPrefix) throws SQLException {if (propertyMapping.getNestedQueryId() != null) {// 获取关联查询结果，下一节分析return getNestedQueryMappingValue(rs, metaResultObject, propertyMapping, lazyLoader, columnPrefix);} else if (propertyMapping.getResultSet() != null) {addPendingChildRelation(rs, metaResultObject, propertyMapping);return DEFERED;} else {final TypeHandler<?> typeHandler = propertyMapping.getTypeHandler();// 拼接前缀final String column = prependPrefix(propertyMapping.getColumn(), columnPrefix);// 从 ResultSet 中获取指定列的值return typeHandler.getResult(rs, column);}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

/** 作者类 */
public class Author {private Integer id;private String name;private Integer age;private Integer sex;private String email;// 省略 getter/setter
}/** 文章类 */
public class Article {private Integer id;private String title;// 一对一关系private Author author;private String content;private Date createTime;// 省略 getter/setter
}

1
2
3
4

public interface ArticleDao {Article findOne(@Param("id") int id);Author findAuthor(@Param("id") int authorId);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

<mapper namespace="xyz.coolblog.dao.ArticleDao"><resultMap id="articleResult" type="Article"><result property="createTime" column="create_time"/><association property="author" column="author_id" javaType="Author" select="findAuthor"/></resultMap><select id="findOne" resultMap="articleResult">SELECTid, author_id, title, content, create_timeFROMarticleWHEREid = #{id}</select><select id="findAuthor" resultType="Author">SELECTid, name, age, sex, emailFROMauthorWHEREid = #{id}</select>
</mapper>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public class OneToOneTest {private SqlSessionFactory sqlSessionFactory;@Beforepublic void prepare() throws IOException {String resource = "mybatis-one-to-one-config.xml";InputStream inputStream = Resources.getResourceAsStream(resource);sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);inputStream.close();}@Testpublic void testOne2One() {SqlSession session = sqlSessionFactory.openSession();try {ArticleDao articleDao = session.getMapper(ArticleDao.class);Article article = articleDao.findOne(1);Author author = article.getAuthor();article.setAuthor(null);System.out.println("\narticles info:");System.out.println(article);System.out.println("\nauthor info:");System.out.println(author);} finally {session.close();}}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

private Object getNestedQueryMappingValue(ResultSet rs, MetaObject metaResultObject, ResultMapping propertyMapping, ResultLoaderMap lazyLoader, String columnPrefix) throws SQLException {// 获取关联查询 id，id = 命名空间 + <association> 的 select 属性值final String nestedQueryId = propertyMapping.getNestedQueryId();final String property = propertyMapping.getProperty();// 根据 nestedQueryId 获取 MappedStatementfinal MappedStatement nestedQuery = configuration.getMappedStatement(nestedQueryId);final Class<?> nestedQueryParameterType = nestedQuery.getParameterMap().getType();/** 生成关联查询语句参数对象，参数类型可能是一些包装类，Map 或是自定义的实体类，* 具体类型取决于配置信息。以上面的例子为基础，下面分析不同配置对参数类型的影响：*   1. <association column="author_id"> *      column 属性值仅包含列信息，参数类型为 author_id 列对应的类型，这里为 Integer* *   2. <association column="{id=author_id, name=title}"> *      column 属性值包含了属性名与列名的复合信息，MyBatis 会根据列名从 ResultSet 中*      获取列数据，并将列数据设置到实体类对象的指定属性中，比如：*          Author{id=1, name="MyBatis 源码分析系列文章导读", age=null, ....}*      或是以键值对 <属性, 列数据> 的形式，将两者存入 Map 中。比如：*          {"id": 1, "name": "MyBatis 源码分析系列文章导读"}**      至于参数类型到底为实体类还是 Map，取决于关联查询语句的配置信息。比如：*          <select id="findAuthor">  ->  参数类型为 Map*          <select id="findAuthor" parameterType="Author"> -> 参数类型为实体类*/final Object nestedQueryParameterObject = prepareParameterForNestedQuery(rs, propertyMapping, nestedQueryParameterType, columnPrefix);Object value = null;if (nestedQueryParameterObject != null) {// 获取 BoundSqlfinal BoundSql nestedBoundSql = nestedQuery.getBoundSql(nestedQueryParameterObject);final CacheKey key = executor.createCacheKey(nestedQuery, nestedQueryParameterObject, RowBounds.DEFAULT, nestedBoundSql);final Class<?> targetType = propertyMapping.getJavaType();// 检查一级缓存是否保存了关联查询结果if (executor.isCached(nestedQuery, key)) {/** 从一级缓存中获取关联查询的结果，并通过 metaResultObject * 将结果设置到相应的实体类对象中*/executor.deferLoad(nestedQuery, metaResultObject, property, key, targetType);value = DEFERED;} else {// 创建结果加载器final ResultLoader resultLoader = new ResultLoader(configuration, executor, nestedQuery, nestedQueryParameterObject, targetType, key, nestedBoundSql);// 检测当前属性是否需要延迟加载if (propertyMapping.isLazy()) {// 添加延迟加载相关的对象到 loaderMap 集合中lazyLoader.addLoader(property, metaResultObject, resultLoader);value = DEFERED;} else {// 直接执行关联查询value = resultLoader.loadResult();}}}return value;
}

1
2
3
4
5
6
7
8
9
10
11
12

// -☆- ResultLoaderMap
public void addLoader(String property, MetaObject metaResultObject, ResultLoader resultLoader) {// 将属性名转为大写String upperFirst = getUppercaseFirstProperty(property);if (!upperFirst.equalsIgnoreCase(property) && loaderMap.containsKey(upperFirst)) {throw new ExecutorException("Nested lazy loaded result property '" + property +"' for query id '" + resultLoader.mappedStatement.getId() +" already exists in the result map. The leftmost property of all lazy loaded properties must be unique within a result map.");}// 创建 LoadPair，并将 <大写属性名，LoadPair对象> 键值对添加到 loaderMap 中loaderMap.put(upperFirst, new LoadPair(property, metaResultObject, resultLoader));
}

1
2
3
4
5
6

<!-- 开启延迟加载 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 关闭积极的加载策略 -->
<setting name="aggressiveLazyLoading" value="false"/>
<!-- 延迟加载的触发方法 -->
<setting name="lazyLoadTriggerMethods" value="equals,hashCode"/>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class OneToOneTest {private SqlSessionFactory sqlSessionFactory;@Beforepublic void prepare() throws IOException {...}@Testpublic void testOne2One() {SqlSession session = sqlSessionFactory.openSession();try {ArticleDao articleDao = session.getMapper(ArticleDao.class);Article article = articleDao.findOne(1);System.out.println("\narticles info:");System.out.println(article);System.out.println("\n延迟加载 author 字段：");// 通过 getter 方法触发延迟加载Author author = article.getAuthor();System.out.println("\narticles info:");System.out.println(article);System.out.println("\nauthor info:");System.out.println(author);} finally {session.close();}}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// -☆- JavassistProxyFactory
public Object invoke(Object enhanced, Method method, Method methodProxy, Object[] args) throws Throwable {final String methodName = method.getName();try {synchronized (lazyLoader) {if (WRITE_REPLACE_METHOD.equals(methodName)) {// 针对 writeReplace 方法的处理逻辑，与延迟加载无关，不分析了} else {if (lazyLoader.size() > 0 && !FINALIZE_METHOD.equals(methodName)) {/** 如果 aggressive 为 true，或触发方法（比如 equals，hashCode 等）被调用，* 则加载所有的所有延迟加载的数据*/if (aggressive || lazyLoadTriggerMethods.contains(methodName)) {lazyLoader.loadAll();} else if (PropertyNamer.isSetter(methodName)) {final String property = PropertyNamer.methodToProperty(methodName);// 如果使用者显示调用了 setter 方法，则将相应的延迟加载类从 loaderMap 中移除lazyLoader.remove(property);// 检测使用者是否调用 getter 方法} else if (PropertyNamer.isGetter(methodName)) {final String property = PropertyNamer.methodToProperty(methodName);// 检测该属性是否有相应的 LoadPair 对象if (lazyLoader.hasLoader(property)) {// 执行延迟加载逻辑lazyLoader.load(property);}}}}}// 调用被代理类的方法return methodProxy.invoke(enhanced, args);} catch (Throwable t) {throw ExceptionUtil.unwrapThrowable(t);}
}

1
2

<setting name="aggressiveLazyLoading" value="false"/>
<setting name="lazyLoadTriggerMethods" value="equals,hashCode"/>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// -☆- ResultLoaderMap
public boolean load(String property) throws SQLException {// 从 loaderMap 中移除 property 所对应的 LoadPairLoadPair pair = loaderMap.remove(property.toUpperCase(Locale.ENGLISH));if (pair != null) {// 加载结果pair.load();return true;}return false;
}// -☆- LoadPair
public void load() throws SQLException {if (this.metaResultObject == null) {throw new IllegalArgumentException("metaResultObject is null");}if (this.resultLoader == null) {throw new IllegalArgumentException("resultLoader is null");}// 调用重载方法this.load(null);
}public void load(final Object userObject) throws SQLException {/** 若 metaResultObject 和 resultLoader 为 null，则创建相关对象。* 在当前调用情况下，两者均不为 null，条件不成立。篇幅原因，下面代码不分析了*/if (this.metaResultObject == null || this.resultLoader == null) {...}// 线程安全检测if (this.serializationCheck == null) {final ResultLoader old = this.resultLoader;// 重新创建新的 ResultLoader 和 ClosedExecutor，ClosedExecutor 是非线程安全的this.resultLoader = new ResultLoader(old.configuration, new ClosedExecutor(), old.mappedStatement, old.parameterObject, old.targetType, old.cacheKey, old.boundSql);}/** 调用 ResultLoader 的 loadResult 方法加载结果，* 并通过 metaResultObject 设置结果到实体类对象中*/this.metaResultObject.setValue(property, this.resultLoader.loadResult());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public Object loadResult() throws SQLException {// 执行关联查询List<Object> list = selectList();// 抽取结果resultObject = resultExtractor.extractObjectFromList(list, targetType);return resultObject;
}private <E> List<E> selectList() throws SQLException {Executor localExecutor = executor;if (Thread.currentThread().getId() != this.creatorThreadId || localExecutor.isClosed()) {localExecutor = newExecutor();}try {// 通过 Executor 就行查询，这个之前已经分析过了return localExecutor.<E>query(mappedStatement, parameterObject, RowBounds.DEFAULT,Executor.NO_RESULT_HANDLER, cacheKey, boundSql);} finally {if (localExecutor != executor) {localExecutor.close(false);}}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

private void storeObject(ResultHandler<?> resultHandler, DefaultResultContext<Object> resultContext,Object rowValue, ResultMapping parentMapping, ResultSet rs) throws SQLException {if (parentMapping != null) {// 多结果集相关，不分析了linkToParents(rs, parentMapping, rowValue);} else {// 存储结果callResultHandler(resultHandler, resultContext, rowValue);}
}private void callResultHandler(ResultHandler<?> resultHandler, DefaultResultContext<Object> resultContext, Object rowValue) {// 设置结果到 resultContext 中resultContext.nextResultObject(rowValue);// 从 resultContext 获取结果，并存储到 resultHandler 中((ResultHandler<Object>) resultHandler).handleResult(resultContext);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class DefaultResultContext<T> implements ResultContext<T> {private T resultObject;private int resultCount;/** 状态字段 */private boolean stopped;// 省略部分代码@Overridepublic boolean isStopped() {return stopped;}public void nextResultObject(T resultObject) {resultCount++;this.resultObject = resultObject;}@Overridepublic void stop() {this.stopped = true;}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

public class DefaultResultHandler implements ResultHandler<Object> {private final List<Object> list;public DefaultResultHandler() {list = new ArrayList<Object>();}// 省略部分源码@Overridepublic void handleResult(ResultContext<? extends Object> context) {// 添加结果到 list 中list.add(context.getResultObject());}public List<Object> getResultList() {return list;}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// -☆-  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:// ...break;case FLUSH:// ...break;default:throw new BindingException("Unknown execution method for: " + command.getName());}if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {...}return result;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// -☆- DefaultSqlSession
public int insert(String statement, Object parameter) {return update(statement, parameter);
}public int delete(String statement, Object parameter) {return update(statement, parameter);
}public int update(String statement, Object parameter) {try {dirty = true;// 获取 MappedStatementMappedStatement ms = configuration.getMappedStatement(statement);// 调用 Executor 的 update 方法return executor.update(ms, wrapCollection(parameter));} catch (Exception e) {throw ExceptionFactory.wrapException("Error updating database.  Cause: " + e, e);} finally {ErrorContext.instance().reset();}
}

1
2

Result openComment();
Result closeComment();

1

Result updateCommentStatus(Integer status);    // 0 - 关闭，1 - 开启

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// -☆- CachingExecutor
public int update(MappedStatement ms, Object parameterObject) throws SQLException {// 刷新二级缓存flushCacheIfRequired(ms);return delegate.update(ms, parameterObject);
}// -☆- BaseExecutor
public int update(MappedStatement ms, Object parameter) throws SQLException {if (closed) {throw new ExecutorException("Executor was closed.");}// 刷新一级缓存clearLocalCache();return doUpdate(ms, parameter);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// -☆- SimpleExecutor
public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {Statement stmt = null;try {Configuration configuration = ms.getConfiguration();// 创建 StatementHandlerStatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);// 创建 Statementstmt = prepareStatement(handler, ms.getStatementLog());// 调用 StatementHandler 的 update 方法return handler.update(stmt);} finally {closeStatement(stmt);}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// -☆- PreparedStatementHandler
public int update(Statement statement) throws SQLException {PreparedStatement ps = (PreparedStatement) statement;// 执行 SQLps.execute();// 返回受影响行数int rows = ps.getUpdateCount();// 获取用户传入的参数值，参数值类型可能是普通的实体类，也可能是 MapObject parameterObject = boundSql.getParameterObject();KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();// 获取自增主键的值，并将值填入到参数对象中keyGenerator.processAfter(executor, mappedStatement, ps, parameterObject);return rows;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

// -☆- Jdbc3KeyGenerator
public void processBefore(Executor executor, MappedStatement ms, Statement stmt, Object parameter) {// 空方法
}public void processAfter(Executor executor, MappedStatement ms, Statement stmt, Object parameter) {processBatch(ms, stmt, getParameters(parameter));
}public void processBatch(MappedStatement ms, Statement stmt, Collection<Object> parameters) {ResultSet rs = null;try {rs = stmt.getGeneratedKeys();final Configuration configuration = ms.getConfiguration();final TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();// 获取主键字段final String[] keyProperties = ms.getKeyProperties();// 获取结果集 ResultSet 的元数据final ResultSetMetaData rsmd = rs.getMetaData();TypeHandler<?>[] typeHandlers = null;// ResultSet 中数据的列数要大于等于主键的数量if (keyProperties != null && rsmd.getColumnCount() >= keyProperties.length) {// 遍历 parametersfor (Object parameter : parameters) {// 对于批量插入，ResultSet 会返回多行数据if (!rs.next()) {break;}final MetaObject metaParam = configuration.newMetaObject(parameter);if (typeHandlers == null) {// 为每个主键属性获取 TypeHandlertypeHandlers = getTypeHandlers(typeHandlerRegistry, metaParam, keyProperties, rsmd);}// 填充结果到运行时参数中populateKeys(rs, metaParam, keyProperties, typeHandlers);}}} catch (Exception e) {throw new ExecutorException(...);} finally {...}
}private Collection<Object> getParameters(Object parameter) {Collection<Object> parameters = null;if (parameter instanceof Collection) {parameters = (Collection) parameter;} else if (parameter instanceof Map) {Map parameterMap = (Map) parameter;/** 如果 parameter 是 Map 类型，则从其中提取指定 key 对应的值。* 至于 Map 中为什么会出现 collection/list/array 等键。大家* 可以参考 DefaultSqlSession 的 wrapCollection 方法*/if (parameterMap.containsKey("collection")) {parameters = (Collection) parameterMap.get("collection");} else if (parameterMap.containsKey("list")) {parameters = (List) parameterMap.get("list");} else if (parameterMap.containsKey("array")) {parameters = Arrays.asList((Object[]) parameterMap.get("array"));}}if (parameters == null) {parameters = new ArrayList<Object>();// 将普通的对象添加到 parameters 中parameters.add(parameter);}return parameters;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

private void populateKeys(ResultSet rs, MetaObject metaParam, String[] keyProperties, TypeHandler<?>[] typeHandlers) throws SQLException {// 遍历 keyPropertiesfor (int i = 0; i < keyProperties.length; i++) {// 获取主键属性String property = keyProperties[i];TypeHandler<?> th = typeHandlers[i];if (th != null) {// 从 ResultSet 中获取某列的值Object value = th.getResult(rs, i + 1);// 设置结果值到运行时参数中metaParam.setValue(property, value);}}
}

1
2
3
4
5
6
7

public class Author {private Integer id;private String name;private Integer age;private Integer sex;private String email;
}

1
2
3

public interface AuthorDao {int insertMany(List<Author> authors);
}

1
2
3
4
5
6
7
8

<insert id="insertMany" keyProperty="id" useGeneratedKeys="true">INSERT INTOauthor (`name`, `age`, `sex`, `email`)VALUES<foreach item="author" index="index" collection="list" separator=",">(#{author.name}, #{author.age}, #{author.sex}, #{author.email})</foreach>
</insert>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

public class InsertManyTest {private SqlSessionFactory sqlSessionFactory;@Beforepublic void prepare() throws IOException {String resource = "mybatis-insert-many-config.xml";InputStream inputStream = Resources.getResourceAsStream(resource);sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);inputStream.close();}@Testpublic void testInsertMany() {SqlSession session = sqlSessionFactory.openSession();try {List<Author> authors = new ArrayList<>();// 添加多个 Author 对象到 authors 中authors.add(new Author("tianxiaobo-1", 20, 0, "coolblog.xyz@outlook.com"));authors.add(new Author("tianxiaobo-2", 18, 0, "coolblog.xyz@outlook.com"));System.out.println("\nBefore Insert: ");authors.forEach(author -> System.out.println("  " + author));System.out.println();AuthorDao authorDao = session.getMapper(AuthorDao.class);authorDao.insertMany(authors);session.commit();System.out.println("\nAfter Insert: ");authors.forEach(author -> System.out.println("  " + author));} finally {session.close();}}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// -☆-  MapperMethod
private Object rowCountResult(int rowCount) {final Object result;/** 这里的 method 类型为 MethodSignature，即方法签名，包含了某个方法较为详细的信息。* 某个方法指的是 Mapper 或 Dao 接口中的方法，比如上一节示例 AuthorDao 中的* insertMany 方法。*/if (method.returnsVoid()) {// 方法返回类型为 void，则不用返回结果，这里将结果置空result = null;} else if (Integer.class.equals(method.getReturnType()) || Integer.TYPE.equals(method.getReturnType())) {// 方法返回类型为 Integer 或 int，直接赋值返回即可result = rowCount;} else if (Long.class.equals(method.getReturnType()) || Long.TYPE.equals(method.getReturnType())) {// 如果返回值类型为 Long 或者 long，这里强转一下即可result = (long) rowCount;} else if (Boolean.class.equals(method.getReturnType()) || Boolean.TYPE.equals(method.getReturnType())) {// 方法返回类型为布尔类型，若 rowCount > 0，则返回 ture，否则返回 falseresult = rowCount > 0;} else {throw new BindingException(...);}return result;
}