Spring Cloud Feign 源碼分析 - feign啟動原理

一. 核心注解

@EnableFeignClients

String[] basePackages 等同 String[] value()
指定要掃描的包路徑，一般用于當項目引用其他的jar，通過指定此屬性來掃描jar包內(nèi)的@FeignClient。例如：@EnableFeignClients(basePackages = {"com.xxx.service", "com.xxx.service2"})

Class<?>[] clients()
指定加載的帶有@FeignClient的類，主動指定后，將不會在classpath下掃描。例如：@EnableFeignClients(clients = {Service1.class, Service2.class})

Class<?>[] defaultConfiguration()
指定全局的configuration，使用@Configuration進行配置。例如：@EnableFeignClients(defaultConfiguration = {Configuration1.class, Configuration1.class})

@FeignClient

String value() 等同 String name()
給當前feignClient設置value

String contextId()
會頂替作為feignClient的name

String qualifier()
等同給feignClient設置注解@Qualifier

String path()
指定統(tǒng)一的調(diào)用前綴

String url()
設置調(diào)用的絕對url或者主機名

boolean decode404() default false
是否來解碼404，而不是拋出FeignExceptions，默認false

Class<?>[] configuration()
定義feignClient的配置類，可重寫內(nèi)部的bean來修改feignClient的調(diào)用實現(xiàn)，如feign.codec.Decoder、feign.codec.Encoder、feign.Contract

Class<?> fallback() default void.class;
Class<?> fallbackFactory() default void.class;
指定fallback時的處理類，必須是一個spring的bean。當調(diào)用失敗時，會調(diào)用相同的fallback實現(xiàn)類的方法。

boolean primary() default true;
指定為primary的bean

二. 源碼分析

首先，我們想要使用feign，需要在SpringApplication的啟動類上加入@EnableFeignClients，看下這個注解的定義。

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

可以看到有@Import(FeignClientsRegistrar.class)，在分析一下FeignClientsRegistrar，是ImportBeanDefinitionRegistrar的實現(xiàn)類。

class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar,
        ResourceLoaderAware, EnvironmentAware {...}

需要重寫一個關鍵的方法：registerBeanDefinitions
AnnotationMetadata 是注解的元信息，包含了當前類的所有注解信息
BeanDefinitionRegistry 用于注冊bean的registry，詳細參考BeanDefinitionRegistry-源碼分析

1. registerDefaultConfiguration 實現(xiàn)分析
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        registerDefaultConfiguration(metadata, registry);
        registerFeignClients(metadata, registry);
    }

該方法做了兩件事，注冊defaultConfiguration和注冊所有的加了@FeignClient的bean。其中defaultConfiguration也就是在最開始提到的EnableFeignClients的一個屬性。

private void registerDefaultConfiguration(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        Map<String, Object> defaultAttrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName(), true);

        if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
            String name;
            if (metadata.hasEnclosingClass()) {
                name = "default." + metadata.getEnclosingClassName();
            }
            else {
                name = "default." + metadata.getClassName();
            }
            registerClientConfiguration(registry, name,
                    defaultAttrs.get("defaultConfiguration"));
        }
    }

首先通過注解元信息中判斷EnableFeignClients是否有屬性defaultConfiguration(可以值為null，但一定有這個屬性)，再設置name，hasEnclosingClass是判斷當前metadata的Class是不是一個內(nèi)部/嵌套類或是在方法中的local class。
一般來說，這里的name = default.com.xxx.XXXApplication (default.啟動類名)。
接著調(diào)用registerClientConfiguration。

private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name, Object configuration) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(FeignClientSpecification.class);
        builder.addConstructorArgValue(name);
        builder.addConstructorArgValue(configuration);
        registry.registerBeanDefinition(
                name + "." + FeignClientSpecification.class.getSimpleName(),
                builder.getBeanDefinition());
    }

public static BeanDefinitionBuilder genericBeanDefinition(Class<?> beanClass) {
        BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new GenericBeanDefinition());
        builder.beanDefinition.setBeanClass(beanClass);
        return builder;
    }

