Spring整合Mybatis原理

Spring整合Mybatis原理

目录

• Spring整合Mybatis原理
  • 1、@MapperScan注解发挥作用
    • 1.1、导入MapperScannerRegistrar类
      • 1.1.2、执行ImportBeanDefinitionRegistrar接口中的registerBeanDefinitions方法
    • 1.2、ClassPathMapperScanner
      • 1.2.1、对筛选出来的BeanDefinition进行处理
    • 1.3、SqlSessionFactoryBean类结构体系
      • 1.3.1、SqlSessionFactoryBean使用
    • 1.4、SqlSessionTemplate
      • 1.4.1、构造方法
      • 1.4.2、增删改查方法
      • 1.4.3、SqlSessionInterceptor
        • Spring整合Mybatis后为什么一级缓存失效
        • sqlsession的提交和回滚在哪里
        • 流程
  • 三、总结
    • Mybatis-Spring 新版本底层源码执行流程

1、@MapperScan注解发挥作用

在Spring整合Mybatis的时候，只需要一个@MapperScan注解就可以来进行操作，所以更加好奇的是@MapperScan底层是怎么来做到的。

下面先来研究一下@MapperScan：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(MapperScannerRegistrar.class)
@Repeatable(MapperScans.class)
public @interface MapperScan {
  ...
}

@Import注解导入了一个MapperScannerRegistrar。而在Spring启动的时候，会在org.Springframework.context.support.AbstractApplicationContext#refresh方法中会来执行@Import导入的类，看下如何来解析@Import注解的。直接来到org.Springframework.context.annotation.ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForConfigurationClass会来解析@Import注解导入进来的类，那么下面就需要来看一下MapperScannerRegistrar做了什么事情。

1.1、导入MapperScannerRegistrar类

下面来看一下MapperScannerRegistrar的结构体系

1.1.2、执行ImportBeanDefinitionRegistrar接口中的registerBeanDefinitions方法

MapperScannerRegistrar类实现了ImportBeanDefinitionRegistrar接口，而实现了接口中的方法，那么在注册BeanDefinition之前，就会来执行ImportBeanDefinitionRegistrar接口中的方法

default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
}

那么只需要看一下MapperScannerRegistrar中的registerBeanDefinitions方法是如何来进行实现的：

1.2、MapperScannerConfigurer

而在上面的代码中，主要是注册了一个MapperScannerConfigurer类型的BeanDefinition。

那么来看一下这个BeanDefinition有什么特点：

MapperScannerRegistrar实现了BeanDefinitionRegistryPostProcessor接口。而这个接口中又会在ConfigurationClassPostProcessor之后发挥作用，而MapperScannerRegistrar对应的BeanDefinition是在此之前来进行解析的，所以将会在下面来解析MapperScannerRegistrar对应的BeanDefinition

那么就会来执行MapperScannerConfigurer中的postProcessBeanDefinitionRegistry方法

1.2、ClassPathMapperScanner

那么看一下Spring-Mybatis中自定义整合的ClassPathMapperScanner中的注册过滤器和扫描逻辑：

将扫描出来的类利用包含过滤器添加到当前逻辑中。

那么来看一下扫描逻辑：

然后可以看到只要接口的类

1.2.1、对筛选出来的BeanDefinition进行处理

然后对扫描出来的接口来进行筛选判断：

org.mybatis.Spring.mapper.ClassPathMapperScanner#processBeanDefinitions

1、首先获取得到接口的全限定类型。如：com.guang.dao.UserDao；

2、将当前的BeanClass设置成MapperFactoryBean，而这个类是FactoryBean类型的。在创建对象的时候，说明是要用getObject方法来创建对象的；

3、设置MapperFactoryBean构造函数中的值。在MapperFactoryBean构造函数中是Class类型，而这里设置的是String，在创建的时候Spring回来进行转换；

4、将MapperFactoryBean的注入模型设置为By-Type。也就是说，MapperFactoryBean中的setXxx中的属性会从容器中来进行查找；

那么看一下MapperFactoryBean的构造方法：

  public MapperFactoryBean(Class<T> mapperInterface) {
    this.mapperInterface = mapperInterface;
  }

