mybatis plugins_MyBatis 源码解析：通过源码深入理解 SQL 的执行过程

1
2
3
4
5
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");	
 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
 SqlSession sqlSession = sqlSessionFactory.openSession();
 LiveCourseMapper mapper = sqlSession.getMapper(LiveCourseMapper.class);	
 List<LiveCourse> liveCourseList = mapper.getLiveCourseList();

1
2
3
4
5
6
public static InputStream getResourceAsStream(ClassLoader loader, String resource) throws IOException {
InputStream in = classLoaderWrapper.getResourceAsStream(resource, loader);
if (in == null) {
  throw new IOException("Could not find resource " + resource);
}
return in;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
InputStream getResourceAsStream(String resource, ClassLoader[] classLoader) {
for (ClassLoader cl : classLoader) {
  if (null != cl) {

    // try to find the resource as passed
    InputStream returnValue = cl.getResourceAsStream(resource);

    // now, some class loaders want this leading "/", so we'll add it and try again if we didn't find the resource
    if (null == returnValue) {
      returnValue = cl.getResourceAsStream("/" + resource);
    }

    if (null != returnValue) {
      return returnValue;
    }
  }
}
return null;

1
2
3
XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
 //解析出configuration对象，并创建SqlSessionFactory
 return build(parser.parse());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
private void parseConfiguration(XNode root) {
try {
  Properties settings = settingsAsPropertiess(root.evalNode("settings"));
  //issue #117 read properties first
  propertiesElement(root.evalNode("properties"));
  loadCustomVfs(settings);
  typeAliasesElement(root.evalNode("typeAliases"));
  pluginElement(root.evalNode("plugins"));
  objectFactoryElement(root.evalNode("objectFactory"));
  objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
  reflectionFactoryElement(root.evalNode("reflectionFactory"));
  settingsElement(settings);
  // read it after objectFactory and objectWrapperFactory issue #631
  environmentsElement(root.evalNode("environments"));
  databaseIdProviderElement(root.evalNode("databaseIdProvider"));
  typeHandlerElement(root.evalNode("typeHandlers"));
  mapperElement(root.evalNode("mappers"));
} catch (Exception e) {
  throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
}
  }

1
private final Map<String, Class<?>> TYPE_ALIASES = new HashMap<String, Class<?>>();

1
2
3
4
private final List<Interceptor> interceptors = new ArrayList<Interceptor>();
public void addInterceptor(Interceptor interceptor) {
    interceptors.add(interceptor);
}

1
private final Map<Type, Map<JdbcType, TypeHandler<?>>> TYPE_HANDLER_MAP = new HashMap<Type, Map<JdbcType, TypeHandler<?>>>();复制代码

1
2
3
4
String type = resultMapNode.getStringAttribute("type",
    resultMapNode.getStringAttribute("ofType",
        resultMapNode.getStringAttribute("resultType",
            resultMapNode.getStringAttribute("javaType"))));

1
resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));

1
2
String nestedResultMap = context.getStringAttribute("resultMap",
    processNestedResultMappings(context, Collections.<ResultMapping> emptyList()));

1
2
3
4
5
6
7
8
9
10
private String processNestedResultMappings(XNode context, List<ResultMapping> resultMappings) throws Exception {
if ("association".equals(context.getName())
    || "collection".equals(context.getName())
    || "case".equals(context.getName())) {
  if (context.getStringAttribute("select") == null) {
    ResultMap resultMap = resultMapElement(context, resultMappings);
    return resultMap.getId();
  }
}
return null;

1
protected final Map<String, ResultMap> resultMaps = new StrictMap<ResultMap>("Result Maps collection");复制代码

1
2
3
public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
return builder.parseScriptNode();

1
2
3
4
5
6
7
8
9
10
11
public SqlSource parseScriptNode() {
    List<SqlNode> contents = parseDynamicTags(context);
    MixedSqlNode rootSqlNode = new MixedSqlNode(contents);
    SqlSource sqlSource = null;
    if (isDynamic) {
      sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
    } else {
      sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
    }
    return sqlSource;
  }

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
List<SqlNode> parseDynamicTags(XNode node) {
    List<SqlNode> contents = new ArrayList<SqlNode>();
    NodeList children = node.getNode().getChildNodes();
    for (int i = 0; i < children.getLength(); i++) {
      XNode child = node.newXNode(children.item(i));
      if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) {
        String data = child.getStringBody("");
        TextSqlNode textSqlNode = new TextSqlNode(data);
        //如果包含${}的话则认为是动态节点
        if (textSqlNode.isDynamic()) {
          contents.add(textSqlNode);
          isDynamic = true;
        } else {
          contents.add(new StaticTextSqlNode(data));
        }
      } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // issue #628
        String nodeName = child.getNode().getNodeName();
        NodeHandler handler = nodeHandlers(nodeName);
        if (handler == null) {
          throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
        }
        handler.handleNode(child, contents);
        isDynamic = true;
      }
    }
    return contents;
  }

1
protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection");复制代码

1
2
3
4
5
6
7
SqlSession sqlSession = sqlSessionFactory.openSession();