先定義了BeanDefinitionBuilder，也就是專門用于構造BeanDefinition的構造器，將一個普通的類定義為BeanDefinition。
這里將FeignClientSpecification定義成BeanDefinition，并設置了構造方法的兩個參數(shù)值，name和configuration。最后將這個beanDefinition注冊到spring容器中。注冊名：name = default.com.xxx.XXXApplication.FeignClientSpecification

至此，F(xiàn)eignClientsRegistrar.registerBeanDefinitions的第一個方法執(zhí)行完成，接下來看看registerFeignClients的實現(xiàn)。

2. registerFeignClients 實現(xiàn)分析
public void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        ClassPathScanningCandidateComponentProvider scanner = getScanner();
        scanner.setResourceLoader(this.resourceLoader);

        Set<String> basePackages;

        Map<String, Object> attrs = metadata
                .getAnnotationAttributes(EnableFeignClients.class.getName());
        AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
                FeignClient.class);
        final Class<?>[] clients = attrs == null ? null
                : (Class<?>[]) attrs.get("clients");
        if (clients == null || clients.length == 0) {
            scanner.addIncludeFilter(annotationTypeFilter);
            basePackages = getBasePackages(metadata);
        }
        else {
            final Set<String> clientClasses = new HashSet<>();
            basePackages = new HashSet<>();
            for (Class<?> clazz : clients) {
                basePackages.add(ClassUtils.getPackageName(clazz));
                clientClasses.add(clazz.getCanonicalName());
            }
            AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
                @Override
                protected boolean match(ClassMetadata metadata) {
                    String cleaned = metadata.getClassName().replaceAll("\\$", ".");
                    return clientClasses.contains(cleaned);
                }
            };
            scanner.addIncludeFilter(
                    new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
        }

        for (String basePackage : basePackages) {
            Set<BeanDefinition> candidateComponents = scanner
                    .findCandidateComponents(basePackage);
            for (BeanDefinition candidateComponent : candidateComponents) {
                if (candidateComponent instanceof AnnotatedBeanDefinition) {
                    // verify annotated class is an interface
                    AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                    AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                    Assert.isTrue(annotationMetadata.isInterface(),
                            "@FeignClient can only be specified on an interface");

                    Map<String, Object> attributes = annotationMetadata
                            .getAnnotationAttributes(
                                    FeignClient.class.getCanonicalName());

                    String name = getClientName(attributes);
                    registerClientConfiguration(registry, name,
                            attributes.get("configuration"));

                    registerFeignClient(registry, annotationMetadata, attributes);
                }
            }
        }
    }

首先獲取了ClassPathScanningCandidateComponentProvider，并設置了資源加載的路徑。ClassPathScanningCandidateComponentProvider看名字也大概知道這個類用于在classPath下掃描滿足一定條件的class類。

整個方法的上半部分比較容易理解，就是在判斷是否在@EnableFeignClients中指定了clients的屬性，本文最初也寫到，如果指定了clients，則只會加載指定的幾個class，同時還需要這幾個class有@FeignClient的注解。如果沒有指定，則設置basePackages為啟動類所在的包路徑，掃描當前包和所有子包，即

com/xxx/**/*.class

篩選條件最終會封裝成TypeFilter，添加到scanner中，后續(xù)掃描出的所有class將根據(jù)設置的條件進行過濾。

