日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時(shí)間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
SpringCloud原理之Feign

絮叨

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

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

  • 當(dāng)客戶端啟動(dòng)的時(shí)候向服務(wù)端注冊當(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)聽shutdown 然后上報(bào)自己掛掉的狀態(tài)給服務(wù)端

服務(wù)端

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

什么是Feign

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

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

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

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

原生的Feign

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

Feign使用簡介

基本用法

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

 
 
 
 
      
  
  
  
  1. interface GitHub { 
    2.   
  
  
  
  2.  // RequestLine注解聲明請求方法和請求地址,可以允許有查詢參數(shù) 
    3.   
  
  
  
  3.  @RequestLine("GET /repos/{owner}/{repo}/contributors") 
    4.   
  
  
  
  4.  List contributors(@Param("owner") String owner, @Param("repo") String repo); 
    5.   
  
  
  
  5. } 
    6.   
  
  
  
  6. static class Contributor { 
    7.   
  
  
  
  7.  String login; 
    8.   
  
  
  
  8.  int contributions; 
    9.   
  
  
  
  9. } 
    10.   
  
  
  
  10. public static void main(String... args) { 
    11.   
  
  
  
  11.  GitHub github = Feign.builder() 
    12.   
  
  
  
  12.             .decoder(new GsonDecoder()) 
    13.   
  
  
  
  13.             .target(GitHub.class, "https://api.github.com"); 
    14.   
  
  
  
  14.  // Fetch and print a list of the contributors to this library. 
    15.   
  
  
  
  15.  List contributors = github.contributors("OpenFeign", "feign"); 
    16.   
  
  
  
  16.  for (Contributor contributor : contributors) { 
    17.   
  
  
  
  17.   System.out.println(contributor.login + " (" + contributor.contributions + ")"); 
    18.   
  
  
  
  18.  } 
    19.   
  
  
  
  19. } 
    20.

自定義

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

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

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

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

 
 
 
 
      
  
  
  
  1. public interface Target { 
    2.   
  
  
  
  2.   // 接口的類型 
    3.   
  
  
  
  3.   Class type(); 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.   // 代理對象的名稱，默認(rèn)為url,負(fù)載均衡時(shí)有用 
    6.   
  
  
  
  6.   String name(); 
    7.   
  
  
  
  7.   // 請求的url地址，eg: https://api/v2 
    8.   
  
  
  
  8.   String url(); 
    9.   
  
  
  
  9. } 
    10.

其中 Target.type 是用來生成代理對象的，url 是 Client 對象發(fā)送請求的地址。

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

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

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

生成代理對象

 
 
 
 
      
  
  
  
  1. public  T newInstance(Target target) { 
    2.   
  
  
  
  2.     // 1. Contract 將 target.type 接口類上的方法和注解解析成 MethodMetadata， 
    3.   
  
  
  
  3.     //    并轉(zhuǎn)換成內(nèi)部的MethodHandler處理方式 
    4.   
  
  
  
  4.     Map nameToHandler = targetToHandlersByName.apply(target); 
    5.   
  
  
  
  5.     Map methodToHandler = new LinkedHashMap(); 
    6.   
  
  
  
  6.     List defaultMethodHandlers = new LinkedList(); 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8.     for (Method method : target.type().getMethods()) { 
    9.   
  
  
  
  9.         if (method.getDeclaringClass() == Object.class) { 
    10.   
  
  
  
  10.             continue; 
    11.   
  
  
  
  11.         } else if (Util.isDefault(method)) { 
    12.   
  
  
  
  12.             DefaultMethodHandler handler = new DefaultMethodHandler(method); 
    13.   
  
  
  
  13.             defaultMethodHandlers.add(handler); 
    14.   
  
  
  
  14.             methodToHandler.put(method, handler); 
    15.   
  
  
  
  15.         } else { 
    16.   
  
  
  
  16.             methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method))); 
    17.   
  
  
  
  17.         } 
    18.   
  
  
  
  18.     } 
    19.   
  
  
  
  19.  
    20.   
  
  
  
  20.     // 2. 生成 target.type 的 jdk 動(dòng)態(tài)代理對象 
    21.   
  
  
  
  21.     InvocationHandler handler = factory.create(target, methodToHandler); 
    22.   
  
  
  
  22.     T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(), 
    23.   
  
  
  
  23.                                          new Class[]{target.type()}, handler); 
    24.   
  
  
  
  24.  
    25.   
  
  
  
  25.     for (DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) { 
    26.   
  
  
  
  26.         defaultMethodHandler.bindTo(proxy); 
    27.   
  
  
  
  27.     } 
    28.   
  
  
  
  28.     return proxy; 
    29.   
  
  
  
  29. } 
    30.

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

