浅谈MyBatis

已于 2022-06-18 18:26:49 修改
阅读量394 收藏
点赞数
分类专栏： SSM 源码 文章标签： java spring mybatis
于 2022-06-13 18:20:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RookiexiaoMu_a/article/details/125264293
版权
一、MyBatis核心组件：
  • Configuration：用于描述 MyBatis 主配置文件信息，MyBatis 框架在启动时会加载主配置文件，将配置信息转换为
    Configuration 对象。
  • SqlSession：面向用户的 API，是 MyBatis 与数据库交互的接口。
  • Executor：SQL 执行器，用于和数据库交互。SqlSession 可以理解为 Executor 组件的外观(外观模式)，真正执行
    SQL 的是 Executor 组件。
  • MappedStatement：用于描述 SQL 配置信息，MyBatis 框架启动时，XML 文件或者注解配置的 SQL信息会被转换为
    MappedStatement 对象注册到 Configuration 组件中。
  • StatementHandler：封装了对 JDBC 中 Statement 对象的操作，包括为 Statement
    参数占位符设置值，通过 Statement 对象执行 SQL语句。
  • TypeHandler：类型处理器，用于 Java 类型与 JDBC 类型之间的转换。
  • ParameterHandler：用于处理 SQL 中的参数占位符，为参数占位符设置值。
  • ResultSetHandler：封装了对 ResultSet 对象的处理逻辑，将结果集转换为 Java 实体对象。

环境：SpringBoot + mybatis

四大组件：Executor、ParameterHandler、StatementHandler、ResultSetHandler

二、启动时期：

项目启动时会加载MybatisAutoConfiguration类，在这个类中创建了SqlSessionFactory，并且会将XML文件或者注解配置的 SQL信息会被转换为 MappedStatement 对象注册到 Configuration 组件中。

@Bean
  @ConditionalOnMissingBean
  public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
    SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
    factory.setDataSource(dataSource);
    factory.setVfs(SpringBootVFS.class);
    if (StringUtils.hasText(this.properties.getConfigLocation())) {
      factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
    }
    applyConfiguration(factory);
    if (this.properties.getConfigurationProperties() != null) {
      factory.setConfigurationProperties(this.properties.getConfigurationProperties());
    }
    if (!ObjectUtils.isEmpty(this.interceptors)) {
      factory.setPlugins(this.interceptors);
    }
    if (this.databaseIdProvider != null) {
      factory.setDatabaseIdProvider(this.databaseIdProvider);
    }
    if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {
      factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
    }
    if (this.properties.getTypeAliasesSuperType() != null) {
      factory.setTypeAliasesSuperType(this.properties.getTypeAliasesSuperType());
    }
    if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
      factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
    }
    if (!ObjectUtils.isEmpty(this.typeHandlers)) {
      factory.setTypeHandlers(this.typeHandlers);
    }
    // 解析本地xml文件成一个个Resource数组放到factory的mapperLocations中
    // Resource中有xml文件的绝对地址
    if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
      factory.setMapperLocations(this.properties.resolveMapperLocations());
    }
    Set<String> factoryPropertyNames = Stream
        .of(new BeanWrapperImpl(SqlSessionFactoryBean.class).getPropertyDescriptors()).map(PropertyDescriptor::getName)
        .collect(Collectors.toSet());
    Class<? extends LanguageDriver> defaultLanguageDriver = this.properties.getDefaultScriptingLanguageDriver();
    if (factoryPropertyNames.contains("scriptingLanguageDrivers") && !ObjectUtils.isEmpty(this.languageDrivers)) {
      // Need to mybatis-spring 2.0.2+
      factory.setScriptingLanguageDrivers(this.languageDrivers);
      if (defaultLanguageDriver == null && this.languageDrivers.length == 1) {
        defaultLanguageDriver = this.languageDrivers[0].getClass();
      }
    }
    if (factoryPropertyNames.contains("defaultScriptingLanguageDriver")) {
      // Need to mybatis-spring 2.0.2+
      factory.setDefaultScriptingLanguageDriver(defaultLanguageDriver);
    }
	// 接着往下看
    return factory.getObject();
  }

@Override
  public SqlSessionFactory getObject() throws Exception {
    if (this.sqlSessionFactory == null) {
      // 进入到这里
      afterPropertiesSet();
    }

    return this.sqlSessionFactory;
  }

