MyBatis源码分析

要分析MyBatis源码，我们还是从编程式用例入手，

public void testSelect() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        SqlSession session = sqlSessionFactory.openSession(); // ExecutorType.BATCH
        try {
            BlogMapper mapper = session.getMapper(BlogMapper.class);
            Blog blog = mapper.selectBlogById(1);
            System.out.println(blog);
        } finally {
            session.close();
        }
    }

把文件读取成流的这一步我们就省略了。所以下面我们分成四步来分析。
第一步，我们通过建造者模式创建一个工厂类，配置文件的解析就是在这一步完成的，包括mybatis-config.xml和Mapper适配器文件。
问题：解析的时候怎么解析的？做了什么？产生了什么对象？结果存放到哪里？解析的结果决定着我们后面有哪些对象可以使用，和到哪里使用

第二步，通过SqlSessionFactory创建一个SqlSession
问题：SqlSession是用来操作数据库的，返回了什么实现类？除了SqlSession，还创建了什么对象？

第三步，获得一个Mapper对象
问题：Mapper是一个接口，没有实现类，是不能被实例化的，那获取到的这个Mapper对象是什么对象？为什么要从SqlSession里面获取？为什么传进去一个接口，然后还要用接口类型来接收？

第四步， 调用接口方法
问题：我们的接口没有实现类，为什么可以调用它的方法？那它调用的是什么方法？它又是根据什么找到我们要执行的SQL的？也就是接口方法是怎么和xml映射器里面的Statement ID关联起来的？

此外，我们的方法参数是怎么转换成SQL参数的？获取到的结果集是怎么转换成对象的？

带着上面这些问题，接下来就详细分析每一步流程，包括里面有哪些核心的对象和关键的方法。

一、配置解析过程

首先我们要清楚的是配置解析过程只解析两种文件，一个是mybatis-config.xml全局配置文件，另外就是可能会有很多的Mapper.xml文件，也就是包括在Mapper接口类上面的注解。

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

首先我们new了一个SqlSessionFactoryBuilder，非常明显的建造者模式，它里面定义了很多个build方法的重载，最终返回的是SqlSessionFactory对象(单例模式)。我们点进build方法：

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
      return build(parser.parse());
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        inputStream.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
  }

这里面创建了一个 XMLConfigBuilder 对象（Configuration 对象也是这个时候创建的）。XMLConfigBuilder是抽象类BaseBuilder的一个子类，专门用来解析全局配置文件的。针对不同的构造目标，还有其他一些子类，比如：
XMLMapperBuilder: 解析Mapper映射器
XMLStatementBuilder: 解析增删改查标签

根据我们解析的文件流，创建了一个parser。然后调用parser的parser()方法，返回了一个Configuration对象，配置文件中所有的信息都会放在Configuration里面，Configuration类里面有很多的属性，有很多是跟config里面的标签直接对应的。我们先看一下parser方法:

public Configuration parse() {
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }

首先判断是否已经被解析过了，如果已经解析过了，就抛exception。也就是说在应用的生命周期里面，config配置文件只需要解析一次，生成的Configuration对象也会存在应用的整个生命周期中。接下来就是parseConfiguration方法：

private void parseConfiguration(XNode root) {
    try {
      //issue #117 read properties first
      propertiesElement(root.evalNode("properties"));
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(settings);
      loadCustomLogImpl(settings);
      typeAliasesElement(root.evalNode("typeAliases"));
      pluginElement(root.evalNode("plugins"));
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      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);
    }
  }

这个方法中有十几个子方法，对应这config文件里面所有一级标签。这里我们只关注一下mappers一级标签，因为上面我们提到，解析配置文件主要解析两种文件，一种是全局配置文件，第二种就是Mapper.xml，进入mapperElement()方法：

private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        if ("package".equals(child.getName())) {
          String mapperPackage = child.getStringAttribute("name");
          configuration.addMappers(mapperPackage);
        } else {
          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);
            InputStream inputStream = Resources.getResourceAsStream(resource);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url != null && mapperClass == null) {
            ErrorContext.instance().resource(url);
            InputStream inputStream = Resources.getUrlAsStream(url);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url == null && mapperClass != null) {
            Class<?> mapperInterface = Resources.classForName(mapperClass);
            configuration.addMapper(mapperInterface);
          } else {
            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
          }
        }
      }
    }
  }

在这个方法中会新建一个XMLMapperBuilder 对象，并调用parser方法开始解析mapper.xml，里面有两个方法：
configurationElement()—— 解 析 所 有 的 子 标 签 ， 其 中buildStatementFromContext()最终获得MappedStatement对象。
bindMapperForNamespace()——把namespace（接口类型）和工厂类绑定起来。
无论是按 package 扫描，还是按接口扫描，最后都会调用到 MapperRegistry 的addMapper()方法。
MapperRegistry里面维护的其实是一个Map容器，存储接口和代理工厂的映射关系。

public <T> void addMapper(Class<T> type) {
    if (type.isInterface()) {
      if (hasMapper(type)) {
        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
      }
      boolean loadCompleted = false;
      try {
        knownMappers.put(type, new MapperProxyFactory<>(type));
        // It's important that the type is added before the parser is run
        // otherwise the binding may automatically be attempted by the
        // mapper parser. If the type is already known, it won't try.
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
        loadCompleted = true;
      } finally {
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }

除了映射器文件，在这里也会去解析Mapper接口方法上的注解。在addMapper()方法里面创建了一个MapperAnnotationBuilder，我们点进去看一下parse()方法。parseCache() 和 parseCacheRef() 方 法 其 实 是 对 @CacheNamespace 和@CacheNamespaceRef这两个注解的处理。parseStatement()方法里面的各种 getAnnotation()，都是对注解的解析，比如@Options，@SelectKey，@ResultMap等等。最后同样会解析成 MappedStatement 对象，也就是说在 XML 中配置，和使用注解配置，最后起到一样的效果。
配置文件解析完成后会调用build方法返回一个DefaultSqlSessionFactory对象：

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

到这里，配置文件解析完成了。

二、会话创建

我们跟数据库的每一次连接，都需要创建一个会话，我们使用openSession()方法创建。

public SqlSession openSession() {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}

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);
      final Executor executor = configuration.newExecutor(tx, execType);
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
}

这个会话里面，需要包含一个Executor用来执行 SQL。Executor 又要指定事务类型和执行器的类型。所以我们会先从Configuration里面拿到Enviroment，Enviroment里面就有事务工厂。

  1. 创建Transaction
    如果配置的是JDBC，则会使用Connection对象的commit()、rollback()、close()管理事务。
    如果配置成MANAGED，会把事务交给容器来管理，比如JBOSS，Weblogic。因为我们跑的是本地程序，如果配置成MANAGE不会有任何事务。如 果 是 Spring + MyBatis ， 则 没 有 必 要 配 置 ， 因 为 我 们 会 直 接 在applicationContext.xml里面配置数据源和事务管理器，覆盖MyBatis的配置。
  2. 创建Executor
    我们知道， Executor的基本类型有三种： SIMPLE、BATCH、REUSE，默认是SIMPLE (settingsElement()读取默认值)，他们都继承了抽象类BaseExecutor。
    在这里插入图片描述

    问题：三种类型的区别（通过update()方法对比）？
    SimpleExecutor：每执行一次update或select，就开启一个Statement对象，用完立刻关闭Statement对象。
    ReuseExecutor：执行 update 或 select，以 sql 作为 key查找 Statement 对象，存在就使用，不存在就创建，用完后，不关闭 Statement 对象，而是放置于 Map 内，供下一次使用。简言之，就是重复使用Statement对象。
    BatchExecutor：执行 update（没有select，JDBC 批处理不支持 select），将所有 sql 都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个Statement 对象，每个Statement 对象都是 addBatch()完毕后，等待逐一执行executeBatch()批处理。与JDBC批处理相同。

如果在全局配置文件中配置了 cacheEnabled=ture，会用装饰器模式对 executor 进行包装：new CachingExecutor(executor)。

 public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    if (ExecutorType.BATCH == executorType) {
      executor = new BatchExecutor(this, transaction);
    } else if (ExecutorType.REUSE == executorType) {
      executor = new ReuseExecutor(this, transaction);
    } else {
      executor = new SimpleExecutor(this, transaction);
    }
    if (cacheEnabled) {
      executor = new CachingExecutor(executor);
    }
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

包装完毕后，会执行:

executor = (Executor) interceptorChain.pluginAll(executor);

此处对executor进行包装，最终返回DefaultSqlSession，属性包括Configuration、Executor对象。

三、获得Mapper对象

现在我们已经有一个DefaultSqlSession了，必须找到Mapper.xml里面定义的statement ID，才能执行对应的SQL语句。

