mybatis源码(十二) mybatis-spring的实现原理

mybatis源码(十二) mybatis-spring的实现原理

1.Spring中的一些概念：

　　1.BeanDefinition：用于描述springbean的配置信息，spring配置Bean的方式通常有3种。

• • xml配置文件的方式
  • java注解的方式。例如@service注解等
  • javaConfig的方式

　　spring容器启动后，首先会对bean的配置信息进行解析。把bean的配置信息转换为BeanDefinition对象。BeanDefiniton是一个接口。通过不同的实现类来描述不同方式的配置的Bean信息

　　2.BeanDefinitionRegistry：BeanDefinitionRegistry是BeanDefinition容器，所有的Bean配置解析后生成的BeanDefinition对象都会注册到BeanDefinitionRegistry对象中。Spring提供了扩展机制，允许用户在Spring框架启动时，往BeanDefinitionRegistry容器中注册BeanDefinition对象。

　　3.BeanFactory：BeanFactory是Spring的Bean工厂，负责Bean的创建及属性注入。它同时是一个Bean容器，Spring框架启动后，会根据BeanDefinition对象创建Bean实例，所有的单例Bean都会注册到BeanFactory容器中。

　　4.BeanFactoryPostProcessor：BeanFactoryPostProcessor是Spring提供的扩展机制，用于在所有的Bean配置信息解析完成后修改Bean工厂信息。例如，向BeanDefinitionRegistry容器中增加额外的BeanDefinition对象，或者修改原有的BeanDefinition对象。BeanFactoryPostProcessor是一个接口，该接口中只有一个方法，postProcessBeanFactory。当我们配置的Bean实现该接口时，Spring解析Bean配置完成后，就会调用所有BeanFactoryPostProcessor实现类的postProcessBeanFactory()方法。

　　5.importBeanDefinitionRegistry：ImportBeanDefinitionRegistrar是一个接口， 该接口的实现类作用于Spring解析Bean的配置阶段，当解析@Configuration注解时，可以通过ImportBeanDefinitionRegistrar接口的实BeanDefinitionRegistry容器中添加额外的BeanDefinition对象。ImportBeanDefinitionRegistrar接口定义如下:ImportBeanDefinitionRegistrar接实现类的registerBeanDefinitions()方法会在Spring解析@Configuration注解时调用。ImportBeanDefinitionRegistrar 接口需要配合@Import注解使用，importingClassMetadata参数为@Import所在注解的配置信息，registry参数为BeanDefinition容器。

public interface ImportBeanDefinitionRegistrar {

    /**
     * Register bean definitions as necessary based on the given annotation metadata of
     * the importing {@code @Configuration} class.
     * <p>Note that {@link BeanDefinitionRegistryPostProcessor} types may <em>not</em> be
     * registered here, due to lifecycle constraints related to {@code @Configuration}
     * class processing.
     * @param importingClassMetadata annotation metadata of the importing class
     * @param registry current bean definition registry
     */
    public void registerBeanDefinitions(
            AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);

}

 　　6.BeanPostProcessor：Bean的后置处理器，在Bean初始化方法(init-method属性指定的方法或afterPropertiesSet()方法)调用前后，会执行BeanPostProcessor中定义的拦截逻辑。BeanPostProcessor接口定义如下:

public interface BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

BeanPostProcessor接口中定义了两个方法，postProcessBeforelnitialization()方法会在所有Bean初始化方法调用之前执行，postProcessAfterlnitialization()方法会在所有Bean的初始化方
法调用之后执行。BeanPostProcessor通常用于处理Spring Bean对应的Java类中的注解信息或者创建Bean的代理对象。

　　7.ClassPathBeanDefinitionScanner：ClassPathBeanDefinitionScanner是BeanDefinition扫描器，能够对指定包下的Class进行扫描，将Class信息转换为BeanDefinition对象注册到BeanDefinitionRegistry容器中ClassPathBeanDefinitionScanner支持自定义的过滤规则，例如我们可以只对使用某种注解的类进行扫描。Spring中的@Service、@Component等注解配置Bean都是通过ClassPathBeanDefinitionScanner实现的。MyBatis Spring 模块中Mapper接口的扫描使用到了ClassPathBeanDefinitionScanner类

 　　8.FactoryBean:FactoryBean是Spring中的工厂Bean， 通常用于处理Spring中配置较为复杂或者由动态代理生成的Bean实例。实现了该接口的Bean不能作为普通的Bean使用，而是作为单个对象的工厂。当我们通过Bean名称获取FactoryBean实例时，获取到的并不是FactoryBean对象本身，而是FactoryBean对象的getObject()方 法返回的实例。例如如下Bean配置:

<bean id="sqlSessionFactory" class="org.mybatis.spring.Sq1SessionFactoryBean">
<property name="dataSource" ref="dataSource" />
</bean>

SqlSessionFactoryBean是一个FactoryBean,通过名称sqlSessionFactory从Spring容器中获取Bean时，获取到的实际上是SqlSessionFactoryBean对象的getObject()方法返回的对象。

2.spring容器启动过程

Spring框架的启动过程大致可以分为以下几步:
　　(1) 对所有Bean的配置信息进行解析，其中包括XML配置文件、Java注解以及Java Config方式配置的Bean。将Bean的配置信息转换为BeanDefinition对象，注册到BeanDefinitionRegistry容器中。
　　(2) 从BeanDefinitionRegistry 容器中获取实现了BeanFactoryPostProcessor接口的Bean定义，然后实例化Bean,调用所有BeanFactoryPostProcessor对象的postProcessBeanFactory()方
　　     法，在postProcessBeanFactory()方法中可以对Bean工厂的信息进行修改。
　　(3) 根据BeanDefinitionRegistry容器 中的BeanDefinition对象实例化所有的单例Bean,并对Bean的属性进行填充。
　　(4) 执行所有实现了BeanPostProcessor 接口的Bean的postProcessBeforelnitialization()方法。 该方法中可以对原始的Bean进行包装。
　　(5) 执行Bean的初始化方法，初始化方法包括配置Bean时通过init-method属性指定的方法，或者通过实现lnitializingBean接口重写的afterPropertiesSet()方法。
　　(6) 执行所有实现了BeanPostProcessor接口的Bean的postProcessAferlnitialization()方法。

　　

 3.mapper动态代理注册过程

 我们在做项目的时候，经常会用到@MapperScan注解扫描指定的mapper接口，那么他的内部是怎么做的呢

首先看到@MapperScan的源码

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(MapperScannerRegistrar.class)
@Repeatable(MapperScans.class)
public @interface MapperScan {
  // 扫描包路径
  String[] value() default {};
  // 扫描包路径
  String[] basePackages() default {};
  // 扫描Mapper接口对应的class文件
  Class<?>[] basePackageClasses() default {};
  // bean 名称生成策略
  Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
  // 只扫描通过某种注解修饰的类和方法
  Class<? extends Annotation> annotationClass() default Annotation.class;
  // 只扫描某种类型的子类型
  Class<?> markerInterface() default Class.class;
  // 指定使用哪个SQLSessionTempleate对象
  String sqlSessionTemplateRef() default "";
  // 指定使用哪个sqlSessionFactory对象
  String sqlSessionFactoryRef() default "";
  // 指定使用自定义的MapperFactoryBean 返回mybatis 代理对象作为spring的bean
  Class<? extends MapperFactoryBean> factoryBean() default MapperFactoryBean.class;

}

通过源码，注意到，使用了一个 @Import(MapperScannerRegistrar.class) ，导入了一个MapperScannerRegistrar类。

进入该类，我们发现该类实现了ImportBeanDefinitionRegistrar 接口 Spring中的ImportBeanDefinitionRegistrar用于在Spring解析Bean的配置阶段往BeanDefinitionRegistry容器中注册额外的BeanDefinition对象。

那么MapperScannerRegister做了哪些操作呢

