mybatis——Spring中的接口映射器

一、接口映射器的配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 自动扫描package下bean -->
    <context:component-scan base-package="org.study.*"/>

    <!-- aop代理 -->
    <aop:aspectj-autoproxy/>

    <!-- 属性文件 -->
    <context:property-placeholder location="classpath*:db.properties"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${mysql.driver}"/>
        <property name="url" value="${mysql.url}"/>
        <property name="username" value="${mysql.username}"/>
        <property name="password" value="${mysql.password}"/>
        <property name="initialSize" value="${mysql.initialSize}"/>
        <property name="minIdle" value="${mysql.minIdle}"/>
        <property name="maxActive" value="${mysql.maxActive}"/>
        <property name="maxWait" value="${mysql.maxWait}"/>
     </bean>
    <!-- mybatis的SQLSessionFactory -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--扫描配置sql的xml文件-->
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>
    </bean>

    <!-- mybatis的mapper接口映射器 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--扫描package下的接口-->
        <property name="basePackage" value="org.study.mapper"/>
    </bean>

    <!-- 事务管理 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 启用声明式事务管理 支持注解@Transaction-->
    <tx:annotation-driven/>

</beans>

前文说明了：sql的xml解析和注解解析，所以省去sqlSessionFactory根据mapperLocations="classpath:mapper/*.xml "匹配对应sql.xml，然后解析。直接看接口映射器实现

二、MapperScannerConfigurer

MapperScannerConfigurer是mybatis-spring.jar中的类，不是mybatis.jar中的类，

主要目的：将mapper接口放入到SpringIOC容器中，并与sql文件映射。跟踪源码前需要要先了解SpringIOC——scan，疑问：

• 有@Component注解的class才会生成的BeanDefinition，然后初始化到SpringIOC容器中，因此接口需要生成BeanDefinition必须重写判断方法，在哪里重写的？
• 生成了BeanDefinition后，由于mapper.class是接口，IOC容器是怎样实例化的？

1、扫描mapper接口生成BeanDefinition实例

MapperScannerConfigurer只有两个方法

• postProcessBeanDefinitionRegistry:扫描mapper接口生成BeanDefinition的主要实现方法。
• processPropertyPlaceHolders：根据properties文件获取MapperScannerConfigurer的属性参数。

重点跟踪postProcessBeanDefinitionRegistry方法

   /* org.mybatis.spring.mapper.MapperScannerConfigurer#postProcessBeanDefinitionRegistry 
    * postProcessBeanDefinitionRegistry这个方法的执行时机：
    * IOC初始化-refresh()中的⑥ invokeBeanFactoryPostProcessors（beanfactory）时执行的
    * 即方法执行时。容器（registry）已经创建并且已经执行过一次scan,这里是另外附加一次scan
    */
  public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    if (this.processPropertyPlaceHolders) { 
      //propertis中获取basePackage参数
      //应该是适配springboot无xml方式实现
      processPropertyPlaceHolders();
    }

    //mybatis-spring.jar自实现的scanner
    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
    scanner.setAddToConfig(this.addToConfig);
    //includeFilters.add(annotationClass)
    scanner.setAnnotationClass(this.annotationClass);
    //includerFilters.add(markerInterface)
    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);
    //mapper接口的实际类型MapperFactoryBean.class
    scanner.setMapperFactoryBeanClass(this.mapperFactoryBeanClass);
    if (StringUtils.hasText(lazyInitialization)) {
      scanner.setLazyInitialization(Boolean.valueOf(lazyInitialization));
    }
    //最重要的实现之一：解决为什么接口没有@Component也会被扫描到
    //回忆一下spring中scan阶段includeFilters的作用：默认@Component注解的class才能被IOC扫描到并生成BeanDefinition实例（注意只是生成实例，还没有加入到容器中）
    //registerFIlters:修改了includeFilters范围
    //若配置了annotationClass：includeFilter.add(annotationClass):例如mapper接口使用@Mapper注解。
    //若配置了markerInterface:includeFilter.add(markerInterface)
    //都没有配置默认所有的class都可以生成BeanDefinition
    scanner.registerFilters();
    //解析basePackage下的class生成BeanDefinition（根据上面的includeFilters）
    scanner.scan(
        StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
  }

scanner.registerFilters（）: includeFilters修改

