Mybatis持久化框架源码阅读3-mapper接口方式

在Mybatis中还有一些配置和参数需要了解：

ExecutorType有三种模式:

• SIMPLE(简单): 对应执行器SimpleExecutor
  SimpleExecutor是每次都会关闭statement，意味着下一次使用需要重新开启statement。如果for循环插入最优是50-100条数据执行一个批次,越多反而越慢,因为PreparedStatement重复预处理，

• REUSE(复用): 对应执行器ReuseExecutor
  ReuseExecutor不会关闭statement，而是把statement放到缓存中。缓存的key为sql语句，value即为对应的statement。也就是说不会每一次调用都去创建一个 Statement 对象，而是会重复利用以前创建好的（如果SQL相同的话），这也就是在很多数据连接池库中常见的 PSCache 概念 。

• BATCH(批量): 对应执行器BatchExecutor
  BatchExecutor中的doupdate并不会想前面两者那样执行返回行数，而是每次执行将statement预存到有序集合，官方说明这个executor是用于执行存储过程的和批量操作的，因此这个方法是循环或者多次执行构建一个存储过程或批处理过程。

SimpleExecutor 是一种常规执行器，每次执行都会创建一个statement，用完后关闭。
ReuseExecutor 是可重用执行器，将statement存入map中，操作map中的statement而不会重复创建statement。
BatchExecutor 是批处理型执行器，doUpdate预处理存储过程或批处理操作，doQuery提交并执行过程。

BatchExecutor Mysql需要在连接字符串开启配置&rewriteBatchedStatements=true

使用方式1.配置文件中修改为Batch

mybatis:
  executor-type: batch

使用方式2.方法中指定，事务失效，要手动提交和回滚

@Autowired
protected SqlSessionFactory sqlSessionFactory;
    