这里会将mapperInterface在进行赋值的时候将java.lang.String转换成Class类型，表示对应的接口。

第二个：

说明了在MapperFactoryBean中的setXxxx方法对应的xxx属性，Spring会自动来进行赋值。而MapperFactoryBean继承了SqlSessionDaoSupport，在SqlSessionDaoSupport类中的set方法中存在setSqlSessionFactory方法和setSqlSessionTemplate方法，所以容器中如果存在着对应类型的对象的时候，那么Spring到时候来进行赋值的时候将会从容器中来进行获取得到对应的bean。

所以：SqlSessionTemplate我们可以自己配置，但是SqlSessionFactory就得由我们自己来进行配置了。

1.3、SqlSessionFactoryBean类结构体系

SqlSessionFactoryBean类就是来帮我们创建SqlSessionFactory，看下SqlSessionFactory的结构如下所示：

SqlSessionFactoryBean也是一个FactoryBean类型的，产生的对象的类型是：SqlSessionFactory。

看一下对应的getObjectType方法：

public Class<? extends SqlSessionFactory> getObjectType() {
  return this.sqlSessionFactory == null ? SqlSessionFactory.class : this.sqlSessionFactory.getClass();
}

看一下对应的getObject方法：

public SqlSessionFactory getObject() throws Exception {
  if (this.sqlSessionFactory == null) {
    afterPropertiesSet();
  }

  return this.sqlSessionFactory;
}

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");
  // 调用对应的buildSqlSessionFactory方法产生一下sqlSessionFactory
  this.sqlSessionFactory = buildSqlSessionFactory();
}

而根据buildSqlSessionFactory方法可以知道，我们可以通过对SqlSessionFactoryBean对象的属性来进行设置，从而实现对Configuration对象属性的设置。

其中有一行代码值得注意下：

targetConfiguration.setEnvironment(new Environment(this.environment,this.transactionFactory == null ?
                                                   new SpringManagedTransactionFactory() : this.transactionFactory,
                                                   this.dataSource));

对于Environment对象来说，看看构造函数：

public Environment(String id, TransactionFactory transactionFactory, DataSource dataSource) {
  if (id == null) {
    throw new IllegalArgumentException("Parameter 'id' must not be null");
  }
  if (transactionFactory == null) {
    throw new IllegalArgumentException("Parameter 'transactionFactory' must not be null");
  }
  this.id = id;
  if (dataSource == null) {
    throw new IllegalArgumentException("Parameter 'dataSource' must not be null");
  }
  this.transactionFactory = transactionFactory;
  this.dataSource = dataSource;
}

需要的第二个参数是TransactionFactory（事务工厂），Spring-Mybatis整合包中，利用SpringManagedTransactionFactory类实现TransactionFactory，重写其中的方法，让当前事务交给Spring来进行处理。

那么后续Mybatis如果存在事务操作的时候，将会由Spring中的事务来进行处理。

1.3.1、SqlSessionFactoryBean使用

这里需要注意的是，下面的使用方式是通过配置类的方式来进行注入的。

因为@MapperScan注解导入的MapperScannerRegistrar的作用就是来注册一个MapperScannerConfigurer类型的BeanDefinition。

所以在下面可以直接利用@Bean注入一个对应类型的BeanDefinition，然后给BeanDefinition来设置一些属性而已。

其中在MapperScannerConfigurer实现InitializingBean接口中的afterPropertiesSet方法中判断了扫描包不能够为空，也就是说要求必须设置basePackage属性

第一种使用方式

第二种使用方式

结合SpringBoot项目使用

@ConfigurationProperties(
    prefix = "mybatis"
)
public class MybatisProperties {
    public static final String MYBATIS_PREFIX = "mybatis";
    private String typeAliasesPackage;
    private String[] mapperLocations;
    private Integer batchExecuteSize = 1000;

    public MybatisProperties() {
    }

    public String getTypeAliasesPackage() {
        return this.typeAliasesPackage;
    }

    public void setTypeAliasesPackage(String typeAliasesPackage) {
        this.typeAliasesPackage = typeAliasesPackage;
    }

