24-Mybatis和Spring集成原理

Mybatis和Spring集成原理

• 前面的系列文章都是单独讲解MyBatis，并未将其和Spring整合起来，看看整合的原理。在了解之前我们大概梳理一下流程:首先MyBatis的核心组件有：SqlSessionFactory和Java接口代理对象，前者用于创建SqlSession，后者是接口的代理对象实现接口访问数据库。

• 本文会按照代码，和基本的思路分析Spring整合MyBatis，如果直接需要源码，可以跳到文章尾部；

一、代码差异

• 先看看集成前需要准备的代码，包括：实体类、接口、Xml文件

@Mapper
public interface UserDao {

    List<User> findAll();
}

@Data
public class User {
    Integer id;
    private String name;
    private String job;
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.intellif.mozping.dao.UserDao" >

  <select id="findAll" resultType="user" >
		select * from user
	</select>
</mapper>

• 前面的内容，不管MyBatis集成Spring与否都是一样的，后面不同的地方分别展示；

1.1 MyBatis

• 先看一段单独使用Mybatis的代码，代码包括：

/**
 * @author by mozping
 * @Classname Test02NotCombine
 * @Description MyBatis单独测试
 * @Date 2019/11/08 19:56
 */
public class Test02NotCombine {

    private static final String CONFIG_FILE_PATH = "mybatis-config.xml";

    @Test
    public void query() throws IOException {
        InputStream in = Resources.getResourceAsStream(CONFIG_FILE_PATH);
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = factory.openSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        List<User> all = mapper.findAll();
        for (User u : all) {
            System.out.println(u);
        }
    }
}

• 下面是配置文件，配置了别名扫描，Xml文件，数据源等配置，这里留意，后面和Spring集成后这些都不需要了

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 别名定义 -->
    <typeAliases>
        <package name="com.intellif.mozping.entity"/>
    </typeAliases>

    <!--配置environment环境 -->
    <environments default="development">
        <!-- 环境配置1，每个SqlSessionFactory对应一个环境 -->
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://192.168.12.168:3306/test"/>
                <property name="username" value="root"/>
                <property name="password" value="introcks1234"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 映射文件，mapper的配置文件 -->
    <mappers>
        <!--直接映射到相应的mapper文件 -->
        <!--<mapper resource="mybatis/mapper/PlayerMapper.xml"/>-->
        <mapper resource="mapper/User.xml"/>
    </mappers>

</configuration>

1.2 MyBatis和Spring

• 再看一段MyBatis和Spring集成后的使用代码：

/**
 * @Description Spring和MyBatis集成后测试
 */
public class Test01Combine {

    @Test
    public void test() throws Exception {

        //ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml"); //加载xml配置文件
        ApplicationContext app = new AnnotationConfigApplicationContext(MainConfig.class); //加载配置对象
        System.out.println("------cut-off---------");

        UserDao mapper = app.getBean(UserDao.class);
        List<User> all = mapper.findAll();
        for (User u : all) {
            System.out.println(u);
        }
    }
}

• 集成后，除了最前面的实体类、接口、Xml文件，还需要一个配置类，也可以是XML配置文件，如果用配置文件，测试类中就使用注释了的一行加载，使用配置类更加简洁，使用AnnotationConfigApplicationContext加载，配置类如下：

/**
 * @Classname MainConfig
 * @Description Spring集成MyBatis后的配置类
 */
@Configuration
@ComponentScan("com.intellif.mozping")
public class MainConfig {

    private static final String URL = "jdbc:mysql://192.168.12.168:3306/test";
    private static final String USERNAME = "root";
    private static final String PASSWORD = "introcks1234";
    private static final String DRIVER = "com.mysql.jdbc.Driver";

    /**
     * MyBatis自身数据源
     */
    @Bean("unPooledDataSource")
    DataSource unPooledDataSource() {
        UnpooledDataSource dataSource = new UnpooledDataSource();
        dataSource.setUrl(URL);
        dataSource.setDriver(DRIVER);
        dataSource.setUsername(USERNAME);
        dataSource.setPassword(PASSWORD);
        return dataSource;
    }

