Spring Cloud OpenFeign的原理（六）

童話述說我的結局發表於2020-12-20
SpringCloud

通過上篇我們瞭解OpenFeign他也可以完成遠端通訊，但是它並不是真正義意上的RPC通訊，因為他是通過封裝代理來實現的，下面和以前一樣，知道了怎麼用就來看下他是怎麼實現的。

一、思考Feign要做的事情

有了ribbon的鋪墊現在看OpenFeign應該很清楚的知道，這玩意就是通過註解拿到服務名，然後通過服務名獲取服務列表，進行解析和負載最終拼接出一個URI路徑進行代理請求，那麼他要完成這一系列動作他就要做下面幾件事。

  • 引數的解析和裝載
  • 針對指定的FeignClient，生成動態代理
  • 針對FeignClient中的方法描述進行解析
  • 組裝出一個Request物件，發起請求

二、原始碼分析

看過我寫的ribbon的應該清楚，如果想要找到進入原始碼的入口那麼應該要找的是FeignClient，但是FeignClient是在哪裡被解析的呢，在應用篇中我在啟動類中加了個@EnableFeignClients註解，這 個註解的作用其實就是開啟了一個FeignClient的掃描，那麼點選啟動類的@EnableFeignClients註解看下他是怎麼開啟FeignClient的掃描的，進去後發現裡面有個@Import(FeignClientsRegistrar.class)這個FeignClientsRegistrar跟Bean的動態裝載有關

 

 

 點選進去有個registerBeanDefinitions方法通過名稱可以知道是一個Bean的注入方法

 

 

 下面我寫一個簡單的例子來描述他是如何實現動態載入的，學FeignClientsRegistrar類 implements ImportBeanDefinitionRegistrar介面並實現registerBeanDefinitions方法

 

 

 這一步搞完後，定義一個註解，把@EnableFeignClients註解上的註解都抄過來並把@Import註解裡面的類改成我們自己定義的類

 

 

 然後在啟動類上用上自定義的註解，那麼在啟動類時就可以進行一個Bean的動態裝載了

 

 

 

 通過這個概念已經很清楚原始碼中FeignClientsRegistrar類的FeignClientsRegistrar是怎麼完成Bean的動態載入了

  • registerDefaultConfifiguration 方法內部從 SpringBoot 啟動類上檢查是否有@EnableFeignClients, 有該註解的話， 則完成 Feign 框架相關的一些配置內容註冊
  • registerFeignClients 方法內部從 classpath 中， 掃描獲得 @FeignClient 修飾的類， 將類的內容解析為 BeanDefifinition , 最終通過呼叫 Spring 框架中的BeanDefifinitionReaderUtils.resgisterBeanDefifinition 將解析處理過的 FeignClientBeanDeififinition 新增到 spring 容器中. 
@Override
    public void registerBeanDefinitions(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
         //註冊預設配置資訊
        registerDefaultConfiguration(metadata, registry);
         //註冊FeignClients（可能有多個）
        registerFeignClients(metadata, registry);
    }

進入registerFeignClients(metadata, registry);這玩意是幹啥的呢，在啟動類中的@EnableFeignClients是可以定義多個basePackers的如果定義了多個那就要掃描FeignClients，下面就是掃描處理過程，看過spring原始碼的人就知道前面是什麼註解解析

    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)));
        }
         //bssePackages是解析不同basePackage路徑下的FeignClient的宣告
        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);
                     //如果每個包路徑下都有一個或多個FeignClient的話就要載入 一次動態configuration配置所以這就是為什麼前面已經載入過了這裡還要載入一次的原因
                    registerClientConfiguration(registry, name,
                            attributes.get("configuration"));
                    //註冊Feignclient
                    registerFeignClient(registry, annotationMetadata, attributes);
                }
            }
        }
    }