    public String[] getMapperLocations() {
        return this.mapperLocations;
    }

    public void setMapperLocations(String[] mapperLocations) {
        this.mapperLocations = mapperLocations;
    }

    public Integer getBatchExecuteSize() {
        return this.batchExecuteSize;
    }

    public void setBatchExecuteSize(Integer batchExecuteSize) {
        this.batchExecuteSize = batchExecuteSize;
    }
}

@Configuration
@EnableConfigurationProperties({MybatisProperties.class})
@AutoConfigureAfter({DataSourceConfig.class})
@MapperScan({"com.guang.common.dao"})
public class MybatisConfig {
    private static final String CONFIG_LOCATION = "classpath:mybatis/mybatis-config.xml";
    private static final String COMMON_MAPPER_LOCATIONS = "classpath:com/guang/common/dao/mapper/*Mapper.xml";
    private final ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver();

    public MybatisConfig() {
    }

    @Bean(
        name = {"sqlSessionFactory"}
    )
    @ConditionalOnClass({DataSource.class})
    @ConditionalOnBean({DataSource.class})
    public SqlSessionFactory sqlSessionFactory(MybatisProperties mybatisProperties, DataSource dataSource, ObjectProvider<Interceptor> interceptorObjectProvider) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setConfigLocation(this.getConfigLocation());
        sqlSessionFactoryBean.setMapperLocations(this.getMapperLocations(mybatisProperties));
        sqlSessionFactoryBean.setDataSource(dataSource);
        sqlSessionFactoryBean.setTypeAliasesPackage(mybatisProperties.getTypeAliasesPackage());
        List<Interceptor> interceptorList = (List)interceptorObjectProvider.stream().collect(Collectors.toList());
        sqlSessionFactoryBean.setPlugins((Interceptor[])interceptorList.toArray(new Interceptor[0]));
        return sqlSessionFactoryBean.getObject();
    }

    @Primary
    @Bean(
        name = {"simpleSqlSessionTemplate"}
    )
    @ConditionalOnClass({SqlSessionFactory.class})
    @ConditionalOnBean({SqlSessionFactory.class})
    public SqlSessionTemplate simpleSqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory, ExecutorType.SIMPLE);
    }

    @Bean(
        name = {"batchSqlSessionTemplate"}
    )
    @ConditionalOnClass({SqlSessionFactory.class})
    @ConditionalOnBean({SqlSessionFactory.class})
    public SqlSessionTemplate batchSqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory, ExecutorType.BATCH);
    }

    @Bean(
        name = {"mapperBatchExecutor"}
    )
    @ConditionalOnClass({SqlSessionTemplate.class})
    @ConditionalOnBean(
        value = {SqlSessionTemplate.class},
        name = {"batchSqlSessionTemplate"}
    )
    public MapperBatchExecutor mapperBatchExecutor(@Qualifier("batchSqlSessionTemplate") SqlSessionTemplate batchSqlSessionTemplate, MybatisProperties mybatisProperties) {
        return new MapperBatchExecutor(batchSqlSessionTemplate, mybatisProperties.getBatchExecuteSize());
    }

    @Bean(
        name = {"pagingInterceptor"}
    )
    public PagingInterceptor pagingInterceptor() {
        return new PagingInterceptor();
    }

    private Resource getConfigLocation() {
        return this.resourceResolver.getResource("classpath:mybatis/mybatis-config.xml");
    }

    private Resource[] getMapperLocations(MybatisProperties mybatisProperties) throws IOException {
        Resource[] mapperLocations = this.resourceResolver.getResources("classpath:com/guang/common/dao/mapper/*Mapper.xml");
        String[] var3 = mybatisProperties.getMapperLocations();
        int var4 = var3.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            String mapperLocation = var3[var5];
            Resource[] addedMapperLocations = this.resourceResolver.getResources(mapperLocation);
            Resource[] originMapperLocations = mapperLocations;
            mapperLocations = new Resource[mapperLocations.length + addedMapperLocations.length];
            System.arraycopy(originMapperLocations, 0, mapperLocations, 0, originMapperLocations.length);
            System.arraycopy(addedMapperLocations, 0, mapperLocations, originMapperLocations.length, addedMapperLocations.length);
        }

        return mapperLocations;
    }
}

