[[419659]]

絮叨

前面一節(jié)我們學(xué)習(xí)了一下eureka,我們來(lái)回顧一下，首先它是一個(gè)cs架構(gòu)，分為客戶端和服務(wù)端，

客戶端 也分為 生成者和消費(fèi)者，也就是服務(wù)提供方和服務(wù)消費(fèi)方，具體客戶端的作用如下

• 當(dāng)客戶端啟動(dòng)的時(shí)候向服務(wù)端注冊(cè)當(dāng)前服務(wù)
• 并和服務(wù)端維持心跳，用的是后臺(tái)線程
• 拉取服務(wù)端的各個(gè)節(jié)點(diǎn)集合，然后定時(shí)更新服務(wù)的信息到本地，因?yàn)榭蛻舳艘彩菚?huì)緩存服務(wù)節(jié)點(diǎn)信息的
• 當(dāng)服務(wù)掛掉的時(shí)候，監(jiān)聽(tīng)shutdown 然后上報(bào)自己掛掉的狀態(tài)給服務(wù)端

服務(wù)端

• 啟動(dòng)后，從其他節(jié)點(diǎn)獲取服務(wù)注冊(cè)信息。
• 運(yùn)行過(guò)程中，定時(shí)運(yùn)行evict任務(wù)，剔除沒(méi)有按時(shí)renew的服務(wù)(包括非正常停止和網(wǎng)絡(luò)故障的服務(wù))。
• 運(yùn)行過(guò)程中，接收到的register、renew、cancel請(qǐng)求，都會(huì)同步至其他注冊(cè)中心節(jié)點(diǎn)，分布式數(shù)據(jù)同步(AP)
• 運(yùn)行過(guò)程中，自我保護(hù)機(jī)制。等等
• SpringCloud原理之eureka

什么是Feign

Feign是一種聲明式、模板化的HTTP客戶端(僅在Application Client中使用)。聲明式調(diào)用是指，就像調(diào)用本地方法一樣調(diào)用遠(yuǎn)程方法，無(wú)需感知操作遠(yuǎn)程http請(qǐng)求。Spring Cloud的聲明式調(diào)用, 可以做到使用 HTTP請(qǐng)求遠(yuǎn)程服務(wù)時(shí)能就像調(diào)用本地方法一樣的體驗(yàn)，開(kāi)發(fā)者完全感知不到這是遠(yuǎn)程方法，更感知不到這是個(gè)HTTP請(qǐng)求。Feign的應(yīng)用，讓Spring Cloud微服務(wù)調(diào)用像Dubbo一樣，Application Client直接通過(guò)接口方法調(diào)用Application Service，而不需要通過(guò)常規(guī)的RestTemplate構(gòu)造請(qǐng)求再解析返回?cái)?shù)據(jù)。它解決了讓開(kāi)發(fā)者調(diào)用遠(yuǎn)程接口就跟調(diào)用本地方法一樣，無(wú)需關(guān)注與遠(yuǎn)程的交互細(xì)節(jié)，更無(wú)需關(guān)注分布式環(huán)境開(kāi)發(fā)。

Feign是聲明性Web服務(wù)客戶端。它使編寫(xiě)Web服務(wù)客戶端更加容易。要使用Feign，請(qǐng)創(chuàng)建一個(gè)接口并對(duì)其進(jìn)行注釋。它具有可插入注釋支持，包括Feign注釋和JAX-RS注釋。Feign還支持可插拔編碼器和解碼器。Spring Cloud添加了對(duì)Spring MVC注釋的支持，并支持使用HttpMessageConvertersSpring Web中默認(rèn)使用的注釋。當(dāng)使用Feign時(shí)，Spring Cloud集成了Ribbon和Eureka以提供負(fù)載平衡的http客戶端。

使用Feign開(kāi)發(fā)時(shí)的應(yīng)用部署結(jié)構(gòu)

Feign是如何設(shè)計(jì)的?

原生的Feign

雖然我們用SpringCloud全家桶比較多，但是其實(shí)呢?他只是對(duì)原生的fegin做了一些封裝，所以刨根問(wèn)底的話，我們還是多了解了解原生的Fegin,對(duì)于我們理解Spring Cloud feign是很有幫助的

Feign使用簡(jiǎn)介

基本用法

基本的使用如下所示，一個(gè)對(duì)于canonical Retrofit sample的適配。

