Spring-MyBatis 之 MapperScannerConfigurer

骑猪看日落 2022-06-08 00:49 168阅读 0赞

如果有成百上千个Mapper接口，那我们也没有必要在 Spring 的配置文件中注册所有的映射器。相反,你可以使用一个 MapperScannerConfigurer , 它 将 会 查 找 类 路 径 下 的 映 射 器 并 自 动 将 它 们 创 建 成 MapperFactoryBean。

要创建 MapperScannerConfigurer,可以在 Spring 的配置中添加如下代码:

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

basePackage 属性是让你为映射器接口文件设置基本的包路径。 你可以使用分号或逗号 作为分隔符设置多于一个的包路径。每个映射器将会在指定的包路径中递归地被搜索到。  
  
  
MapperScannerConfigurer 属性不支持使用了 PropertyPlaceholderConfigurer 的属 性替换,因为会在 Spring 其中之前来它加载。但是,你可以使用 PropertiesFactoryBean 和 SpEL 表达式来作为替代。  
  
  
注 意 , 没 有 必 要 去 指 定 SqlSessionFactory 或 SqlSessionTemplate , 因 为 MapperScannerConfigurer 将会创建 MapperFactoryBean,之后自动装配。但是,如果你使 用了一个 以上的 DataSource ,那 么自动 装配可 能会失效 。这种 情况下 ,你可 以使用 sqlSessionFactoryBeanName 或 sqlSessionTemplateBeanName 属性来设置正确的 bean 名 称来使用。这就是它如何来配置的,注意 bean 的名称是必须的,而不是 bean 的引用,因 此,value 属性在这里替代通常的 ref:

MapperScannerConfigurer实现了BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware 接口。

**InitializingBean**

public interface InitializingBean {
        void afterPropertiesSet() throws Exception;
    }

实现

public void afterPropertiesSet() throws Exception {
            Assert.notNull(this.basePackage, "Property \'basePackage\' is required");
        }

afterPropertiesSet()方法除了一句对basePackage属性的验证代码外并没有太多的逻辑实现。

**BeanDefinitionRegistryPostProcessor**

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
        void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry var1) throws BeansException;
    }

BeanDefinitionRegistryPostProcessor接口有获取BeanDefinitionRegistry的能力，BeanDefinitionRegistry是Spring所有Bean的注册中心，通过这个注册中心可以自定义修改已经定义好的Bean，这样可以加工甚至替换已经定义的Bean，高度化定制Bean的创建。

MapperScannerConfigurer实现了BeanDefinitionRegistryPostProcessor接口，具体实现：

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
            if(this.processPropertyPlaceHolders) {
                this.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.registerFilters();
            scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ",; \t\n"));
        }

重点关注三个主要的方法，分别是  
processPropertyPlaceHolders();   
scanner.registerFilters();  
scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG\_LOCATION\_DELIMITERS));

**processPropertyPlaceHolders属性的处理**

执行属性的处理，简单的说，就是把xml中$\{XXX\}中的XXX替换成属性文件中的相应的值。

/*
       * BeanDefinitionRegistries are called early in application startup, before
       * BeanFactoryPostProcessors. This means that PropertyResourceConfigurers will not have been
       * loaded and any property substitution of this class' properties will fail. To avoid this, find
       * any PropertyResourceConfigurers defined in the context and run them on this class' bean
       * definition. Then update the values.
       */
      private void processPropertyPlaceHolders() {
        Map<String, PropertyResourceConfigurer> prcs = applicationContext.getBeansOfType(PropertyResourceConfigurer.class);
    
        if (!prcs.isEmpty() && applicationContext instanceof ConfigurableApplicationContext) {
          BeanDefinition mapperScannerBean = ((ConfigurableApplicationContext) applicationContext)
              .getBeanFactory().getBeanDefinition(beanName);
    
          // PropertyResourceConfigurer does not expose any methods to explicitly perform
          // property placeholder substitution. Instead, create a BeanFactory that just
          // contains this mapper scanner and post process the factory.
          DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
          factory.registerBeanDefinition(beanName, mapperScannerBean);
    
          for (PropertyResourceConfigurer prc : prcs.values()) {
            prc.postProcessBeanFactory(factory);
          }
    
          PropertyValues values = mapperScannerBean.getPropertyValues();
    
          this.basePackage = updatePropertyValue("basePackage", values);
          this.sqlSessionFactoryBeanName = updatePropertyValue("sqlSessionFactoryBeanName", values);
          this.sqlSessionTemplateBeanName = updatePropertyValue("sqlSessionTemplateBeanName", values);
        }
      }