public void saveOrder(Order t) {
  SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
  OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
  
  try{
   orderMapper.save(t);
   sqlSession.commit();
  }catch(Exception e){
   logger.error("批量导入数据异常，事务回滚", e);
   sqlSession.rollback();
  }finally {
   if (sqlSession != null) {
      sqlSession.close();
   }
}

StatementType三中模式:

• STATEMENT:mybatis使用jdbc的Statement编译语句

• PREPARED: mbatis使用jdbc的PreparedStatement编译语句,使用?占位

• CALLABLE: mybatis使用jdbc的CallableStatement编译语句,存储过程

StatementHandler:

configuration.newStatementHandler()方法内部进行创建
在Executor进行数据查询时,会根据MappedStatement中StatementType生成对应的StatementHandler处理器(实现类RoutingStatementHandler). 

RoutingStatementHandler

在实例化时,父类BaseStatementHandler中会初始化parameterHandler和resultSetHandler
parameterHandler: 默认从XMLLanguageDriver中生成一个DefaultParameterHandler参数处理器,参数的设置是executor执行prepareStatement()方法时在在StatementHandler.setParameters()
resultSetHandler: DefaultResultSetHandler默认结果处理器

Mapper的初始化和获取

@MapperScan

启动类上使用@MapperScan("com.xxx")注解

• 注解上有@Import(MapperScannerRegistrar.class),会注册一个MapperScannerConfigurer.class的BeanDefinition.指定扫描出来的bean是MapperFactoryBean.class

• MapperScannerConfigurer是一个BeanDefinitionRegitryPostProcessor,在扫描到所有BeanDefinitiion后执行postProcessBeanDefinitionRegistry(),使用ClassPathMapperScanner扫描器进行扫描,把扫描出来的bean声明为MapperFactoryBean并赋予sqlSessionFactory,sqlSessionTemplate.

• 在MapperFactoryBean父类DaoSupport 的bean的生命周期回调afterPropertiesSet()方法的时候,会进行checkDaoConfig();把当前代理对象添加到configuration.mapperRegistry中.

• 使用时:在MapperFactoryBean进行实例化时调用getObject()方法. 从sqlsession中获取

public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {

  /**
   * {@inheritDoc}
   *
   * @deprecated Since 2.0.2, this method not used never.
   */
  @Override
  @Deprecated
  public void setResourceLoader(ResourceLoader resourceLoader) {
    // NOP
  }

  /**
   * {@inheritDoc}
   */
  /**
   * 方法实现说明:spring ioc在解析我们的住配置类的时候,会解析@MapperScann注解,然后 调用registerBeanDefinitions方法来进行注册我们的bean定义信息
   * 
   * @author:xsls
   * @param importingClassMetadata
   *          :主配置类的信息(包含了class信息)
   * @param registry
   *          bean定义注册器
   * @return:
   * @exception:
   * @date:2019/8/20 22:13
   */
  @Override
  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

    /**
     * 从我们传入的配置类中来解析@MapperScan注解信息,然后吧MapperScan注解的属性转化为 AnnotationAttributes类型(Map类型)
     */
    AnnotationAttributes mapperScanAttrs = AnnotationAttributes
        .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
    /**
     * 若上一步解析出来的mapperScanAttrs不为空(说明配置类上加了@MapperScan注解)
     */
    if (mapperScanAttrs != null) {
      /**
       * 调用重写的方法registerBeanDefinitions generateBaseBeanName(importingClassMetadata, 0) 我们即将注册的bean定义的名称
       * com.liutx.config.MyBatisConfig#MapperScannerRegistrar#0
       */
      registerBeanDefinitions(mapperScanAttrs, registry, generateBaseBeanName(importingClassMetadata, 0));
    }
  }

  void registerBeanDefinitions(AnnotationAttributes annoAttrs, BeanDefinitionRegistry registry, String beanName) {

    /**
     * 创建bean定义构造器 通过够构造器来构建出我们的bean定义<MapperScannerConfigurer> 应用到的设计模式[建造者模式]
     */
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);

    /**
     * 手动为我们MapperScannerConfigurer 开启processPropertyPlaceHolders属性为true 我们需要着重研究下MapperScannerConfigurer类的继承结构
     */
    builder.addPropertyValue("processPropertyPlaceHolders", true);

    /**
     * 为我们的MapperScannerConfigurer 解析我们@MapperScanner 指定扫描的的注解类型
     */
    Class<? extends Annotation> annotationClass = annoAttrs.getClass("annotationClass");
    if (!Annotation.class.equals(annotationClass)) {
      builder.addPropertyValue("annotationClass", annotationClass);
    }

    /**
     * 是否配置了标记接口
     */
    Class<?> markerInterface = annoAttrs.getClass("markerInterface");
    if (!Class.class.equals(markerInterface)) {
      builder.addPropertyValue("markerInterface", markerInterface);
    }

    /**
     * 设置MapperScannerConfigurer的beanName 生成器对象
     */
    Class<? extends BeanNameGenerator> generatorClass = annoAttrs.getClass("nameGenerator");
    if (!BeanNameGenerator.class.equals(generatorClass)) {
      builder.addPropertyValue("nameGenerator", BeanUtils.instantiateClass(generatorClass));
    }

    /**
     * 解析@MapperScan注解属性MapperFactoryBean 设置到MapperScannerConfigurer 声明一个自定义的MapperFactoryBean 返回一个代理对象
     */
    Class<? extends MapperFactoryBean> mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
    if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
      builder.addPropertyValue("mapperFactoryBeanClass", mapperFactoryBeanClass);
    }

    /**
     * 解析@MapperScan 的sqlSessionTemplateRef到底使用是哪个sqlSessionTemplate 设置到MapperScannerConfigurer 多数据源的情况下需要指定
     */
    String sqlSessionTemplateRef = annoAttrs.getString("sqlSessionTemplateRef");
    if (StringUtils.hasText(sqlSessionTemplateRef)) {
      builder.addPropertyValue("sqlSessionTemplateBeanName", annoAttrs.getString("sqlSessionTemplateRef"));
    }

    /**
     * 解析@MapperScan的sqlSessionFactoryRef属性 设置到 MapperScannerConfigurer 多数据情况下的话 ，需要指定使用哪个 sqlSessionFactory
     */
    String sqlSessionFactoryRef = annoAttrs.getString("sqlSessionFactoryRef");
    if (StringUtils.hasText(sqlSessionFactoryRef)) {
      builder.addPropertyValue("sqlSessionFactoryBeanName", annoAttrs.getString("sqlSessionFactoryRef"));
    }

    /**
     * 解析@MapperScan 扫描的的包或者是class对象
     */
    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()));

    /**
     * 指定MapperScannerConfigurer 是否为懒加载
     */
    String lazyInitialization = annoAttrs.getString("lazyInitialization");
    if (StringUtils.hasText(lazyInitialization)) {
      builder.addPropertyValue("lazyInitialization", lazyInitialization);
    }

    builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(basePackages));

    /**
     * 为我们的容器中注册了MapperScannerConfigurer的接口
     */
    registry.registerBeanDefinition(beanName, builder.getBeanDefinition());

  }

  /**
   * 方法实现说明:生成我们bean定义的名称
   * 
   * @author:xsls
   * @param importingClassMetadata
   *          传入的配置类
   * @param index
   *          默认传入0
   * @return: com.liutx.config.MyBatisConfig#MapperScannerRegistrar#0
   * @exception:
   * @date:2019/8/20 22:29
   */
  private static String generateBaseBeanName(AnnotationMetadata importingClassMetadata, int index) {
    return importingClassMetadata.getClassName() + "#" + MapperScannerRegistrar.class.getSimpleName() + "#" + index;
  }

  /**
   * A {@link MapperScannerRegistrar} for {@link MapperScans}.
   *
   * @since 2.0.0
   */
  static class RepeatingRegistrar extends MapperScannerRegistrar {
    /**
     * {@inheritDoc}
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
      AnnotationAttributes mapperScansAttrs = AnnotationAttributes
          .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScans.class.getName()));
      if (mapperScansAttrs != null) {
        AnnotationAttributes[] annotations = mapperScansAttrs.getAnnotationArray("value");
        for (int i = 0; i < annotations.length; i++) {
          registerBeanDefinitions(annotations[i], registry, generateBaseBeanName(importingClassMetadata, i));
        }
      }
    }
  }

}

@Mapper

在使用mybatis-spring-boot-starter依赖后，自动会依赖mybatis-spring-boot-autoconfig,该架包使用SPI方式，在spring.factories中增加自动配置类。

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.mybatis.spring.boot.autoconfigure.MybatisLanguageDriverAutoConfiguration,\
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration

• MybatisAutoConfiguratioin

  • 若当前IOC没有sqlSessionFactory-bean,sqlSessionTemplate-bean,会分别创建一个

  • 如果当前IOC没有MapperFactory-bean,MapperScannerCofnigurer-bean,则会导入AutoConfigurationMapperScannerRegistrar

• AutoConfigurationMapperScannerRegistrar

  • 其通过registerBeanDefinitions()方法，向IOC注入一个MapperScannerConfigurer.class的beanDifinition.

• MapperScannerConfigurer

  • 其通过postProcessBeanDefinitionRegistry()后置处理方法，声明一个ClassPathMapperScanner包扫描类，扫描basePackage，扫描条件为@Mapper注解，扫描结果转为MapperFactoryBean工厂Bean。在要从IOC中getBean()获取接口实例对象的地方，实际调用FactoryBean的getObject()方法去返回实例对象。

至此不需要@MapperScan注解添加@Mapper注解也可以成功获取到Mapper实例

获取Mapper的流程

• Mapper获取与执行流程:
  下面是动态代理类MapperProxy，调用Mapper接口的所有方法都会先调用到这 个代理类的invoke方法（注意由于Mybatis中的Mapper接口没有实现类，所以 MapperProxy这个代理对象中没有委托类，也就是说MapperProxy干了代理类 和委托类的事情）。

• 在MapperProxy.invoke()方法内主要是创建MapperMethod 对象或者是从缓存中获取MapperMethod对象。获取到这个对象后执行execute 方法。 所以这边需要进入MapperMethod的execute方法：这个方法判断你当前执行的 方式是增删改查哪一种，并通过SqlSession执行相应的操作。（这边以 sqlSession.selectOne这种方式进行分析~）

• sqlSessionTemplate会在MapperFactoryBean创建时父类SqlSessionDaoSupport构造方法中创建默认的sqlSessionTemplate. 在SqlSessionTemplate构造方法中创建具体执行的sqlsession代理对象属性叫sqlSessionProxy,JDK代理增强方法是SqlSessionInterceptor().

• SqlSessionTemplate是一个门面模式,包含了select()insert()update()delete()方法,实绩使用sqlSessionProxy对象去执行.

SqlSessionDaoSupport构造方法中创建默认的sqlsessionTemplate,下面是sqlsessionTemplate构造方法：

/**
  * SqlSessionDaoSupport的由来，是因为Mapper生成的MapperFactoryBean继承了SqlSessionDaoSupport
 */
public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {

  private Class<T> mapperInterface;

  private boolean addToConfig = true;

  public MapperFactoryBean() {
    // intentionally empty
  }

  /**
   * 他扫描我们的UserMapper的时候的bean定义是接口类型的，我们知道接口类型是不能够被实例化的 所以在ClassPathMapperScanner扫描之后马上进行来处理UserMapper的bean定义
   * definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName);
   * definition.setBeanClass(this.mapperFactoryBeanClass); 把UserMapper的bean定义给改成我们的MapperFactoryBean,
   * 最终我们实例化UserMapper就是我们的MapperFactoryBean类型,
   * definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName);
   * 就是来指定我们的实例化MapperFactoryBean的构造函数的参数。这么做的目的就是 因为MapperFactoryBean 是我们的Factorybean对象, 最终返回的是getObject()方法放回的对象
   * 而getObject()对象返回的是一个jdk代理对象，我们知道jdk代理对象需要代理接口， 所以这里就是为了保存我们传入进来的接口类型
   *
   * @param mapperInterface
   */
  public MapperFactoryBean(Class<T> mapperInterface) {
    this.mapperInterface = mapperInterface;
  }

}

/**
  * SqlSession接口的实例化对象。由此类调用sqlSessionProxy代理对象的query()触发查询
 */
public class SqlSessionTemplate implements SqlSession, DisposableBean {

  private final SqlSessionFactory sqlSessionFactory;

  private final ExecutorType executorType;

  private final SqlSession sqlSessionProxy;

  private final PersistenceExceptionTranslator exceptionTranslator;

  /**
   * 方法实现说明:mybatis整合spring的时候会调用该方法对sqlSessionTempalte进行赋值
   */
  public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
    /**
     * sqlSessionFactory工厂对象 sqlSessionFactory.getConfiguration().getDefaultExecutorType() sql的默认执行器对象 public enum
     * ExecutorType { SIMPLE, REUSE, BATCH }
     */
    this(sqlSessionFactory, sqlSessionFactory.getConfiguration().getDefaultExecutorType());
  }

  /**
   */
  public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType) {
    this(sqlSessionFactory, executorType,
        new MyBatisExceptionTranslator(sqlSessionFactory.getConfiguration().getEnvironment().getDataSource(), true));
  }

  /**
   * 方法实现说明:真正会调该构造方法进行赋值初始化
   *
   * @author:xsls
   * @param sqlSessionFactory:工厂对象
   * @param executorType:执行器类型
   * @param exceptionTranslator:异常翻译器对象(MyBatisExceptionTranslator)
   */
  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());
  }

  public SqlSessionFactory getSqlSessionFactory() {
    return this.sqlSessionFactory;
  }

  public ExecutorType getExecutorType() {
    return this.executorType;
  }

  public PersistenceExceptionTranslator getPersistenceExceptionTranslator() {
    return this.exceptionTranslator;
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public <T> T selectOne(String statement) {
    return this.sqlSessionProxy.selectOne(statement);
  }

  /**
   * {@inheritDoc}
   */
  /**
   * 方法实现说明:sqlSessionTemplate调用查询单个
   * 
   */
  @Override
  public <T> T selectOne(String statement, Object parameter) {
    /**
     * 因为在sqlSessionTemplate中的属性 sqlSessionproxy是sqlSession一个代理对象，所以会调用代理对象 SqlSessionInterceptor.invoke方法
     */
    return this.sqlSessionProxy.selectOne(statement, parameter);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public <K, V> Map<K, V> selectMap(String statement, String mapKey) {
    return this.sqlSessionProxy.selectMap(statement, mapKey);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey) {
    return this.sqlSessionProxy.selectMap(statement, parameter, mapKey);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds) {
    return this.sqlSessionProxy.selectMap(statement, parameter, mapKey, rowBounds);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public <E> List<E> selectList(String statement) {
    return this.sqlSessionProxy.selectList(statement);
  }

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

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

  /**
   * {@inheritDoc}
   */
  @Override
  public void select(String statement, ResultHandler handler) {
    this.sqlSessionProxy.select(statement, handler);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public void select(String statement, Object parameter, ResultHandler handler) {
    this.sqlSessionProxy.select(statement, parameter, handler);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
    this.sqlSessionProxy.select(statement, parameter, rowBounds, handler);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public int insert(String statement) {
    return this.sqlSessionProxy.insert(statement);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public int insert(String statement, Object parameter) {
    return this.sqlSessionProxy.insert(statement, parameter);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public int update(String statement) {
    return this.sqlSessionProxy.update(statement);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public int update(String statement, Object parameter) {
    return this.sqlSessionProxy.update(statement, parameter);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public int delete(String statement) {
    return this.sqlSessionProxy.delete(statement);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public int delete(String statement, Object parameter) {
    return this.sqlSessionProxy.delete(statement, parameter);
  }

  /**
   * 方法实现说明:通过SqlSessionTeplate获取我们的this.sqlSessionFactory.getConfiguration()对象 来获取我们的Mapper对象
   *
   * @author:xsls
   * @param type:mapper接口类型
   * @return: 返回接口Mapper的代理对象
   * @exception:
   * @date:2019/8/22 20:37
   */
  @Override
  public <T> T getMapper(Class<T> type) {
    /**
     * 最终去sqlSessionFactory.Configuration.mapperRegistry去获取我们的Mapper对象
     */
    return getConfiguration().getMapper(type, this);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public void commit() {
    throw new UnsupportedOperationException("Manual commit is not allowed over a Spring managed SqlSession");
  }


  /**
   * {@inheritDoc}
   */
  @Override
  public void rollback() {
    throw new UnsupportedOperationException("Manual rollback is not allowed over a Spring managed SqlSession");
  }


  /**
   * {@inheritDoc}
   */
  @Override
  public void close() {
    throw new UnsupportedOperationException("Manual close is not allowed over a Spring managed SqlSession");
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public void clearCache() {
    this.sqlSessionProxy.clearCache();
  }

  /**
   * {@inheritDoc}
   *
   */
  @Override
  public Configuration getConfiguration() {
    return this.sqlSessionFactory.getConfiguration();
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public Connection getConnection() {
    return this.sqlSessionProxy.getConnection();
  }



  /**
   * Allow gently dispose bean:
   *
   * <pre>
   * {@code
   *
   * <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
   *  <constructor-arg index="0" ref="sqlSessionFactory" />
   * </bean>
   * }
   * </pre>
   *
   * The implementation of {@link DisposableBean} forces spring context to use {@link DisposableBean#destroy()} method
   * instead of {@link SqlSessionTemplate#close()} to shutdown gently.
   *
   * @see SqlSessionTemplate#close()
   * @see "org.springframework.beans.factory.support.DisposableBeanAdapter#inferDestroyMethodIfNecessary(Object, RootBeanDefinition)"
   * @see "org.springframework.beans.factory.support.DisposableBeanAdapter#CLOSE_METHOD_NAME"
   */
  @Override
  public void destroy() {
    // This method forces spring disposer to avoid call of SqlSessionTemplate.close() which gives
    // UnsupportedOperationException
  }

  /**
   * Proxy needed to route MyBatis method calls to the proper SqlSession got from Spring's Transaction Manager It also
   * unwraps exceptions thrown by {@code Method#invoke(Object, Object...)} to pass a {@code PersistenceException} to the
   * {@code PersistenceExceptionTranslator}.
   */
  private class SqlSessionInterceptor implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      /**
       * 尝试从事务的线程变量中获取session,若没有获取到就直接新开一个session， 所以加事务可以缓存我们的sqlSession(也就是我们的SqlSessionTemplate对象)
       */
      SqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,
          SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);
      try {
        /**
         * 调用我们的目标方法代理的就是我们的session接口的方法 因为上一步返回的session是我们DefaultSqlSession对象, 所以在这里直接调用到我们的DefaultSqlSession的方法中
         */
        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()
          /**
           * 提交我们的session
           */
          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
          /**
           * 抛异常 关闭我们的session
           */
          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);
        }
      }
    }
  }

}

在sqlSessionTemplate初始化方法中，会初始化sqlSessionProxy代理对象，在增删改方法上增加代理方法。

/**
   * Proxy needed to route MyBatis method calls to the proper SqlSession got from Spring's Transaction Manager It also
   * 为每个增删改方法都增加代理方法。
   */
private class SqlSessionInterceptor implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      /**
       * 尝试从事务的线程变量中获取session,若没有获取到就直接新开一个session， 所以加事务可以缓存我们的sqlSession(也就是我们的SqlSessionTemplate对象)
       */
      SqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,
          SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);
      try {
        /**
         * 调用我们的目标方法代理的就是我们的session接口的方法 因为上一步返回的session是我们DefaultSqlSession对象, 所以在这里直接调用到我们的DefaultSqlSession的方法中
         */
        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()
          /**
           * 提交我们的session
           */
          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
          /**
           * 抛异常 关闭我们的session
           */
          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);
        }
      }
    }
  }