interface GitHub { 
 // RequestLine注解聲明請(qǐng)求方法和請(qǐng)求地址,可以允許有查詢參數(shù) 
 @RequestLine("GET /repos/{owner}/{repo}/contributors") 
 List<Contributor> contributors(@Param("owner") String owner, @Param("repo") String repo); 
} 
static class Contributor { 
 String login; 
 int contributions; 
} 
public static void main(String... args) { 
 GitHub github = Feign.builder() 
            .decoder(new GsonDecoder()) 
            .target(GitHub.class, "https://api.github.com"); 
 // Fetch and print a list of the contributors to this library. 
 List<Contributor> contributors = github.contributors("OpenFeign", "feign"); 
 for (Contributor contributor : contributors) { 
  System.out.println(contributor.login + " (" + contributor.contributions + ")"); 
 } 
} 

自定義

Feign 有許多可以自定義的方面。舉個(gè)簡(jiǎn)單的例子，你可以使用 Feign.builder() 來(lái)構(gòu)造一個(gè)擁有你自己組件的API接口。如下:

interface Bank { 
 @RequestLine("POST /account/{id}") 
 Account getAccountInfo(@Param("id") String id); 
} 
... 
// AccountDecoder() 是自己實(shí)現(xiàn)的一個(gè)Decoder 
Bank bank = Feign.builder().decoder(new AccountDecoder()).target(Bank.class, https://api.examplebank.com); 

Feign 動(dòng)態(tài)代理

Feign 的默認(rèn)實(shí)現(xiàn)是 ReflectiveFeign，通過(guò) Feign.Builder 構(gòu)建。再看代碼前，先了解一下 Target 這個(gè)對(duì)象。

public interface Target<T> { 
  // 接口的類(lèi)型 
  Class<T> type(); 
 
  // 代理對(duì)象的名稱，默認(rèn)為url,負(fù)載均衡時(shí)有用 
  String name(); 
  // 請(qǐng)求的url地址，eg: https://api/v2 
  String url(); 
} 

其中 Target.type 是用來(lái)生成代理對(duì)象的，url 是 Client 對(duì)象發(fā)送請(qǐng)求的地址。

public Feign build() { 
    // client 有三種實(shí)現(xiàn) JdkHttp/ApacheHttp/okHttp，默認(rèn)是 jdk 的實(shí)現(xiàn) 
    SynchronousMethodHandler.Factory synchronousMethodHandlerFactory = 
        new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger, 
                                             logLevel, decode404, closeAfterDecode, propagationPolicy); 
    ParseHandlersByName handlersByName = 
        new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder, 
                                errorDecoder, synchronousMethodHandlerFactory); 
    return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder); 
} 

總結(jié)：介紹一下幾個(gè)主要的參數(shù)：

• Client 這個(gè)沒(méi)什么可說(shuō)的，有三種實(shí)現(xiàn) JdkHttp/ApacheHttp/okHttp
• RequestInterceptor 請(qǐng)求攔截器
• Contract REST 注解解析器，默認(rèn)為 Contract.Default()，即支持 Feign 的原生注解。
• InvocationHandlerFactory 生成 JDK 動(dòng)態(tài)代理，實(shí)際執(zhí)行是委托給了 MethodHandler。

生成代理對(duì)象

public <T> T newInstance(Target<T> target) { 
    // 1. Contract 將 target.type 接口類(lèi)上的方法和注解解析成 MethodMetadata， 
    //    并轉(zhuǎn)換成內(nèi)部的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))); 
        } 
    } 
 
    // 2. 生成 target.type 的 jdk 動(dòng)態(tài)代理對(duì)象 
    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; 
} 

總結(jié)：newInstance 生成了 JDK 的動(dòng)態(tài)代理，從 factory.create(target, methodToHandler) 也可以看出 InvocationHandler 實(shí)際委托給了 methodToHandler。methodToHandler 默認(rèn)是 SynchronousMethodHandler.Factory 工廠類(lèi)創(chuàng)建的。

MethodHandler 方法執(zhí)行器

ParseHandlersByName.apply 生成了每個(gè)方法的執(zhí)行器 MethodHandler，其中最重要的一步就是通過(guò) Contract 解析 MethodMetadata。