BeanDefinitionRegistries会在应用启动的时候调用，并且会早于BeanFactoryPostProcessors的调用，这就意味着PropertyResourceConfigurers还没有被加载所有对于属性文件的引用将会失效。为避免此种情况发生，此方法手动地找出定义的PropertyResourceConfigurers并进行提前调用以保证对于属性的引用可以正常工作。

**scanner.registerFilters根据配置属性生成过滤器**

scanner.registerFilters();方法会根据配置的属性生成对应的过滤器，然后这些过滤器在扫描的时候会起作用。

public void registerFilters() {
        boolean acceptAllInterfaces = true;
        //对于annotationClass属性的处理
        if (this.annotationClass != null) {
          addIncludeFilter(new AnnotationTypeFilter(this.annotationClass));
          acceptAllInterfaces = false;
        }
        //对于markerInterface属性的处理
        if (this.markerInterface != null) {
          addIncludeFilter(new AssignableTypeFilter(this.markerInterface) {
            @Override
            protected boolean matchClassName(String className) {
              return false;
            }
          });
          acceptAllInterfaces = false;
        }
        if (acceptAllInterfaces) {
          // default include filter that accepts all classes
          addIncludeFilter(new TypeFilter() {
            @Override
            public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
              return true;
            }
          });
        }
        //不扫描package-info.java文件
        addExcludeFilter(new TypeFilter() {
          @Override
          public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
            String className = metadataReader.getClassMetadata().getClassName();
            return className.endsWith("package-info");
          }
        });
      }

代码中得知，根据之前属性的配置生成了对应的过滤器。  
  
（1）annotationClass属性处理。  
如果annotationClass不为空，表示用户设置了此属性，那么就要根据此属性生成过滤器以保证达到用户想要的效果，而封装此属性的过滤器就是AnnotationTypeFilter。AnnotationTypeFilter保证在扫描对应Java文件时只接受标记有注解为annotationClass的接口。  
  
（2）markerInterface属性处理。  
如果markerInterface不为空，表示用户设置了此属性，那么就要根据此属性生成过滤器以保证达到用户想要的效果，而封装此属性的过滤器就是实现AssignableTypeFilter接口的局部类。表示扫描过程中只有实现markerInterface接口的接口才会被接受。  
  
（3）全局默认处理。  
在上面两个属性中如果存在其中任何属性，acceptAllInterfaces的值将会改变，但是如果用户没有设定以上两个属性，那么，Spring会为我们增加一个默认的过滤器实现TypeFilter接口的局部类，旨在接受所有接口文件。  
  
（4）package-info.java处理。  
对于命名为package-info的Java文件，默认不作为逻辑实现接口，将其排除掉，使用TypeFilter接口的局部类实现match方法。  
  
从上面的函数我们看出，控制扫描文件Spring通过不同的过滤器完成，这些定义的过滤器记录在了includeFilters和excludeFilters属性中。

**scanner.scan扫描Mapper接口类：**

scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG\_LOCATION\_DELIMITERS));

ClassPathMapperScanner的doScan方法,会将mapper包中的类替换成MapperFactoryBean，MapperFactoryBean实现了FactoryBean接口，每次生成对应Bean的时候，其实调用的FactoryBean的getObject方法。也就是说我们在注入Mapper的时候，其实调用的是FactoryBean的getObject方法，而这个方法会生成Mapper的代理类MapperProxy的实例。mybatis-spring就这样“偷梁换柱”的把mapper包中的类的实例替换成了代理类的实例：

/**
             * scan是个全局方法，扫描工作通过doScan(basePackages)方法，同时，还包括了includeAnnotationConfig属性的处理，
    	 * Perform a scan within the specified base packages.
    	 * @param basePackages the packages to check for annotated classes
    	 * @return number of beans registered
    	 */
    	public int scan(String... basePackages) {
    		int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
    
    		doScan(basePackages);
    
    		// Register annotation config processors, if necessary.
                    //如果配置了includeAnnotationConfig，则注册对应注解的处理器以保证注解功能的正常使用。
    		if (this.includeAnnotationConfig) {                        
                            //主要是完成对于注解处理器的简单注册,比如AutowiredAnnotationBeanPostProcessor、RequiredAnnotationBeanPostProcessor等
    			AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
    
    		}
    
    		return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
    	}

