mybaties核心组件概念

Configuration：用于描述 MyBatis 主配置文件信息，MyBatis 框架在启动时自动配置类中，会加载mapper配置文件，将配置信息转换为 Configuration 对象，然后把该对象传入给sqlSessionFactory供后续使用。

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 实体对象。

mybaties主要逻辑点

mybaties自动配置流程
mybaties mapper接口动态代理注入到spring中流程
sql执行流程

下面就围绕这三掉来分析下mybaties的源码和执行流程

mybaties自动配置流程

mybaties mapper接口动态代理注入到spring中流程

sql执行流程

图中根据执行逻辑分成了三大块。

蓝色部分：通过调用MapperFactoryBean的getObject方法生成mapper对应的动态代理。

红色部分：调用mapper方法的时候，触发对应动态代理拦截对应的方法。

绿色部分：

sqlsession执行一条sql的逻辑。主要先从configration中获取对应的MappedStatement，然后创建

Executor执行器（默认是SimpleExecutor），执行器流程：

获取StatementHandler，先执行jdbc的prepare，
然后用ParameterHandler把mapper方法中传入的参数（对象或者值）解析后设置到Jdbc的statement中。
执行jdbc execute方法，去执行具体的sql。
ResultSetHandler调用handleCursorResultSets方法处理查询返回的结果，主要是进行对象的映射处理。最后把结果再依次返回。

mybaties自动配置流程

配置入口类MybatisAutoConfiguration

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

  @Bean
  @ConditionalOnMissingBean
  public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
    ExecutorType executorType = this.properties.getExecutorType();
    if (executorType != null) {
      return new SqlSessionTemplate(sqlSessionFactory, executorType);
    } else {
      return new SqlSessionTemplate(sqlSessionFactory);
    }
  }

这个类没啥好说的，主要看sqlSessionFactory，它是通过SqlSessionFactoryBean的getObject生成的。

继续看getObject方法，里面主要就是调用了buildSqlSessionFactory方法

protected SqlSessionFactory buildSqlSessionFactory() throws Exception {
        ...省略不关心代码
        for (Resource mapperLocation : this.mapperLocations) {
          if (mapperLocation == null) {
            continue;
          }
          try {
              // 解析mapper对应的xml文件，它会把xml解析成一个个的MappedStatement，即每个查询标签都会被解析成一个MappedStatement
              // 解析完后，会间接存入Configuration中。
            XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
                targetConfiguration, mapperLocation.toString(), targetConfiguration.getSqlFragments());
            xmlMapperBuilder.parse();
          } catch (Exception e) {
            throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
          } finally {
            ErrorContext.instance().reset();
          }
          LOGGER.debug(() -> "Parsed mapper file: '" + mapperLocation + "'");
        }
       ...省略不关心代码
    // 创建sqlSessionFactory类，并把targetConfiguration作为参数
    return this.sqlSessionFactoryBuilder.build(targetConfiguration);
  }

经过此步骤后，mybaties中mapper的解析工作已经完成了，后续就可以通过动态代理拦截方法，去执行sql了。

mybaties mapper接口动态代理注入到spring中流程

MapperScan

@Import(MapperScannerRegistrar.class)
    @Repeatable(MapperScans.class)
    public @interface MapperScan {
}

MapperScannerRegistrar

@Override
  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    AnnotationAttributes mapperScanAttrs = AnnotationAttributes
        .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
    if (mapperScanAttrs != null) {
      registerBeanDefinitions(importingClassMetadata, mapperScanAttrs, registry,
          generateBaseBeanName(importingClassMetadata, 0));
    }
  }
