【一起學源碼-微服務】Feign 源碼一：源碼初探，通過Demo Debug Feign源碼

前言

前情回顧

上一講深入的講解了Ribbon的初始化過程及Ribbon與Eureka的整合代碼，與Eureka整合的類就是DiscoveryEnableNIWSServerList，同時在DynamicServerListLoadBalancer中會調用PollingServerListUpdater 進行定時更新Eureka注冊表信息到BaseLoadBalancer中，默認30s調度一次。

本講目錄

這一講主要是講Fegin Demo以及通過入口注解@EnableFeignCliets和@FeignClient來進行源碼初探。

目錄如下：

1. Feign代碼Demo
2. Feign調用原理
3. @EnableEurekaClient和@FeignClient注解掃描

說明

原創不易，如若轉載 請標明來源！

博客地址：一枝花算不算浪漫
微信公眾號：壹枝花算不算浪漫

源碼分析

Feign代碼Demo

Fegin的Demo還是延續之前講解的Eureka的代碼。地址為：
https://github.com/barrywangmeng/spring-cloud-learn

如上圖所示，ServiceB調用ServiceA的服務，定義了一個@FeignClient標注的ServiceAFeignClient接口，里面定義了ServiceA中Controller提供的接口信息。

Feign調用原理

接着我們可以啟動所有服務，調用ServiceBController，然后在serviceAFeignClient處打上斷點看一下：

我們發現這里serviceAFeignClient顯示的是：ReflectiveFeign$FeignInvocationHandler@7642 ，這里其實是使用了動態代理，因為ServiceAFeignClient 是一個接口，所以這里可以猜測到底層使用的是JDK動態代理。

接着可以簡單地梳理下Feign請求簡單原理圖：

@EnableEurekaClient和@FeignClient注解掃描

先看下@EnableFeignClients注解代碼：

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

    //等價於basePackages屬性，更簡潔的方式
    String[] value() default {};
    //指定多個包名進行掃描
    String[] basePackages() default {};

    //指定多個類或接口的class,掃描時會在這些指定的類和接口所屬的包進行掃描
    Class<?>[] basePackageClasses() default {};

     //為所有的Feign Client設置默認配置類
    Class<?>[] defaultConfiguration() default {};

     //指定用@FeignClient注釋的類列表。如果該項配置不為空，則不會進行類路徑掃描
    Class<?>[] clients() default {};
}

接着看下@FeignClient注解代碼：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FeignClient {

    //指定Feign Client的名稱，如果項目使用了 Ribbon，name屬性會作為微服務的名稱，用於服務發現
    @AliasFor("name")
    String value() default "";
    //用serviceId做服務發現已經被廢棄，所以不推薦使用該配置
    @Deprecated
    String serviceId() default "";
    //指定Feign Client的serviceId，如果項目使用了 Ribbon，將使用serviceId用於服務發現,但上面可以看到serviceId做服務發現已經被廢棄，所以也不推薦使用該配置
    @AliasFor("value")
    String name() default "";
    //為Feign Client 新增注解@Qualifier
    String qualifier() default "";
    //請求地址的絕對URL，或者解析的主機名
    String url() default "";
    //調用該feign client發生了常見的404錯誤時，是否調用decoder進行解碼異常信息返回,否則拋出FeignException
    boolean decode404() default false;
     //Feign Client設置默認配置類
    Class<?>[] configuration() default {};
    //定義容錯的處理類，當調用遠程接口失敗或超時時，會調用對應接口的容錯邏輯,fallback 指定的類必須實現@FeignClient標記的接口。實現的法方法即對應接口的容錯處理邏輯
    Class<?> fallback() default void.class;
    //工廠類，用於生成fallback 類示例，通過這個屬性我們可以實現每個接口通用的容錯邏輯，減少重復的代碼
    Class<?> fallbackFactory() default void.class;
    //定義當前FeignClient的所有方法映射加統一前綴
    String path() default "";
    //是否將此Feign代理標記為一個Primary Bean，默認為ture
    boolean primary() default true;
}

接着我們看下@EnableFeignClients中注入的
@Import(FeignClientsRegistrar.class) 源碼：