public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {

  private ResourceLoader resourceLoader;

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

  /**
   * {@inheritDoc}
   */
  @Override
  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    AnnotationAttributes mapperScanAttrs = AnnotationAttributes
        .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
    if (mapperScanAttrs != null) {
      // 调用registerBeanDefinitions（）方法注册BeanDefinition对象
      registerBeanDefinitions(mapperScanAttrs, registry);
    }
  }

  void registerBeanDefinitions(AnnotationAttributes annoAttrs, BeanDefinitionRegistry registry) {
    // ClassPathMapperScanner是Mybatis Spring模块自定义的BeanDefinition扫描器
    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);

    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<>();
    basePackages.addAll(
        Arrays.stream(annoAttrs.getStringArray("value"))
            .filter(StringUtils::hasText)
            .collect(Collectors.toList()));

    basePackages.addAll(
        Arrays.stream(annoAttrs.getStringArray("basePackages"))
            .filter(StringUtils::hasText)
            .collect(Collectors.toList()));
    // 添加需要扫描的包
    basePackages.addAll(
        Arrays.stream(annoAttrs.getClassArray("basePackageClasses"))
            .map(ClassUtils::getPackageName)
            .collect(Collectors.toList()));
    // 注册扫描过滤规则
    scanner.registerFilters();
    // 对包中的类进行扫描生成BeanDefinition对象
    scanner.doScan(StringUtils.toStringArray(basePackages));
  }

  /**
   * A {@link MapperScannerRegistrar} for {@link MapperScans}.
   * @since 2.0.0
   */
  static class RepeatingRegistrar extends MapperScannerRegistrar {
    /**
     * {@inheritDoc}
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
        BeanDefinitionRegistry registry) {
      AnnotationAttributes mapperScansAttrs = AnnotationAttributes
          .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScans.class.getName()));
      if (mapperScansAttrs != null) {
        Arrays.stream(mapperScansAttrs.getAnnotationArray("value"))
            .forEach(mapperScanAttrs -> registerBeanDefinitions(mapperScanAttrs, registry));
      }
    }
  }

}

如上面的代码所示，MapperScannerRegistrar类实现了ImportBeanDefinitionRegistrar接口的registerBeanDefinitions()方法，
该方法调用了重载的registerBeanDefinitions()进行处理。在重载方法中，首先创建了一个ClassPathMapperScanner对象，然后获取MapperScan注解的属性信息，根据MapperScan的annotationClass和
markerlnterface属性对扫描的Class进行过滤，最后调用ClassPathMapperScanner对象的doScan()方法进行扫描。ClassPathMapperScanner是Spring中ClassPathBeanDefinitionScanner的子类，用于扫描特定包下的Mapper接口，将Mapper接口信息转换为对应的BeanDefinition对象。下面是ClassPathMapperScanner 类doScan()方法的实现:

/**
   * 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) {
    // 调用父类的doScan（）方法，將包中的Class转换为BeanDefinitionHolder对象
    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 {
      // 对BeanDefinitionHolder进行处理
      processBeanDefinitions(beanDefinitions);
    }

    return beanDefinitions;
  }

  private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
    GenericBeanDefinition definition;
    for (BeanDefinitionHolder holder : beanDefinitions) {
      // 获取BeanDefinition对象
      definition = (GenericBeanDefinition) holder.getBeanDefinition();
      String beanClassName = definition.getBeanClassName();
      LOGGER.debug(() -> "Creating MapperFactoryBean with name '" + holder.getBeanName()
          + "' and '" + beanClassName + "' mapperInterface");

      // the mapper interface is the original class of the bean
      // but, the actual class of the bean is MapperFactoryBean
      definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName);
      // 將BeanDefinition对象的beanClass属性设置为MapperFactoryBean
      definition.setBeanClass(this.mapperFactoryBean.getClass());
      // 修改BeanDefinition对象的propertyValues属性，將sqlSessionFactory注入到MapperFactoryBean中
      definition.getPropertyValues().add("addToConfig", this.addToConfig);

      boolean explicitFactoryUsed = false;
      if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {
        definition.getPropertyValues().add("sqlSessionFactory", new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
        explicitFactoryUsed = true;
      } else if (this.sqlSessionFactory != null) {
        definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
        explicitFactoryUsed = true;
      }

      if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {
        if (explicitFactoryUsed) {
          LOGGER.warn(() -> "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
        }
        definition.getPropertyValues().add("sqlSessionTemplate", new RuntimeBeanReference(this.sqlSessionTemplateBeanName));
        explicitFactoryUsed = true;
      } else if (this.sqlSessionTemplate != null) {
        if (explicitFactoryUsed) {
          LOGGER.warn(() -> "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
        }
        definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
        explicitFactoryUsed = true;
      }

      if (!explicitFactoryUsed) {
        LOGGER.debug(() -> "Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
        definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
      }
    }
  }

如上面的代码所示，在ClassPathMapperScanner类的doScan()方法中，做了如下几部操作
　　1.首先调用父类的doScan()方法，将指定包下的Mapper接口信息转换为BeanDefinitionHolder对象，BeanDefinitionHolder 中持有一个BeanDefinition对象及Bean的名称和所有别名。
　　2.所有的Mapper接口转换为BeanDefinitionHolder对象后，接着调用processBeanDefinitions()方法，对所有BeanDefinitionHolder对象进行处理。
　　3.在processBeanDefinitions()方法中，对所有BeanDefinitionHolder对象进行遍历，获取BeanDefinitionHolder对象中持有的BeanDefinition对象。然后对BeanDefinition对象的信息进行修改， 将
BeanDefinition对象的beanClass属性设置为MapperFactoryBean,并向BeanDefinition 对象中增加几个PropertyValue对象，对应MapperFactoryBean的addToConfig和sq|SessionTemplate等属性。
将BeanDefinition 对象的beanClass 属性设置为MapperFactoryBean这一步很重要， 当Spring将所有的Bean配置信息转换为BeanDefinition对象后，就会根据BeanDefinition对象来实例化Bean。
由于BeanDefinition对象的beanClass属性被设置为MapperFactoryBean，因此Spring在创建Bean时实例化的是MapperFactoryBean对象。Spring 会根据BeanDefinition对象中的PropertyValues对象对MapperFactoryBean对象进行属性填充，因MapperFactoryBean对象的addToConfig和sqlSessionTemplate属性会被自动注入。MapperFactoryBean实现了FactoryBean接口。Spring中的FactoryBean, FactoryBean是单个Bean的工厂Bean, 当我们根据Mapper类型从Spring容器中获取FactoryBean时，获取到的并不是FactoryBean本身，而是FactoryBean的getObject()方法返回的对象。

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

MapperFactoryBean的getObject()方法中，调用SqlSession对象的getMapper()方 法返回一个Mapper动态代理对象。