曹工說Spring Boot源碼（11）-- context:component-scan，你真的會用嗎（此次來講說它的奇技淫巧）

寫在前面的話

相關背景及資源：

曹工說Spring Boot源碼（1）-- Bean Definition究竟是什麼，附spring思惟導圖分享

曹工說Spring Boot源碼（2）-- Bean Definition究竟是什麼，我們對着接口，逐個方法講解

曹工說Spring Boot源碼（3）-- 手動註冊Bean Definition不比遊戲好玩嗎，咱們來試一下

曹工說Spring Boot源碼（4）-- 我是怎麼自定義ApplicationContext，從json文件讀取bean definition的？

曹工說Spring Boot源碼（5）-- 怎麼從properties文件讀取bean

曹工說Spring Boot源碼（6）-- Spring怎麼從xml文件裏解析bean的

曹工說Spring Boot源碼（7）-- Spring解析xml文件，到底從中獲得了什麼（上）

曹工說Spring Boot源碼（8）-- Spring解析xml文件，到底從中獲得了什麼（util命名空間）

曹工說Spring Boot源碼（9）-- Spring解析xml文件，到底從中獲得了什麼（context命名空間上）

曹工說Spring Boot源碼（10）-- Spring解析xml文件，到底從中獲得了什麼（context:annotation-config 解析）

工程代碼地址 思惟導圖地址

工程結構圖：

概要

本篇已是spring源碼第11篇，最近都在講解：spring解析xml文件，到底得到了什麼？得到了什麼呢，感興趣的能夠挑選感興趣的看；目前呢，已經講到了context命名空間，接下來準備講解component-scan，可是吧，這個真的是一個重量級的嘉賓，且不說原理，光是用法，就夠咱們感覺感覺啥叫主角了。

常規用法

咱們在package：org.springframework.contextnamespace.componentscantest下存放了如下幾個文件：

MainClassForTestComponentScan.java 測試類，包含main方法，不是bean

PersonTestController.java 使用了@Controller註解，裏面使用@Autowired自動注入了PersonService

PersonService.java 使用了@Service註解

下邊看下代碼：

//定義一個bean
package org.springframework.contextnamespace.componentscantest;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Slf4j
@Data
@Controller
public class PersonTestController {

    @Autowired
    private PersonService personService;
}

// 再一個bean
package org.springframework.contextnamespace.componentscantest;

import org.springframework.stereotype.Service;

@Service
public class PersonService {
    private String personname;
}

//測試代碼
package org.springframework.contextnamespace.componentscantest;

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.util.MyFastJson;

import java.util.List;
import java.util.Map;

@Slf4j
public class MainClassForTestComponentScan {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
                new String[]{"classpath:context-namespace-test-component-scan.xml"},false);
        context.refresh();


        List<BeanDefinition> list =
                context.getBeanFactory().getBeanDefinitionList();
        // 我本身的工具類，使用json輸出bean definition
        MyFastJson.printJsonStringForBeanDefinitionList(list);
        
        Object bean = context.getBean(PersonTestController.class);
        System.out.println("PersonController bean:" + bean);

    }
}

xml文件以下：

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/context
                 http://www.springframework.org/schema/context/spring-context.xsd">
    
    <context:component-scan base-package="org.springframework.contextnamespace.componentscantest"/>
</beans>

輸出：

PersonController bean:PersonTestController(personService=org.springframework.contextnamespace.componentscantest.PersonService@3e11f9e9)

能夠看到，注入成功。

我代碼裏，其實還輸出了所有的beanDefinition，我簡單整理了一下，一共包含了以下幾個：

beanDefinition中的beanClass
org.springframework.context.annotation.CommonAnnotationBeanPostProcessor
org.springframework.contextnamespace.componentscantest.PersonService 咱們本身的業務bean
org.springframework.contextnamespace.componentscantest.PersonTestController 業務bean
org.springframework.context.annotation.ConfigurationClassPostProcessor
org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor
org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor
org.springframework.context.annotation.ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor

看來，一個簡單的註解，背後卻默默作了不少騷操做啊，除了本身的業務bean外，還有5個框架自帶的bean，類型呢，從命名能夠看出，都是些什麼PostProcessor，有興趣的，能夠翻到我前一篇，裏面講解了AutowiredAnnotationBeanPostProcessor。

閱讀理解

咱們從spring-context.xsd文件能夠找到這個元素的官方說明。

Scans the classpath for annotated components that will be auto-registered as
Spring beans. By default, the Spring-provided @Component, @Repository,
@Service, and @Controller stereotypes will be detected.


Note: This tag implies the effects of the 'annotation-config' tag, activating @Required,
@Autowired, @PostConstruct, @PreDestroy, @Resource, @PersistenceContext and @PersistenceUnit
annotations in the component classes, which is usually desired for autodetected components
(without external configuration). Turn off the 'annotation-config' attribute to deactivate
this default behavior, for example in order to use custom BeanPostProcessor definitions
for handling those annotations.


Note: You may use placeholders in package paths, but only resolved against system
properties (analogous to resource paths). A component scan results in new bean definition
being registered; Spring's PropertyPlaceholderConfigurer will apply to those bean
definitions just like to regular bean definitions, but it won't apply to the component
scan settings themselves.

See Javadoc for org.springframework.context.annotation.ComponentScan for information
on code-based alternatives to bootstrapping component-scanning.

我用個人425分壓線4級翻譯了一下：

掃描類路徑下的註解組件，它們將會被主動註冊爲spring bean。默認狀況下，能夠識別如下註解：
@Component, @Repository,@Service, and @Controller。

注意：這個元素隱含了 的做用，會默認激活bean class類裏的@Required,
@Autowired, @PostConstruct, @PreDestroy, @Resource, @PersistenceContext and @PersistenceUnit 註解，這個功能也是通常默認須要的。將annotation-config屬性，設爲false，能夠關閉這項功能，好比想要本身定製處理這些註解的BeanPostProcessor時。

注意：你可使用在包路徑裏，使用placeholder，可是隻能引用system property。 component scan會致使新的bean definition被註冊，Spring的PropertyPlaceholderConfigurer對這些bean，依然生效，可是，PropertyPlaceholderConfigurer 不能對 component scan生效。

若是要基於註解啓動component-scan，請查看org.springframework.context.annotation.ComponentScan

這個只是元素自己的介紹，你知道，這個元素的屬性仍是有辣麼多的，咱們用一個表格，來看看其屬性的意思：

annotation-config屬性的做用

這個屬性的意思是，原本，component-scan不是默認包含了 的功能嗎，因此纔可以識別並解析@Autowired等註解，那要是咱們關了這個功能，再試試還能不能注入呢？

<context:component-scan 
        //這裏設爲false，關閉@autowired等註解的解析功能
        annotation-config="false"
        base-package="org.springframework.contextnamespace.componentscantest"/>

再次測試，輸出以下：

PersonController bean:PersonTestController(personService=null)

能夠發現，注入沒成功。

並且，此次，個人beanDefinition輸出語句顯示，一共只有兩個beanDefinition，就是咱們定義的那兩個業務bean。

這麼看來，annotation-config的魔術手被咱們斬斷了，固然，代價就是，不能自動注入了。

use-default-filters屬性的做用

原本這個屬性的做用吧，從字面上看是說：

Indicates whether automatic detection of classes annotated with @Component, @Repository, @Service,
or @Controller should be enabled. Default is "true".

即：是否自動檢測註解了@Component, @Repository, @Service,or @Controller 的類。

後面翻看了一下源碼，更加明確了意義：

在component-scan這個元素的解析器裏（ComponentScanBeanDefinitionParser），有個屬性：

private static final String USE_DEFAULT_FILTERS_ATTRIBUTE = "use-default-filters";

關鍵代碼以下：

protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {
        XmlReaderContext readerContext = parserContext.getReaderContext();

        boolean useDefaultFilters = true;
        if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {
            useDefaultFilters = Boolean.valueOf(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));
        }

        // 1.建立ClassPathBeanDefinitionScanner，下面的 2 3 4 等，表明一步一步跟代碼的跳轉順序
        ClassPathBeanDefinitionScanner scanner = createScanner(readerContext, useDefaultFilters);
        ...
    }

    // 2.
    protected ClassPathBeanDefinitionScanner createScanner(XmlReaderContext readerContext, boolean useDefaultFilters) {
        // 3 
        return new ClassPathBeanDefinitionScanner(readerContext.getRegistry(), useDefaultFilters);
    }
    // 3 
    public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
        this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
    }

    // 4
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment) {
         // 5
        super(useDefaultFilters, environment);

        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
        this.registry = registry;

        // Determine ResourceLoader to use.
        if (this.registry instanceof ResourceLoader) {
            setResourceLoader((ResourceLoader) this.registry);
        }
    }
    
    // 第5處，進入如下邏輯
    public ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters, Environment environment) {
         // 若是使用默認filter，則註冊默認filter
        if (useDefaultFilters) {
            registerDefaultFilters();
        }
        this.environment = environment;
    }

下邊就是核心了：

