mybatis_sql执行过程源码解析

最新推荐文章于 2024-04-26 06:45:38 发布

weixin_33743703

最新推荐文章于 2024-04-26 06:45:38 发布

阅读量211

点赞数

文章标签： java 数据库 python

原文链接：https://my.oschina.net/grace233/blog/2051310

版权

2019独角兽企业重金招聘Python工程师标准>>>

测试代码

public class MybatisTests {

    SqlSessionFactory factory;

    @Before
    public void loadConfig() {
        try (InputStream inputStream = Resources.getResourceAsStream("mybatis2.xml")) {
            factory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void testInsert2() {
        SqlSession session = factory.openSession();
        User user = session.selectOne("findUserById", 1);
        System.out.println(user);
        session.close();
    }
}

通过跟踪testInsert2()方法去查看mybatis内部的sql执行过程。

获取SqlSession对象

DefaultSqlSessionFactory的重载方法中支持传入autoCommit(是否自动提交)，transactionIsolationLevel(事务隔离级别)，ExecutorType(sql执行器类型：SIMPLE, REUSE, BATCH),Connection 等来创建SqlSession对象。

事务隔离级别:

public enum TransactionIsolationLevel {
  NONE(Connection.TRANSACTION_NONE),
  READ_COMMITTED(Connection.TRANSACTION_READ_COMMITTED),
  READ_UNCOMMITTED(Connection.TRANSACTION_READ_UNCOMMITTED),
  REPEATABLE_READ(Connection.TRANSACTION_REPEATABLE_READ),
  SERIALIZABLE(Connection.TRANSACTION_SERIALIZABLE);
}

进入openSession()方法，实际上执行的方法是factory.openSessionFromDataSource()方法:

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

调用 session.selectOne()方法进行查询

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

继续跟踪，进入的是DefaultSqlSession.selectList()方法:

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

先根据key从Configuration中获取到MappedStatement对象。然后执行excutor.query()方法。

先跟踪wrapCollection(parameter)方法:

private Object wrapCollection(final Object object) {
    if (object instanceof Collection) {
      StrictMap<Object> map = new StrictMap<Object>();
      map.put("collection", object);
      if (object instanceof List) {
        map.put("list", object);
      }
      return map;
    } else if (object != null && object.getClass().isArray()) {
      StrictMap<Object> map = new StrictMap<Object>();
      map.put("array", object);
      return map;
    }
    return object;
}

wrapCollection(parameter)方法就是在处理集合类型的参数:如果Collection对象，就放到一个Map对象中，key为"collection",如果是list对象，key为"list",如果是array对象，key为"array".否则就是原本的对象。(这里也就能理解之前在mapper.xml中传参为集合的时候为什么名称一定要是collectin,list之类的了)。

Executor执行器的操作流程

跟踪excutor.query()方法:（sqlSession委托executor去真正执行数据库的增删改查操作）,这里进入的是CachingExecutor实现类。在创建sqlSession的时候从源码分析中可以知道默认使用的是CachingExecutor实现类。

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

getBoundSql()方法负责构造sql语句和输入参数。

BoundSql对象中已经将sql转为了?形式，并且parameterMappings中放了sql入参的各种属性，parameterObject放的是真正的参数对象。

createCacheKey()方法先略过。

继续跟踪query方法：

@Override
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);
        if (list == null) {
          list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

在这个方法中，先去查询二级缓存，如果二级缓存中没有数据，再进入query方法(委托给BaseExector去继续处理)。

也就是说CachingExecutor只负责处理二级缓存，如果没有二级缓存，则委托给BaseExector处理。

再进去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;
}

localCache这个对象负责的是一级缓存，如果一级缓存中没有数据，就进入queryFromDatabase()方法去数据库中查询。

跟踪queryFromDatabase()方法:

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

这个方法内进行了防止缓存穿透的防范。(先在缓存中存储一个占位符，这个缓存的数据主要是为了在查询的过程中，对外提供缓存数据，以此来保护数据库。)

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

跟踪newStatementHandler()方法，发现这里面其实是在构造PreparedStatementHandler或者StatementHandler对象。

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

跟踪prepareStatement()方法，发现里面就是在构造prepareStatement对象或者Statement对象并为其设置参数。然后后面的query()方法就是直接调用JDBC的代码了。