Spring整合Mybatis原理

Spring整合Mybatis原理
- 1、@MapperScan注解发挥作用
- 三、总结
  - 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;

}

巴特西

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 新版本底层源码执行流程

最新文章

热门文章