void registerBeanDefinitions(AnnotationMetadata annoMeta, AnnotationAttributes annoAttrs,
      BeanDefinitionRegistry registry, String beanName) {
    // 指定BeanDefinition对应的类，这里是MapperScannerConfigurer，这个类很重要后续会解释
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
    builder.addPropertyValue("processPropertyPlaceHolders", true);
    
    ... 省去不重要代码

    // 设置mapperFactoryBeanClass属性，这个是MapperFactoryBean，最终就是调用它的getObject方法，生成对应mapper的动态代理，
    //，然后注入到spring中的
    Class<? extends MapperFactoryBean> mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
    if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
      builder.addPropertyValue("mapperFactoryBeanClass", mapperFactoryBeanClass);
    }
    // 可以直接定义覆盖默认的sqlSessionTemplateRef
    String sqlSessionTemplateRef = annoAttrs.getString("sqlSessionTemplateRef");
    if (StringUtils.hasText(sqlSessionTemplateRef)) {
      builder.addPropertyValue("sqlSessionTemplateBeanName", annoAttrs.getString("sqlSessionTemplateRef"));
    }
    // 可以直接定义覆盖默认的sqlSessionFactory，比如配置多数据源的时候，可以定义自己的fatory
    String sqlSessionFactoryRef = annoAttrs.getString("sqlSessionFactoryRef");
    if (StringUtils.hasText(sqlSessionFactoryRef)) {
      builder.addPropertyValue("sqlSessionFactoryBeanName", annoAttrs.getString("sqlSessionFactoryRef"));
    }
    // 要扫描的mapper路径，只会把该路径下的mapper注册成动态代理
    List<String> basePackages = new ArrayList<>();
    basePackages.addAll(
        Arrays.stream(annoAttrs.getStringArray("value")).filter(StringUtils::hasText).collect(Collectors.toList()));

    basePackages.addAll(Arrays.stream(annoAttrs.getStringArray("basePackages")).filter(StringUtils::hasText)
        .collect(Collectors.toList()));

    basePackages.addAll(Arrays.stream(annoAttrs.getClassArray("basePackageClasses")).map(ClassUtils::getPackageName)
        .collect(Collectors.toList()));

    if (basePackages.isEmpty()) {
      basePackages.add(getDefaultBasePackage(annoMeta));
    }

    String lazyInitialization = annoAttrs.getString("lazyInitialization");
    if (StringUtils.hasText(lazyInitialization)) {
      builder.addPropertyValue("lazyInitialization", lazyInitialization);
    }

    builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(basePackages));
	// 把MapperScannerConfigurer类生成对应，并且注入到spring容器中
    registry.registerBeanDefinition(beanName, builder.getBeanDefinition());

  }

上面方法会把MapperScannerConfigurer实例化，并且注入到容器中。

MapperScannerConfigurer类创建成功后会调用它的postProcessBeanDefinitionRegistry方法，该方法属于BeanDefinitionRegistryPostProcessor接口，注册了BeanDefinition后，spring会触发该方法，所以再分析该方法。

MapperScannerConfigurer

@Override
  public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    if (this.processPropertyPlaceHolders) {
      processPropertyPlaceHolders();
    }
    // 核心类，主要是扫描指定的mapper路径下所有的mapper接口，然后注入到spring的时候，注入的名字还是接口名
    // 但是注入的实际类替换成了MapperFactoryBean,该类是一个FactoryBean，当调用它的getObject的时候，会生成
    // 对应接口的动态代理
    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
    scanner.setAddToConfig(this.addToConfig);
    scanner.setAnnotationClass(this.annotationClass);
    scanner.setMarkerInterface(this.markerInterface);
    scanner.setSqlSessionFactory(this.sqlSessionFactory);
    scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
    scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
    scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
    scanner.setResourceLoader(this.applicationContext);
    scanner.setBeanNameGenerator(this.nameGenerator);
    // 设置MapperFactoryBean类
    scanner.setMapperFactoryBeanClass(this.mapperFactoryBeanClass);
    if (StringUtils.hasText(lazyInitialization)) {
      scanner.setLazyInitialization(Boolean.valueOf(lazyInitialization));
    }
    scanner.registerFilters();
    // 调用scan，把对应包路径下的所有类，注入到spring容器中
    scanner.scan(
        StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
  }

ClassPathMapperScanner继承了ClassPathBeanDefinitionScanner，该类的san方法可以扫描指定路径下的所有类，并把他们注入到spring容器中。

经过上面这个方法后，指定mapper路径下的所有接口，会以动态代理的方式注入到spring容器中。

sql执行流程

上面分析了动态代理生成的核心类是MapperFactoryBean的getObject方法，这里先分析动态代理生成逻辑

MapperFactoryBean

public T getObject() throws Exception {
    return getSqlSession().getMapper(this.mapperInterface);
  }

会调用到

SqlSessionTemplate

public <T> T getMapper(Class<T> type) {
      // 这里获取Configuration类，然后调用getMapper方法。
    return getConfiguration().getMapper(type, this);
  }

最后会调用到这里，创建动态代理

MapperProxyFactory

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

上面可以看到动态代理拦截方法类是MapperProxy，当执行动态代理对应方法的时候，会先执行该类的拦截方法invoke -> cachedInvoker ，最后调用到的拦截方法是MapperMethod的execute，如下：

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

  private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
    List<E> result;
    Object param = method.convertArgsToSqlCommandParam(args);
    if (method.hasRowBounds()) {
      RowBounds rowBounds = method.extractRowBounds(args);
        // 执行sqlSession的方法，其实这里是sqlSessionTemplate，具体可以看前面传入的参数
      result = sqlSession.selectList(command.getName(), param, rowBounds);
    } else {
      result = sqlSession.selectList(command.getName(), param);
    }
    .....
    return result;
  }

会根据不同的类型来执行不同的处理sql方法，这里以executeForMany为入口分析，调用了sqlSessionTemplate的selectList方法。如下：

SqlSessionTemplate

public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    return this.sqlSessionProxy.selectList(statement, parameter, rowBounds);
  }

sqlSessionProxy是什么东西？

其实这是一个SqlSession的代理类，主要作用是执行具体sql之前先opensession获取一个sqlsession，sql执行完后再closesession。

具体代码如下：

SqlSessionTemplate

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
      PersistenceExceptionTranslator exceptionTranslator) {

    notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
    notNull(executorType, "Property 'executorType' is required");

    this.sqlSessionFactory = sqlSessionFactory;
    this.executorType = executorType;
    this.exceptionTranslator = exceptionTranslator;
      // 创建sqlSession动态代理
    this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),
        new Class[] { SqlSession.class }, new SqlSessionInterceptor());
  }
// 动态代理拦截方法
private class SqlSessionInterceptor implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 先获取sqlsession，里面就是调用了SqlSessionFactory的openSession方法。
      SqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,
          SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);
      try {
          // 调用SqlSession具体的方法
        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) {
            // 收尾工作，管理session
          closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
        }
      }
    }
  }

跟踪的getSqlSession方法，会发现SqlSession的实现类是DefaultSqlSession，它的selectList方法如下

DefaultSqlSession

@Override
  public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
        // 获取xml解析出来的MappedStatement
      MappedStatement ms = configuration.getMappedStatement(statement);
        // 调用执行器的query方法，这里的Executor默认的是SimpleExecutor
      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();
    }
  }

经过一系列调用最终会调用到如下代码

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 configuration = ms.getConfiguration();
        // 创建StatementHandler，默认它的实现类是PreparedStatementHandler，newStatementHandler方法中
        // 还会调用interceptorChain.pluginAll给StatementHandler设置拦截器配置，这样后续就可以定义StatementHandler
        // 对应的拦截器了。
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      // 最终会执行JDBC中prepare操作
      stmt = prepareStatement(handler, ms.getStatementLog());
        // 执行查询操作
      return handler.query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }
  
  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
      // 最终通过数据源获取一个JDBC连接
    Connection connection = getConnection(statementLog);
      // 最终也会执行JDBC的prepare操作
    stmt = handler.prepare(connection, transaction.getTimeout());
      // 这里的最终会调用到ParameterHandler的setParameters方法，把mapper方法中的参数转换后，传入
      // JDBC的statement中。
    handler.parameterize(stmt);
    return stmt;
  }

继续看query方法，这里的handler是PreparedStatementHandler

如下：

@Override
  public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
      // jdbc具体执行方法
    ps.execute();
      // 调用ResultSethandler进行查询结果数据处理，主要做数据对象映射，然后把处理后的数据返回。
    return resultSetHandler.handleResultSets(ps);
  }

  @Override
  public void parameterize(Statement statement) throws SQLException {
      // 这个就是上面提到的，“把mapper方法中的参数转换后，传入
      // JDBC的statement中”
    parameterHandler.setParameters((PreparedStatement) statement);
  }

彻底看懂springboot mybaties源码流程

mybaties核心组件概念

mybaties主要逻辑点

mybaties自动配置流程

mybaties mapper接口动态代理注入到spring中流程

sql执行流程

继续阅读

聊一聊Swagger-UI的那些事情软件简介Swagger 原生Bootstrap-ui Bootstrap的UIKnife4j Bootstrap的升级版的UI

springboot使用 swagger-ui 2.10.5 有关版本更新带来的问题

Spring Cloud整合Sleuth，当请求完成后，Zipkin没有链路信息

JAVA自学之路——马士兵

Rabbitmq命令行手动创建队列

整合 Spring 开发框架及服务端技术

SSM整合02---Spring-SpringMVC层一、添加web框架支持二、web.xml三、spring-mvc.xml

SSM框架（二）------------表现层的SpringMVC

Intellij idea基于Maven 的SSM 框架整合

微服务-性能压测\缓存redis和分布式锁redisson和SpringCache

Spring数据和Redis

SpringMVC的启动过程源码分析1 SpringMVC 配置XML的方式启动2 SpringMVC纯注解模式启动

Java Spring 框架

java 8 Lamda 求 List 中 Bigdecimal类型的各种值求最大值求最小值求和求平均值

(SpringBoot)日志种类：log、monitor、access、out、gc、backup

SpringCloud微服务（四）之ribbon笔记ribbon是什么？入门案例自定义均衡负载算法