概述

mybatis將與spring集成的代碼拆分到了mybatis-spring模塊，避免mybatis與spring之間的耦合，如果你只需要純粹的使用mybatis api，就避免了必須將spring依賴也耦合進來的問題。mybatis使用中一般是將Sql語句寫在xml文件中，為方便操作，我們會創建一個Mapper接口文件進行映射，mybatis提供了采用動態代理方式對Mapper接口類進行包裝，這樣我們就可以像使用普通對象一樣執行各種方法調用。

mybatis和spring集成的一個核心任務就是將這些動態代理包裝的Mapper對象注入到IoC容器中，這樣其它Bean就可以方便的使用如@Autowired等方式進行依賴注入。

【資料圖】

MapperScannerConfigurer

需要將mybatis生成的動態代理對象注入到IoC容器中，自然我們想到之前的BeanFactoryPostProcessor的子類BeanDefinitionRegistryPostProcessor這個擴展類。MapperScannerConfigurer就是實現了BeanDefinitionRegistryPostProcessor接口，然后在該接口中通過類掃描器scanner進行掃描注冊。

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) { if (this.processPropertyPlaceHolders) {     processPropertyPlaceHolders();    }    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);//指定引用的SqlSessionFactory    scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);    scanner.setResourceLoader(this.applicationContext);    scanner.setBeanNameGenerator(this.nameGenerator);    scanner.registerFilters();    //basePackage指定掃描Mapper接口包路徑    scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));}

ClassPathMapperScanner這個就是繼承之前介紹過的Spring中ClassPathBeanDefinitionScanner類掃描器進行了擴展，它可以實現將包路徑下至少含有一個方法的接口類注冊到IoC中。

這里有個問題：注冊進入的BeanDefinition中beanClass指向的都是接口，到后續創建對象時會存在問題，接口是沒法創建實例的。所以，ClassPathMapperScanner掃描器在注冊完成后，又會對BeanDefinition進行處理。處理邏輯位于ClassPathMapperScanner#processBeanDefinitions()方法中，其核心邏輯見下：

private void processBeanDefinitions(Set beanDefinitions) {    GenericBeanDefinition definition;    for (BeanDefinitionHolder holder : beanDefinitions) {      definition = (GenericBeanDefinition) holder.getBeanDefinition();      String beanClassName = definition.getBeanClassName();      definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName); // issue #59      definition.setBeanClass(this.mapperFactoryBeanClass);   ...    }}

其中最重要的一條語句：definition.setBeanClass(this.mapperFactoryBeanClass)，偷偷的將BeanDefinition的beanClass替換成了MapperFactoryBean，而不再指向Mapper接口類。同時將Mapper接口類作為參數傳入到了MapperFactoryBean中，即調用下面構造方法：

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

MapperFactoryBean實現了FactoryBean接口，這樣實際上它是通過getObject()方法獲取到對象然后注入到IoC容器中。而在getObject()方法中，我們就可以使用mybatis api獲取到Mapper接口類的動態代理對象：SqlSession#getMapper()

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

上面我們分析了如何將Mapper接口類注入到IoC容器中的實現思路，現在總結下主要有：

擴展點引入

通過MapperScannerConfigurer，解決了如何將Mapper接口類注入到IoC容器的問題，現在還有另外一個問題，這個擴展點只有注冊到Spring中才會起作用，那又如何將其注冊到Spring中呢？

方式一：最直接方式就是直接創建MapperScannerConfigurer類型的Bean實例，比如：

這種方式是最簡單直接的，但是使用角度來說不方便，所以，mybatis-spring-1.2新增了兩種方式：標簽方式和@MapperScan注解方式。

首先來看下標簽方式，添加mybatis的schema，然后就可以使用:

后臺處理類NamespaceHandler給標簽注冊解析器MapperScannerBeanDefinitionParser：

public class NamespaceHandler extends NamespaceHandlerSupport {  @Override  public void init() {    registerBeanDefinitionParser("scan", new MapperScannerBeanDefinitionParser());  }}

再看下MapperScannerBeanDefinitionParser解析器：

protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);    ClassLoader classLoader = ClassUtils.getDefaultClassLoader();    builder.addPropertyValue("processPropertyPlaceHolders", true);    try {      String annotationClassName = element.getAttribute(ATTRIBUTE_ANNOTATION);      if (StringUtils.hasText(annotationClassName)) {        @SuppressWarnings("unchecked")        Class annotationClass = (Class) classLoader            .loadClass(annotationClassName);        builder.addPropertyValue("annotationClass", annotationClass);      }      String markerInterfaceClassName = element.getAttribute(ATTRIBUTE_MARKER_INTERFACE);      if (StringUtils.hasText(markerInterfaceClassName)) {        Class markerInterface = classLoader.loadClass(markerInterfaceClassName);        builder.addPropertyValue("markerInterface", markerInterface);      }      String nameGeneratorClassName = element.getAttribute(ATTRIBUTE_NAME_GENERATOR);      if (StringUtils.hasText(nameGeneratorClassName)) {        Class nameGeneratorClass = classLoader.loadClass(nameGeneratorClassName);        BeanNameGenerator nameGenerator = BeanUtils.instantiateClass(nameGeneratorClass, BeanNameGenerator.class);        builder.addPropertyValue("nameGenerator", nameGenerator);      }      String mapperFactoryBeanClassName = element.getAttribute(ATTRIBUTE_MAPPER_FACTORY_BEAN_CLASS);      if (StringUtils.hasText(mapperFactoryBeanClassName)) {        @SuppressWarnings("unchecked")        Class mapperFactoryBeanClass = (Class) classLoader            .loadClass(mapperFactoryBeanClassName);        builder.addPropertyValue("mapperFactoryBeanClass", mapperFactoryBeanClass);      }    } catch (Exception ex) {      XmlReaderContext readerContext = parserContext.getReaderContext();      readerContext.error(ex.getMessage(), readerContext.extractSource(element), ex.getCause());    }    builder.addPropertyValue("sqlSessionTemplateBeanName", element.getAttribute(ATTRIBUTE_TEMPLATE_REF));    builder.addPropertyValue("sqlSessionFactoryBeanName", element.getAttribute(ATTRIBUTE_FACTORY_REF));    builder.addPropertyValue("lazyInitialization", element.getAttribute(ATTRIBUTE_LAZY_INITIALIZATION));    builder.addPropertyValue("basePackage", element.getAttribute(ATTRIBUTE_BASE_PACKAGE));    return builder.getBeanDefinition();  }

最關鍵的就是第一句BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);，又是將MapperScannerConfigurer動態注入到Spring中，下面一堆都是解析標簽屬性進行依賴注入。

再來看下@MapperScan注解方式，如：@MapperScan(basePackages = "org.simon.demo01.mapper")：

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

@MapperScan注解上面使用了使用了一種非常常見的擴展方式：@Import擴展。通過@Import注解，引入了MapperScannerRegistrar，它是ImportBeanDefinitionRegistrar類型，通常和@Import注解組合使用，實現動態注入功能：

@Override  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {    //獲取注解上屬性    AnnotationAttributes mapperScanAttrs = AnnotationAttributes        .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));    if (mapperScanAttrs != null) {      registerBeanDefinitions(mapperScanAttrs, registry, generateBaseBeanName(importingClassMetadata, 0));    }  }  void registerBeanDefinitions(AnnotationAttributes annoAttrs, BeanDefinitionRegistry registry, String beanName) {    //創建一個MapperScannerConfigurer的BeanDefinition    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);    /**     * 下面就是解析注解屬性值，通過PropertyValue方式進行依賴注入到Bean中     */    builder.addPropertyValue("processPropertyPlaceHolders", true);    Class 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);    }    ...//各種依賴注入    builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(basePackages));    //將生成的BeanDefinition注冊到IoC中    registry.registerBeanDefinition(beanName, builder.getBeanDefinition());}

方法中同樣有BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class)這句，動態的將MapperScannerConfigurer注入到Spring中，然后是一堆的解析注解屬性進行依賴注入，這樣通過@Import+ImportBeanDefinitionRegistrar動態注入，就實現了將MapperScannerConfigurer擴展點注冊到Spring中。

SpringBoot自動裝配

不論是通過標簽方式，還是@MapperScan注解方式，這些是常規的第三方模塊與Spring進行集成方式。這種集成方式比較繁瑣的是：你不光要通過或@MapperScan注解將第三方集成進來，你還需要初始化一些依賴對象，比如這里的DataSource、SqlSessionFactory等。當一個項目集成了很多第三方模塊時，每個模塊都這樣搞一下，配置的工作量就大了，比如最常使用的ssm集成配，傳統Spring集成要搞一大堆配置。

所以，SpringBoot提出了一個比較優秀的思想：自動裝配。需要什么模塊直接把依賴添加進來，自動完成裝配，對于個性化可以在屬性文件中進行配置，從使用角度來說，即插即用，不需要有太多的編碼。第三方程序和spring就像完全融入一體一樣，簡化項目構建時集成成本，也降低項目配置的復雜性，所以SpringBoot會被越來越多的項目所采用，進而也推動微服務的興起。

在SpringBoot中使用mybatis，直接依賴mybatis-spring-boot-starter，它會把mybatis、mybatis-spring和mybatis-spring-boot-autoconfigure三個依賴包都添加進來。前面兩個依賴包好理解，這里關鍵是第三個依賴包，就是通過它實現了mybatis自動裝配功能。下面我們來看下SpringBoot是如何實現mybatis的主動裝配。

