@MapperScan 源码解析

大家好，又见面了，我是你们的朋友全栈君。

@MapperScan

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

@Import 的作用就是向spring容器中导入一个BeanDefinition对象

MapperScannerRegistrar

public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware { 
    ... }

通过源码看出这个导入的类还是一个ImportBeanDefinitionRegistrar，这个接口下面有一个registerBeanDefinitions（…）
通过这个方法的 BeanDefinitionRegistry ，就可以完成BeanDefinition 的注册

public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { 
   
// 获取MapperScan注解的信息
    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);
    }

	//annotationClass 的设置，也就是扫描出来的类必须标注了annotationClass ，否则不会扫描
    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"));
    // 获取指定的sqlSessionFactoryRef 在@MapperScan注解上有一个 SqlSessionFactoryRef的属性可以指定
    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));
  }

1. 获取MapperScan注解上的一些信息
2. 定义一个扫描器 ClassPathMapperScanner ，这个扫描器其实是继承自spring的ClassPathBeanDefinitionScanner，但是在实例化的时后
   第二个参数值为false ， super(registry, false); 意思是说不适用spring提供的默认的过滤方式
   对于spring的扫描器而言，需要满足两个条件才会被扫描，首先不能是接口，其次是不需要标注@Component注解，所以这里想要扫描
   mapper 的接口就需要自己去实现过滤的规则，到那时这里的annotationClass 只是记录一下，具体的操作在registerFilters()
   3.注册Filters
   4.进行doScan 扫描

还有一点需要注意的是，spring在进行扫描的时候，会去调用一个方法isCandidateComponent（），这个方法在spring的scanner中的实现如下

	protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) { 
   
		AnnotationMetadata metadata = beanDefinition.getMetadata();
		// 不是接口或抽象类，如果是抽象类那么抽象类上得是Lookup注解
		return (metadata.isIndependent() && (metadata.isConcrete() ||
				(metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName()))));
	}

这个方法可以进行接口的过滤，但是mybatis的接口是需要扫描到spring 容器的，所以对于@MapperScan的扫描器重写了这个方法

  @Override
  protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) { 
   
    return beanDefinition.getMetadata().isInterface() && beanDefinition.getMetadata().isIndependent();
  }

也就是@MapperScan 中的扫描器只会扫描接口

接下来思考一个问题，通过上述方式的确是能让spring帮助mybatis进行扫描，但是扫描出来的BeanClass是什么呢？？？ 是mapper接口???
显然不能是这些，接口是无法直接进行实例化的，所以这些扫描出来的BeanDefinition还需要进行处理
处理的逻辑就在doScan()==>processBeanDefinitions()

private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) { 
   
    GenericBeanDefinition definition;
    for (BeanDefinitionHolder holder : beanDefinitions) { 
   
      definition = (GenericBeanDefinition) holder.getBeanDefinition();

      if (logger.isDebugEnabled()) { 
   
        logger.debug("Creating MapperFactoryBean with name '" + holder.getBeanName() 
          + "' and '" + definition.getBeanClassName() + "' mapperInterface");
      }

	  //修改构造方法的参数 
      definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); // issue #59
      definition.setBeanClass(this.mapperFactoryBean.getClass());//修改BeanClass

      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) { 
   
        if (logger.isDebugEnabled()) { 
   
          logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
        }
        definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
      }
    }
  }

主要关注两行
definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName());
definition.setBeanClass(this.mapperFactoryBean.getClass());
第一步是修改了构造方法的参数，就是在通过构造方法实例化的时候的参数，那么mapperFactoryBean是什么呢？

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> { 
   
  private Class<T> mapperInterface;

  public MapperFactoryBean() { 
   
    //intentionally empty 
  }
  
  public MapperFactoryBean(Class<T> mapperInterface) { 
   
    this.mapperInterface = mapperInterface;
  }
 
  @Override
  public T getObject() throws Exception { 
   
    return getSqlSession().getMapper(this.mapperInterface);
  }

  @Override
  public Class<T> getObjectType() { 
   
    return this.mapperInterface;
  }
...
...
}

可以看出来MapperFactoryBean 就是一个 FactoryBean，并且提供了一个构造方法，然后再进行构造的时候出入进来的依然还是接口的类型，但是实际的类型就不一样了，因为FactoryBean 可以通过getObject的方法来返回实际的类型
可以看到getObject 返回的是 getSqlSession().getMapper(this.mapperInterface)，SqlSession在mybatis是可以返回一个Mapper的实现类的，所以真正的对象的创建，代理依然是Mybatis完成的，spring只不过是做对象的管理而已

但是这里是直接 getSqlsession 的，那么这个SqlSession是哪里来的？
在Mybatis中 SqlSession是需要通过SqlSessionFactory 这个对象生成出来的

回到processBeanDefinitions（）

 //当前的ClasspathMapperScanner中有没有指定 sqlSessionFactoryBeanName，如果有
 //就修改BeanDefinition中的参数值，也就是说在实例化的时候，机会通过set方法去出入这个参数值
 //这样就有了一个SqlSessionFactory 了
 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) { 
   
        if (logger.isDebugEnabled()) { 
   
          logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
        }
        //如果说在spring中没有指定SqlSessionFactoryBean ，那么就会将当前Bean的自动注入的模型改为by_type，那么
        //在实例化当前bean的时候，就会自动注入通过byType找到的Bean
        definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
      }
    }