context:component-scan使用说明

https://www.cnblogs.com/fightingcoding/p/component-scan.html

https://blog.csdn.net/chunqiuwei/article/details/16115135

默认情况下，<context:component-scan>查找使用构造型（stereotype）注解所标注的类，如@Component(组件)，@Service（服务），@Controller（控制器），@Repository（数据仓库）。

我们具体看下<context:component-scan>的一些属性，以下是一个比较具体的<context:component-scan>配置

 
 

   
   

    
    

   
   
   
   

    
    

     
     <context:component-scan base-package="com.wjx.betalot" <!-- 扫描的基本包路径 -->
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                             annotation-config="true" 
     
     <!-- 是否激活属性注入注解 -->
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                             name-generator="org.springframework.context.annotation.AnnotationBeanNameGenerator"  
     
     <!-- Bean的ID策略生成器 -->
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                             resource-pattern="**/*.class" 
     
     <!-- 对资源进行筛选的正则表达式，这边是个大的范畴，具体细分在include-filter与exclude-filter中进行 -->
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                             scope-resolver="org.springframework.context.annotation.AnnotationScopeMetadataResolver" 
     
     <!-- scope解析器 ，与scoped-proxy只能同时配置一个 -->
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                             scoped-proxy="no" 
     
     <!-- scope代理，与scope-resolver只能同时配置一个 -->
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                             use-default-filters="false" 
     
     <!-- 是否使用默认的过滤器，默认值true -->
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                                       >
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <!-- 注意：若使用include-filter去定制扫描内容，要在use-default-filters="false"的情况下，不然会“失效”，被默认的过滤机制所覆盖 -->                   
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <!-- annotation是对注解进行扫描 -->
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <context:include-filter type="annotation" expression="org.springframework.stereotype.Component"/> 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <!-- assignable是对类或接口进行扫描 -->
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <context:include-filter type="assignable" expression="com.wjx.betalot.performer.Performer"/>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <context:include-filter type="assignable" expression="com.wjx.betalot.performer.impl.Sonnet"/>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <!-- 注意：在use-default-filters="false"的情况下，exclude-filter是针对include-filter里的内容进行排除 -->
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <context:exclude-filter type="assignable" expression="com.wjx.betalot.performer.impl.RainPoem"/>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <context:exclude-filter type="regex" expression=".service.*"/> 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     </context:component-scan>
    
    
   
   
 
 

以上配置注释已经很详细了，当然因为这些注释，你若是想复制去验证，你得删掉注释。我们具体再说明一下这些注释：

back-package：标识了<context:component-scan>元素所扫描的包，可以使用一些通配符进行配置

annotation-config:<context:component-scan>元素也完成了<context:annotation-config>元素的工作，开关就是这个属性，false则关闭属性注入注解功能

