MyBatis 源码

一、准备工作

---

MyBatis 工作流程：应用程序首先加载 mybatis-config.xml 配置文件，并根据配置文件的内容创建 SqlSessionFactory 对象；然后，通过 SqlSessionFactory 对象创建 SqlSession 对象，SqlSession 接口中定义了执行 SQL 语句所需要的各种方法。之后，通过 SqlSession 对象执行映射配置文件中定义的 SQL 语句，完成相应的数据操作。最后通过 SqlSession 对象提交事务，关闭 SqlSession 对象，整个过程具体实现如下：就按照下面的流程进行源码分析

public void test01() throws IOException {
    // 1、获取sqlSessionFactory对象
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
        Employee employee = mapper.getEmpById(1);
        System.out.println(mapper);
        System.out.println(employee);
    } finally {
        openSession.close();
    }

}

二、SqlSessionFactory 对象的初始化过程

---

SqlSessionFactory  对象的初始化序列图如下：

​
【1】 从这行代码入手，首先创建了一个 SqlSessionFactoryBuilder 工厂，这是一个建造者模式的设计思想，由 builder 建造者来创建 SqlSessionFactory 工厂。

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

【2】 然后调用 SqlSessionFactoryBuilder 中的 build方法传递一个InputStream 输入流，Inputstream 输入流就是配置文件 mybatis-config.xml，SqlSessionFactoryBuilder 根据传入的 InputStream 输入流和environment、properties属性创建一个 XMLConfigBuilder对象（解析器）。SqlSessionFactoryBuilder 对象调用 XMLConfigBuilder 的 parse()方法。配置文件中的内容被解析后封装到 Configuration 对象中。同时解析 mapper 标签。返回一个 XPathParser 类型的实例。

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    //创建文件的解析器 XPathParse
    XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
    return build(parser.parse());
} 

//进入上述的内部方法 parser.parse()
public Configuration parse() {
    parsed = true;
    //获取  configuration  标签，全局最大的标签
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
}

//进入上述的内部方法 parseConfiguration(parser.evalNode("/configuration"));
// 此方法中的方法内部都是将解析的标签内容 set 进 configuration 对象中
private void parseConfiguration(XNode root) {
    Properties settings = settingsAsPropertiess(root.evalNode("settings"));
    propertiesElement(root.evalNode("properties"));
        //......
    
    //将 setting 标签中的全局变量都set 到configuration 对象中
    settingsElement(settings);
    
    environmentsElement(root.evalNode("environments"));
    databaseIdProviderElement(root.evalNode("databaseIdProvider"));
    typeHandlerElement(root.evalNode("typeHandlers"));
        
        //解析mapper 标签：很重要
    mapperElement(root.evalNode("mappers"));
}

//列举上述 settingsElement(settings); 内部的源码
private void settingsElement(Properties props) throws Exception {
    configuration.setAutoMappingBehavior(AutoMappingBehavior.valueOf(props.getProperty("autoMappingBehavior", "PARTIAL")));
    
    //false 表示默认值
    configuration.setUseGeneratedKeys(booleanValueOf(props.getProperty("useGeneratedKeys"), false));
    configuration.setDefaultExecutorType(ExecutorType.valueOf(props.getProperty("defaultExecutorType", "SIMPLE")));
    configuration.setDefaultStatementTimeout(integerValueOf(props.getProperty("defaultStatementTimeout"), null));
    //......
}

​

【3】解析 mapper.xml 文件，也是通过 XPathParser 类型的解析器，具体源码如下：将结果保存在 Configuration 中

/**    配置信息如下：
        <mappers>
        <mapper resource="EmployeeMapper.xml" />
    </mappers>
**/
private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
        for (XNode child : parent.getChildren()) {
          String resource = child.getStringAttribute("resource");
          String url = child.getStringAttribute("url");
          String mapperClass = child.getStringAttribute("class");
          if (resource != null && url == null && mapperClass == null) {
            ErrorContext.instance().resource(resource);
                        //将配置文件转化为流文件，mapper.xml 文件
            InputStream inputStream = Resources.getResourceAsStream(resource);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
                        //解析 mapper.xml 文件
            mapperParser.parse();
          }
        }
    }
}

//进入 mapperParser.parse(); 方法
public void parse() {
    if (!configuration.isResourceLoaded(resource)) {
        //解析 mapper标签中的内容
        configurationElement(parser.evalNode("/mapper"));
        configuration.addLoadedResource(resource);
        bindMapperForNamespace();
    }

    parsePendingResultMaps();
    parsePendingChacheRefs();
    parsePendingStatements();
}

//进入 configurationElement(parser.evalNode("/mapper")); 方法
//解析mapper中的标签内容
private void configurationElement(XNode context) {
    String namespace = context.getStringAttribute("namespace");
    builderAssistant.setCurrentNamespace(namespace);
    cacheRefElement(context.evalNode("cache-ref"));
    cacheElement(context.evalNode("cache"));
    parameterMapElement(context.evalNodes("/mapper/parameterMap"));
    resultMapElements(context.evalNodes("/mapper/resultMap"));
    sqlElement(context.evalNodes("/mapper/sql"));
    //解析增删改查标签
    buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
}

【4】解析 mapper 中的增删改查标签：拿到所有标签能写的属性，将详细信息保存进 MappedStatement（是一个Map，Key 存放的是 命令空间+id） 中，一个 MappedStatement 就代表一个增删改查标签的详细信息。

// 进入增删改查标签的源码 buildStatementFromContext
private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
    for (XNode context : list) {
        //获取到 解析增删改查标签的解析器 statementParser
        final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
        //解析标签中的内容
        statementParser.parseStatementNode();
    }
}
public void parseStatementNode() {
    String id = context.getStringAttribute("id");
    String databaseId = context.getStringAttribute("databaseId");

    if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
      return;
    }

    Integer fetchSize = context.getIntAttribute("fetchSize");
    Integer timeout = context.getIntAttribute("timeout");
    String parameterMap = context.getStringAttribute("parameterMap");
    String parameterType = context.getStringAttribute("parameterType");
    //....
    
    //将解析的结果进行封装
    builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
        fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
        resultSetTypeEnum, flushCache, useCache, resultOrdered, 
        keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
    }
}

//进入 builderAssistant.addMappedStatement 方法
public MappedStatement addMappedStatement(
    //......
    MappedStatement statement = statementBuilder.build();
    //并将结果添加到 Configuration 中，MappedStatement 是一个 map 对象
    configuration.addMappedStatement(statement);
    return statement;
}

​

【5】Configuration 对象保存了所有配置文件的详细信息，包括全局配置文件和 sql 映射文件。
​
Configuration  中包含的 MappedStatement 对象信息：
​
Configuration  中包含的 MapperRegistory 对象，其中的 knownMappers 包含的是接口的代理对象。
​

【6】DefaultSqlSessionFactory：传入上面返回的 Configuration 对象，通过 build 的方法创建一个 DefaultSqlSessionFactory 包含配置了全局信息的 Configuration；

public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
}

DefaultSqlSessionFactory : SqlSessionFactory 的默认实现类，是真正生产会话的工厂类，这个类的实例的生命周期是全局的，它只会在首次调用时生成一个实例（单例模式），就一直存在直到服务器关闭。 

三、SqlSession 对象的初始化过程

---

SqlSession 对象的初始化序列图如下：会创建 Executor

​

SqlSession 对象是 MyBatis 中最重要的一个对象，这个接口能够让你执行命令，获取映射，管理事务。SqlSession 中定义了一系列模版方法，让你能够执行简单的 CRUD 操作，也可以通过 getMapper 获取 Mapper 层，执行自定义 SQL 语句，因为 SqlSession 在执行 SQL 语句之前是需要先开启一个会话，涉及到事务操作，所以还会有 commit、 rollback、close 等方法。这也是模版设计模式的一种应用。