@Override
  public void afterPropertiesSet() throws Exception {
    notNull(dataSource, "Property 'dataSource' is required");
    notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
    state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null),
              "Property 'configuration' and 'configLocation' can not specified with together");
	// 创建SqlSessionFactory，我们进去看看
    this.sqlSessionFactory = buildSqlSessionFactory();
  }

SqlSessionFactoryBean

protected SqlSessionFactory buildSqlSessionFactory() throws IOException {

    Configuration configuration;

    XMLConfigBuilder xmlConfigBuilder = null;
    
    /** .......省略部分代码 */

	// 判断mapperLocations是否不为空，这个值在上文已经设置，里面存储的是一个Resource数组
    if (!isEmpty(this.mapperLocations)) {
      for (Resource mapperLocation : this.mapperLocations) {
        if (mapperLocation == null) {
          continue;
        }

        try {
          XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
              configuration, mapperLocation.toString(), configuration.getSqlFragments());
          // 解析xml配置文件的SQL信息转换为 MappedStatement 对象注册到 Configuration 组件中
          xmlMapperBuilder.parse();
        } catch (Exception e) {
          throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
        } finally {
          ErrorContext.instance().reset();
        }

        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Parsed mapper file: '" + mapperLocation + "'");
        }
      }
    } else {
      if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("Property 'mapperLocations' was not specified or no matching resources found");
      }
    }

    return this.sqlSessionFactoryBuilder.build(configuration);
  }

Configuration组件中的MappedStatements是一个Map类型，key是sql的方法，value是MappedStatement对象，里面包含id，sql语句等等
在这里插入图片描述
在这里插入图片描述

创建完SqlSessionFactory之后创建SqlSessionTemplate

@Bean
    @ConditionalOnMissingBean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        ExecutorType executorType = this.properties.getExecutorType();
        if (executorType != null) {
            return new SqlSessionTemplate(sqlSessionFactory, executorType);
        } else {
        	// 传入sqlSessionFactory
            return new SqlSessionTemplate(sqlSessionFactory);
        }
    }
三、运行时期：

当我们使用到Dao时，由于我们并没有写任何Dao的实现，所以在Spring DI(属性注入)的时候肯定是注入的代理类，调用方法的时候会调用InvocationHandler的invoke方法：

@Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      // 是否是Object
      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);
  }

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

这里我用的是SELECT查询语句，返回的是多个数据，所以我们进入到executeForMany(sqlSession, args)方法

private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
    List<E> result;
    Object param = method.convertArgsToSqlCommandParam(args);
    if (method.hasRowBounds()) {
      RowBounds rowBounds = method.extractRowBounds(args);
      result = sqlSession.<E>selectList(command.getName(), param, rowBounds);
    } else {
      // 真正的查询方法来了，注意看
      result = sqlSession.<E>selectList(command.getName(), param);
    }
    // issue #510 Collections & arrays support
    if (!method.getReturnType().isAssignableFrom(result.getClass())) {
      if (method.getReturnType().isArray()) {
        return convertToArray(result);
      } else {
        return convertToDeclaredCollection(sqlSession.getConfiguration(), result);
      }
    }
    return result;
  }


@Override
  public <E> List<E> selectList(String statement, Object parameter) {
  	// 进去看
    return this.sqlSessionProxy.<E> selectList(statement, parameter);
  }

SqlSessionTemplate.SqlSessionInterceptor

@Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      // 获取Sqlsession
      SqlSession sqlSession = getSqlSession(
          SqlSessionTemplate.this.sqlSessionFactory,
          SqlSessionTemplate.this.executorType,
          SqlSessionTemplate.this.exceptionTranslator);
      try {
      	// 调用方法
        Object result = method.invoke(sqlSession, args);
        if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
          // force commit even on non-dirty sessions because some databases require
          // a commit/rollback before calling close()
          sqlSession.commit(true);
        }
        return result;
      } catch (Throwable t) {
        Throwable unwrapped = unwrapThrowable(t);
        if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
          // release the connection to avoid a deadlock if the translator is no loaded. See issue #22
          closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
          sqlSession = null;
          Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException) unwrapped);
          if (translated != null) {
            unwrapped = translated;
          }
        }
        throw unwrapped;
      } finally {
        if (sqlSession != null) {
          closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
        }
      }
    }

