前言

前情回顧

上一講深入的講解了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 和公眾號：壹枝花算不算浪漫，如若轉載請標明來源!

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

相關推薦