/* org.mybatis.spring.mapper.ClassPathMapperScanner#registerFilters */
  public void registerFilters() {
    boolean acceptAllInterfaces = true;

    // 配置注解，includeFilters添加注解类，basePackage下使用注解的类会被扫描到
    if (this.annotationClass != null) {
      addIncludeFilter(new AnnotationTypeFilter(this.annotationClass));
      acceptAllInterfaces = false;
    }

    // 配置接口，includeFilters添加接口，basePackage下实现接口的class会被扫描到
    if (this.markerInterface != null) {
      addIncludeFilter(new AssignableTypeFilter(this.markerInterface) {
        @Override
        protected boolean matchClassName(String className) {
          return false;
        }
      });
      acceptAllInterfaces = false;
    }
    //若没有配置注解和接口，默认扫描所有的class
    if (acceptAllInterfaces) {
      addIncludeFilter((metadataReader, metadataReaderFactory) -> true);
    }

    // 不扫描 *package-info.java
    addExcludeFilter((metadataReader, metadataReaderFactory) -> {
      String className = metadataReader.getClassMetadata().getClassName();
      return className.endsWith("package-info");
    });
  }

scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS))：扫描basePackage下的class

/* org.mybatis.spring.mapper.ClassPathMapperScanner#doScan */
  public Set<BeanDefinitionHolder> doScan(String... basePackages) {
   //org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan 
    //前面springioc-scan()中的doScan()方法
    //ClassPathMapperScanner重写了isCandidateComponent()
    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;
  }

调用super.doScan（basePackages）时： 由于重写isCandidateComponent()：接口生成的BeanDefinition也会加入到容器中。
原方法：includeFilters扫描到class文件并生成BeanDefinition实例，isCandidateComponent()会判断不是接口、抽象类，才会将BeanDefinition放入到IOC容器中
重写后：接口的BeanDefinition也会放入到IOC容器中（仅限basePackage下）

/* org.mybatis.spring.mapper.ClassPathMapperScanner#isCandidateComponent */
  protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
    //是接口返回true，原判断是metadata.isConcrete()：!(isInterface() || isAbstract())
    return beanDefinition.getMetadata().isInterface() && beanDefinition.getMetadata().isIndependent();
  }

processBeanDefinitions():初始化BeanDefinition的属性：

/* org.mybatis.spring.mapper.ClassPathMapperScanner#processBeanDefinitions */
  private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
    GenericBeanDefinition definition;
    for (BeanDefinitionHolder holder : beanDefinitions) {
      definition = (GenericBeanDefinition) holder.getBeanDefinition();
      String beanClassName = definition.getBeanClassName();
      LOGGER.debug(() -> "Creating MapperFactoryBean with name '" + holder.getBeanName() + "' and '" + beanClassName
          + "' mapperInterface");

      //解决：接口为什么能实例化成一个Bean
      //原beanClassName设置为构造方法的参数
      //beanClassName = MapperFactoryBean.class
      //经过上面配置，SpringIOC容器生成接口的实例实际是MapperFactoryBean类型的 
      //最后beanName(userMapper) - singletonObject(new MapperFactoryBean(UserMapper.class))     
      definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName); // issue #59
      definition.setBeanClass(this.mapperFactoryBeanClass);

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

      boolean explicitFactoryUsed = false;
      if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {
        //新增属性：definition.sqlSessionFactory根据BeanName注入
        definition.getPropertyValues().add("sqlSessionFactory",
            new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
        explicitFactoryUsed = true;
      } else if (this.sqlSessionFactory != null) {
        //新增属性：definition.sqlSessionFactory直接ref注入
        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.sqlSessionTemplate根据BeanName注入
        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.sqlSessionTemplate直接ref注入
        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);
      }
      //延迟实例化  默认false
      definition.setLazyInit(lazyInitialization);
    }
  }

到这里mapper接口的BeanDefinition实例已经全部初始化完成了，接下来就是Bean实例化了。Bean实例前先猜想一下这个实例是什么样的。

    // 例如一个UserMapper.class，
    MapperFactoryBean factoryBean = new MapperFactoryBean(UserMapper.class);
    factoryBean.setSqlSessionFactory(sqlSessionFactory);
    factoryBean.setSqlSessionTemplate(sqlSessionTemplate);

2、MapperFactoryBean初始化

 SpringIOC——refresh初始化中漏掉的实现FactoryBean接口的Bean的特殊处理，除beanName= "&" + beanName，其他初始化逻辑与Bean一模一样。