public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {

    notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
    notNull(executorType, NO_EXECUTOR_TYPE_SPECIFIED);
	//从当前线程的threadLocal 中获取sqlSessionHolder
    SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
	//调用静态方法sessionHoler 判断是否存在符合要求的sqlSession
    SqlSession session = sessionHolder(executorType, holder);
    // 判断当前sqlSessionHolder 中是否持有sqlSession (即当前操作是否在事务当中)
    if (session != null) {
      return session;
    }

    if (LOGGER.isDebugEnabled()) {
      LOGGER.debug("Creating a new SqlSession");
    }
	//获取新的sqlSession 对象。这里由sessionFacory产生的defaultSqlSession
    session = sessionFactory.openSession(executorType);
	//判断，当前是否存在事务，将sqlSession 绑定到sqlSessionHolder 中，并放到threadLoacl 当中
    registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);

    return session;
  }

由此可知，SqlSession的创建时机是：如果开启了事务，在一个事务中是共享一个SqlSession的，只有第一次使用的时候会创建，如果没有开启事务，那么每次使用时都创建一个新的SqlSession。

紧接着我们进去看真正的方法调用的地方：

DefaultSqlSession.

@Override
  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 {
      // 根据方法名（类名+方法名）从configuration中的MappedStatements属性获取MappedStatement
      MappedStatement ms = configuration.getMappedStatement(statement);
      // SqlSession中封装了Executor，Executor才是真正的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();
    }
  }

在selectList方法中根据方法名（类名+方法名）从configuration中的MappedStatements属性获取MappedStatement，之前有说到，在MyBatis启动时会创建SqlSessionFactory，同时将所有的xml文件解析成MappedStatement放入configuration组件中。
然后executor调用相应的方法：

Plugin.java

@Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      Set<Method> methods = signatureMap.get(method.getDeclaringClass());
      if (methods != null && methods.contains(method)) {
      	// 进入到这里
        return interceptor.intercept(new Invocation(target, method, args));
      }
      return method.invoke(target, args);
    } catch (Exception e) {
      throw ExceptionUtil.unwrapThrowable(e);
    }
  }

被分页插件拦截

@Override
    public Object intercept(Invocation invocation) throws Throwable {
        try {
            Object[] args = invocation.getArgs();
            MappedStatement ms = (MappedStatement) args[0];
            Object parameter = args[1];
            RowBounds rowBounds = (RowBounds) args[2];
            ResultHandler resultHandler = (ResultHandler) args[3];
            Executor executor = (Executor) invocation.getTarget();
            CacheKey cacheKey;
            BoundSql boundSql;
            //由于逻辑关系，只会进入一次
            if(args.length == 4){
                //4 个参数时
                boundSql = ms.getBoundSql(parameter);
                cacheKey = executor.createCacheKey(ms, parameter, rowBounds, boundSql);
            } else {
                //6 个参数时
                cacheKey = (CacheKey) args[4];
                boundSql = (BoundSql) args[5];
            }
            List resultList;
            //调用方法判断是否需要进行分页，如果不需要，直接返回结果
            if (!dialect.skip(ms, parameter, rowBounds)) {
                //反射获取动态参数
                String msId = ms.getId();
                Configuration configuration = ms.getConfiguration();
                Map<String, Object> additionalParameters = (Map<String, Object>) additionalParametersField.get(boundSql);
                //判断是否需要进行 count 查询
                if (dialect.beforeCount(ms, parameter, rowBounds)) {
                    String countMsId = msId + countSuffix;
                    Long count;
                    //先判断是否存在手写的 count 查询
                    MappedStatement countMs = getExistedMappedStatement(configuration, countMsId);
                    if(countMs != null){
                        count = executeManualCount(executor, countMs, parameter, boundSql, resultHandler);
                    } else {
                        countMs = msCountMap.get(countMsId);
                        //自动创建
                        if (countMs == null) {
                            //根据当前的 ms 创建一个返回值为 Long 类型的 ms
                            countMs = MSUtils.newCountMappedStatement(ms, countMsId);
                            msCountMap.put(countMsId, countMs);
                        }
                        count = executeAutoCount(executor, countMs, parameter, boundSql, rowBounds, resultHandler);
                    }
                    //处理查询总数
                    //返回 true 时继续分页查询，false 时直接返回
                    if (!dialect.afterCount(count, parameter, rowBounds)) {
                        //当查询总数为 0 时，直接返回空的结果
                        return dialect.afterPage(new ArrayList(), parameter, rowBounds);
                    }
                }
                //判断是否需要进行分页查询
                if (dialect.beforePage(ms, parameter, rowBounds)) {
                    //生成分页的缓存 key
                    CacheKey pageKey = cacheKey;
                    //处理参数对象
                    parameter = dialect.processParameterObject(ms, parameter, boundSql, pageKey);
                    //调用方言获取分页 sql
                    String pageSql = dialect.getPageSql(ms, boundSql, parameter, rowBounds, pageKey);
                    BoundSql pageBoundSql = new BoundSql(configuration, pageSql, boundSql.getParameterMappings(), parameter);
                    //设置动态参数
                    for (String key : additionalParameters.keySet()) {
                        pageBoundSql.setAdditionalParameter(key, additionalParameters.get(key));
                    }
                    //执行分页查询
                    resultList = executor.query(ms, parameter, RowBounds.DEFAULT, resultHandler, pageKey, pageBoundSql);
                } else {
                    //不执行分页的情况下，也不执行内存分页
                    resultList = executor.query(ms, parameter, RowBounds.DEFAULT, resultHandler, cacheKey, boundSql);
                }
            } else {
                //rowBounds用参数值，不使用分页插件处理时，仍然支持默认的内存分页
                resultList = executor.query(ms, parameter, rowBounds, resultHandler, cacheKey, boundSql);
            }
            return dialect.afterPage(resultList, parameter, rowBounds);
        } finally {
            dialect.afterAll();
        }
    }

