亲宝软件园·资讯

展开

MyBatis Mapper注入

枯木fc 人气:0

在 SpringBoot 体系中,MyBatis 对 Mapper 的注入常见的方式我知道的有 2 种:

1、@MapperScan

MapperScan 类是 mybatis-spring 包里面的。

通过在启动类上使用 @MapperScan,然后通过 basePackages 属性指定 Mapper 文件所在的目录来进行扫描装载,默认情况下指定目录下的所有.java文件都会被当做 Mapper 来加载处理。

@MapperScan(basePackages = "com.test.springboot.mapper")
@ServletComponentScan(basePackages = "com.test.springboot.filters")
@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

可以看到,在 MapperScan 注解上有使用了 @Import(MapperScannerRegistrar.class) ,也就是把MapperScannerRegistrar 当做配置类注入 Spring 容器。

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

MapperScannerRegistrar 类是一个 ImportBeanDefinitionRegistrar 的实现,会在创建注入 Spring 容器后,被 Spring 主动触发。其重载的方法主要是创建并注册了一个 MapperScannerConfigurer 类型的 registry,这个 registry 主要就是去指定的 basePackages目录扫描指定的文件,并将其装载成 BeanDefinition 注入 Spring 容器。

public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {}
@Override
  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    AnnotationAttributes mapperScanAttrs = AnnotationAttributes
        .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
    if (mapperScanAttrs != null) {
      registerBeanDefinitions(importingClassMetadata, mapperScanAttrs, registry,
          generateBaseBeanName(importingClassMetadata, 0));
    }
  }

  void registerBeanDefinitions(AnnotationMetadata annoMeta, AnnotationAttributes annoAttrs,
      BeanDefinitionRegistry registry, String beanName) {

    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
    builder.addPropertyValue("processPropertyPlaceHolders", true);

    Class<? extends Annotation> annotationClass = annoAttrs.getClass("annotationClass");
    if (!Annotation.class.equals(annotationClass)) {
      builder.addPropertyValue("annotationClass", annotationClass);
    }
  // ...
  }

下面是MapperScannerConfigurer 的主要实现,其主要依赖于 ClassPathMapperScanner 来实现扫面,在 MapperScan 指定了 basePackages 的情况下,它只会扫描这个指定目录,否则可能就是扫描整个 classpath 了(就类似 SpringBoot 的完整扫描)。

@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.setMapperFactoryBeanClass(this.mapperFactoryBeanClass);
    if (StringUtils.hasText(lazyInitialization)) {
      scanner.setLazyInitialization(Boolean.valueOf(lazyInitialization));
    }
    if (StringUtils.hasText(defaultScope)) {
      scanner.setDefaultScope(defaultScope);
    }
    scanner.registerFilters();
    scanner.scan(
        StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
  }

在 ClassPathMapperScanner 的实现中,我们可以看到他会把扫描到的目标类(比如用 @Mapper 注解的类 xxxMapper.java)的 BeanDefinition 的 beanClass 设置为 MapperFactoryBean,后续根据 BeanDefinition 创建的 Bean 也就是 MapperFactoryBean 的类型了。因为MapperFactoryBean 是一个工厂类,那么在 SpringBoot 要对 xxxMapper 实例化的时候,它会判断到 xxxMapper 对应的 Bean 是一个工厂类,然后会去调用 它的 getObject 方法创建 xxxMapper.java 的实例(当然这里肯定是个代理类)。

private Class<? extends MapperFactoryBean> mapperFactoryBeanClass = MapperFactoryBean.class;

  public void setMapperFactoryBeanClass(Class<? extends MapperFactoryBean> mapperFactoryBeanClass) {
    this.mapperFactoryBeanClass = mapperFactoryBeanClass == null ? MapperFactoryBean.class : mapperFactoryBeanClass;
  }

  /**
   * Calls the parent search that will search and register all the candidates. Then the registered objects are post
   * processed to set them as MapperFactoryBeans
   */
  @Override
  public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);

    if (beanDefinitions.isEmpty()) {
      LOGGER.warn(() -> "No MyBatis mapper was found in '" + Arrays.toString(basePackages)
          + "' package. Please check your configuration.");
    } else {
      processBeanDefinitions(beanDefinitions);
    }

    return beanDefinitions;
  }

  private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
    AbstractBeanDefinition definition;
    BeanDefinitionRegistry registry = getRegistry();
    for (BeanDefinitionHolder holder : beanDefinitions) {
      definition = (AbstractBeanDefinition) holder.getBeanDefinition();
          // ...    String beanClassName = definition.getBeanClassName();
      definition.setBeanClass(this.mapperFactoryBeanClass);

      definition.getPropertyValues().add("addToConfig", this.addToConfig);

      // Attribute for MockitoPostProcessor
      // https://github.com/mybatis/spring-boot-starter/issues/475
      definition.setAttribute(FACTORY_BEAN_OBJECT_TYPE, beanClassName);

      // ...if (ConfigurableBeanFactory.SCOPE_SINGLETON.equals(definition.getScope()) && defaultScope != null) {
        definition.setScope(defaultScope);
      }

      if (!definition.isSingleton()) {
        BeanDefinitionHolder proxyHolder = ScopedProxyUtils.createScopedProxy(holder, registry, true);
        if (registry.containsBeanDefinition(proxyHolder.getBeanName())) {
          registry.removeBeanDefinition(proxyHolder.getBeanName());
        }
        registry.registerBeanDefinition(proxyHolder.getBeanName(), proxyHolder.getBeanDefinition());
      }

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