public Map<String, MethodHandler> apply(Target key) { 
    // 1. contract 將接口類(lèi)中的方法和注解解析 MethodMetadata 
    List<MethodMetadata> metadata = contract.parseAndValidatateMetadata(key.type()); 
    Map<String, MethodHandler> result = new LinkedHashMap<String, MethodHandler>(); 
    for (MethodMetadata md : metadata) { 
        // 2. buildTemplate 實(shí)際上將 Method 方法的參數(shù)轉(zhuǎn)換成 Request 
        BuildTemplateByResolvingArgs buildTemplate; 
        if (!md.formParams().isEmpty() && md.template().bodyTemplate() == null) { 
            // 2.1 表單 
            buildTemplate = new BuildFormEncodedTemplateFromArgs(md, encoder, queryMapEncoder); 
        } else if (md.bodyIndex() != null) { 
            // 2.2 @Body 注解 
            buildTemplate = new BuildEncodedTemplateFromArgs(md, encoder, queryMapEncoder); 
        } else { 
            // 2.3 其余 
            buildTemplate = new BuildTemplateByResolvingArgs(md, queryMapEncoder); 
        } 
        // 3. 將 metadata 和 buildTemplate 封裝成 MethodHandler 
        result.put(md.configKey(), 
                   factory.create(key, md, buildTemplate, options, decoder, errorDecoder)); 
    } 
    return result; 
} 

總結(jié)：這個(gè)方法由以下幾步：

Contract 統(tǒng)一將方法解析 MethodMetadata(*)，這樣就可以通過(guò)實(shí)現(xiàn)不同的 Contract 適配各種 REST 聲明式規(guī)范。buildTemplate 實(shí)際上將 Method 方法的參數(shù)轉(zhuǎn)換成 Request。將 metadata 和 buildTemplate 封裝成 MethodHandler。

這樣通過(guò)以上三步就創(chuàng)建了一個(gè) Target.type 的代理對(duì)象 proxy，這個(gè)代理對(duì)象就可以像訪問(wèn)普通方法一樣發(fā)送 Http 請(qǐng)求，其實(shí)和 RPC 的 Stub 模型是一樣的。了解 proxy 后，其執(zhí)行過(guò)程其實(shí)也就一模了然。

Feign 調(diào)用過(guò)程

FeignInvocationHandler#invoke

private final Map<Method, MethodHandler> dispatch; 
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    ... 
    // 每個(gè)Method方法對(duì)應(yīng)一個(gè)MethodHandler 
    return dispatch.get(method).invoke(args); 
} 

總結(jié)：和上面的結(jié)論一樣，實(shí)際的執(zhí)行邏輯實(shí)際上是委托給了 MethodHandler。

SynchronousMethodHandler#invoke

// 發(fā)起 http 請(qǐng)求，并根據(jù) retryer 進(jìn)行重試 
public Object invoke(Object[] argv) throws Throwable { 
    // template 將 argv 參數(shù)構(gòu)建成 Request 
    RequestTemplate template = buildTemplateFromArgs.create(argv); 
    Options options = findOptions(argv); 
    Retryer retryer = this.retryer.clone(); 
 
    // 調(diào)用client.execute(request, options) 
    while (true) { 
        try { 
            return executeAndDecode(template, options); 
        } catch (RetryableException e) { 
            try { 
                // 重試機(jī)制 
                retryer.continueOrPropagate(e); 
            } catch (RetryableException th) { 
                ... 
            } 
            continue; 
        } 
    } 
} 

總結(jié)：invoke 主要進(jìn)行請(qǐng)求失敗的重試機(jī)制，至于具體執(zhí)行過(guò)程委托給了 executeAndDecode 方法。

// 一是編碼生成Request；二是http請(qǐng)求；三是解碼生成Response 
Object executeAndDecode(RequestTemplate template, Options options) throws Throwable { 
    // 1. 調(diào)用攔截器 RequestInterceptor，并根據(jù) template 生成 Request 
    Request request = targetRequest(template); 
    // 2. http 請(qǐng)求 
    Response response = client.execute(request, options); 
 // 3. response 解碼 
    if (Response.class == metadata.returnType()) { 
        byte[] bodyData = Util.toByteArray(response.body().asInputStream()); 
        return response.toBuilder().body(bodyData).build(); 
    } 
    ... 
} 
 