【1】通过 DefaultSqlSessionFactory 的 openSession 方法获取 SqlSession；

SqlSession openSession = sqlSessionFactory.openSession();

【2】进入 openSession方法：需要传入 Executor 的类型，在配置文件中可以指定，默认是 simple；

public SqlSession openSession() {
        //configuration.getDefaultExecutorType() 执行器Executor 的默认类型 simple（总共三种类型 reuse、simple、batch）
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}

【3】进入 openSessionFromDataSource 方法：重点是创建了 Executor执行器对象和 SqlSession 对象，传入事务和类型。

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      final Environment environment = configuration.getEnvironment();
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      
      //创建事务
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      
      //四大组件之一 Executor
      final Executor executor = configuration.newExecutor(tx, execType);
      return new DefaultSqlSession(configuration, executor, autoCommit);
    }
}

【4】进入创建 Executor 的方法：configuration.newExecutor(tx, execType); Exeutor 是用来做增删改查的，里面包含了 query等方法；

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    //根据类型创建对应的 Executor
    if (ExecutorType.BATCH == executorType) {
      executor = new BatchExecutor(this, transaction);
    } else if (ExecutorType.REUSE == executorType) {
      executor = new ReuseExecutor(this, transaction);
    } else {
      //默认的 executor 是 SimpleExecutor
      executor = new SimpleExecutor(this, transaction);
    }
    //是否开启的二级缓存，好处是查询之前会先从缓存中获取
    if (cacheEnabled) {
      executor = new CachingExecutor(executor);
    }
        
        //每一个 executor 都需要通过 拦截器进行重新包括（插件使用。。。。重要）
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
}

【5】展示 Executor 对象中的信息：

public interface Executor {
    //增删改查操作
    int update(MappedStatement ms, Object parameter) throws SQLException;
    <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException;
    List<BatchResult> flushStatements() throws SQLException;

    //事务相关操作
    void commit(boolean required) throws SQLException;
    void rollback(boolean required) throws SQLException;
    //......
}

【6】创建 DefaultSqlSession 并将上述创建的 Executor传入，并包含 Configuration;

return new DefaultSqlSession(configuration, executor, autoCommit);

四、getMapper 对象的初始化过程

---

getMapper 对象的初始化序列图如下：  会创建 MapperProxy代理对象；MapperProxy 是 Mapper 映射 SQL 语句的关键对象，我们写的 Dao 层或者 Mapper 层都是通过 MapperProxy来和对应的 SQL语句进行绑定的。下面我们就来解释一下绑定过程。
 ​

【1】通过 getMapper 获取代理对象；

EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);

【2】进入 getMapper 方法内部，发现调用的是 Configuration 对象的 getMapper 方法，并将 SqlSession 作为参数传入；

public <T> T getMapper(Class<T> type) {
    return configuration.<T>getMapper(type, this);
}

【3】进入 Configuration 对象的 getMapper 方法，通过调用 mapperRegistry 对象的 getMapper 方法；

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

【4】进入 MapperRegistry 的 getMapper 方法，根据接口类型获取其代理对象工厂 mapperProxyFactory；

@SuppressWarnings("unchecked")
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    //根据接口类型获取其代理对象
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    // 会创建一个 mapperProxy
    return mapperProxyFactory.newInstance(sqlSession);
}

【5】进入 mapperProxyFactory.newInstance(sqlSession); 方法，其主要是创建 MapperProxy 代理对象；

public T newInstance(SqlSession sqlSession) {
        //获取代理对象
    final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
}

【6】进入 MapperProxy 代理对象，主要包含如下三个属性：并且实现了 InvocationHandler，是JDK 动态代理的一部分；

public class MapperProxy<T> implements InvocationHandler, Serializable {