调用了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) {
        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);
        }
        //这个集合返回以后 Spring容器会将里面的所有内容注册到容器中
        return beanDefinitions;
      }
    
      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");
          }
    
          // the mapper interface is the original class of the bean
          // but, the actual class of the bean is MapperFactoryBean
          //把接口的类型设置进去
          definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); // issue #59
          //设置Bean的真实类型MapperFactoryBean
          definition.setBeanClass(this.mapperFactoryBean.getClass());
          //是否把Mapper接口加入到Mybatis的Config当中去
          definition.getPropertyValues().add("addToConfig", this.addToConfig);
    
          boolean explicitFactoryUsed = false;
          //如果sqlSessionFactoryBeanName的名字不为空 则在Spring容器中查询
          //适合多数据源
          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;
          }
          //如果sqlSessionTemplateBeanName的名字不为空 则在Spring容器中查询//适合多数据源
          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);
          }
        }
      }

下面是super.doScan方法

/**
    	 * Perform a scan within the specified base packages,
    	 * returning the registered bean definitions.
    	 * <p>This method does <i>not</i> register an annotation config processor
    	 * but rather leaves this up to the caller.
    	 * @param basePackages the packages to check for annotated classes
    	 * @return set of beans registered if any for tooling registration purposes (never {@code null})
    	 */
    	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
                    //如果没有扫描到任何文件发出警告
    		Assert.notEmpty(basePackages, "At least one base package must be specified");
    		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
                    //扫描basePackage路径下Mapper接口
    		for (String basePackage : basePackages) {
                            /*
                             如果当前bean是用于生成代理的bean那么需要进一步处理
                             findCandidateComponents方法根据传入的包路径信息并结合类文件路径拼接成文件的绝对路径，
                             同时完成了文件的扫描过程并且根据对应的文件生成了对应的bean，
                             使用ScannedGenericBeanDefinition类型的bean承载信息，bean中只记录了resource和source信息。
                             我们更感兴趣的是isCandidateComponent(metadataReader)，此句代码用于判断当前扫描的文件是否符合要求，
                             而我们之前注册的一些过滤器信息也正是在此时派上用场的。
                             */
    			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
    			for (BeanDefinition candidate : candidates) {
                                    //解析scope属性
    				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
    				candidate.setScope(scopeMetadata.getScopeName());
    				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
    				if (candidate instanceof AbstractBeanDefinition) {
    					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
    				}
                                    //如果是AnnotatedBeanDefinition类型的bean,需要检测下常用注解如：Primary、Lazy等
    				if (candidate instanceof AnnotatedBeanDefinition) {
    					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
    				}
                                    //检测当前bean是否已经注册
    				if (checkCandidate(beanName, candidate)) {
    					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
    					definitionHolder =
    							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    					beanDefinitions.add(definitionHolder);
    					registerBeanDefinition(definitionHolder, this.registry);
    				}
    			}
    		}  return beanDefinitions;} 
     
    
    
    doScan该方法主要做了以下操作：
    
    1）扫描basePackage下面的java文件
    
    2）解析扫描到的java文件
    
    3）调用各个在上一步骤注册的过滤器，执行相应的方法。
    
    4）为解析后的java注册bean，注册方式采用编码的动态注册实现。
    
    5）构造MapperFactoryBean的属性，mapperInterface，sqlSessionFactory等等，填充到BeanDefinition里面去。
    
    做完这些，MapperFactoryBean对象也就构造完成了，扫描方式添加dao的工作也完成了。
    
     
     
    
    
     最后Mapper执行的方法(insert,delete,update,delete等)是调用是org.apache.ibatis.binding.MapperMethod的execute方法
    
    
       public Object execute(SqlSession sqlSession, Object[] args) {
        Object result;
        switch (command.getType()) {
          case INSERT: {
        	Object param = method.convertArgsToSqlCommandParam(args);
            result = rowCountResult(sqlSession.insert(command.getName(), param));
            break;
          }
          case UPDATE: {
            Object param = method.convertArgsToSqlCommandParam(args);
            result = rowCountResult(sqlSession.update(command.getName(), param));
            break;
          }
          case DELETE: {
            Object param = method.convertArgsToSqlCommandParam(args);
            result = rowCountResult(sqlSession.delete(command.getName(), param));
            break;
          }
          case SELECT:
            if (method.returnsVoid() && method.hasResultHandler()) {
              executeWithResultHandler(sqlSession, args);
              result = null;
            } else if (method.returnsMany()) {
              result = executeForMany(sqlSession, args);
            } else if (method.returnsMap()) {
              result = executeForMap(sqlSession, args);
            } else if (method.returnsCursor()) {
              result = executeForCursor(sqlSession, args);
            } else {
              Object param = method.convertArgsToSqlCommandParam(args);
              result = sqlSession.selectOne(command.getName(), param);
            }
            break;
          case FLUSH:
            result = sqlSession.flushStatements();
            break;
          default:
            throw new BindingException("Unknown execution method for: " + command.getName());
        }
        if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
          throw new BindingException("Mapper method '" + command.getName() 
              + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
        }
        return result;
      }