SpringCloud升级之路2020.0.x版-26.OpenFeign的组件

落日映苍穹つ 2022-09-14 11:11 188阅读 0赞

![9c32fbfe8787075e3884c801d020e77f.png][]

> 本系列代码地址：https://github.com/JoJoTec/spring-cloud-parent

首先，我们给出官方文档中的组件结构图：  
\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jrW9fLUy-1633609229588)(http://www.plantuml.com/plantuml/proxy?cache=no&src=https://raw.githubusercontent.com/OpenFeign/feign/master/src/docs/overview-mindmap.iuml)\]

官方文档中的组件，是以实现功能为维度的，我们这里是以源码实现为维度的（因为之后我们使用的时候，需要根据需要定制这些组件，所以需要从源码角度去拆分分析），可能会有一些小差异。

### 负责解析类元数据的 Contract ###

OpenFeign 是通过**代理类元数据**来自动生成 HTTP API 的，那么到底解析哪些类元数据，哪些类元数据是有效的，是通过指定 Contract 来实现的，我们可以通过实现这个 Contract 来自定义一些类元数据的解析，例如，我们自定义一个注解：

//仅可用于方法上
    @java.lang.annotation.Target(METHOD)
    //指定注解保持到运行时
    @Retention(RUNTIME)
    @interface Get {
        //请求 uri
        String uri();
    }

这个注解很简单，标注了这个注解的方法会被自动封装成 GET 请求，请求 uri 为 `uri()` 的返回。

然后，我们自定义一个 Contract 来处理这个注解。由于 `MethodMetadata` 是 final 并且是 package private 的，所以我们只能继承 `Contract.BaseContract` 去自定义注解解析：

//外部自定义必须继承 BaseContract，因为里面生成的 MethodMetadata 的构造器是 package private 的
    static class CustomizedContract extends Contract.BaseContract {
        @Override
        protected void processAnnotationOnClass(MethodMetadata data, Class<?> clz) {
            //处理类上面的注解，这里没用到
        }
        @Override
        protected void processAnnotationOnMethod(MethodMetadata data, Annotation annotation, Method method) {
            //处理方法上面的注解
            Get get = method.getAnnotation(Get.class);
            //如果 Get 注解存在，则指定方法 HTTP 请求方式为 GET，同时 uri 指定为注解 uri() 的返回
            if (get != null) {
                data.template().method(Request.HttpMethod.GET);
                data.template().uri(get.uri());
            }
        }
        @Override
        protected boolean processAnnotationsOnParameter(MethodMetadata data, Annotation[] annotations, int paramIndex) {
            //处理参数上面的注解，这里没用到
            return false;
        }
    }

然后，我们来使用这个 Contract：

interface HttpBin {
        @Get(uri = "/get")
        String get();
    }
    
    public static void main(String[] args) {
        HttpBin httpBin = Feign.builder()
                .contract(new CustomizedContract())
                .target(HttpBin.class, "http://www.httpbin.org");
        //实际上就是调用 http://www.httpbin.org/get
        String s = httpBin.get();
    }

一般的，我们不会使用这个 Contract，因为我们业务上一般不会自定义注解。这是底层框架需要用的功能。比如在 spring-mvc 环境下，我们需要兼容 spring-mvc 的注解，这个实现类就是 `SpringMvcContract`。

### 编码器 Encoder 与解码器 Decoder ###

编码器与解码器接口定义：

public interface Decoder {
      Object decode(Response response, Type type) throws IOException, DecodeException, FeignException;
    }
    public interface Encoder {
      void encode(Object object, Type bodyType, RequestTemplate template) throws EncodeException;
    }

OpenFeign 可以自定义编码解码器，我们这里使用 FastJson 自定义实现一组编码与解码器，来了解其中使用的原理。

/**
     * 基于 FastJson 的反序列化解码器
     */
    static class FastJsonDecoder implements Decoder {
        @Override
        public Object decode(Response response, Type type) throws IOException, DecodeException, FeignException {
            //读取 body
            byte[] body = response.body().asInputStream().readAllBytes();
            return JSON.parseObject(body, type);
        }
    }
    
    /**
     * 基于 FastJson 的序列化编码器
     */
    static class FastJsonEncoder implements Encoder {
        @Override
        public void encode(Object object, Type bodyType, RequestTemplate template) throws EncodeException {
            if (object != null) {
                //编码 body
                template.header(CONTENT_TYPE, ContentType.APPLICATION_JSON.getMimeType());
                template.body(JSON.toJSONBytes(object), StandardCharsets.UTF_8);
            }
        }
    }

然后，我们通过 `http://httpbin.org/anything` 来测试，这个链接会返回我们发送的请求的一切元素。

interface HttpBin {
        @RequestLine("POST /anything")
        Object postBody(Map<String, String> body);
    }
    
    public static void main(String[] args) {
        HttpBin httpBin = Feign.builder()
                .decoder(new FastJsonDecoder())
                .encoder(new FastJsonEncoder())
                .target(HttpBin.class, "http://www.httpbin.org");
        Object o = httpBin.postBody(Map.of("key", "value"));
    }

查看响应，可以看到我们发送的 json body 被正确的接收到了。

目前，OpenFeign 项目中的编码器以及解码器主要实现包括：

<table> 
 <thead> 
  <tr> 
   <th>序列化</th> 
   <th>需要额外添加的依赖</th> 
   <th>实现类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>直接转换成字符串，默认的编码解码器</td> 
   <td>无</td> 
   <td><code>feign.codec.Encoder.Default</code> 和 <code>feign.codec.Decoder.Default</code></td> 
  </tr> 
  <tr> 
   <td>gson</td> 
   <td>feign-gson</td> 
   <td><code>feign.gson.GsonEncoder</code> 和 <code>feign.gson.GsonDecoder</code></td> 
  </tr> 
  <tr> 
   <td>xml</td> 
   <td>feign-jaxb</td> 
   <td><code>feign.jaxb.JAXBEncoder</code> 和 <code>feign.jaxb.JAXBDecoder</code></td> 
  </tr> 
  <tr> 
   <td>json (jackson)</td> 
   <td>feign-jackson</td> 
   <td><code>feign.jackson.JacksonEncoder</code> 和 <code>feign.jackson.JacksonDecoder</code></td> 
  </tr> 
 </tbody> 
</table>

我们在 Spring Cloud 环境中使用的时候，在 Spring MVC 中是有统一的编码器以及解码器的，即 `HttpMessageConverters`，并且通过胶水项目做了兼容，所以我们统一用 `HttpMessageConverters` 指定自定义编码解码器就好。

### 请求拦截器 RequestInterceptor ###

RequestInterceptor 的接口定义：

public interface RequestInterceptor {
      void apply(RequestTemplate template);
    }

可以从接口看出，RequestInterceptor 其实就是对于 RequestTemplate 进行额外的操作。对于每次请求，都会经过所有的 RequestInterceptor 处理。

举个例子，我们可以对于每个请求加上特定的 Header：

interface HttpBin {
        //发到这个链接的所有请求，响应会返回请求中的所有元素
        @RequestLine("GET /anything")
        String anything();
    }
    
    static class AddHeaderRequestInterceptor implements RequestInterceptor {
        @Override
        public void apply(RequestTemplate template) {
            //添加 header
            template.header("test-header", "test-value");
        }
    }
    
    public static void main(String[] args) {
        HttpBin httpBin = Feign.builder()
                .requestInterceptor(new AddHeaderRequestInterceptor())
                .target(HttpBin.class, "http://www.httpbin.org");
        String s = httpBin.anything();
    }

执行程序，可以在响应中看到我们发送请求中添加的 header。

### Http 请求客户端 Client ###

OpenFeign 底层的 Http 请求客户端是可以自定义的，OpenFeign 针对不同的 Http 客户端都有封装，默认的是通过 Java 内置的 Http 请求 API。我们来看下 Client 的接口定义源码：

public interface Client {
      /**
       * 执行请求
       * @param request HTTP 请求
       * @param options 配置选项
       * @return
       * @throws IOException
       */
      Response execute(Request request, Options options) throws IOException;
    }

Request 是 feign 中对于 Http 请求的定义，Client 的实现需要将 Request 转换成对应底层的 Http 客户端的请求并调用合适的方法进行请求。Options 是一些请求通用配置，包括：

public static class Options {
        //tcp 建立连接超时
        private final long connectTimeout;
        //tcp 建立连接超时时间单位
        private final TimeUnit connectTimeoutUnit;
        //请求读取响应超时
        private final long readTimeout;
        //请求读取响应超时时间单位
        private final TimeUnit readTimeoutUnit;
        //是否跟随重定向
        private final boolean followRedirects;
    }

目前，Client 的实现包括以下这些：

<table> 
 <thead> 
  <tr> 
   <th>底层 HTTP 客户端</th> 
   <th>需要添加的依赖</th> 
   <th>实现类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Java HttpURLConnection</td> 
   <td>无</td> 
   <td><code>feign.Client.Default</code></td> 
  </tr> 
  <tr> 
   <td>Java 11 HttpClient</td> 
   <td>feign-java11</td> 
   <td><code>feign.http2client.Http2Client</code></td> 
  </tr> 
  <tr> 
   <td><a href="https://hc.apache.org/httpcomponents-client-ga/" rel="nofollow">Apache HttpClient</a></td> 
   <td>feign-httpclient</td> 
   <td><code>feign.httpclient.ApacheHttpClient</code></td> 
  </tr> 
  <tr> 
   <td><a href="https://hc.apache.org/httpcomponents-client-5.0.x/index.html" rel="nofollow">Apache HttpClient 5</a></td> 
   <td>feign-hc5</td> 
   <td><code>feign.hc5.ApacheHttp5Client</code></td> 
  </tr> 
  <tr> 
   <td><a href="https://developers.google.com/api-client-library/java/google-http-java-client/" rel="nofollow">Google HTTP Client</a></td> 
   <td>feign-googlehttpclient</td> 
   <td><code>feign.googlehttpclient.GoogleHttpClient</code></td> 
  </tr> 
  <tr> 
   <td><a href="https://developers.google.com/api-client-library/java/google-http-java-client/" rel="nofollow">Google HTTP Client</a></td> 
   <td>feign-googlehttpclient</td> 
   <td><code>feign.googlehttpclient.GoogleHttpClient</code></td> 
  </tr> 
  <tr> 
   <td>jaxRS</td> 
   <td>feign-jaxrs2</td> 
   <td><code>feign.jaxrs2.JAXRSClient</code></td> 
  </tr> 
  <tr> 
   <td><a href="http://square.github.io/okhttp/" rel="nofollow">OkHttp</a></td> 
   <td>feign-okhttp</td> 
   <td><code>feign.okhttp.OkHttpClient</code></td> 
  </tr> 
  <tr> 
   <td><a href="https://github.com/Netflix/ribbon" rel="nofollow">Ribbon</a></td> 
   <td>feign-ribbon</td> 
   <td><code>feign.ribbon.RibbonClient</code></td> 
  </tr> 
 </tbody> 
</table>

### 错误解码器相关 ###

可以指定错误解码器 `ErrorDecoder`，同时还可以指定异常抛出策略 `ExceptionPropagationPolicy`.

`ErrorDecoder` 是读取 HTTP 响应判断是否有错误需要抛出异常使用的：

public interface ErrorDecoder {
        public Exception decode(String methodKey, Response response);
    }

只有响应码不为 2xx 的时候，才会调用配置的 `ErrorDecoder` 的 `decode` 方法。默认的 `ErrorDecoder` 的实现是：

public static class Default implements ErrorDecoder {
    
        @Override
        public Exception decode(String methodKey, Response response) {
          //将不同响应码包装成不同的异常
          FeignException exception = errorStatus(methodKey, response);
          //提取 Retry-After 这个 HTTP 响应头，如果存在这个响应头则将异常封装为 RetryableException
          //对于 RetryableException，在后面的分析我们会知道如果抛出这个异常会触发重试器的重试
          Date retryAfter = retryAfterDecoder.apply(firstOrNull(response.headers(), RETRY_AFTER));
          if (retryAfter != null) {
            return new RetryableException(
                response.status(),
                exception.getMessage(),
                response.request().httpMethod(),
                exception,
                retryAfter,
                response.request());
          }
          return exception;
        }
      }

可以看出， ErrorDecoder 是可能给异常封装一层异常的，这有时候对于我们在外层捕捉会造成影响，所以可以通过指定 `ExceptionPropagationPolicy` 来拆开这层封装。`ExceptionPropagationPolicy` 是一个枚举类：

public enum ExceptionPropagationPolicy {
      //什么都不做
      NONE, 
      //是否将 RetryableException 的原始 exception 提取出来作为异常抛出
      //目前只针对 RetryableException 生效，调用 exception 的 getCause，如果不为空就返回这个 cause，否则返回原始 exception
      UNWRAP,
      ;
    }

接下来看个例子：

interface TestHttpBin {
        //请求一定会返回 500
        @RequestLine("GET /status/500")
        Object get();
    }
    
    static class TestErrorDecoder implements ErrorDecoder {
        @Override
        public Exception decode(String methodKey, Response response) {
            //获取错误码对应的 FeignException
            FeignException exception = errorStatus(methodKey, response);
            //封装为 RetryableException
            return new RetryableException(
                    response.status(),
                    exception.getMessage(),
                    response.request().httpMethod(),
                    exception,
                    new Date(),
                    response.request());
        }
    }
    
    public static void main(String[] args) {
        TestHttpBin httpBin = Feign.builder()
                .errorDecoder(new TestErrorDecoder())
                //如果这里没有指定为 UNWRAP 那么下面抛出的异常就是 RetryableException，否则就是 RetryableException 的 cause 也就是 FeignException
                .exceptionPropagationPolicy(ExceptionPropagationPolicy.UNWRAP)
                .target(TestHttpBin.class, "http://httpbin.org");
        httpBin.get();
    }

执行后可以发现抛出了 `feign.FeignException$InternalServerError: [500 INTERNAL SERVER ERROR] during [GET] to [http://httpbin.org/status/500] [TestHttpBin#get()]: []` 这个异常。

## 针对 RetryableException 的重试器 Retryer ##

在调用发生异常的时候，我们可能希望按照一定策略进行重试，抽象这种重试策略一般包括：

*  对于哪些异常会重试
 *  什么时候重试，什么时候结束重试，例如重试 n 次以后

对于那些异常会重试，这个由 ErrorDecoder 决定。如果异常需要被重试，就把它封装成 `RetryableException`，这样 Feign 就会使用 Retryer 进行重试。对于什么时候重试，什么时候结束重试，这些就是 Retryer 需要考虑的事情：

public interface Retryer extends Cloneable {
      /**
        * 判断继续重试，或者抛出异常结束重试
        */
      void continueOrPropagate(RetryableException e);
      /**
        * 对于每次请求，都会调用这个方法创建一个新的同样配置的 Retryer 对象
        */
      Retryer clone();
    }

我们来看一下 Retryer 的默认实现：

class Default implements Retryer {
    	//最大重试次数
        private final int maxAttempts;
    	//初始重试间隔
        private final long period;
    	//最大重试间隔
        private final long maxPeriod;
    	//当前重试次数
        int attempt;
    	//当前已经等待的重试间隔时间和
        long sleptForMillis;
    
        public Default() {
    	  //默认配置，初始重试间隔为 100ms，最大重试间隔为 1s，最大重试次数为 5
          this(100, SECONDS.toMillis(1), 5);
        }
    
        public Default(long period, long maxPeriod, int maxAttempts) {
          this.period = period;
          this.maxPeriod = maxPeriod;
          this.maxAttempts = maxAttempts;
    	  //当前重试次数从 1 开始，因为第一次进入 continueOrPropagate 之前就已经发生调用但是失败了并抛出了 RetryableException
          this.attempt = 1;
        }
    
        // visible for testing;
        protected long currentTimeMillis() {
          return System.currentTimeMillis();
        }
    
        public void continueOrPropagate(RetryableException e) {
    	  //如果当前重试次数大于最大重试次数则
          if (attempt++ >= maxAttempts) {
            throw e;
          }
    
          long interval;
    	  //如果指定了 retry-after，则以这个 header 为准决定等待时间
          if (e.retryAfter() != null) {
            interval = e.retryAfter().getTime() - currentTimeMillis();
            if (interval > maxPeriod) {
              interval = maxPeriod;
            }
            if (interval < 0) {
              return;
            }
          } else {
    		//否则，通过 nextMaxInterval 计算
            interval = nextMaxInterval();
          }
          try {
            Thread.sleep(interval);
          } catch (InterruptedException ignored) {
            Thread.currentThread().interrupt();
            throw e;
          }
    	  //记录一共等待的时间
          sleptForMillis += interval;
        }
    
    	//每次重试间隔增长 50%，直到最大重试间隔
        long nextMaxInterval() {
          long interval = (long) (period * Math.pow(1.5, attempt - 1));
          return interval > maxPeriod ? maxPeriod : interval;
        }
    
        @Override
        public Retryer clone() {
    	  //复制配置
          return new Default(period, maxPeriod, maxAttempts);
        }
    }

默认的 Retryer 功能也比较丰富，用户可以参考这个实现更适合自己业务场景的重试器。

## 每个 HTTP 请求的配置 Options ##

无论是哪种 HTTP 客户端，都需要如下几个配置：

*  连接超时：这个是 TCP 连接建立超时时间
 *  读取超时：这个是收到 HTTP 响应之前的超时时间
 *  是否跟随重定向  
    OpenFeign 可以通过 Options 进行配置：

public static class Options {
        private final long connectTimeout;
        private final TimeUnit connectTimeoutUnit;
        private final long readTimeout;
        private final TimeUnit readTimeoutUnit;
        private final boolean followRedirects;
    }

例如我们可以这么配置一个连接超时为 500ms，读取超时为 6s，跟随重定向的 Feign：

Feign.builder().options(new Request.Options(
        500, TimeUnit.MILLISECONDS, 6, TimeUnit.SECONDS, true
    ))

![ccec2447258b785b5e976308258207e8.png][]

我们这一节详细介绍了 OpenFeign 的各个组件，有了这些知识，其实我们自己就能实现 Spring-Cloud-OpenFeign 里面的胶水代码。其实 Spring-Cloud-OpenFeign 就是将这些组件以 Bean 的形式注册到 NamedContextFactory 中，供不同微服务进行不同的配置。

> **微信搜索“我的编程喵”关注公众号，每日一刷，轻松提升技术，斩获各种offer**：

![3f58a37c57d531d20ebc9a795bc54dcf.png][]

[9c32fbfe8787075e3884c801d020e77f.png]: /images/20220828/c9d5b260fb0d44bb9f0e09dbdeef30c5.png
[ccec2447258b785b5e976308258207e8.png]: /images/20220828/b0eefa8c4f3f447c9da67e0b44287248.png
[3f58a37c57d531d20ebc9a795bc54dcf.png]: /images/20220828/d94db7fed6814bb689c4811e5e503f5d.png