    /**
     * 配置sqlSessionFactoryBean，用于创建 sqlSessionFactory
     * 这里通过Qualifier来注入一个数据源，如果注入的是dataSource，就注入DruidDataSource
     * 如果注入 unPooledDataSource，就不使用数据源，使用的是MyBatis内置的数据源
     */
    @Bean("sqlSessionFactoryBean")
    public SqlSessionFactoryBean sqlSessionFactoryBean(@Qualifier("unPooledDataSource") DataSource dataSource) {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        //1.数据源配置
        sqlSessionFactoryBean.setDataSource(dataSource);
        //2.别名扫描
        sqlSessionFactoryBean.setTypeAliasesPackage("com.intellif.mozping.entity");
        //3.Xml映射文件扫描，这里传的是数组，每一个元素只能代表一个xml，不能*.xml代表全部
        sqlSessionFactoryBean.setMapperLocations(new ClassPathResource("mapper/User.xml"));

        //注意前面的别名和Xml扫描都可以在配置文件配，这然后这里加入配置就好了，
        //如果前面配置了，其实配置文件就可以不要了
        //sqlSessionFactoryBean.setConfigLocation(new ClassPathResource("mybatis-config.xml"));
        return sqlSessionFactoryBean;
    }

    @Bean("mapperScannerConfigurer")
    MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setBasePackage("com.intellif.mozping.dao");
        return mapperScannerConfigurer;
    }
}

• MyBatis和Spring集成的关键是mybatis-spring这个包，源码：https://github.com/mybatis/spring ，通过这个包来实现自动配置，我们主要看看增加的几个Bean，其实就是我们配置的几个Bean；
• 其中 SqlSessionFactoryBean 用于创建 SqlSessionFactory，MapperScannerConfigurer用于扫描Java接口，unPooledDataSource是MyBatis内置的数据源(也可以使用Druid等第三方数据源)，

二、主要类

2.1 SqlSessionFactoryBean

• SqlSessionFactoryBean用于创建 SqlSessionFactory，这可以在Spring中创建SqlSessionFactory，回顾我们前面1.1中的代码，在没有和Spring集成时我们需要一个配置文件来创建 SqlSessionFactory ，集成之后显然这些配置也是需要的，只不过这次是将配置交给SqlSessionFactoryBean，然后由SqlSessionFactoryBean来创建 SqlSessionFactory；

2.1.1 核心属性

• 核心属性自然是原本我们需要在配置文件中写的MyBatis的全部配置，下面只列举了一小部分：

private Resource configLocation;
  //配置对象
  private Configuration configuration;

  //xml文件地址
  private Resource[] mapperLocations;
    
  //数据源
  private DataSource dataSource;

 //用于构建sqlSessionFactory的Builder，这个类是mybatis自身提供的，在参考文章：[Mybatis 核心流程01-初始化阶段] 有分析过
  private SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();

  private SqlSessionFactory sqlSessionFactory;

  private Interceptor[] plugins;

  //类型处理器，可以自定义类型处理器
  private TypeHandler<?>[] typeHandlers;

  //别名配置
  private Class<?>[] typeAliases;

• 下面是 SqlSessionFactoryBean 核心属性提供的 setXX 方法：

2.1.2 buildSqlSessionFactory

• buildSqlSessionFactory是最核心的方法，用于创建SqlSessionFactory；这里面使用了 MyBatis 原本创建 SqlSessionFactory 的几个Builder辅助类，包括XMLConfigBuilder，XMLMapperBuilder(将映射文件转换为配置)和