name-generator:这个属性指定你的构造型注解，注册为Bean的ID生成策略，这个生成器基于接口BeanNameGenerator实现generateBeanName方法，你可以自己写个类去自定义策略。这边，我们可不显示配置，它是默认使用org.springframework.context.annotation.AnnotationBeanNameGenerator生成器，也就是类名首字符小写的策略，如Performer类，它注册的Bean的ID为performer.并且可以自定义ID，如@Component("Joy").这边简单贴出这个默认生成器的实现。

 
 

   
   

    
    

   
   
   
   

    
    

     
     public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             if (definition instanceof AnnotatedBeanDefinition) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 if (StringUtils.hasText(beanName)) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     // Explicit bean name found.
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     return beanName;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             // Fallback: generate a unique default bean name.
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             return buildDefaultBeanName(definition, registry);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

 

 Spring除了实现了AnnotationBeanNameGenerator生成器外，还有个org.springframework.beans.factory.support.DefaultBeanNameGenerator生成器，它为了防止Bean的ID重复，它的生成策略是类路径+分隔符+序号

 ，如com.wjx.betalot.performer.impl.Sonnet注册为Bean的ID是com.wjx.betalot.performer.impl.Sonnet#0，这个生成器不支持自定义ID，否则抛出异常。同样贴出代码，有兴趣的可以去看下。

 
 

   
   

    
    

   
   
   
   

    
    

     
     public static String generateBeanName(
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 BeanDefinition definition, BeanDefinitionRegistry registry, boolean isInnerBean)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 throws BeanDefinitionStoreException {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             String generatedBeanName = definition.getBeanClassName();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             if (generatedBeanName == null) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 if (definition.getParentName() != null) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     generatedBeanName = definition.getParentName() + "$child";
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 else if (definition.getFactoryBeanName() != null) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     generatedBeanName = definition.getFactoryBeanName() + "$created";
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             if (!StringUtils.hasText(generatedBeanName)) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 throw new BeanDefinitionStoreException("Unnamed bean definition specifies neither " +
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                         "'class' nor 'parent' nor 'factory-bean' - can't generate bean name");
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             String id = generatedBeanName;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             if (isInnerBean) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 // Inner bean: generate identity hashcode suffix.
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 id = generatedBeanName + GENERATED_BEAN_NAME_SEPARATOR + ObjectUtils.getIdentityHexString(definition);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             else {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 // Top-level bean: use plain class name.
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 // Increase counter until the id is unique.
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 int counter = -1;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 while (counter == -1 || registry.containsBeanDefinition(id)) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     counter++;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     id = generatedBeanName + GENERATED_BEAN_NAME_SEPARATOR + counter;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             return id;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   
 
 

 

resource-pattern：对资源进行筛选的正则表达式，这边是个大的范畴，具体细分在include-filter与exclude-filter中进行。

scoped-proxy: scope代理，有三个值选项，no(默认值)，interfaces(接口代理)，targetClass（类代理），那什么时候需要用到scope代理呢，举个例子，我们知道Bean的作用域scope有singleton，prototype，request,session,那有这么一种情况，当你把一个session或者request的Bean注入到singleton的Bean中时，因为singleton的Bean在容器启动时就会创建A，而session的Bean在用户访问时才会创建B，那么当A中要注入B时，有可能B还未创建，这个时候就会出问题，那么代理的时候来了，B如果是个接口，就用interfaces代理，是个类则用targetClass代理。这个例子出处：http://www.bubuko.com/infodetail-1434289.html。

scope-resolver:这个属性跟name-generator有点类似，它是基于接口ScopeMetadataResolver的，实现resolveScopeMetadata方法，目的是为了将@Scope(value="",proxyMode=ScopedProxyMode.NO,scopeName="")的配置解析成为一个ScopeMetadata对象,Spring这里也提供了两个实现，我们一起看下。首先是org.springframework.context.annotation.AnnotationScopeMetadataResolver中，

 
 

   
   

    
    

   
   
   
   

    
    

     
     public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             ScopeMetadata metadata = new ScopeMetadata();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             if (definition instanceof AnnotatedBeanDefinition) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(annDef.getMetadata(), this.scopeAnnotationType);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 if (attributes != null) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     metadata.setScopeName(attributes.getAliasedString("value", this.scopeAnnotationType, definition.getSource()));
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     ScopedProxyMode proxyMode = attributes.getEnum("proxyMode");
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     if (proxyMode == null || proxyMode == ScopedProxyMode.DEFAULT) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                         proxyMode = this.defaultProxyMode;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     metadata.setScopedProxyMode(proxyMode);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             return metadata;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   
 
 

 

对比一下org.springframework.context.annotation.Jsr330ScopeMetadataResolver中的实现：

 
 

   
   

    
    

   
   
   
   

    
    

     
     public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             ScopeMetadata metadata = new ScopeMetadata();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             metadata.setScopeName(BeanDefinition.SCOPE_PROTOTYPE);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             if (definition instanceof AnnotatedBeanDefinition) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 Set
     
     <String> annTypes = annDef.getMetadata().getAnnotationTypes();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 String found = null;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 for (String annType : annTypes) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     Set
     
     <String> metaAnns = annDef.getMetadata().getMetaAnnotationTypes(annType);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     if (metaAnns.contains("javax.inject.Scope")) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                         if (found != null) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                             throw new IllegalStateException("Found ambiguous scope annotations on bean class [" +
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                                     definition.getBeanClassName() + "]: " + found + ", " + annType);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                         found = annType;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                         String scopeName = resolveScopeName(annType);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                         if (scopeName == null) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                             throw new IllegalStateException(
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                                     "Unsupported scope annotation - not mapped onto Spring scope name: " + annType);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                         metadata.setScopeName(scopeName);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             return metadata;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   
 
 

 

ps:scope-resolver与scoped-proxy只能配置一个,配置了scope-resolver后你要使用代理，可以配置@Scope总的proxyMode属性项

use-default-filters：是否使用默认的扫描过滤。

<context:include-filter> ：用来告知哪些类需要注册成Spring Bean,使用type和expression属性一起协作来定义组件扫描策略。type有以下5种

过滤器类型	描述
annotation	过滤器扫描使用注解所标注的那些类，通过expression属性指定要扫描的注释
assignable	过滤器扫描派生于expression属性所指定类型的那些类
aspectj	过滤器扫描与expression属性所指定的AspectJ表达式所匹配的那些类
custom	使用自定义的org.springframework.core.type.TypeFliter实现类，该类由expression属性指定
regex	过滤器扫描类的名称与expression属性所指定正则表示式所匹配的那些类

 

 

 

 

 

 

 

要注意的是：若使用include-filter去定制扫描内容，要在use-default-filters="false"的情况下，不然会“失效”，被默认的过滤机制所覆盖

<context:exclude-filter>：与<context:include-filter> 相反,用来告知哪些类不需要注册成Spring Bean，同样注意的是：在use-default-filters="false"的情况下，exclude-filter是针对include-filter里的内容进行排除。

 

 

在xml配置了这个标签后，spring可以自动去扫描base-pack下面或者子包下面的java文件，如果扫描到有@Component @Controller@Service等这些注解的类，则把这些类注册为bean

注意：如果配置了<context:component-scan>那么<context:annotation-config/>标签就可以不用再xml中配置了，因为前者包含了后者。另外<context:component-scan>还提供了两个子标签

1.        <context:include-filter>

2.       <context:exclude-filter>

在说明这两个子标签前，先说一下<context:component-scan>有一个use-default-filters属性，改属性默认为true,这就意味着会扫描指定包下的全部的标有@Component的类，并注册成bean.也就是@Component的子注解@Service,@Reposity等。所以如果仅仅是在配置文件中这么写

<context:component-scan base-package="tv.huan.weisp.web"/>

 Use-default-filter此时为true那么会对base-package包或者子包下的所有的进行java类进行扫描,并把匹配的java类注册成bean。

 

 可以发现这种扫描的粒度有点太大，如果你只想扫描指定包下面的Controller，该怎么办？此时子标签<context:incluce-filter>就起到了勇武之地。如下所示

<context:component-scan base-package="tv.huan.weisp.web .controller">  

<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>   

</context:component-scan>  

这样就会只扫描base-package指定下的有@Controller下的java类，并注册成bean

但是因为use-dafault-filter在上面并没有指定，默认就为true，所以当把上面的配置改成如下所示的时候，就会产生与你期望相悖的结果（注意base-package包值得变化）

<context:component-scan base-package="tv.huan.weisp.web">  

<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>   

</context:component-scan>  

此时，spring不仅扫描了@Controller，还扫描了指定包所在的子包service包下注解@Service的java类

此时指定的include-filter没有起到作用，只要把use-default-filter设置成false就可以了。这样就可以避免在base-packeage配置多个包名这种不是很优雅的方法来解决这个问题了。

另外在我参与的项目中可以发现在base-package指定的包中有的子包是不含有注解了，所以不用扫描，此时可以指定<context:exclude-filter>来进行过滤，说明此包不需要被扫描。综合以上说明

Use-dafault-filters=”false”的情况下：<context:exclude-filter>指定的不扫描，<context:include-filter>指定的扫描