class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar,
        ResourceLoaderAware, EnvironmentAware {

    // patterned after Spring Integration IntegrationComponentScanRegistrar
    // and RibbonClientsConfigurationRegistgrar

    private ResourceLoader resourceLoader;

    private Environment environment;

    public FeignClientsRegistrar() {
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

   //在這個重載的方法里面做了兩件事情：
   //1.將EnableFeignClients注解對應的配置屬性注入
   //2.將FeignClient注解對應的屬性注入
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        //注入EnableFeignClients注解對應的配置屬性
        registerDefaultConfiguration(metadata, registry);
       //注入FeignClient注解對應的屬性
        registerFeignClients(metadata, registry);
    }

   /**
   * 拿到 EnableFeignClients注解 defaultConfiguration 字段的值
   * 然后進行注入
   *
   **/
    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"));
        }
    }

    public void registerFeignClients(AnnotationMetadata metadata,
                                 BeanDefinitionRegistry registry) {
        // 獲取ClassPath掃描器
        ClassPathScanningCandidateComponentProvider scanner = getScanner();
        // 為掃描器設置資源加載器
        scanner.setResourceLoader(this.resourceLoader);

        Set<String> basePackages;
        // 1. 從@EnableFeignClients注解中獲取到配置的各個屬性值
        // 這里可以獲取到配置的：basePackages=com.barrywang.service.feign
        Map<String, Object> attrs = metadata
                .getAnnotationAttributes(EnableFeignClients.class.getName());
        // 2. 注解類型過濾器，只過濾@FeignClient   
        AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
                FeignClient.class);
        // 3. 從1. 中的屬性值中獲取clients屬性的值        
        final Class<?>[] clients = attrs == null ? null
                : (Class<?>[]) attrs.get("clients");
        if (clients == null || clients.length == 0) {
            // 掃描器設置過濾器且獲取需要掃描的基礎包集合
            scanner.addIncludeFilter(annotationTypeFilter);
            basePackages = getBasePackages(metadata);
        }else {
            // clients屬性值不為null，則將其clazz路徑轉為包路徑
            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)));
        }

        // 3. 掃描基礎包，且滿足過濾條件下的接口封裝成BeanDefinition
        for (String basePackage : basePackages) {
            // 找到basePackage下定義的@FeignClient接口列表
            Set<BeanDefinition> candidateComponents = scanner
                    .findCandidateComponents(basePackage);
            // 遍歷掃描到的bean定義        
            for (BeanDefinition candidateComponent : candidateComponents) {
                if (candidateComponent instanceof AnnotatedBeanDefinition) {
                    // 並校驗掃描到的bean定義類是一個接口
                    AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                    AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                    Assert.isTrue(annotationMetadata.isInterface(),
                            "@FeignClient can only be specified on an interface");

                    // 獲取@FeignClient注解上的各個屬性值
                    Map<String, Object> attributes = annotationMetadata
                            .getAnnotationAttributes(
                                    FeignClient.class.getCanonicalName());

                    String name = getClientName(attributes);
                    // 可以看到這里也注冊了一個FeignClient的配置bean
                    // 這個方法是創建了一個FeignClientFactoryBean的工廠類，里面保存@FeignClient注解的所有屬性值
                    registerClientConfiguration(registry, name,
                            attributes.get("configuration"));
                    // 注冊bean定義到spring中
                    registerFeignClient(registry, annotationMetadata, attributes);
                }
            }
        }
    }

   /**
   * 注冊bean
   **/
    private void registerFeignClient(BeanDefinitionRegistry registry,
       AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
        // 1.獲取類名稱，也就是本例中的FeignService接口
        String className = annotationMetadata.getClassName();

        // 2.BeanDefinitionBuilder的主要作用就是構建一個AbstractBeanDefinition
        // AbstractBeanDefinition類最終被構建成一個BeanDefinitionHolder
        // 然后注冊到Spring中
        // 注意：beanDefinition類為FeignClientFactoryBean，故在Spring獲取類的時候實際返回的是
        // FeignClientFactoryBean類
        BeanDefinitionBuilder definition = BeanDefinitionBuilder
            .genericBeanDefinition(FeignClientFactoryBean.class);
        validate(attributes);

        // 3.添加FeignClientFactoryBean的屬性，
        // 這些屬性也都是我們在@FeignClient中定義的屬性
        definition.addPropertyValue("url", getUrl(attributes));
        definition.addPropertyValue("path", getPath(attributes));
        String name = getName(attributes);
        definition.addPropertyValue("name", name);
        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);

        // 4.設置別名 name就是我們在@FeignClient中定義的name屬性
        String alias = name + "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;
        }

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

    private void validate(Map<String, Object> attributes) {
        AnnotationAttributes annotation = AnnotationAttributes.fromMap(attributes);
        // This blows up if an aliased property is overspecified
        // FIXME annotation.getAliasedString("name", FeignClient.class, null);
        Assert.isTrue(
            !annotation.getClass("fallback").isInterface(),
            "Fallback class must implement the interface annotated by @FeignClient"
        );
        Assert.isTrue(
            !annotation.getClass("fallbackFactory").isInterface(),
            "Fallback factory must produce instances of fallback classes that implement the interface annotated by @FeignClient"
        );
    }

    private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name,
            Object configuration) {
        // 創建一個使用FeignClientSpecification構建的BeanDefinitionBuilder的類
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .genericBeanDefinition(FeignClientSpecification.class);
        builder.addConstructorArgValue(name);
        builder.addConstructorArgValue(configuration);
        registry.registerBeanDefinition(
                name + "." + FeignClientSpecification.class.getSimpleName(),
                builder.getBeanDefinition());
    }

   ......
   ......
   ......
}

在這里做了兩件事情：

1. 將EnableFeignClients注解對應的配置屬性注入；
2. 將FeignClient注解對應的屬性注入。

生成FeignClient對應的bean，注入到Spring 的IOC容器。

總結

在我們查看處理@EnableFeignClients和@FeignClient注解的地方，最后調用registerFeignClient() 會構造一個：

BeanDefinitionBuilder definition = BeanDefinitionBuilder
                .genericBeanDefinition(FeignClientFactoryBean.class);

所以我們后續會重點查看FeignClientFactoryBean 這個類。

申明

本文章首發自本人博客：https://www.cnblogs.com/wang-meng 和公眾號：壹枝花算不算浪漫，如若轉載請標明來源!

感興趣的小伙伴可關注個人公眾號：壹枝花算不算浪漫