protected SqlSessionFactory buildSqlSessionFactory() throws IOException {

    Configuration configuration;

    XMLConfigBuilder xmlConfigBuilder = null;
    if (this.configuration != null) {
      configuration = this.configuration;
      if (configuration.getVariables() == null) {
        configuration.setVariables(this.configurationProperties);
      } else if (this.configurationProperties != null) {
        configuration.getVariables().putAll(this.configurationProperties);
      }
    } else if (this.configLocation != null) {
      xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
      configuration = xmlConfigBuilder.getConfiguration();
    } else {
      configuration = new Configuration();
      if (this.configurationProperties != null) {
        configuration.setVariables(this.configurationProperties);
      }
    }

    if (this.objectFactory != null) {
      configuration.setObjectFactory(this.objectFactory);
    }

    if (this.objectWrapperFactory != null) {
      configuration.setObjectWrapperFactory(this.objectWrapperFactory);
    }

    if (this.vfs != null) {
      configuration.setVfsImpl(this.vfs);
    }

    if (hasLength(this.typeAliasesPackage)) {
      String[] typeAliasPackageArray = tokenizeToStringArray(this.typeAliasesPackage,
          ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
      for (String packageToScan : typeAliasPackageArray) {
        configuration.getTypeAliasRegistry().registerAliases(packageToScan,
                typeAliasesSuperType == null ? Object.class : typeAliasesSuperType);
      }
    }

    if (!isEmpty(this.typeAliases)) {
      for (Class<?> typeAlias : this.typeAliases) {
        configuration.getTypeAliasRegistry().registerAlias(typeAlias);
      }
    }

    if (!isEmpty(this.plugins)) {
      for (Interceptor plugin : this.plugins) {
        configuration.addInterceptor(plugin);
      }
    }

    if (hasLength(this.typeHandlersPackage)) {
      String[] typeHandlersPackageArray = tokenizeToStringArray(this.typeHandlersPackage,
          ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
      for (String packageToScan : typeHandlersPackageArray) {
        configuration.getTypeHandlerRegistry().register(packageToScan);
      }
    }

    if (!isEmpty(this.typeHandlers)) {
      for (TypeHandler<?> typeHandler : this.typeHandlers) {
        configuration.getTypeHandlerRegistry().register(typeHandler);
      }
    }

    if (this.databaseIdProvider != null) {//fix #64 set databaseId before parse mapper xmls
      try {
        configuration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
      } catch (SQLException e) {
        throw new NestedIOException("Failed getting a databaseId", e);
      }
    }

    if (this.cache != null) {
      configuration.addCache(this.cache);
    }

    if (xmlConfigBuilder != null) {
      try {
        xmlConfigBuilder.parse();

      } catch (Exception ex) {
        throw new NestedIOException("Failed to parse config resource: " + this.configLocation, ex);
      } finally {
        ErrorContext.instance().reset();
      }
    }

    if (this.transactionFactory == null) {
      this.transactionFactory = new SpringManagedTransactionFactory();
    }

    configuration.setEnvironment(new Environment(this.environment, this.transactionFactory, this.dataSource));

    if (!isEmpty(this.mapperLocations)) {
      for (Resource mapperLocation : this.mapperLocations) {
        if (mapperLocation == null) {
          continue;
        }
        try {
         //加载xml映射文件
          XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
              configuration, mapperLocation.toString(), configuration.getSqlFragments());
          xmlMapperBuilder.parse();
        } catch (Exception e) {
          throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
        } finally {
          ErrorContext.instance().reset();
        }
      }
    } 
    //根据配置对象创建 SqlSessionFactory
    return this.sqlSessionFactoryBuilder.build(configuration);
  }

• 大概梳理一下SqlSessionFactoryBean的设计，本身提供了很多SetXX方法用于设置配置，配置的设置比较灵活，既可以单独设置某一些配置，也可以设置配置对象或者配置文件的问题，因此我们既可以保留mybatis的配置文件，也可以去掉通过SqlSessionFactoryBean注入相关的配置。
• SqlSessionFactoryBean继承了FactoryBean(不了解FactoryBean需要补一补啦)，因此它是一个工厂Bean，可以创建SqlSessionFactory；
• 在构建SqlSessionFactory的时候，所用到的方式还是保留了MyBatis中本身构建的方式，SqlSessionFactoryBean 本身就是将配置转换为配置对象，这里从最后一行代码 this.sqlSessionFactoryBuilder.build(configuration) 可以看出来，SqlSessionFactoryBean本身就做了一下配置转换，那么创建 SqlSessionFactory 的时机是什么时候呢，看2.1.3 。

这里需要我们对整个MyBatis的原理，流程需要有一定的了解，可以参考前面的相关文章。

2.1.3 创建时机

• 前面我们看到了创建SqlSessionFactory的方法细节，那么创建的时机是在什么时候？SqlSessionFactoryBean 实现了 InitializingBean接口，时机就在Bean初始化完成后调用该接口的回调方法afterPropertiesSet，代码如下：

  @Override
  public void afterPropertiesSet() throws Exception {
  
    this.sqlSessionFactory = buildSqlSessionFactory();
  
  }

• 这里会创建 SqlSessionFactory ，且是在Bean初始化完成之后调用 afterPropertiesSet ， 这和Bean的生命周期知识相关。

2.2 MapperFactoryBean

• 在我们了解MapperScannerConfigurer之前，先简单看看 MapperFactoryBean 的作用，它的作用就是创建Java接口的代理对象，对于MyBatis这个细节不清楚的建议阅读参考文章[2]
• MapperFactoryBean也实现了FactoryBean，我们看看getObject方法，其实就是获取SqlSession之后再获取Mapper对象，和我们1.1中的代码 UserDao mapper = sqlSession.getMapper(UserDao.class) 一样，因此其实 MapperFactoryBean 本身也不需要做太多工作，因为获取代理对象的工作还是委托给 SqlSession来做的，而这是MyBatis本身提供的机制。

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

• 由MapperFactoryBean 的作用我们知道，如果我们有一个接口比如前面的 UserDao ，需要得到代理对象就可以实例化一个MapperFactoryBean类型的Bean，注释中给出的配置方式如下：

    <bean id="baseMapper" class="org.mybatis.spring.mapper.MapperFactoryBean" abstract="true" lazy-init="true">
      <property name="sqlSessionFactory" ref="sqlSessionFactory" />
    </bean>
 
    <bean id="oneMapper" parent="baseMapper">
      <property name="mapperInterface" value="my.package.MyMapperInterface" />
    </bean>
 
    <bean id="anotherMapper" parent="baseMapper">
      <property name="mapperInterface" value="my.package.MyAnotherMapperInterface" />
    </bean>

• 不过假设我们有很多接口，为每一个接口配置一次显然不方便，在直接使用MyBatis的过程中，我们通过UserDao mapper = sqlSession.getMapper(UserDao.class);来获取代理对象，与Spring集成之后，他会将全部的代理对象创建好放在IOC容器，因此就有了MapperScannerConfigurer

2.3 MapperScannerConfigurer

• MapperScannerConfigurer 用于扫描我们的Java接口，给他配置一个路径即可

    @Bean("mapperScannerConfigurer")
    MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setBasePackage("com.intellif.mozping.dao");
        return mapperScannerConfigurer;
    }