这里结合MapperFactoryBean实现，发现了FactoryBean作用：提供接口实例化的机会，接口绑定技术。接口是肯定不能实例化的，但是可以实例化一个FactoryBean实例代替接口。

例如：UserMapper接口的BeanDefinition实例化出来就是一个MapperFactoryBean实例，

断点发现，确实是一个MapperFactoryBean实例,其中记录了UserMapper.class信息。

 

 接口映射器实例化已经完成了，但是实际代码一般是下面这样的

@Autowired
private UserMapper userMapper；//MapperFactoryBean没有实现UserMaper，所以依赖注入时，注入的肯定不是MapperFactoryBean实例。
...
userMapper.seletUserById(1L);

断点发现依赖注入时，userMapper确实不是MapperFactoryBean实例，而是一个代理实例

 根据FactoryBean接口，猜想可能是在依赖注入时，依赖注入的是FactoryBean.getObject()实例

public interface FactoryBean<T> {

    String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
    T getObject() throws Exception;
    @Nullable
    Class<?> getObjectType();
    default boolean isSingleton() {
        return true;
    }

}

最终发现Bean初始化时有一个了解不够全面的地方：org.springframework.beans.factory.support.AbstractBeanFactory#getObjectForBeanInstance，
也是实现FactoryBean接口的Bean与其他类型Bean的区别所在。
① !(Bean instanceof FactoryBean) 直接返回Bean实例
②(Bean instanceof FactoryBean) 初始化时返回FactoryBean实例，其他情况下（例如DI）时返回的是FactoryBean.getObject()实例

    protected Object getObjectForBeanInstance(
            Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

        //UserMapper初始化时由于MapperFactoryBean instanceof FactoryBean，传入的name = "&userMapper"
        //依赖注入时传入的是name = "userMapper"
        if (BeanFactoryUtils.isFactoryDereference(name)) {
            //Bean instanceof FactoryBean的Bean初始化时,name = "&userMapper"直接返回FactoryBean实例
            if (beanInstance instanceof NullBean) {
                return beanInstance;
            }
            if (!(beanInstance instanceof FactoryBean)) {
                throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
            }
            if (mbd != null) {
                mbd.isFactoryBean = true;
            }
            return beanInstance;
        }

        // 没有实现FactoryBean的Bean直接返回Bean实例
        if (!(beanInstance instanceof FactoryBean)) {
            return beanInstance;
        }
        //依赖注入时name = "userMapper"
        //返回的是FactoryBean.getObject()实例，
        Object object = null;
        if (mbd != null) {
            mbd.isFactoryBean = true;
        }
        else {
            object = getCachedObjectForFactoryBean(beanName);
        }
        if (object == null) {
            // Return bean instance from factory.
            FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
            // Caches object obtained from FactoryBean if it is a singleton.
            if (mbd == null && containsBeanDefinition(beanName)) {
                mbd = getMergedLocalBeanDefinition(beanName);
            }
            boolean synthetic = (mbd != null && mbd.isSynthetic());
            object = getObjectFromFactoryBean(factory, beanName, !synthetic);
        }
        return object;
    }

到这里初始化就剩下一个MapperFactoryBean.getObject()：先小结一下：

① SpringIOC容器中userMapper是MapperFactoryBean类型的

② SpringIOC容器中userService中userMapper是MapperFactoryBean.getObject()类型的（UserMapper.class）

3、MapperFactoryBean.getObject()

/* org.mybatis.spring.mapper.MapperFactoryBean#getObject */
  public T getObject() throws Exception {
    //这里sqlSession是SqlSessionTemplate类型的
    return getSqlSession().getMapper(this.mapperInterface);
  }

/* org.mybatis.spring.SqlSessionTemplate#getMapper */
  public <T> T getMapper(Class<T> type) {
    return getConfiguration().getMapper(type, this);
  }

/* 
 * 下面就是mybatis.jar中的逻辑了，也就回到了前文的逻辑了
 */

/* org.apache.ibatis.session.Configuration#getMapper */
  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
  }

/* org.apache.ibatis.binding.MapperRegistry#getMapper */
  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    if (mapperProxyFactory == null) {
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }

/* org.apache.ibatis.binding.MapperProxyFactory*/
  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }

  protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }