Mybatis spring and mybatis and m

Mybatis spring and mybatis and mybatis-springboot-starter

这篇博文主要涉及到的是mybatis是怎么集成到spring已经spring boot的，有关mybatis的用法及其自身的源码

设计，我会到开另一个文章进行分析

mybatis可以通过 mybatis-spring 和mybatis-springboot-starter这两个模块分别集成到纯spring应用或者是

springboot应用，其实两者都是有异曲同工的感觉的。

首先梳理下mybatis的重要元素，这部分后期会详细的分析

mybatis最重要的三大件分别是SqlSessionFactory， SqlSession， Mapper，这三个也是我们在纯mybatis应用

开发中涉及到最多的三个组建。它们也有着各自的生命周期。

当mybatis需要集成到spring的时候，首先就是要通过spring 的方式管理这些组建，同时，支持mybatis datasource

和transaction的托管，由spring全权维护。

这篇文章着重介绍的是spring 如何识别并且注册mybatis的mappers。

这里的mappers注册识别，主要包含了手动单体注册和扫描注册。

手动组册

通过 MapperFactoryBean 进行mapper的注册。

<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
  <property name="mapperInterface" value="org.mybatis.spring.sample.mapper.UserMapper" />
  <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

这里的核心思想，就是通过依赖的SqlSessionFactory得到对应的configuration，将对应的UserMapper注册到mybatis中。应为这里的的MapperFactoryBean是一个spring里的factoryBean，它负责生成实际的Mapper，提供使用方注入使用

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

自动扫描mapper

如果一个应用中设计到的mapper数量非常的多，单一手动的注册所有的mapper会变得特别琐碎，于是就用了自动mapper扫描注册

这里mybatis使用到了spring里的一个很有意思的类，它可以完成额外的BeanDefinition的注册。

这个类就是ClassPathBeanDefinitionScanner.java

于是，mybatis就继承扩充了这个类，叫做ClassPathMapperScanner，可以完成所有的Mapper的扫描注册。每扫描一个符合条件的mapper接口，就生成一个MapperFactoryBean，用来完成这个Mapper的实例化。

Note

在mybatis里，如果你恰巧使用xml进行查询语句的编写（虽然mybatis后期支持annotion，但是还是xml亲切），只要你把xml mapper文件放到和interface 文件同样的包里，就可以完成自动注册

由于ClassPathMapperScanner相对来说比较底层，实际操作的过程中，我们主要会用两个类

@MapperScan annotion and MapperScannerConfigurer 来真正的完成mapper注册

@MapperScan

这是一个很有意思的annotaion类，它利用了MapperScannerRegistrar来调用ClassPathMapperScanner，最终完成mapper的注册。

 public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

    AnnotationAttributes annoAttrs = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);

    // this check is needed in Spring 3.1
    if (resourceLoader != null) {
      scanner.setResourceLoader(resourceLoader);
    }

    Class<? extends Annotation> annotationClass = annoAttrs.getClass("annotationClass");
    if (!Annotation.class.equals(annotationClass)) {
      scanner.setAnnotationClass(annotationClass);
    }

    Class<?> markerInterface = annoAttrs.getClass("markerInterface");
    if (!Class.class.equals(markerInterface)) {
      scanner.setMarkerInterface(markerInterface);
    }

    Class<? extends BeanNameGenerator> generatorClass = annoAttrs.getClass("nameGenerator");
    if (!BeanNameGenerator.class.equals(generatorClass)) {
      scanner.setBeanNameGenerator(BeanUtils.instantiateClass(generatorClass));
    }

    Class<? extends MapperFactoryBean> mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
    if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
      scanner.setMapperFactoryBean(BeanUtils.instantiateClass(mapperFactoryBeanClass));
    }

    scanner.setSqlSessionTemplateBeanName(annoAttrs.getString("sqlSessionTemplateRef"));
    scanner.setSqlSessionFactoryBeanName(annoAttrs.getString("sqlSessionFactoryRef"));

    List<String> basePackages = new ArrayList<String>();
    for (String pkg : annoAttrs.getStringArray("value")) {
      if (StringUtils.hasText(pkg)) {
        basePackages.add(pkg);
      }
    }
    for (String pkg : annoAttrs.getStringArray("basePackages")) {
      if (StringUtils.hasText(pkg)) {
        basePackages.add(pkg);
      }
    }
    for (Class<?> clazz : annoAttrs.getClassArray("basePackageClasses")) {
      basePackages.add(ClassUtils.getPackageName(clazz));
    }
    scanner.registerFilters();
    scanner.doScan(StringUtils.toStringArray(basePackages));

MapperScannerConfigurer

这个类是曾经的mapper标准扫描方案，他是一个 BeanDefinitionRegistryPostProcessor 的子类，利用 spring里BeanDefinitionRegistryPostProcessor可以操作并且添加新的BeanDefinition的特性，可以完成对与mapper的注册发现。

  @Override
  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);
    scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
    scanner.setResourceLoader(this.applicationContext);
    scanner.setBeanNameGenerator(this.nameGenerator);
    scanner.registerFilters();
    scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
  }

mybatis-springboot-starter

终于，到了最有意思的springboot 和mybatis的继承，这个主要要归功于 MybatisAutoConfiguration.class

这里充分利用了spring boot的autoconfiguration ，

如果没有MapperFactoryBean 存在，就会利用它本身的内部静态类 AutoConfiguredMapperScannerRegistrar 来完成mapper的注册

mapper interfaes has to be annotated with annotation @Mapper

其中，他内部也是使用了 ClassPathMapperScanner 来完成mapper的注册。

  @Configuration
  @Import({ AutoConfiguredMapperScannerRegistrar.class })
  @ConditionalOnMissingBean(MapperFactoryBean.class)
  public static class MapperScannerRegistrarNotFoundConfiguration {



  public static class AutoConfiguredMapperScannerRegistrar
      implements BeanFactoryAware, ImportBeanDefinitionRegistrar, ResourceLoaderAware {

    private BeanFactory beanFactory;

    private ResourceLoader resourceLoader;

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

      logger.debug("Searching for mappers annotated with @Mapper");

      ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);

      try {
        if (this.resourceLoader != null) {
          scanner.setResourceLoader(this.resourceLoader);
        }

        List<String> packages = AutoConfigurationPackages.get(this.beanFactory);
        if (logger.isDebugEnabled()) {
          for (String pkg : packages) {
            logger.debug("Using auto-configuration base package '{}'", pkg);
          }
        }

        scanner.setAnnotationClass(Mapper.class);
        scanner.registerFilters();
        scanner.doScan(StringUtils.toStringArray(packages));
      } catch (IllegalStateException ex) {
        logger.debug("Could not determine auto-configuration package, automatic mapper scanning disabled.", ex);
      }
    }

SqlSessionTemplate

SqlSessionTemplate 实现了 SqlSession,内部也包含了一个sqlSession的代理，通过手段，可以完成sqlsession对于spring transaction的绑定，再也不需要手动开启关闭session，也不用自己维护transaction

 this.sqlSessionProxy = (SqlSession) newProxyInstance(
        SqlSessionFactory.class.getClassLoader(),
        new Class[] { SqlSession.class },
        new SqlSessionInterceptor());

同时 SqlSessionTemplate 可以将mybatis的 PersistenceExceptions 转化为统一的DataAccessExceptions

上面只是简单的介绍了mybatis和spring的融合，mybatis虽然每天都在用，spring也是，但是两者内部的源代码，还是很值得推敲和学习。这里只是介绍了皮毛，以备后期自我学习。