  private static final long serialVersionUID = -6424540398559729838L;
  //主要包含 sqlSession 、 mapper接口和 其中的方法
  private final SqlSession sqlSession;
  private final Class<T> mapperInterface;
  private final Map<Method, MapperMethod> methodCache;
  //......
}

【7】我们进入 5 中的 newInstance 方法：使用 JDK 实现动态代理 Proxy.newProxyInstance(....)，创建 MapperProxy 代理对象。内部包含 SqlSession 进行增删改查。也就是说，MyBatis 中 Mapper 和 SQL 语句的绑定正是通过动态代理来完成的。通过动态代理，我们就可以方便的在 Dao 层或者 Mapper 层定义接口，实现自定义的增删改查操作了。

@SuppressWarnings("unchecked")
//JDK 动态代理
protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}

【8】代理对象展示：
​

五、通过代理对象调用目标方法的初始化过程

---

mapper.getEmpById(1) 查询执行的序列图如下：
​

【1】进入代理类调用目标方法入口：

Employee employee = mapper.getEmpById(1);

【2】首先会进入代理方法的 invoke 方法：

//调用代理对象的入口
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    //首先判断调用的是不是 Object 对象的方法
    if (Object.class.equals(method.getDeclaringClass())) {
      try {
        return method.invoke(this, args);
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }
    //将当前方法包装成 MapperMethod 
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    return mapperMethod.execute(sqlSession, args);
}

【3】进入  mapperMethod.execute(sqlSession, args); 目标方法执行，传入 sqlSession 和参数；

public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    switch (command.getType()) {
      case INSERT: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.insert(command.getName(), param));
        break;
      }
      case UPDATE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.update(command.getName(), param));
        break;
      }
      case DELETE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.delete(command.getName(), param));
        break;
      }
      case SELECT:
        //当前方法无返回值时执行
        if (method.returnsVoid() && method.hasResultHandler()) {
          executeWithResultHandler(sqlSession, args);
          result = null;
        //返回多个执行方法
        } else if (method.returnsMany()) {
          result = executeForMany(sqlSession, args);
        //返回Map执行
        } else if (method.returnsMap()) {
          result = executeForMap(sqlSession, args);
        //返回游标执行
        } else if (method.returnsCursor()) {
          result = executeForCursor(sqlSession, args);
        } else {
          //其余执行此方法
                  //该方法是将当前参数：如果是1个参数则返回，如果多个则组装成 map 返回
          Object param = method.convertArgsToSqlCommandParam(args);
          result = sqlSession.selectOne(command.getName(), param);
        }
        break;
    return result;
}

【4】调用单个查询 sqlSession.selectOne 方法：调用查询多个的方法，返回 list的第一个元素即可；statement 就是当前sql 的唯一表示，对应 xml 中的 namespace；

public <T> T selectOne(String statement, Object parameter) {
    List<T> list = this.<T>selectList(statement, parameter);
    if (list.size() == 1) {
      return list.get(0);
    } else if (list.size() > 1) {
      throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
    } else {
      return null;
    }
}

​

【5】进入 selectList(statement, parameter); 方法：会获取 mapperedStatement 对象，同时调用 Executor 的query 方法执行

@Override
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      //首先获取 mapperedStatement 对象
      MappedStatement ms = configuration.getMappedStatement(statement);
      //通过 executor 的query 方法执行
      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    }
}

【6】获取 mapperedStatement 通过 BoundSql 它代表 sql 语句的详细信息：通过query 方法进行查询；

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameter);
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

​

【7】进入上述的 query 方法，先调用 cacheExecutor 缓存，如果不存在则调用全局配置 Executor ，我们这里使用的默认 simpleExecutor 方法：先会调用二级缓存，再调用一级缓存；如果不存在则执行 queryFromDatabase 查出以后也会保存在以及缓存中；

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    //先调用本地缓存
    list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
    if (list != null) {
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
    }  else {
        //如果缓存中不存在，则调用 queryFromDatabase
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    return list;
}

