Mybatis源码---重写一个最简单的Mybatis架构实现（三）

最新推荐文章于 2021-08-22 14:52:10 发布

小雨的光

最新推荐文章于 2021-08-22 14:52:10 发布

阅读量474

点赞数

分类专栏： mybatis源码分析

本文链接：https://blog.csdn.net/qq_28802119/article/details/83504659

版权

mybatis源码分析专栏收录该内容

8 篇文章 0 订阅

订阅专栏

前两篇文章里，我们实现了一个简单的Mybatis。只要愿意，如果完善了后续的数据库操作，我们完全可以用它来替换本来的Mybatis。在本篇文章里，我们要做的是完成我们自定义Mybatis与Spring或SpringBoot集成时的自动配置。首先，我们在来熟悉一下在XML中配置MapperScannerConfigurer时的使用：

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
  <property name="basePackage" value="com.mapper"/>
 </bean>

在前面的文章里，我们详细分析过为Mapper接口生成代理的配置方法，这里不做过多描述。MapperScannerConfigurer类会为我们批量完成Mapper接口代理类的生成。看XML中的配置可以发现，需要为它注入一些属性。我们再来看看MapperScannerConfigurer类的源码中属性定义的部分：

public class MapperScannerConfigurer implements BeanDefinitionRegistryPostProcessor, 
 
InitializingBean, ApplicationContextAware, BeanNameAware {

  private String basePackage;

  private boolean addToConfig = true;
 
  private SqlSessionFactory sqlSessionFactory;

  private SqlSessionTemplate sqlSessionTemplate;

  private String sqlSessionFactoryBeanName;

  private String sqlSessionTemplateBeanName;

  private Class<? extends Annotation> annotationClass;

  private Class<?> markerInterface;

  private ApplicationContext applicationContext;

  private String beanName;

  private boolean processPropertyPlaceHolders;

  private BeanNameGenerator nameGenerator;

}

从名称我们也可以大致猜出来它们的含义。需要重点说一下几个特别的属性：

1. annotationClass是用来指定扫描哪个注解的。这样，MapperScannerConfigurer类只会为声明了该注解的类生成代理类。这样，就可以防止MapperScannerConfigurer把我们不需要生成代理类的类也生成代理类了。

2.markerInterface是用来声明抽象Mapper接口的。比如，我们声明了一个所有Mapper接口都要继承的接口AbstractMapper，它本身并不需要被扫描，那么，就可以看设置为markerInterface来防止被扫描。

之所以要重点说明MapperScannerConfigurer类的属性含义，是因为在Mybatis被自动配置的时候，其实就是这些内容被自动设值了。Mybatis自动配置的关键是@MapperScan，可以看看它的源码：

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

  String[] value() default {};

  String[] basePackages() default {};

  Class<?>[] basePackageClasses() default {};

  Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

  Class<? extends Annotation> annotationClass() default Annotation.class;

  Class<?> markerInterface() default Class.class;

  String sqlSessionTemplateRef() default "";

  String sqlSessionFactoryRef() default "";

  Class<? extends MapperFactoryBean> factoryBean() default MapperFactoryBean.class;

}

在@MapperScan注解中，我们发现它和MapperScannerConfigurer类的属性看起来很像。其实，这就是所谓默认配置了，Spring用注解中设置值的方式替代了XML中的属性注入。那么问题来了，@MapperScan的值是什么时候起作用的呢？我们发现@MapperScan注解的声明中有一行代码：@Import(MapperScannerRegistrar.class)。而@Import注解是用来引入@Configuration注解声明的内容的。这一切怎么解释呢？

我们看看@SpringBootApplication注解的源码：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
		@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

}

我们看到@SpringBootApplication注解声明时用到了@SpringBootConfiguration注解，那好，我们看看@SpringBootConfiguration注解的源码：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {

}

好了，我们明白了一件事，被@SpringBootApplication声明的类其实也被@Configuration注解声明了，被@SpringBootApplication注解声明的类其实就是主启动类了。前面的文章中提到过在主启动类其实执行了AbstractApplicationContext的run()方法(Spring容器启动的主要流程)，代码如下：