找到Statement ID有两种方式，一种是直接调用session的方法，在参数里面传入statement ID，这种方式属于硬编码，我们没有办法知道有多少处调用，修改起来也很麻烦。另外一个问题是如果参数传入错误，在编译阶段也不会报错，不利于预先发现问题：

Blog blog = (Blog) session.selectOne("com.gupaoedu.mapper.BlogMapper.selectBlogById ", 1);

所以在MyBatis后期版本提供了第二种方式，就是定义一个接口，然后再调用Mapper接口的方法。
由于我们的接口名称跟Mapper.xml的namespace是对应的，接口的方法跟Statement ID也都是对应的，所以根据方法就能找到对应的要执行的SQL。

BlogMapper mapper = session.getMapper(BlogMapper.class);

在这里我们要主要研究一下Mapper对象是怎么获得的，它的本质是什么？
DefaultSqlSession的getMapper()方法调用了Configuration的getMapper()方法。

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

Configuration的getMapper()方法，又调用了MapRegistry的getMapper()方法

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

我们知道，在解析mapper标签和Mapper.xml的时候已经把接口类型和类型对应的MapperProxyFactory放到一个map中，获取Mapper的代理对象，实际上是从map中获取对应的工厂类后，最终通过JDK动态代理创建的。

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

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

public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
}

思考：JDK的动态代理和MyBatis中用到的JDK动态代理有什么区别？
JDK动态代理：


在这里插入图片描述

JDK动态代理代理，在实现了InvocationHandler的代理类里面，需要传入一个被代理对象的实现类。

MyBatis中的JDK动态代理：


在这里插入图片描述

不需要实现类的原因：我们只需要根据接口类型+方法的名称，就可以找到StatementID了，而唯一要做的一件事情也是这件，所以不需要实现类。 在MapperProxy里面直接执行逻辑（也就是执行SQL）就可以

总结：获得Mapper对象的过程，实质上是获取了一个MapperProxy的代理对象，MapperProxy中有SqlSession、mapperInterface、methodCache。

四、执行SQL

Blog blog = mapper.selectBlogById(1);

由于所有的Mapper都是MapperProxy的代理对象，所以任意的方法都是执行MapperProxy的invoke()方法。
问题1：我们引入MapperProxy为了解决什么问题？硬编码和编译时检查的问题，它需要做的事情时根据方法找到对应的statement ID。
问题2：这里没有实现类，进入到Invoke方法的时候做了什么事情？他是怎么找到我们要执行的SQL的？
我们看一下MapperProxy的invoke方法：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, args);
      } else if (isDefaultMethod(method)) {
        return invokeDefaultMethod(proxy, method, args);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    return mapperMethod.execute(sqlSession, args);
  }

  private MapperMethod cachedMapperMethod(Method method) {
    return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
  }
  1. 首先判断是否要执行SQL还是直接执行方法
    Object本身的方法和Java 8中的默认方法不需要取执行SQL
  2. 获取缓存
    这里加入缓存时为了提升MapperMethod的获取速度
// 获取缓存，保存了方法签名和接口方法的关系 final MapperMethod mapperMethod = cachedMapperMethod(method);

Map 的 computeIfAbsent()方法：只有 key 不存在或者 value 为 null 的时候才调用mappingFunction()。

接下来又调用了mapperMethod.execute()方法，MapperMethod里面主要有两个属性，一个时SqlCommand，一个时MethodSignature，这两个都是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:
        if (method.returnsVoid() && method.hasResultHandler()) {
          executeWithResultHandler(sqlSession, args);
          result = null;
        } else if (method.returnsMany()) {
          result = executeForMany(sqlSession, args);
        } else if (method.returnsMap()) {
          result = executeForMap(sqlSession, args);
        } else if (method.returnsCursor()) {
          result = executeForCursor(sqlSession, args);
        } else {
          Object param = method.convertArgsToSqlCommandParam(args);
          result = sqlSession.selectOne(command.getName(), param);
          if (method.returnsOptional()
              && (result == null || !method.getReturnType().equals(result.getClass()))) {
            result = Optional.ofNullable(result);
          }
        }
        break;
      case FLUSH:
        result = sqlSession.flushStatements();
        break;
      default:
        throw new BindingException("Unknown execution method for: " + command.getName());
    }
    if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
      throw new BindingException("Mapper method '" + command.getName()
          + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
    }
    return result;
  }