1.4、SqlSessionTemplate

首先看一下体系结构图

实现了SqlSession接口，那么就有了SqlSession的功能。

说明，我们可以使用SqlsesseionTemplate对象来代替SqlSession对象来进行使用。

1.4.1、构造方法

看一下对应的构造方法，只有一个构造方法。也就是说，如果想要来设置SqlSessionTemplate成为bean，那么当前容器中必须要有一个SqlSessionFactory类型的Bean。

注意这里的参数信息：

• 1、SqlSessionFactory是创建SqlSessionTemplate对象时候传入进来的，然后赋值给当前SqlSessionTemplate类中的属性sqlSessionFactory；
• 2、ExecutorType执行器类型是从当前SqlSessionFactory获取得到的，然后赋值给当前SqlSessionTemplate类中的属性ExecutorType；
• 3、sqlSessionProxy是sqlSession的代理对象，是利用JDK动态代理产生的对象；

1.4.2、增删改查方法

随便看一下都是类似如下所示，使用sqlSessionProxy来进行执行的

public <T> T selectOne(String statement, Object parameter) {
  return this.sqlSessionProxy.selectOne(statement, parameter);
}

那么执行方法的时候，肯定会指定到InvocationHandler中的invoke方法中来。

那么来看一下SqlSessionInterceptor中的invoke方法。

1.4.3、SqlSessionInterceptor

从上面来看，可以知道是一个InvocationHandler，那么直接来看一下对应的invoke方法实现：

Spring整合Mybatis后为什么一级缓存失效

Spring-Mybatis提供的用来整合Spring和Mybatis的，所以又利用到了Spring中的事务中的内容，那么重点来研究一下这里的代码：

SqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,
                                      SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);

首先要获取得到对应的SqlSession，SqlSession是mybatis中的门面。获取得到了SqlSession之后，才能够来执行对应的方法。

那么看一下如何获取得到SqlSession的。

首先看看是如何放入到当前线程上下文的。

这里有几个需要注意的点：

• 1、mybatis中的数据源和@Transactional注解或者是TransactionTemplate使用的要是同一个数据源；
• 2、一定要在开启事务的情况，获取的才是同一个SqlSession；没有开启事务，每次获取得到的SqlSession都是新创建的；

然后看下执行阶段，如下所示：

@Transactional
public void insert(){
  userMapper.insert(new User());
  orderMapper.insert(new Order());
}

看一下对应的执行

首先执行的时候判断

public static boolean isSqlSessionTransactional(SqlSession session, SqlSessionFactory sessionFactory) {
  notNull(session, NO_SQL_SESSION_SPECIFIED);
  notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
  // 判断是否是同一个SqlSession
  SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
  return (holder != null) && (holder.getSqlSession() == session);
}

如果是同一个SqlSession，那么就先不提交！如果不是同一个SqlSession，那么一个方法执行完成之后，就执行对应的SqlSession.commit()方法，各自占用一个数据库连接。最终如果正常的执行的话，始终占用的是同一个数据库连接，在同一个数据库连接中来执行对应的方法。

Mybatis中的一级缓存是基于SqlSession来实现的，所以在执行同一个sql时，如果使用的是同一个SqlSession对象，那么就能利用到一级缓存，提高sql的执行效率。 但是在Spring整合Mybatis后，如果没有执行某个方法时，该方法上没有加@Transactional注解，也就是没有开启Spring事务，那么后面在执行具体sql时，没执行一个sql时都会新生成一个SqlSession对象来执行该sql，这就是我们说的一级缓存失效（也就是没有使用同一个SqlSession对象），而如果开启了Spring事务，那么该Spring事务中的多个sql，在执行时会使用同一个SqlSession对象，从而一级缓存生效，具体的底层执行流程在上图。