MethodHandler 方法執(zhí)行器

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

 
 
 
 
      
  
  
  
  1. public Map apply(Target key) { 
    2.   
  
  
  
  2.     // 1. contract 將接口類中的方法和注解解析 MethodMetadata 
    3.   
  
  
  
  3.     List metadata = contract.parseAndValidatateMetadata(key.type()); 
    4.   
  
  
  
  4.     Map result = new LinkedHashMap(); 
    5.   
  
  
  
  5.     for (MethodMetadata md : metadata) { 
    6.   
  
  
  
  6.         // 2. buildTemplate 實(shí)際上將 Method 方法的參數(shù)轉(zhuǎn)換成 Request 
    7.   
  
  
  
  7.         BuildTemplateByResolvingArgs buildTemplate; 
    8.   
  
  
  
  8.         if (!md.formParams().isEmpty() && md.template().bodyTemplate() == null) { 
    9.   
  
  
  
  9.             // 2.1 表單 
    10.   
  
  
  
  10.             buildTemplate = new BuildFormEncodedTemplateFromArgs(md, encoder, queryMapEncoder); 
    11.   
  
  
  
  11.         } else if (md.bodyIndex() != null) { 
    12.   
  
  
  
  12.             // 2.2 @Body 注解 
    13.   
  
  
  
  13.             buildTemplate = new BuildEncodedTemplateFromArgs(md, encoder, queryMapEncoder); 
    14.   
  
  
  
  14.         } else { 
    15.   
  
  
  
  15.             // 2.3 其余 
    16.   
  
  
  
  16.             buildTemplate = new BuildTemplateByResolvingArgs(md, queryMapEncoder); 
    17.   
  
  
  
  17.         } 
    18.   
  
  
  
  18.         // 3. 將 metadata 和 buildTemplate 封裝成 MethodHandler 
    19.   
  
  
  
  19.         result.put(md.configKey(), 
    20.   
  
  
  
  20.                    factory.create(key, md, buildTemplate, options, decoder, errorDecoder)); 
    21.   
  
  
  
  21.     } 
    22.   
  
  
  
  22.     return result; 
    23.   
  
  
  
  23. } 
    24.

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

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

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

Feign 調(diào)用過程

FeignInvocationHandler#invoke

 
 
 
 
      
  
  
  
  1. private final Map dispatch; 
    2.   
  
  
  
  2. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    3.   
  
  
  
  3.     ... 
    4.   
  
  
  
  4.     // 每個(gè)Method方法對應(yīng)一個(gè)MethodHandler 
    5.   
  
  
  
  5.     return dispatch.get(method).invoke(args); 
    6.   
  
  
  
  6. } 
    7.

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

