获取SqlSession对象

SqlSession session = sqlSessionFactory.openSession();

首先通过SqlSessionFactory的openSession方法获取SqlSession接口的实现类DefaultSqlSession对象。

public interface SqlSessionFactory {  SqlSession openSession();  SqlSession openSession(boolean autoCommit);  SqlSession openSession(Connection connection);  SqlSession openSession(TransactionIsolationLevel level);  SqlSession openSession(ExecutorType execType);  SqlSession openSession(ExecutorType execType, boolean autoCommit);  SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);  SqlSession openSession(ExecutorType execType, Connection connection);  Configuration getConfiguration();

}

SqlSessionFactory接口提供一系列重载的openSession方法，其参数如下：

• boolean autoCommit：是否开启JDBC事务的自动提交，默认为false。

• Connection：提供连接。

• TransactionIsolationLevel：定义事务隔离级别。

• ExecutorType：定义执行器类型。

DefaultSqlSessionFactory对象调用覆写的openSession方法：

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

得到一个定义了ExecutorType为configuration的默认执行器SIMPLE,事务隔离级别为null,JDBC事务自动提交为false的DefaultSqlSession对象。

获取MapperProxy代理对象

有了DefaultSqlSession对象，以查询一条数据为例，来看一下整个处理过程。

For example:

SqlSession session = sqlSessionFactory.openSession();try {
  BlogMapper mapper = session.getMapper(BlogMapper.class);
  Blog blog = mapper.selectBlog(101);
} finally {
  session.close();
}

MyBatis时序图:

根据MyBatis文档推荐的方法，调用Mapper接口中的方法实现对数据库的操作，上述例子中根据blog ID获取Blog对象。
通过DefaultSqlSession对象的getMapper方法获取的是一个MapperProxy代理对象，这也是Mapper接口不用实现类的原因。当调用BlogMapper中的方法时，由于BlogMapper是一个JDK动态代理对象，它会运行invoke方法，代码如下：

  @Override
  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);
    }    //生成MapperMethod对象
    final MapperMethod mapperMethod = cachedMapperMethod(method);    //执行execute方法
    return mapperMethod.execute(sqlSession, args);
  }

  private MapperMethod cachedMapperMethod(Method method) {
    MapperMethod mapperMethod = methodCache.get(method);    if (mapperMethod == null) {
      mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
      methodCache.put(method, mapperMethod);
    }    return mapperMethod;
  }
...

invoke方法判断代理的对象是否是一个类，由于代理对象是一个接口，所以通过cachedMapperMethod生成一个MappedMethod对象，然后执行execute方法，execute方法代码如下：

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

因为这里是根据ID查询一个对象，所以最终调用了DefaultSqlSession的selectOne方法，selectOne方法又调用自身selectList方法，最终将查询操作委托给Executor：

@Override
  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.<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;
    }
  }

public <E> List<E> selectList(String statement, Object parameter) {    return this.selectList(statement, parameter, RowBounds.DEFAULT);
  }  @Override
  public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {    try {      //根据id获取MappedStatement对象
      MappedStatement ms = configuration.getMappedStatement(statement);      //wrapCollection方法处理集合参数
      //委托Exector执行SQL
      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执行过程

Executor（执行器），才是真正对JDBC操作的实例，它的结构如下：

CachingExecutor: SqlSession默认会调用CachingExecutor执行器的query方法，先从二级缓存获取数据，当无法从二级缓存获取数据时，则委托给BaseExcutor进行操作，CachingExecutor执行过程代码如下：

 public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {    //判断是否有二级缓存  
    Cache cache = ms.getCache();    if (cache != null) {
      flushCacheIfRequired(ms);      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        @SuppressWarnings("unchecked")        //从二级缓存获取数据
        List<E> list = (List<E>) tcm.getObject(cache, key);        //如果二级缓存没有数据则委托给BaseExcutor进行操作
        if (list == null) {          list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          tcm.putObject(cache, key, list); // issue #578 and #116
        }        return list;
      }
    }    //如果没有二级缓存则委托给BaseExcutor进行操作
    return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

BaseExecutor是一个抽象类，查询操作时BaseExecutor首先从一级缓存获取数据，如果没有则由其子类来进行数据库操作，其query方法如下：

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

最后，我们例子中的查询操作交给了SimpleExecutor这个子类，可以看到SimpleExecutor直接调用了JDBC的代码，最终得到了我们查询的结果，其方法代码如下：

 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.<E>query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }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;
  }

原文出处：https://www.cnblogs.com/abcboy/p/9656302.html