getObject 方法内部是先获取它的 SqlSessionTemplate 实例,然后根据 mapperInterface(这个是 xxxMapper.java 的全限定名)去获取 xxxMapper 对应的 MapperProxy 实例,然后对 xxxMapper 类的方法调用都会因为代理而一步步转到 MapperProxy -> SqlSessionTemplate -> sqlSessionProxy(一个 SqlSession 的代理实例)上去执行。

2、@Mapper

Mapper 类是 mybatis 包里面的。

单纯只在类上加 @Mapper 的注解肯定是没用的,这里我们还需要另外一个官方项目mybatis-spring-boot-autoconfigure 的协助了(这是个自动配置的项目,因此需要 SpringBoot 的支持,换一句话说就是项目还要另外再加入 Spring 官方的 spring-boot-configuration-processor 依赖),这样可以在只加了 @Mapper 注解的情况下让 Mapper文件顺利的被扫描和注入。

为了依赖使用的方便与统一,可以直接使用mybatis-spring-boot-starter依赖

<dependency>
      <groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybatis-spring-boot-starter</artifactId>
      <version>${mybatis-spring.version}</version>
</dependency>

我们可以在mybatis-spring-boot-autoconfigure 依赖的 META-INF 目录下找到 spring.factories 的文件,这个是 SpringBoot 主动来扫描需要进行自动配置注入的目标文件。这里面可以看到后面的主角 MybatisAutoConfiguration 类,这个类加载了 Mybatis 的配置文件,声明依赖了一些 Bean等,然后也能找到它又通过 @Import 主动注入了一个叫AutoConfiguredMapperScannerRegistrar 的类。

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.mybatis.spring.boot.autoconfigure.MybatisLanguageDriverAutoConfiguration,\
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration
@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 {    // ...
    @org.springframework.context.annotation.Configuration
    @Import(AutoConfiguredMapperScannerRegistrar.class)
    @ConditionalOnMissingBean({ MapperFactoryBean.class, MapperScannerConfigurer.class })
    public static class MapperScannerRegistrarNotFoundConfiguration implements InitializingBean {
      @Override
      public void afterPropertiesSet() {
        logger.debug(
            "Not found configuration for registering mapper bean using @MapperScan, MapperFactoryBean and MapperScannerConfigurer.");
      }
    }    // ...
}

注入的这个AutoConfiguredMapperScannerRegistrar 和前文的MapperScannerRegistrar有点类似,是一个扫描类的注册器。它在这里注册的也是MapperScannerConfigurer, 不同的是这里明确指定扫描的是带 Mapper 注解的文件,然后这里扫描的的 basePackage 是它自动获取的,实际就是启动类所在目录以及子目录。后面的扫描过程也就和方法一的后面是一样的了。

List<String> packages = AutoConfigurationPackages.get(this.beanFactory);
// ...BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
builder.addPropertyValue("processPropertyPlaceHolders", true);
builder.addPropertyValue("annotationClass", Mapper.class);
builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(packages));

MyBtatis 团队貌似更加推崇使用 @Mapper 的方式,因为他们在 AutoConfiguredMapperScannerRegistrar 的注释里面这么写道:这个方法会和 SpringBoot 一样,扫描的是同一个基础 pacakge。如果你想获得更多能力,那么你可以显式的使用 MapperScan 注解,但是 Mapper 注解的方式能使类型映射器正常的工作,开箱即用,就像是在使用 Spring Data JPA 库一样。

/**
   * This will just scan the same base package as Spring Boot does. If you want more power, you can explicitly use
   * {@link org.mybatis.spring.annotation.MapperScan} but this will get typed mappers working correctly, out-of-the-box,
   * similar to using Spring Data JPA repositories.
   */

参考文章:

关于MyBatis的@Mapper和@MapperScan注解的一点思考

MapperFactoryBean的创建

MapperFactoryBean和MapperScannerConfigurer的作用和区别

加载全部内容

相关教程
猜你喜欢
用户评论