里面很多逻辑，不用管，我们直接看里面的executor.query代码：

CachingExecutor

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

BaseExecutor

@Override
  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++;
      // localCache：MyBatis的一级缓存
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      // list不为空，说明MyBatis的一级缓存中已经有数据
      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是MyBatis的一级缓存，MyBatis的一级缓存是SqlSession级别的，因为Executor是SqlSession的一个属性（在getSqlSession()时），如果缓存中有数据，则直接返回，如果没有则从数据库查询数据。

1、Mybatis一级缓存的生命周期和SqlSession一致。
2、Mybatis的缓存没有更新缓存和缓存过期的概念，同时只是使用了默认的hashmap，也没有做容量上的限定。
3、Mybatis的一级缓存最大范围是SqlSession内部，有多个SqlSession或者分布式的环境下，有操作数据库写的话，会引起脏数据，建议是把一级缓存的默认级别设定为Statement，即不使用一级缓存。

我们进入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);
    }
    // 将新数据添加至缓存,key就是sql语句加上一些其他，例如方法名
    localCache.putObject(key, list);
    if (ms.getStatementType() == StatementType.CALLABLE) {
      localOutputParameterCache.putObject(key, parameter);
    }
    return list;
  }

localCache是BaseExecutor中的一个属性：
在这里插入图片描述
而PerpetualCache里面是一个Map
在这里插入图片描述
key的大概样子【与sql有关】：
在这里插入图片描述
接下来我们进入到doQuery方法看看：
SimpleExecutor

@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
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      // 准备Statement，在方法里获取了Connection对象
      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);
    // 通过连接对象获取Statement 
    stmt = handler.prepare(connection, transaction.getTimeout());
    handler.parameterize(stmt);
    return stmt;
  }

在doQuery方法里面获取了Connection 对象，并且创建了Statement。

接下来我们看一下handler.query(stmt, resultHandler)方法

// RoutingStatementHandler
@Override
  public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    return delegate.<E>query(statement, resultHandler);
  }

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

DefaultResultSetHandler

@Override
  public List<Object> handleResultSets(Statement stmt) throws SQLException {
    ErrorContext.instance().activity("handling results").object(mappedStatement.getId());

    final List<Object> multipleResults = new ArrayList<Object>();

    int resultSetCount = 0;
    ResultSetWrapper rsw = getFirstResultSet(stmt);

    List<ResultMap> resultMaps = mappedStatement.getResultMaps();
    int resultMapCount = resultMaps.size();
    validateResultMapsCount(rsw, resultMapCount);
    while (rsw != null && resultMapCount > resultSetCount) {
      ResultMap resultMap = resultMaps.get(resultSetCount);
      // 处理结果集
      handleResultSet(rsw, resultMap, multipleResults, null);
      rsw = getNextResultSet(stmt);
      cleanUpAfterHandlingResultSet();
      resultSetCount++;
    }

    String[] resultSets = mappedStatement.getResultSets();
    if (resultSets != null) {
      while (rsw != null && resultSetCount < resultSets.length) {
        ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
        if (parentMapping != null) {
          String nestedResultMapId = parentMapping.getNestedResultMapId();
          ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
          handleResultSet(rsw, resultMap, null, parentMapping);
        }
        rsw = getNextResultSet(stmt);
        cleanUpAfterHandlingResultSet();
        resultSetCount++;
      }
    }
	// 返回multipleResults中的数据，数据在handleResultSet方法里面放入的
    return collapseSingleResultList(multipleResults);
  }