protected void registerDefaultFilters() {
        /**
         * 默認掃描Component註解
         */
        this.includeFilters.add(new AnnotationTypeFilter(Component.class));
        ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
        try {
            // 這裏能夠看到，還支持 ManagedBean 註解
            this.includeFilters.add(new AnnotationTypeFilter(
                    ((Class<? extends Annotation>) cl.loadClass("javax.annotation.ManagedBean")), false));
            logger.info("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
        }
        try {
             // 還支持 javax.inject.Named 註解
            this.includeFilters.add(new AnnotationTypeFilter(
                    ((Class<? extends Annotation>) cl.loadClass("javax.inject.Named")), false));
            logger.info("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
        }
    }

因此，這個屬性的做用就是：假設指定的掃描包內有20個類，其中2個class註解了@component，則這兩個類纔是真正被掃描的類，至於具體的解析，這個屬性就不關心了。

context:exclude-filter屬性的做用

爲何不分析context:include-filter，由於假設某個類沒有註解@component，按理說，是不加入掃描範圍的；

若是咱們的include-filter把這個類歸入範圍，則還要自定義bean definition的解析邏輯才能將這個類變成bean。

咱們這裏有個demo，其中TeacherController和TeacherService是註解了ShouldExclude的。

xml以下：

<context:component-scan
        use-default-filters="true"
        base-package="org.springframework.contextnamespace">
    // 咱們這裏使用了annotation類型，要把包含了ShouldExclude註解的，所有排除
    <context:exclude-filter type="annotation" expression="org.springframework.contextnamespace.ShouldExclude"></context:exclude-filter>
    // 這裏使用regex類型，排除掉TestController
    <context:exclude-filter type="regex" expression="org.springframework.contextnamespace.TestController"></context:exclude-filter>
</context:component-scan>

因此，上面的xml，咱們能夠將3個bean所有排除。

context:include-filter屬性的做用

在前面，咱們說，這個屬性很差測試，但我想到也許能夠這樣測：

<context:component-scan
           use-default-filters="false"
           base-package="org.springframework.contextnamespace">
       <context:include-filter
               type="annotation"
               expression="org.springframework.stereotype.Component"/>
       <context:exclude-filter type="regex" expression="org.springframework.contextnamespace.TestController"/>
   </context:component-scan>

use-default-filters 這裏設爲false，排除掉默認的@component的include filter；

可是咱們在下面，再經過include-filter來達到一樣效果。

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

通過上述改造後，運行正常。

注：以上部分是前兩天寫的（代碼要後邊上傳，在家裏電腦上），如下部分是公司電腦寫的，前面的代碼在家裏，忘記提交了。因此demo會略微不同，不過不影響實驗。

前面我說很差測試，但我發現仍是能夠搞。咱們將會單獨定義一個自定義註解：

package org.springframework.contextnamespace;

import org.springframework.stereotype.Component;

import java.lang.annotation.*;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
// 你們注意，這裏的@component我注掉了
//@Component
public @interface DerivedComponent {

    /**
     * The value may indicate a suggestion for a logical component name,
     * to be turned into a Spring bean in case of an autodetected component.
     * @return the suggested component name, if any
     */
    String value() default "";

}

而後呢，下面這兩個類我是使用上面的註解來標註了的：

@DerivedComponent
public class PersonService {
    private String personname1;
}

@DerivedComponent
public class PersonTestController {

//    @Autowired
    @Resource
    private PersonService personService;
}

xml以下：

<context:component-scan
        use-default-filters="false"
        base-package="org.springframework.contextnamespace.componentscan">
    <context:include-filter type="annotation" expression="org.springframework.contextnamespace.DerivedComponent"/>
</context:component-scan>

有必要解釋下：

use-default-filters="false"：爲true時，會將註解了@component或者@controller等註解的class包含進候選bean；這裏設爲false，就不會進行上述行爲；

：這裏呢，類型爲註解，註解類就是咱們自定義的那個。

整體意思就是，掃描指定包下面的，帶有@DerivedComponent註解的類；忽略帶有@component等註解的類。

這樣設置，咱們的測試程序會如何：

PersonController bean:PersonTestController(personService=org.springframework.contextnamespace.componentscan.PersonService@4f615685)

it works！沒想到，這樣均可以。

咱們看看他們的bean definition：

{
        "abstract":false,
        "autowireCandidate":true,
        "autowireMode":0,
        "beanClassName":"org.springframework.contextnamespace.componentscan.PersonService",
        "constructorArgumentValues":{
            "argumentCount":0,
            "empty":true,
            "genericArgumentValues":[],
            "indexedArgumentValues":{}
        },
        "dependencyCheck":0,
        "enforceDestroyMethod":false,
        "enforceInitMethod":false,
        "lazyInit":false,
        "lenientConstructorResolution":true,
        "metadata":{
            "abstract":false,
             // 這裏能夠看到，註解確實是DerivedComponent
            "annotationTypes":["org.springframework.contextnamespace.DerivedComponent"],
            "className":"org.springframework.contextnamespace.componentscan.PersonService",
            "concrete":true,
            "final":false,
            "independent":true,
            "interface":false,
            "interfaceNames":[],
            "memberClassNames":[],
            "superClassName":"java.lang.Object"
        },
        "methodOverrides":{
            "empty":true,
            "overrides":[]
        },
        "nonPublicAccessAllowed":true,
        "primary":false,
        "propertyValues":{
            "converted":false,
            "empty":true,
            "propertyValueList":[]
        },
        "prototype":false,
        "qualifiers":[],
        "resolvedAutowireMode":0,
        
        "resourceDescription":"file [F:\\work_java_projects\\spring-boot-first-version-learn\\all-demo-in-spring-learning\\spring-xml-demo\\target\\classes\\org\\springframework\\contextnamespace\\componentscan\\PersonService.class]",
        "role":0,
        "scope":"singleton",
        "singleton":true,
        
        "synthetic":false
    }

具體原理，下節具體分析，主要呢， 的解析代碼，主要就是負責收集beandefinition，

而上面這種自定義註解收集的方式的缺點在於，不能像@component等註解那樣，有不少的屬性能夠設置。咱們的自定義註解，只能是使用默認的beanDefinition配置，好比默認單例，等等。固然，你也能夠直接使用和@component如出一轍的屬性，不過那也沒啥必要了，對吧。

這部分的源碼，我放在了：

https://gitee.com/ckl111/spring-boot-first-version-learn/tree/master/all-demo-in-spring-learning/spring-xml-demo/src/main/java/org/springframework/contextnamespace/componentscan

最後這個自定義註解的內容，小馬哥的spring boot編程思想裏也提到了，在161頁，我手邊沒有電子版本，因此抱歉了。

總結

component-scan，用了這麼些年，看來真的只是用，裏面的原理仍是隻知其一;不知其二，通過上面的分析，我也本身系統梳理了一遍。你們看看有啥問題的，歡迎指出來，一塊兒進步。