Mybatis 执行查询的整个流程

最新推荐文章于 2023-09-05 23:53:40 发布

转载最新推荐文章于 2023-09-05 23:53:40 发布 · 317 阅读

1 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/heweipo/blog/621613

文章标签：

#java #数据库 #python

本文详细介绍了MyBatis框架中实现分页查询的具体过程，包括使用Spring-Mybatis组合进行数据库操作的方法、如何利用DefaultSqlSession进行代理调用、CachingExecutor中缓存的使用策略、BaseExecutor的一级缓存机制、SimpleExecutor执行查询的过程，以及PreparedStatementHandler执行Statement和DefaultResultSetHandler处理结果集等关键步骤。

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

先来一张图，看看整个流程。。。。。

1、使用Spring-Mybatis ， SqlSessionTemplate 进行数据库操作

RowBounds row = new RowBounds(1,10);// 分页参数
List<Map<String, Object>> list = commonRepository.selectList("GradeMapper.getGrade", params,row);


sqlSessionTemplate.selectList(statement, parameter,rowBounds); // 调用代理

2、public class DefaultSqlSession implements SqlSession ，通过代理可以调用默认使用DefaultSqlSession进行数据库操作，真正的操作又是委托给 Executor

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

3、public class CachingExecutor implements Executor ，查询首先要做的就是判断缓存中是否存在，如果有就直接返回，否则就从数据中查询，这里的缓存是二级缓存

@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, parameterObject, boundSql);
      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);
}

4、public abstract class BaseExecutor implements Executor ，这里的缓存是一级缓存

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

6、public class SimpleExecutor extends BaseExecutor 如果缓存中没有数据只能从数据库中获取，数据库获取数据需要如下几步

@Override
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()); // 首先创建Statement，其次赋值Params
    return handler.<E>query(stmt, resultHandler); // 执行数据操作
  } finally {
    closeStatement(stmt); // 关闭数据库连接
  }
}

7、stmt = prepareStatement(handler, ms.getStatementLog()); 创建Statement，其次赋值Params

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
  Statement stmt;
  Connection connection = getConnection(statementLog);// 获取数据库连接
  stmt = handler.prepare(connection); // 创建Statement
  handler.parameterize(stmt); // 赋值Params
  return stmt;
}

1）prepare 设置他的超时以及批量数，以及选择 Statement 的形式

statement = instantiateStatement(connection);
setStatementTimeout(statement);
setFetchSize(statement);
return statement;

2）选择 Statement 形式，可滚动的结果集，mappedStatement.getResultSetType() 就是我们配置<select resultSetType> 属性

@Override
protected Statement instantiateStatement(Connection connection) throws SQLException {
  String sql = boundSql.getSql();
  if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) { // 设置获取主键属性的值
    String[] keyColumnNames = mappedStatement.getKeyColumns();
    if (keyColumnNames == null) {
        return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
      } else {
        return connection.prepareStatement(sql, keyColumnNames);
      }
  } else if (mappedStatement.getResultSetType() != null) { // 如果设置了滚动类型
    return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
  } else { // 默认构建
    return connection.prepareStatement(sql);
  }
}

3）handler.parameterize(stmt) 设置参数，参数设置的重点在于参数类型的获取，也就是 JdbcType 的作用

@Override
public void setParameters(PreparedStatement ps) {
  ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
  List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
  if (parameterMappings != null) {
    for (int i = 0; i < parameterMappings.size(); i++) {
      ParameterMapping parameterMapping = parameterMappings.get(i);
      if (parameterMapping.getMode() != ParameterMode.OUT) {
        Object value;
        String propertyName = parameterMapping.getProperty();
        if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
            value = boundSql.getAdditionalParameter(propertyName);
        } else if (parameterObject == null) {
          value = null;
        } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
          value = parameterObject;
        } else {
          MetaObject metaObject = configuration.newMetaObject(parameterObject);
          value = metaObject.getValue(propertyName);
        }
        TypeHandler typeHandler = parameterMapping.getTypeHandler();
        // 获取jdbcType,一般XML中不需要配置这个参数，系统可以自动匹配
        JdbcType jdbcType = parameterMapping.getJdbcType(); 
        if (value == null && jdbcType == null) {
          jdbcType = configuration.getJdbcTypeForNull();
        }
        try {
          // 这里如果jdbcType=null，那么获取的就是UnknownTypeHandler
          typeHandler.setParameter(ps, i + 1, value, jdbcType);
        } catch (TypeException e) {
            throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
        } catch (SQLException e) {
            throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
        }
      }
    }
  }
}

8、public class PreparedStatementHandler extends BaseStatementHandler 执行 Statement execute

@Override
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
  PreparedStatement ps = (PreparedStatement) statement;
  ps.execute(); // 执行sql语句
  return resultSetHandler.<E> handleResultSets(ps); // 处理结果集
}

9、public class DefaultResultSetHandler implements ResultSetHandler 处理结果集

1）判断是否有嵌套的 ResultMap ，这个也是在 <select resultMap>设置的

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

2）假设没有嵌套的ResultMap ，那么进行结果集遍历，也就是Mybatis的分页

private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
throws SQLException {
  DefaultResultContext<Object> resultContext = new DefaultResultContext<Object>();
  //首先跳过不需要的记录数
  skipRows(rsw.getResultSet(), rowBounds);
  // 滚动结果集，直到 limit
  while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) { 
    ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);
    //获取行中的数据
    Object rowValue = getRowValue(rsw, discriminatedResultMap);
    // 解析值并存储
    storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet()); 
  }
}

3）skipRows(rsw.getResultSet(), rowBounds) 首先跳过不需要的记录数

private void skipRows(ResultSet rs, RowBounds rowBounds) throws SQLException {
if (rs.getType() != ResultSet.TYPE_FORWARD_ONLY) {
    if (rowBounds.getOffset() != RowBounds.NO_ROW_OFFSET) {
      rs.absolute(rowBounds.getOffset());
    }
  } else { 
  // 没有设置滚动类型时默认就是 TYPE_FORWARD_ONLY ，这里就算是这个值，也可以使用 absolute ，为什么不用呢？
    for (int i = 0; i < rowBounds.getOffset(); i++) {
      rs.next();
    }
  }
}

4）shouldProcessMoreRows(resultContext, rowBounds) 是否已经到了Limit

private boolean shouldProcessMoreRows(ResultContext<?> context, RowBounds rowBounds) throws SQLException {
    return !context.isStopped() && context.getResultCount() < rowBounds.getLimit();
}

5）getRowValue(rsw, discriminatedResultMap) 从结果集的每一行中获取数据，同样这里也需要类型转换，ResultMap 中可以配置 JavaType JdbcType 对获取数据类型是有点作用的。

private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap) throws SQLException {
  final ResultLoaderMap lazyLoader = new ResultLoaderMap();
  Object resultObject = createResultObject(rsw, resultMap, lazyLoader, null);
  // 获取类型转换器和以前一样
  if (resultObject != null && !typeHandlerRegistry.hasTypeHandler(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;
}

6）storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet()) 存储数据

private void storeObject(ResultHandler<?> resultHandler, DefaultResultContext<Object> resultContext, Object rowValue, ResultMapping parentMapping, ResultSet rs) throws SQLException {
  if (parentMapping != null) {
    linkToParents(rs, parentMapping, rowValue);
  } else {
    callResultHandler(resultHandler, resultContext, rowValue);
  }

转载于:https://my.oschina.net/heweipo/blog/621613