final Environment environment = configuration.getEnvironment();
  final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
  tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
  final Executor executor = configuration.newExecutor(tx, execType);
  return new DefaultSqlSession(configuration, executor, autoCommit);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public <T> T getMapper(Class<T> type) {
    return configuration.<T>getMapper(type, this);
  }

  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
  }

  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    if (mapperProxyFactory == null) {
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }

1
2
3
4
5
6
7
8
public T newInstance(SqlSession sqlSession) {
	final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
	return newInstance(mapperProxy);
}

protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

1
2
3
4
5
6
7
8
9
10
11
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    if (Object.class.equals(method.getDeclaringClass())) {
      try {
        return method.invoke(this, args);
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    return mapperMethod.execute(sqlSession, args);
  }

1
2
3
4
//获取MappedStatement，在mapper解析的时候注册到configuration对象中的
MappedStatement ms = configuration.getMappedStatement(statement);
//默认为SimpleExecutor，sql的执行类
return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);

1
2
3
4
5
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
//获取BoundSql，在此处处理if，where，choose动态节点，很重要
BoundSql boundSql = ms.getBoundSql(parameter);
CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
return query(ms, parameter, rowBounds, resultHandler, key, boundSql);

1
2
3
4
5
6
public class BoundSql {
  private String sql;
  private List<ParameterMapping> parameterMappings;
  private Object parameterObject;
  private Map<String, Object> additionalParameters;
  private MetaObject metaParameters;

1
2
3
4
5
6
7
8
9
10
11
12
public BoundSql getBoundSql(Object parameterObject) {
    DynamicContext context = new DynamicContext(configuration, parameterObject);
    rootSqlNode.apply(context);
    SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
    Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
    SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    for (Map.Entry<String, Object> entry : context.getBindings().entrySet()) {
      boundSql.setAdditionalParameter(entry.getKey(), entry.getValue());
    }
    return boundSql;
}

1
2
3
4
5
6
public boolean apply(DynamicContext context) {
    for (SqlNode sqlNode : contents) {
      sqlNode.apply(context);
    }
    return true;
  }

1
2
3
4
5
6
public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
//将#{}替换为?，解析出ParameterMappings
String sql = parser.parse(originalSql);
return new StaticSqlSource(configuration, sql, handler.getParameterMappings());

1
2
3
4
public String handleToken(String content) {
  parameterMappings.add(buildParameterMapping(content));
  return "?";
}

1
2
3
public BoundSql getBoundSql(Object parameterObject) {
  return new BoundSql(configuration, sql, parameterMappings, parameterObject);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public RawSqlSource(Configuration configuration, SqlNode rootSqlNode, Class<?> parameterType) {
    this(configuration, getSql(configuration, rootSqlNode), parameterType);
  }

  public RawSqlSource(Configuration configuration, String sql, Class<?> parameterType) {
    SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
    Class<?> clazz = parameterType == null ? Object.class : parameterType;
    sqlSource = sqlSourceParser.parse(sql, clazz, new HashMap<String, Object>());
  }

  private static String getSql(Configuration configuration, SqlNode rootSqlNode) {
    DynamicContext context = new DynamicContext(configuration, null);
    rootSqlNode.apply(context);
    return context.getSql();
  }


  public BoundSql getBoundSql(Object parameterObject) {
    return sqlSource.getBoundSql(parameterObject);
  }

1
2
3
4
5
Configuration configuration = ms.getConfiguration();
  //创建StatementHandler，默认为PreparedStatementHandler
  StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
  stmt = prepareStatement(handler, ms.getStatementLog());
  return handler.<E>query(stmt, resultHandler);

1
2
3
4
5
6
7
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException { Statement stmt;
Connection connection = getConnection(statementLog);
//设置fetchSize，timeout
stmt = handler.prepare(connection, transaction.getTimeout());
//statement.setParameter sql实际执行参数设置
handler.parameterize(stmt);
return stmt;

1
2
3
public void parameterize(Statement statement) throws SQLException {
   parameterHandler.setParameters((PreparedStatement) statement);
}

1
2
3
4
5
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
  PreparedStatement ps = (PreparedStatement) statement;
  ps.execute();  //sql执行
  return resultSetHandler.<E> handleResultSets(ps); //处理结果集
}

1
2
3
4
5
6
7
8
9
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
private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
  throws SQLException {
DefaultResultContext<Object> resultContext = new DefaultResultContext<Object>();
//处理分页，跳过指定的行，如果rs类型不是TYPE_FORWARD_ONLY，直接absolute，否则的话循环rs.next
skipRows(rsw.getResultSet(), rowBounds);
//循环处理结果集，获取下一行值
while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
  ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);
  //处理行值，重点分析
  Object rowValue = getRowValue(rsw, discriminatedResultMap);
  //保存对象，通过list保存生成的对象Object
  storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap) throws SQLException {
final ResultLoaderMap lazyLoader = new ResultLoaderMap();
Object resultObject = createResultObject(rsw, resultMap, lazyLoader, null);
if (resultObject != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
  final MetaObject metaObject = configuration.newMetaObject(resultObject);
  boolean foundValues = !resultMap.getConstructorResultMappings().isEmpty();
  if (shouldApplyAutomaticMappings(resultMap, false)) {
    foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, null) || foundValues;
  }
  foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, null) || foundValues;
  foundValues = lazyLoader.size() > 0 || foundValues;
  resultObject = foundValues ? resultObject : null;
  return resultObject;
}
return resultObject;