后半部分則是根據(jù)basePackages來掃描指定路徑下的class文件，將過濾后的BeanDefinition進行注冊。
這里有一個關鍵方法：Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage); 即掃描指定路徑下的所有class，同時按照要求進行過濾，過濾條件是且的關系。

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
        Set<BeanDefinition> candidates = new LinkedHashSet<>();
        try {
            String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                    resolveBasePackage(basePackage) + '/' + this.resourcePattern;
            Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
            boolean traceEnabled = logger.isTraceEnabled();
            boolean debugEnabled = logger.isDebugEnabled();
            for (Resource resource : resources) {
                if (resource.isReadable()) {
                    try {
                        MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
                        if (isCandidateComponent(metadataReader)) {
                            ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                            sbd.setResource(resource);
                            sbd.setSource(resource);
                            if (isCandidateComponent(sbd)) {
                                candidates.add(sbd);
                            }
              //省略下面一系列l(wèi)og輸出的判斷
                            
        }
        catch (IOException ex) {
            throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
        }
        return candidates;
    }

首先根據(jù)路徑掃描.class的字節(jié)碼文件，resources數(shù)組即為掃描結果的類資源文件，讀取文件流封裝成MetadataReader。
isCandidateComponent 這個方法則是將掃描結果進行過濾，將不符合條件的結果去掉。

protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
        for (TypeFilter tf : this.excludeFilters) {
            if (tf.match(metadataReader, getMetadataReaderFactory())) {
                return false;
            }
        }
        for (TypeFilter tf : this.includeFilters) {
            if (tf.match(metadataReader, getMetadataReaderFactory())) {
                return isConditionMatch(metadataReader);
            }
        }
        return false;
    }

比如我們這里添加了includeFilters的過濾條件：

  1. 要求包含@FeignClient的注解
  2. 啟動參數(shù)profiles里指定了local (這一條并不作為filter，而是一種condition)

這里tf.match會根據(jù)TypeFilter的match方法進行判斷，過濾@FeignClient的條件，再通過isConditionMatch來判斷是否滿足condition的條件。
假如我們其中的一個FeignClient指定為@Profile("!local")，也會被上述條件過濾掉。

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ProfileCondition.class)
public @interface Profile {

@Profile 其實是一種@Conditional,對應的實現(xiàn)類是ProfileCondition.class

一系列的條件都滿足后，這些metadataReader會被封裝成ScannedGenericBeanDefinition返回，findCandidateComponents執(zhí)行完成。

獲得BeanDefinition的Set集合后，遍歷每一個對象，注冊ClientConfiguration和FeignClient。
最后的registerFeignClient方法就是將每個feignClient的類定義成FeignClientFactoryBean，由BeanDefinitionBuilder進行屬性填充，最后封裝成BeanDefinition進行注冊。BeanDefinition的beanName是contextId或name + “FeignClient”

private void registerFeignClient(BeanDefinitionRegistry registry,
            AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
        String className = annotationMetadata.getClassName();
        BeanDefinitionBuilder definition = BeanDefinitionBuilder
                .genericBeanDefinition(FeignClientFactoryBean.class);
        validate(attributes);
        definition.addPropertyValue("url", getUrl(attributes));
        definition.addPropertyValue("path", getPath(attributes));
        String name = getName(attributes);
        definition.addPropertyValue("name", name);
        String contextId = getContextId(attributes);
        definition.addPropertyValue("contextId", contextId);
        definition.addPropertyValue("type", className);
        definition.addPropertyValue("decode404", attributes.get("decode404"));
        definition.addPropertyValue("fallback", attributes.get("fallback"));
        definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
        definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);

        String alias = contextId + "FeignClient";
        AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();

        boolean primary = (Boolean)attributes.get("primary"); // has a default, won't be null

        beanDefinition.setPrimary(primary);

        String qualifier = getQualifier(attributes);
        if (StringUtils.hasText(qualifier)) {
            alias = qualifier;
        }

        BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
                new String[] { alias });
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }

三. 總結

至此，關于@EnableFeignClients的啟動加載過程就分析完成。
總結一下：

  1. 注冊默認的defaultConfiguration
  2. 根據(jù)是否指定了client決定要掃描的類范圍
  3. 將掃描的結果進行過濾
  4. 將結果列表封裝FeignClientFactoryBean的BeanDefinition注冊到spring容器中。

四. 后續(xù)

下一篇將分析FeignClientFactoryBean如何實現(xiàn)feign的調(diào)用。

最后編輯于 ：
?著作權歸作者所有,轉載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

友情鏈接更多精彩內(nèi)容