點選registerFeignClient(registry, annotationMetadata, attributes);看下做了啥事，這裡面的邏輯其實就幹了一件事，就是通過BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);注入一個Bean；這個注入的過程中有個比較重要的程式碼BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(FeignClientFactoryBean.class);這是一個構造者，構造一個BeanDefinition,裡面把FeignClientFactoryBean.class給傳了進去

 

 

 

 下面進入.genericBeanDefinition(FeignClientFactoryBean.class);看把 FeignClientFactoryBean.class類傳進去幹嘛，發現註冊的Bean就是引數中自己傳進來的beanClass,這個傳進去的beanClass是工廠Bean

Spring Cloud FengnClient實際上是利用Spring的代理工廠來生成代理類，所以在這裡地方才會把所有的FeignClient的BeanDefifinition設定為FeignClientFactoryBean型別，而FeignClientFactoryBean繼承自FactoryBean，它是一個工廠Bean。在Spring中，FactoryBean是一個工廠Bean，用來建立代理Bean。工廠 Bean 是一種特殊的 Bean, 對於 Bean 的消費者來說， 他邏輯上是感知不到這個 Bean 是普通的 Bean 還是工廠 Bean, 只是按照正常的獲取 Bean 方式去呼叫， 但工廠bean 最後返回的例項不是工廠Bean 本身， 而是執行工廠 Bean 的 getObject 邏輯返回的示例。

 

 

 點選這個工廠Bean的FeignClientFactoryBean類中發現裡面有個getObject()方法，這個工廠Bean就是通過這個getTarget();返回一個真正的例項

 

 

 畫下時序圖

 

 

 

 前面說到了在啟動時會通過@EnableFeignClients去掃描所有指定路徑下的@FeignClient註解宣告的一個介面，然後在掃描到以後要去生成一個動態代理的類，這個動態代理的生成就是在呼叫getObject（）時完成 ，而且getObject()又會呼叫他方法裡面的getTarget（）去完成這件事，

它從applicationContext取出FeignContext，FeignContext繼承了NamedContextFactory，它是用來來統一維護feign中各個feign客戶端相互隔離的上下文。他只所以能完成隔離跟他父類中的contexts()方法有很大關係

<T> T getTarget() {
//FeignContext註冊到容器是在FeignAutoConfiguration上完成的
//在初始化FeignContext時，會把configurations在容器中放入FeignContext中。configurations的
//來源就是在前面registerFeignClients方法中將@FeignClient的配置configuration。
FeignContext context = this.applicationContext.getBean(FeignContext.class);
Feign.Builder builder = feign(context);//構建Builder物件
//如果url為空，則走負載均衡，生成有負載均衡功能的代理類
if (!StringUtils.hasText(this.url)) {
if (!this.name.startsWith("http")) {
this.url = "http://" + this.name;
}
else {
this.url = this.name;
}
this.url += cleanPath();
return (T) loadBalance(builder, context,
new HardCodedTarget<>(this.type, this.name, this.url));
}
//如果指定了url，則生成預設的代理類
if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
this.url = "http://" + this.url;
}
String url = this.url + cleanPath();
Client client = getOptional(context, Client.class);
if (client != null) {
if (client instanceof LoadBalancerFeignClient) {
// not load balancing because we have a url,
// but ribbon is on the classpath, so unwrap
client = ((LoadBalancerFeignClient) client).getDelegate();
}
if (client instanceof FeignBlockingLoadBalancerClient) {
// not load balancing because we have a url,
// but Spring Cloud LoadBalancer is on the classpath, so unwrap
client = ((FeignBlockingLoadBalancerClient) client).getDelegate();
}
builder.client(client);
}//生成預設代理類
Targeter targeter = get(context, Targeter.class);
return (T) targeter.target(this, builder, context,
new HardCodedTarget<>(this.type, this.name, url));
}

 

 

 

 上面有段程式碼Feign.Builder builder = feign(context);是構建Builder物件

 

    protected Feign.Builder feign(FeignContext context) {
        FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
        Logger logger = loggerFactory.create(this.type);

        // @formatter:off
        Feign.Builder builder = get(context, Feign.Builder.class)
                // required values
                //開啟日誌級別
                .logger(logger)
                //編碼
                .encoder(get(context, Encoder.class))
                //解碼
                .decoder(get(context, Decoder.class))
                //連線。這個連線用在解析模板的，後面會提
                .contract(get(context, Contract.class));
        // @formatter:on

        configureFeign(context, builder);

        return builder;
    }