【8】进入 queryFromDatabase 方法：调用 BaseExecutor 对象中的 doQuery方法   ms 当前增删改查标签的详细信息

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    try {
      //调用 BaseExecutor对象中的 doQuery方法   ms 当前增删改查标签的详细信息
      list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } 
    return list;
}

【9】进入 SimpleExecutor 对象的 doQuery 方法：底层包含了 Statement 对象，表示对 JDBC 的封装，同时创建了四大对象之一 StatementHandler 作用：创建 Statement 对象；在创建 StatementHandler 的时候构造器里面会同时创建 ParameterHandler和 ResultSetHandler。

public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    //原生 JDBC 的 Statement对象
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
      //创建四个对象之一 StatementHandler
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      //从 StatementHandler 中获取 Statement 对象
      stmt = prepareStatement(handler, ms.getStatementLog());
      return handler.<E>query(stmt, resultHandler);
    } 
}

【10】进入 newStatementHandler 方法，查看 StatementHandler 对象的创建；

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
        //使用拦截器链包装 StatementHandler
    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
    return statementHandler;
}

【11】进入 RoutingStatementHandler 方法：我们可以在查询标签中设置 StatementType 就根据如下方法创建我们需要的 Statement 对象；默认使用的是 PREPARED（预编译的形式），会创建一个 PreparedStatementHandler；

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());
    }
}

【12】通过 StatementHandler 创建 Statement 对象，进入 stmt = prepareStatement(handler, ms.getStatementLog()); 方法：预编译 sql 产生的 PreparedStatement 对象，调用四大对象之一 ParameterHandler 进行参数的预编译；也是 JDBC 原生的对象；

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    //创建一个链接
    Connection connection = getConnection(statementLog);
    //进行预编译
    stmt = handler.prepare(connection, transaction.getTimeout());
    //进行参数预编译
    handler.parameterize(stmt);
    return stmt;
}

【13】进入创建 ParameterHandler 的方法：newParameterHandler(mappedStatement, parameterObject, boundSql); 同时也调用了 pluginAll 方法，通过拦截器链对 ParameterHandler  进行封装；

public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
    ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
    //也调用了拦截器链
    parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
    return parameterHandler;
}

【14】进入创建 ResultSetHandler 的方法：configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql); 同时也调用了 pluginAll 方法，通过拦截器链对 ParameterHandler  进行封装；也输入四大对象之一；用于处理查询得到的数据；

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;
}

【15】最终返回执行的结果和关闭连接，以及查询流程总结：
    ■ StatementHandler：处理 sql语句预编译，设置参数等相关工作；
    ■ ParameterHandler：设置预编译参数用的；
    ■ResultHandler：处理结果集；
    ■TypeHandler：在整个过程中，进行数据库类型和 javaBean类型的映射；

​

六、总结

---

【1】根据配置文件（全局，sql映射）初始化出 Configuration 对象；
【2】创建一个 DefaultSqlSession对象，他里面包含 Configuration以及 Executor（根据全局配置文件中的 defaultExecutorType创建出对应的 Executor）；
【3】DefaultSqlSession.getMapper()：拿到 Mapper接口对应的 MapperProxy；
【4】MapperProxy里面有（DefaultSqlSession）；
【5】执行增删改查方法：
    1）、代理对象调用 DefaultSqlSession 的增删改查（最终调用 Executor 的增删改查）；
    2）、会创建一个 StatementHandler 对象。（同时也会创建出 ParameterHandler 和 ResultSetHandler）
    3）、调用 StatementHandler预编译参数以及设置参数值，使用 ParameterHandler 来给 sql设置参数；
    4）、调用 StatementHandler 的增删改查方法；
    5）、ResultSetHandler 封装结果；
注意：四大对象每个创建的时候都有一个 interceptorChain.pluginAll(parameterHandler);后面的插件应用中使用；

​
----关注公众号，获取更多内容----