个人理解：实际上Spring整合Mybatis后一级缓存失效并不是问题，是正常的实现，因为，一个方法如果没有开启Spring事务，那么在执行sql时候，那就是每个sql单独一个事务来执行，也就是单独一个SqlSession对象来执行该sql，如果开启了Spring事务，那就是多个sql属于同一个事务，那自然就应该用一个SqlSession来执行这多个sql。所以，在没有开启Spring事务的时候，SqlSession的一级缓存并不是失效了，而是存在的生命周期太短了（执行完一个sql后就被销毁了，下一个sql执行时又是一个新的SqlSession了）。

sqlsession的提交和回滚在哪里

对于SqlSession来说，最终的commit和rollback方法，都会调用到connection.commit()和connection.rollback()方法上去。

而在Spring接管了事务之后，在Spring控制的事务中，也会在方法提交或者回滚之后释放数据库连接。

流程

Spring整合Mybatis之后SQL执行流程： Spring整合Mybatis之后SQL执行流程 | ProcessOn免费在线作图,在线流程图,在线思维导图 |

三、总结

由很多框架都需要和Spring进行整合，而整合的核心思想就是把其他框架所产生的对象放到Spring容器中，让其成为Bean。

比如Mybatis，Mybatis框架可以单独使用，而单独使用Mybatis框架就需要用到Mybatis所提供的一些类构造出对应的对象，然后使用该对象，就能使用到Mybatis框架给我们提供的功能，和Mybatis整合Spring就是为了将这些对象放入Spring容器中成为Bean，只要成为了Bean，在我们的Spring项目中就能很方便的使用这些对象了，也就能很方便的使用Mybatis框架所提供的功能了。

Mybatis-Spring 新版本底层源码执行流程

1、通过@MapperScan导入了MapperScannerRegistrar类；

2、MapperScannerRegistrar类实现了ImportBeanDefinitionRegistrar接口，所以Spring在启动时会调用MapperScannerRegistrar类中的registerBeanDefinitions方法；

3、在registerBeanDefinitions方法中定义了一个ClassPathMapperScanner对象，用来扫描mapper，设置ClassPathMapperScanner对象可以扫描到接口，因为在Spring中是不会扫描接口的

4、同时因为ClassPathMapperScanner中重写了isCandidateComponent方法，导致isCandidateComponent只会认为接口是备选者Component

通过利用Spring的扫描后，会把接口扫描出来并且得到对应的BeanDefinition

5、接下来把扫描得到的BeanDefinition进行修改，把BeanClass修改为MapperFactoryBean，把AutowireMode修改为byType

6、扫描完成后，Spring就会基于BeanDefinition去创建Bean了，相当于每个Mapper对应一个FactoryBean

7、在MapperFactoryBean中的getObject方法中，调用了getSqlSession()去得到一个sqlSession对象，然后根据对应的Mapper接口生成一个Mapper接口代理对象，这个代理对象就成为Spring容器中的Bean

8、sqlSession对象是Mybatis中的，一个sqlSession对象需要SqlSessionFactory来产生

9、MapperFactoryBean的AutowireMode为byType，所以Spring会自动调用set方法，有两个set方法，一个setSqlSessionFactory，一个setSqlSessionTemplate，而这两个方法执行的前提是根据方法参数类型能找到对应的bean，所以Spring容器中要存在SqlSessionFactory类型的bean和SqlSessionTemplate类型的bean。（注意要注册两个的话，记得要在SIMPLESQLSESSIONTEMPLATE上加上@Primary注解）

10、如果你定义的是一个SqlSessionFactory类型的bean，那么最终也会被包装为一个SqlSessionTemplate对象，并且赋值给sqlSession属性

11、而在SqlSessionTemplate类中就存在一个getMapper方法，这个方法中就产生一个Mapper接口代理对象

到时候，当执行该代理对象的某个方法时，就会进入到Mybatis框架的底层执行流程，详细的请看下图

Spring整合Mybatis之后SQL执行流程： Spring整合Mybatis之后SQL执行流程 | ProcessOn免费在线作图,在线流程图,在线思维导图 |

有点遗漏的步骤，我在这里补充一下：

带来的好处是，可以不使用@MapperScan注解，而可以直接定义一个Bean，比如：

@Bean
public static MapperScannerConfigurer mapperScannerConfigurer() {
	MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
	mapperScannerConfigurer.setBasePackage("com.luban");
	return mapperScannerConfigurer;
}