• 下面是测得代码中获取到的代理对象，和直接使用MyBatis是一样的

• MapperScannerConfigurer 扫描Java接口的机制是什么？这里不具体分析源码，稍微带一下，MapperScannerConfigurer实现了BeanDefinitionRegistryPostProcessor接口，通过接口方法postProcessBeanDefinitionRegistry来修改Bean定义信息，将包下全部的Java接口扫描并注册Bean定义信息，设置Bean类型是MapperFactoryBean类型，因此后面容器就会初始化对应的MapperFactoryBean，有兴趣可以阅读参考文章[3]

• 另外也可以去掉MapperScannerConfigurer这个Bean的定义，使用注解：@MapperScan(value=“com.intellif.mozping.dao”)，它和Bean的效果是一样的，具体看2.4。

• MapperScannerConfigurer扫描多个Java接口并创建对应的代理对象，所以一般不会直接使用MapperFactoryBean，而是使用 MapperScannerConfigurer；

2.4 @MapperScan

• @MapperScan注解可以起到和 MapperScannerConfigurer 这个Bean的一样的功能，比如下面两段代码是等效的：

    //注解扫描接口
    @MapperScan(value="com.intellif.mozping.dao")

    //MapperScannerConfigurer扫描接口
    @Bean("mapperScannerConfigurer")
    MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setBasePackage("com.intellif.mozping.dao");
        return mapperScannerConfigurer;
    }

• 如果了解ImportBeanDefinitionRegistrar接口(不了解请阅读参考文章[4]：)，那么 @MapperScan的原理就很好理解，看下面的代码：

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

    //省略代码...
}

• MapperScannerRegistrar类是关键，从下面的方法registerBeanDefinitions可以看到，其作用主要是将注解了MapperScan的类Bean定义信息注册，而注解了MapperScan的正是我们MyBatis的Java接口；

public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {

  @Override
  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    //扫描注解了MapperScan的类
    AnnotationAttributes mapperScanAttrs = AnnotationAttributes
        .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
    if (mapperScanAttrs != null) {
      registerBeanDefinitions(mapperScanAttrs, registry, generateBaseBeanName(importingClassMetadata, 0));
    }
  }
  //省略其他代码...
}

三、小结

类名	功能
SqlSessionFactoryBean …	创建SqlSessionFactory，是一个FactoryBean，会在InitializingBean的afterPropertiesSet回调创建 SqlSessionFactory
MapperFactoryBean	创建代理对象MethodProxy，是一个FactoryBean，MethodProxy实现目标接口且内部持有SqlSession，是接口访问数据库的关键
MapperScannerConfigurer	扫描多个Java接口并创建对应的代理对象，会在 BeanDefinitionRegistryPostProcessor 回调的时候注册 MapperFactoryBean 相关的Bean定义信息用于后面的 MapperFactoryBean 实例化。
@MapperScan	等价替换MapperScannerConfigurer ，原理是@Import(MapperScannerRegistrar.class)，MapperScannerRegistrar是一个ImportBeanDefinitionRegistrar实现类，一种注册Bean的方式。

• 源码地址：MyBatis整合Spring示例

四、参考

• [1] Mybatis 核心流程01-初始化阶段
• [2] Mybatis 核心流程02-代理阶段
• [3] Spring-Mybatis运行机制概括
• [4] spring中ImportBeanDefinitionRegistrar的应用