上面的builder構造完後繼續向下走，配置完Feign.Builder之後，再判斷是否需要LoadBalance，如果需要，則通過LoadBalance的方法來設定。實際上他們最終呼叫的是Target.target()方法。 

loadBalance這玩意比較重要因為他是生成具備負載均衡能力的feign客戶端，為feign客戶端構建起繫結負載均衡客戶端Client client = (Client)this.getOptional(context, Client.class); 從上下文中獲取一個Client，預設是LoadBalancerFeignClient。
它是在FeignRibbonClientAutoConfifiguration這個自動裝配類中，通過Import實現的
@Import({ HttpClientFeignLoadBalancedConfiguration.class, 
         OkHttpFeignLoadBalancedConfiguration.class, 
         DefaultFeignLoadBalancedConfiguration.class })
protected <T> T loadBalance(Feign.Builder builder, FeignContext context,
            HardCodedTarget<T> target) {
        //針對某一個服務的client
        Client client = getOptional(context, Client.class);
        if (client != null) {
           //將client設定進去相當於增加了客戶端負載均衡解析的機制
            builder.client(client);
            Targeter targeter = get(context, Targeter.class);
            return targeter.target(this, builder, context, target);
        }

        throw new IllegalStateException(
                "No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon?");
    }

點選上圖的targeter.target(this, builder, context, target);因為熔斷準備在後面講，所以在選tartget的實現時選擇DefaultTarget.target 

 

 點選feign.target()往下走，走到這裡其實就已經到了核心邏輯了，前面不一直說動態代理嗎，前面走的都是人生最長的套路，前面自己寫的控制層程式碼通過@Resource註解注入的UserOpenFeign他最終會呼叫下面的方法返回一個例項，那麼下面看下這newInstance()方法做了啥，發現這玩意有兩個實現，至於選擇哪個就要看build()返回的是什麼了，向下看發現build（）返回的是ReflectiveFeign，所以選第二個

這個方法是用來建立一個動態代理的方法，在生成動態代理之前，會根據Contract協議（協議解析規則，解析介面類的註解資訊，解析成內部的MethodHandler的處理方式。從實現的程式碼中可以看到熟悉的Proxy.newProxyInstance方法產生代理類。而這裡需要對每個定義的介面方法進行特定的處理實現，所以這裡會出現一個MethodHandler的概念，就是對應方法級別的InvocationHandler。 

 

 public <T> T newInstance(Target<T> target) {
 //根據介面類和Contract協議解析方式，解析介面類上的方法和註解，轉換成內部的MethodHandler處理方式
    Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
    Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();
    List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();

    for (Method method : target.type().getMethods()) {
      if (method.getDeclaringClass() == Object.class) {
        continue;
      } else if (Util.isDefault(method)) {
        DefaultMethodHandler handler = new DefaultMethodHandler(method);
        defaultMethodHandlers.add(handler);
        methodToHandler.put(method, handler);
      } else {
        methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
      }
    }
    // 基於Proxy.newProxyInstance 為介面類建立動態實現，將所有的請求轉換給InvocationHandler 處理。
    InvocationHandler handler = factory.create(target, methodToHandler);
    T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(),
        new Class<?>[] {target.type()}, handler);

    for (DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {
      defaultMethodHandler.bindTo(proxy);
    }
    return proxy;
  }

下面通過debugger驗證下，會看到userOpenFeign的返回的是代理類，通過下圖可以知道當呼叫userOpenFeign時他其實是呼叫ReflectiveFeign中的handler，而通過Debugger發現這個handler是FeginInvocationHandler,

竟然是走了代理那麼他一定是走了ReflectiveFeign的代理方法invoke（）方法

 

 

 

 

 

相關文章