DefaultResultSetHandler

private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
    try {
      if (parentMapping != null) {
        handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
      } else {
        if (resultHandler == null) {
          // 创建默认的结果处理器
          DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
          // 处理每一行的数据
          handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
          // 将处理好的数据放入multipleResults中
          multipleResults.add(defaultResultHandler.getResultList());
        } else {
          handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
        }
      }
    } finally {
      // issue #228 (close resultsets)
      closeResultSet(rsw.getResultSet());
    }
  }

相关文章：
MyBatis四大组件：https://blog.csdn.net/csdn_tiger1993/article/details/112417864

https://www.freesion.com/article/14401169270/
SqlSession创建时机：https://www.ucloud.cn/yun/69739.html
MyBatis源码：https://blog.csdn.net/weixin_39687667/article/details/111276301

xiaomu_a
关注
专栏目录
springboot-mybatis-custom-language-driver.zip
12-13
MyBatis自定义 循环查询、IN查询、if动态SQL语句书写方式。 文章参考：https://blog.csdn.net/Zereao/article/details/103527229
Mybatis—LanguageDriver
最新发布
乐只悠悠
11-15 1411
LanguageDriver主要用于构造SqlSource和ParameterHandler，从LanguageDriver在Mybatis中调用链路来看，Configuration#newParameterHandler通过调用LanguageDriver#createParameterHandler完成构建ParameterHandler，通过调用LanguageDriver#createSqlSource来完成构建SqlSource。
MyBatis参数类型Object，且属性中含有List
积累与备忘
07-11 5424
总之一句话，传递多个参数，要么用Map，要么用Bean Mapper接口定义 int batchInsert2(@Param("st1")String st1,@Param("st2")String st2,@Param("st3")String st3, @Param("directions") List directions); int batchInsert1(@Param(
Mybatis - 自定义BaseMapper LanguageDriver（注解方式）
zhuwei_clark的博客
03-03 3198
在使用mybatis的注解的形式的时候我们都希望能封装一些基础的方法。本篇内容就是基于此，本篇内容的源码 源码 如果可以，欢迎点个star BaseMapper如下： /** * 基础base * @param <T> * @param <K> */ public interface BaseMapper<T, K> { /** ...
Mybatis工具—对象工厂（ObjectFactory）
乐只悠悠
09-01 1008
ObjectFactory是一个定义了创建新对象的接口，即如其名称得上是一个对象工厂。Mybatis每次在创建Mapper映射结果对象实例的时候，就会使用ObjectFactory来完成对象实例。
浅谈MyBatis-Plus学习之Oracle的主键Sequence设置的方法
09-07
本文将深入探讨如何在MyBatis-Plus（MP）框架中配置Oracle的主键Sequence。 首先，Oracle Sequence是Oracle数据库提供的一种序列号生成器，它能够按照预设的步长和起始值生成唯一的数字，常用于生成主键值。在创建...
浅谈Mybatis乐观锁插件
08-28
浅谈Mybatis乐观锁插件 Mybatis乐观锁插件是为了解决数据库并发修改问题而设计的插件，该插件可以自动给数据库表添加版本号字段，实现乐观锁机制。下面是相关知识点的详细说明： 1. 背景：在多用户同时访问同一条...
浅谈Mybatis版本升级踩坑及背后原理分析
08-19
浅谈Mybatis版本升级踩坑及背后原理分析 Mybatis版本升级踩坑及背后原理分析是Mybatis开发中的一大难点，因为Mybatis版本的升级可能会导致一些不兼容的变化，从而导致系统出现一些问题。了解Mybatis版本升级踩坑及...
浅谈MyBatis通用Mapper实现原理
08-26
浅谈MyBatis通用Mapper实现原理 MyBatis通用Mapper是MyBatis框架中的一种通用Mapper实现方式，主要提供了一些通用的方法，这些方法是以接口的形式提供的。通用Mapper的实现原理主要是通过Java反射机制和MyBatis框架...
浅谈mybatis 乐观锁实现,解决并发问题
08-24
浅谈MyBatis乐观锁实现，解决并发问题 MyBatis乐观锁是一种解决并发问题的机制，在高并发的业务场景中，乐观锁可以避免数据的并发修改。下面将深入探讨MyBatis乐观锁的实现机制和示例代码。 一、什么是乐观锁？ ...
《Mybatis源码》第14章 LanguageDriver
迦南学院
11-25 1014
总结 LanguageDriver借助XMLScriptBuilder解析标签，创建SqlSource XMLScriptBuilder负责解析XML标签，也就是这里负责解析，封装成SqlNode，然后在调用的时候，再根据参数解析，拼接成最后的SQL 引入 在执行器执行query()方法的时候，会直接在MappedStatement里面获取BoundSql @Override public <E> List<E> query(MappedStatement ms, Obj
mybatis+mybatisplus源码学习（十二）XMLLanguageDriver
码易的博客
07-07 712
目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 XMLLanguageDriver用于对sql脚本进行解析，解析各种标签。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ （1） @Override public SqlSource createSqlSource(Configuration configuration, String script, Class<?> parameterType) { // issue ..
mybatis源码篇（四）—— objectFactory、mappers标签解析
zhoushimiao1990的博客
09-04 850
我们之前在mybatis中添加了mappers配置，但是没有添加过objectFactory配置： <mappers> <mapper resource="cn/zsm/mybatis/man/ManMapper.xml"/> <mapper resource="cn/zsm/mybatis/student/StudentM...
MyBatis基础知识
CyrilのJava世界
05-15 340
1、简介 1.1、什么是 MyBatis？ MyBatis 是一款优秀的持久层框架 它支持自定义 SQL、存储过程以及高级映射。 MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。 MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。 MyBatis本是apache的一个开源项目iBatis，2010年这个项目由apache software
mybatis之XMLLanguageDriver使用方式例子
lhever_的博客
08-15 8386
mybatis中的XMLLanguageDriver类出现的一大原因在于:使用注解配置sql语句没有使用xml的方式灵活和强大，为了弥补这种缺陷，XMLLanguageDriver出现了。下面只是简单的举个例子，贴点代码，不多做解释。因为对于使用过mybatis的人，一看就明白。SimpleSelectInLangDriverpackage com.core.mybatis.languageDriv
MyBatis 源码学习4——Mybatis核心组件(下）
qq_39172525的博客
05-07 325
五、MappedStatement MappedStatement：描述<select|update|insert|delete>或者@Select、@Update等注解配置的SQL信息。 <select>标签中的常用属性： id：命名空间中唯一的标识符，可以被用来引用这条配置信息。 parameterType：用于指定这条语句的参数类的完全限定名或别名。MyBatis能...
Mybatis的if test字符串比较问题(报NumberFormatException异常)
weixin_45818787的博客
02-16 1677
No.1 <if test="isFlag=='Y'"> and msg.expire_time &lt; now() </if> 会报NumberFormatException异常，这样就可以了。 <if test="isFlag=='Y'.toString()"> and msg.expire_time &lt; now() </if> No.2 <if test=" name=='hellworld' "> <if&
修改Mybatis-Plus源码利用反射支持Seata代理数据源
qq_35721287的博客
12-10 1419
准备工作 1.拉取mybatisplus项目源码 开始 1.阅读mp的启动类源码 /* * Copyright (c) 2011-2020, baomidou (jobob@qq.com). * <p> * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use...
MyBatis 源码学习10——动态SQL实现原理（上）
qq_39172525的博客
05-11 798
一、动态SQL的使用 动态SQL：事先无法预知具体的条件，需要在运行时根据具体的情况动态地生成SQL语句。 使用MyBatis动态SQL进行条件查询的一个案例： MyBatis动态SQL相关的标签： • <if>:通过OGNL表达式判断参数内容是否为空，如果表达式结果为true，则MyBatis框架会自动拼接标签内的SQL内容，否则会对标签内的SQL片段进行忽略 • <where>:用于保证至少有一个查询条件时，才会在SQL语句中追加WHERE关键字，同时能够剔除WHERE关键字后
"深入浅出MyBatis从入门到精通
该讲义共分为五大部分，从MyBatis的概述、入门程序、使用MyBatis完成CRUD操作、MyBatis核心配置文件详解以及手写MyBatis框架等多个方面对MyBatis进行了全面而深入的介绍。 在第一部分中，讲义对MyBatis框架进行了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值