Request targetRequest(RequestTemplate template) { 
    // 執(zhí)行攔截器 
    for (RequestInterceptor interceptor : requestInterceptors) { 
        interceptor.apply(template); 
    } 
    // 生成 Request 
    return target.apply(template); 

這個(gè)是原生feign的調(diào)用過(guò)程，總的來(lái)說(shuō)分為2部 一個(gè)是 客戶端的封裝，一個(gè)調(diào)用方法的封裝

Spring Cloud Feign 的原理解析

我們前面看了原生的feign之后呢?對(duì)于Spring Cloud的Feign的話理解起來(lái)就很簡(jiǎn)單了，我們知道Spring cloud 是基于SpringBoot SpringBoot 又是基于Spring,那么Spring就是一個(gè)膠水框架，它就是把各個(gè)組件把它封裝起來(lái)，所以呢，這樣就簡(jiǎn)單很多了嘛

小六六在這邊就不一一的給大家演示SpringCloud 是如何使用Feign的了，小六六默認(rèn)大家都懂，哈哈，那么就直接說(shuō)原理吧

工作原理

我們來(lái)想想平時(shí)我們使用feign的時(shí)候，會(huì)是一個(gè)怎么樣的流程

• 添加了 Spring Cloud OpenFeign 的依賴
• 在 SpringBoot 啟動(dòng)類(lèi)上添加了注解 @EnableFeignCleints
• 按照 Feign 的規(guī)則定義接口 DemoService， 添加@FeignClient 注解
• 在需要使用 Feign 接口 DemoService 的地方， 直接利用@Autowire 進(jìn)行注入
• 使用接口完成對(duì)服務(wù)端的調(diào)用

那我們基于這些步驟來(lái)分析分析，本文并不會(huì)說(shuō)非常深入去看每一行的源碼

• SpringBoot 應(yīng)用啟動(dòng)時(shí)， 由針對(duì) @EnableFeignClient 這一注解的處理邏輯觸發(fā)程序掃描 classPath中所有被@FeignClient 注解的類(lèi)， 這里以 XiaoLiuLiuService 為例， 將這些類(lèi)解析為 BeanDefinition 注冊(cè)到 Spring 容器中
• Sping 容器在為某些用的 Feign 接口的 Bean 注入 XiaoLiuLiuService 時(shí)， Spring 會(huì)嘗試從容器中查找 XiaoLiuLiuService 的實(shí)現(xiàn)類(lèi)
• 由于我們從來(lái)沒(méi)有編寫(xiě)過(guò) XiaoLiuLiuService 的實(shí)現(xiàn)類(lèi)， 上面步驟獲取到的 XiaoLiuLiuService 的實(shí)現(xiàn)類(lèi)必然是 feign 框架通過(guò)擴(kuò)展 spring 的 Bean 處理邏輯， 為 XiaoLiuLiuService 創(chuàng)建一個(gè)動(dòng)態(tài)接口代理對(duì)象， 這里我們將其稱為 XiaoLiuLiuServiceProxy 注冊(cè)到spring 容器中。
• Spring 最終在使用到 XiaoLiuLiuService 的 Bean 中注入了 XiaoLiuLiuServiceProxy 這一實(shí)例。
• 當(dāng)業(yè)務(wù)請(qǐng)求真實(shí)發(fā)生時(shí)， 對(duì)于 XiaoLiuLiuService 的調(diào)用被統(tǒng)一轉(zhuǎn)發(fā)到了由 Feign 框架實(shí)現(xiàn)的 InvocationHandler 中， InvocationHandler 負(fù)責(zé)將接口中的入?yún)⑥D(zhuǎn)換為 HTTP 的形式， 發(fā)到服務(wù)端， 最后再解析 HTTP 響應(yīng)， 將結(jié)果轉(zhuǎn)換為 Java 對(duì)象， 予以返回。

所以我們基于原生的feign來(lái)分析分析，其實(shí)就是多了2步，前面的原生feign會(huì)幫助我們生成代理對(duì)象，這個(gè)是我們調(diào)用方法的主體，也是這個(gè)代理對(duì)象才有能力去請(qǐng)求http請(qǐng)求，那么spring就想辦法，把這一類(lèi)的對(duì)象放到spring的上下文中，那么我們下次調(diào)用的時(shí)候，這個(gè)對(duì)象當(dāng)然就有了http請(qǐng)求的能力了。

結(jié)束

我是小六六，三天打魚(yú)，兩天曬網(wǎng)，今天我的分享就到了。