我们以查询SQL为例，会走到sqlSession.selectOne()方法，selectOne()最终也是调用了selectList()。

public <T> T selectOne(String statement, Object parameter) {
    // Popular vote was to return null on 0 results and throw exception on too many.
    List<T> list = this.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;
    }
  }

在SelectList()中，我们先根据commandname（StatementID）从Configuration中拿到MappedStatement，这个ms上面有我们在xml中配置的所有属性，包括id、statementType、sqlSource、useCache、入参、出参等等。

public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      MappedStatement ms = configuration.getMappedStatement(statement);
      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

然后执行executor.query()，前面我们说到了Executor有三种基本类型，SIMPLE/REUSE/BATCH，还有一种包装类型，CachingExecutor。
那么在这里到底会选择哪一种执行器呢？我们要回过头去看看DefaultSqlSession 在初始化的时候是怎么赋值的，这个就是我们的会话创建过程。如果启用了二级缓存，就会先调用CachingExecutor 的query()方法，里面有缓存相关的操作，然后才是再调用基本类型的执行器，比如默认的SimpleExecutor。在没有开启二级缓存的情况下，先会走到BaseExecutor的query()方法（否则会先
走到CachingExecutor）。

BaseExecutor.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);
  }
  
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List<E> list;
    try {
      queryStack++;
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      queryStack--;
    }
    if (queryStack == 0) {
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }
  1. 创建cacheKey：从Configuration 中获取MappedStatement， 然后从BoundSql 中获取SQL 信
    息，创建CacheKey。这个CacheKey就是缓存的Key。然后再调用另一个query()方法。
    2）在query方法中，queryStack用于记录查询栈，防止递归查询重复处理缓存。flushCache=true的时候，会先清理本地缓存（一级缓存）：clearLocalCache(); 如果没有缓存，会从数据库查询：queryFromDatabase()，如果LocalCacheScope == STATEMENT，会清理本地缓存。

从数据库查询数据：

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    localCache.putObject(key, EXECUTION_PLACEHOLDER);
    try {
      list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
      localCache.removeObject(key);
    }
    localCache.putObject(key, list);
    if (ms.getStatementType() == StatementType.CALLABLE) {
      localOutputParameterCache.putObject(key, parameter);
    }
    return list;
  }

a)缓存
先在缓存用占位符占位。执行查询后，移除占位符，放入数据。
b)查询
执行Executor的doQuery()；默认是SimpleExecutor

SimpleExecutor.doQuery():

public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      stmt = prepareStatement(handler, ms.getStatementLog());
      return handler.query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }

1）创建StatementHandler
在configuration.newStatementHandler()中，new 一个StatementHandler，先得到RoutingStatementHandler。RoutingStatementHandler 里 面 没 有 任 何 的 实 现 ， 是 用 来 创 建 基 本 的StatementHandler 的。这里会根据 MappedStatement 里面的 statementType 决定
StatementHandler 的 类 型 。 默 认 是 PREPARED （ STATEMENT 、 PREPARED 、
CALLABLE）。

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

StatementHandler 里面包含了处理参数的 ParameterHandler 和处理结果集的ResultSetHandler。
这两个对象都是在上面new的时候创建的。

protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    //省略部分代码
    this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
    this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
  }

这三个对象都是可以被插件拦截的四大对象之一，所以在创建之后都要用拦截器进行包装的方法。

2）创建Statement
用new 出来的StatementHandler创建Statement对象——prepareStatement()方法对语句进行预编译，处理参数。handler.parameterize(stmt) ;

3）执行的StatementHandler的query()方法
RoutingStatementHandler的query()方法。delegate 委派，最终执行PreparedStatementHandler的query()方法

4）执行PreparedStatement的execute()方法
后面就是JDBC包中的PreparedStatement的执行了。

5）ResultSetHandler处理结果集
return resultSetHandler.handleResultSets(ps);

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 194,088评论 5赞 459
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 81,715评论 2赞 371
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 141,361评论 0赞 319
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 52,099评论 1赞 263
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 60,987评论 4赞 355
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 46,063评论 1赞 272
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 36,486评论 3赞 381
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 35,175评论 0赞 253
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 39,440评论 1赞 290
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,518评论 2赞 309
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,305评论 1赞 326
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,190评论 3赞 312
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 37,550评论 3赞 298
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 28,880评论 0赞 17
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,152评论 1赞 250
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 41,451评论 2赞 341
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 40,637评论 2赞 335