SynchronousMethodHandler#invoke

 
 
 
 
      
  
  
  
  1. // 發(fā)起 http 請求，并根據(jù) retryer 進(jìn)行重試 
    2.   
  
  
  
  2. public Object invoke(Object[] argv) throws Throwable { 
    3.   
  
  
  
  3.     // template 將 argv 參數(shù)構(gòu)建成 Request 
    4.   
  
  
  
  4.     RequestTemplate template = buildTemplateFromArgs.create(argv); 
    5.   
  
  
  
  5.     Options options = findOptions(argv); 
    6.   
  
  
  
  6.     Retryer retryer = this.retryer.clone(); 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8.     // 調(diào)用client.execute(request, options) 
    9.   
  
  
  
  9.     while (true) { 
    10.   
  
  
  
  10.         try { 
    11.   
  
  
  
  11.             return executeAndDecode(template, options); 
    12.   
  
  
  
  12.         } catch (RetryableException e) { 
    13.   
  
  
  
  13.             try { 
    14.   
  
  
  
  14.                 // 重試機(jī)制 
    15.   
  
  
  
  15.                 retryer.continueOrPropagate(e); 
    16.   
  
  
  
  16.             } catch (RetryableException th) { 
    17.   
  
  
  
  17.                 ... 
    18.   
  
  
  
  18.             } 
    19.   
  
  
  
  19.             continue; 
    20.   
  
  
  
  20.         } 
    21.   
  
  
  
  21.     } 
    22.   
  
  
  
  22. } 
    23.

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

 
 
 
 
      
  
  
  
  1. // 一是編碼生成Request；二是http請求；三是解碼生成Response 
    2.   
  
  
  
  2. Object executeAndDecode(RequestTemplate template, Options options) throws Throwable { 
    3.   
  
  
  
  3.     // 1. 調(diào)用攔截器 RequestInterceptor，并根據(jù) template 生成 Request 
    4.   
  
  
  
  4.     Request request = targetRequest(template); 
    5.   
  
  
  
  5.     // 2. http 請求 
    6.   
  
  
  
  6.     Response response = client.execute(request, options); 
    7.   
  
  
  
  7.  // 3. response 解碼 
    8.   
  
  
  
  8.     if (Response.class == metadata.returnType()) { 
    9.   
  
  
  
  9.         byte[] bodyData = Util.toByteArray(response.body().asInputStream()); 
    10.   
  
  
  
  10.         return response.toBuilder().body(bodyData).build(); 
    11.   
  
  
  
  11.     } 
    12.   
  
  
  
  12.     ... 
    13.   
  
  
  
  13. } 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15. Request targetRequest(RequestTemplate template) { 
    16.   
  
  
  
  16.     // 執(zhí)行攔截器 
    17.   
  
  
  
  17.     for (RequestInterceptor interceptor : requestInterceptors) { 
    18.   
  
  
  
  18.         interceptor.apply(template); 
    19.   
  
  
  
  19.     } 
    20.   
  
  
  
  20.     // 生成 Request 
    21.   
  
  
  
  21.     return target.apply(template); 
    22.

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

Spring Cloud Feign 的原理解析

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

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

工作原理

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

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

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

  • SpringBoot 應(yīng)用啟動(dòng)時(shí)， 由針對 @EnableFeignClient 這一注解的處理邏輯觸發(fā)程序掃描 classPath中所有被@FeignClient 注解的類， 這里以 XiaoLiuLiuService 為例， 將這些類解析為 BeanDefinition 注冊到 Spring 容器中
  • Sping 容器在為某些用的 Feign 接口的 Bean 注入 XiaoLiuLiuService 時(shí)， Spring 會(huì)嘗試從容器中查找 XiaoLiuLiuService 的實(shí)現(xiàn)類
  • 由于我們從來沒有編寫過 XiaoLiuLiuService 的實(shí)現(xiàn)類， 上面步驟獲取到的 XiaoLiuLiuService 的實(shí)現(xiàn)類必然是 feign 框架通過擴(kuò)展 spring 的 Bean 處理邏輯， 為 XiaoLiuLiuService 創(chuàng)建一個(gè)動(dòng)態(tài)接口代理對象， 這里我們將其稱為 XiaoLiuLiuServiceProxy 注冊到spring 容器中。
  • Spring 最終在使用到 XiaoLiuLiuService 的 Bean 中注入了 XiaoLiuLiuServiceProxy 這一實(shí)例。
  • 當(dāng)業(yè)務(wù)請求真實(shí)發(fā)生時(shí)， 對于 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 對象， 予以返回。

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

結(jié)束

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


網(wǎng)站標(biāo)題：SpringCloud原理之Feign
轉(zhuǎn)載源于：http://www.dlmjj.cn/article/cdjdogi.html