public void refresh() throws BeansException, IllegalStateException {
            //刷新前的预处理
            prepareRefresh();

            // 获取BeanFactory
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // BeanFactory的预准备工作（BeanFactory进行一些设置）
            prepareBeanFactory(beanFactory);
           // BeanFactory准备工作完成后进行的后置处理工作，子类通过重写这个方法来在BeanFactory创建并预准备完成以后               做进一步的设置
            postProcessBeanFactory(beanFactory);

            // 执行BeanFactoryPostProcessor的后置处理方法
            invokeBeanFactoryPostProcessors(beanFactory);

            // 注册BeanPostProcessors，此时并不执行这些bean的后置处理器
            registerBeanPostProcessors(beanFactory);

             // 初始化MessageSource
             initMessageSource();

             // 初始化事件派发器
             initApplicationEventMulticaster();

             // 是一个空方法，留给容器的子类实现，子类重写这个方法，在容器刷新的时候可以自定义一些逻辑
             onRefresh();

             // 注册事件驱动
             registerListeners();

             //初始化所有剩下的单实例bean
             finishBeanFactoryInitialization(beanFactory);

             // 完成BeanFactory的初始化创建工作，IOC容器就创建完成
             finishRefresh();
    }

在执行其中的obtainFreshBeanFactory()方法时，关键代码如下：

DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
   this.beanFactory = beanFactory;
}

好了，重点来了。我们看看MapperScannerRegistrar 类的源码：

public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {

  private ResourceLoader resourceLoader;

  /**
   * {@inheritDoc}
   */
  @Override
  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));
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public void setResourceLoader(ResourceLoader resourceLoader) {
    this.resourceLoader = resourceLoader;
  }

}

可以发现，大篇幅的代码都只描述了一个方法----registerBeanDefinitions()。本来还可以继续往下挖，但是呢，已经不是很有必要了吧？很明显可以猜出来，在SpringBoot主启动类启动时，会在加载BeanDefinition的阶段执行MapperScannerRegistrar类的registerBeanDefinitions()方法。这个方法比较简单，只要抓住ClassPathMapperScanner scan这条线索很容易就看懂了，和MapperScannerConfigurer类做的事情是一毛一样的。所以，我们只要定义一个类似@MapperScan的注解，然后把MapperScannerRegistrar类引入就可以了。

最后是福利时间，下面两段代码就是改造完成的MapperScannerRegistrar类和@MapperScan注解源码了，亲测可用。

@Component
public class FisherScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {

  private ResourceLoader resourceLoader;

  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

    AnnotationAttributes annoAttrs = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(FisherScan.class.getName()));
    ClassPathFisherScanner scanner = new ClassPathFisherScanner(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 FisherFactoryBean> mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
    if (!FisherFactoryBean.class.equals(mapperFactoryBeanClass)) {
      scanner.setFisherFactoryBean(BeanUtils.instantiateClass(mapperFactoryBeanClass));
    }

    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));
  }

  /**
   * {@inheritDoc}
   */
  public void setResourceLoader(ResourceLoader resourceLoader) {
    this.resourceLoader = resourceLoader;
  }

}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FisherScannerRegistrar.class)
public @interface FisherScan {

  String[] value() default {};

  String[] basePackages() default {};

  Class<?>[] basePackageClasses() default {};

  Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

  Class<? extends Annotation> annotationClass() default Annotation.class;

  Class<?> markerInterface() default Class.class;

  Class<? extends FisherFactoryBean> factoryBean() default FisherFactoryBean.class;

}

小雨的光

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mybatis源码---重写一个最简单的Mybatis架构实现（三）

前两篇文章里，我们实现了一个简单的Mybatis。只要愿意，如果完善了后续的数据库操作，我们完全可以用它来替换本来的Mybatis。在本篇文章里，我们要做的是完成我们自定义Mybatis与Spring或SpringBoot集成时的自动配置。首先，我们在来熟悉一下在XML中配置MapperScannerConfigurer时的使用：&lt;bean class="org.mybatis....
复制链接

扫一扫