1、首先，定義一個mybatis主動裝配配置類，如下：

@org.springframework.context.annotation.Configuration@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })@ConditionalOnSingleCandidate(DataSource.class)@EnableConfigurationProperties(MybatisProperties.class)@AutoConfigureAfter({ DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class })public class MybatisAutoConfiguration implements InitializingBean {  public MybatisAutoConfiguration(MybatisProperties properties, ObjectProvider interceptorsProvider,      ObjectProvider typeHandlersProvider, ObjectProvider languageDriversProvider,      ResourceLoader resourceLoader, ObjectProvider databaseIdProvider,      ObjectProvider> configurationCustomizersProvider) { ...  }  @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 (factoryPropertyNames.contains("defaultScriptingLanguageDriver")) {      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);    }  }    public static class AutoConfiguredMapperScannerRegistrar implements BeanFactoryAware, ImportBeanDefinitionRegistrar {    private BeanFactory beanFactory;    @Override    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {      if (!AutoConfigurationPackages.has(this.beanFactory)) {        logger.debug("Could not determine auto-configuration package, automatic mapper scanning disabled.");        return;      }      logger.debug("Searching for mappers annotated with @Mapper");      List packages = AutoConfigurationPackages.get(this.beanFactory);      if (logger.isDebugEnabled()) {        packages.forEach(pkg -> logger.debug("Using auto-configuration base package "{}"", pkg));      }      BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);      builder.addPropertyValue("processPropertyPlaceHolders", true);      builder.addPropertyValue("annotationClass", Mapper.class);      builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(packages));      BeanWrapper beanWrapper = new BeanWrapperImpl(MapperScannerConfigurer.class);      Stream.of(beanWrapper.getPropertyDescriptors())          .filter(x -> x.getName().equals("lazyInitialization")).findAny()          .ifPresent(x -> builder.addPropertyValue("lazyInitialization", "${mybatis.lazy-initialization:false}"));      registry.registerBeanDefinition(MapperScannerConfigurer.class.getName(), builder.getBeanDefinition());    }    @Override    public void setBeanFactory(BeanFactory beanFactory) {      this.beanFactory = beanFactory;    }  }  @org.springframework.context.annotation.Configuration  @Import(AutoConfiguredMapperScannerRegistrar.class)  @ConditionalOnMissingBean({ MapperFactoryBean.class, MapperScannerConfigurer.class })  public static class MapperScannerRegistrarNotFoundConfiguration implements InitializingBean {  }}

這里主要利用MapperScannerRegistrarNotFoundConfiguration類上的@Import(AutoConfiguredMapperScannerRegistrar.class)引入，然后在AutoConfiguredMapperScannerRegistrar中BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class)這句又是動態注入MapperScannerConfigurer。不過，主動裝配配置類中，還會把相關的依賴也一起創建、初始化，比如：SqlSessionFactory、SqlSessionTemplate。

@EnableConfigurationProperties(MybatisProperties.class)把mybatis相關配置引入進來，這樣在創建、初始化過程中的定制需求就可以通過配置修改。

2、有了這個主動裝配配置類還不行，下一步就是看如何讓主動裝配配置類生效。SpringBoot提供了SpringFactoriesLoader工廠加載機制，類似于JDK中的SPI機制，實現將模塊META-INF/spring.factories文件中配置注入到Spring容器中。mybatis-spring-boot-autoconfigure模塊下META-INF/spring.factories文件中就有MybatisAutoConfiguration：

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

3、使用時依賴添加進來，配置下屬性，就可以直接使用，基本不再需要編碼：

mybatis.mapper-locations: classpath:mapper/*Mapper.xmlmybatis.type-aliases-package: com.example.demo.entity

總結

從上面來看，mybatis和spring集成的關鍵的是將mybatis-spring模塊下MapperScannerConfigurer集成進來，因為，它是一個BeanDefinitionRegistryPostProcessor類型的擴展，內部通過自定義scanner掃描Mapper接口自動注冊到IoC容器中，這一點在各種集成方式中是統一一樣的。不同點在于：MapperScannerConfigurer擴展類是如何被引入的。傳統的Spring方式通過@Mapper注解或自定義標簽實現，但是對于一些依賴對象還是需要手工創建，比較繁瑣；而SpringBoot利用自動裝配，讓第三方模塊集成變成了一個插件，即插即用，無需太多編碼。

分析了mybatis集成方式，從中也學習了如何利用Spring的各種擴展點進行定制，更重要的是也為我們開發自己模塊和Spring集成提供了思路。

關鍵詞：