1
2
3
4
//获取属性的值
Object value = getPropertyMappingValue(rsw.getResultSet(), metaObject, propertyMapping, lazyLoader, columnPrefix);
//设置属性的值,通过反射来设置
metaObject.setValue(property, value);

1
2
3
4
5
6
7
8
9
10
11
12
13
private Object getPropertyMappingValue(ResultSet rs, MetaObject metaResultObject, ResultMapping propertyMapping, ResultLoaderMap lazyLoader, String columnPrefix) throws SQLException {
//获取嵌套查询对应的属性值，最终还是通过Executor.query来获取属性值
if (propertyMapping.getNestedQueryId() != null) {
  return getNestedQueryMappingValue(rs, metaResultObject, propertyMapping, lazyLoader, columnPrefix);
} else if (propertyMapping.getResultSet() != null) {
  addPendingChildRelation(rs, metaResultObject, propertyMapping);   // TODO is that OK?
  return DEFERED;
} else {
  final TypeHandler<?> typeHandler = propertyMapping.getTypeHandler();
  final String column = prependPrefix(propertyMapping.getColumn(), columnPrefix);
  //通过typeHandler来获取属性的值，如StringTypeHandler获取属性值：rs.getString(columnName)
  return typeHandler.getResult(rs, column);
}

1
2
3
4
5
6
7
8
9
10
<resultMap id="liveCourseMap" type="com.jd.mybatis.entity.LiveCourse">
		<result column="id" property="id"></result>
		<result column="course_name" property="courseName"></result>
		<!-- 通过嵌套映射来获取关联属性的值 -->
		<collection property="users" ofType="com.jd.mybatis.entity.LiveCourseUser">
			<result column="uid" property="id"></result>
			<result column="user_name" property="userName"></result>
			<result column="id" property="liveCourseId"></result>
		</collection>
</resultMap>

1
select l.id,course_name,u.id uid,u.user_name from jdams_school_live l left join jdams_school_live_users u on l.id = u.live_id where l.yn =1 and l.id = 121 order by course_start_time复制代码

1
2
3
4
5
6
7
8
9
10
//创建rowKey，根据rowKey判断对应创建没创建
final CacheKey rowKey = createRowKey(discriminatedResultMap, rsw, null);
//创建的LiveCourse对象会保存到nestedResultObjects
Object partialObject = nestedResultObjects.get(rowKey);

 rowValue = getRowValue(rsw, discriminatedResultMap, rowKey, null, partialObject);
 //只有是第一次创建LiveCourse时才会进行保存
 if (partialObject == null) {
     storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
    }

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
Object resultObject = partialObject;
//如果已经创建LiveCoure对象
if (resultObject != null) {
  final MetaObject metaObject = configuration.newMetaObject(resultObject);
  putAncestor(resultObject, resultMapId, columnPrefix);
  //不用创建LiveCouse对象，直接处理嵌套映射即可
  applyNestedResultMappings(rsw, resultMap, metaObject, columnPrefix, combinedKey, false);
  ancestorObjects.remove(resultMapId);
} else {
  final ResultLoaderMap lazyLoader = new ResultLoaderMap();
  //创建LiveCoure对象，同简单映射
  resultObject = createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
  if (resultObject != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
    final MetaObject metaObject = configuration.newMetaObject(resultObject);
    boolean foundValues = !resultMap.getConstructorResultMappings().isEmpty();
    //自动映射，同简单映射
    if (shouldApplyAutomaticMappings(resultMap, true)) {
      foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
    }
    //人工映射，同简单映射
    foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
    putAncestor(resultObject, resultMapId, columnPrefix);
    //处理嵌套映射
    foundValues = applyNestedResultMappings(rsw, resultMap, metaObject, columnPrefix, combinedKey, true) || foundValues;
    ancestorObjects.remove(resultMapId);
    foundValues = lazyLoader.size() > 0 || foundValues;
    resultObject = foundValues ? resultObject : null;
  }
  if (combinedKey != CacheKey.NULL_CACHE_KEY) {
    nestedResultObjects.put(combinedKey, resultObject);
  }
}

1
2
3
4
5
6
7
8
9
10
private void linkObjects(MetaObject metaObject, ResultMapping resultMapping, Object rowValue) {
final Object collectionProperty = instantiateCollectionPropertyIfAppropriate(resultMapping, metaObject);
//如果外层对象已经有集合属性值时，直接将创建的对象添加到集合中
if (collectionProperty != null) {
  final MetaObject targetMetaObject = configuration.newMetaObject(collectionProperty);
  targetMetaObject.add(rowValue);
} else {
  //创建集合，然后设置属性值
  metaObject.setValue(resultMapping.getProperty(), rowValue);
}