SpringCloud Open feign 使用okhttp 优化详解

时间：2021-10-27 22:33:02

我就废话不多说了，大家还是直接看代码吧~

  1. <!--web 模块 -->
  2. <dependency>
  3. <groupId>org.springframework.boot</groupId>
  4. <artifactId>spring-boot-starter-web</artifactId>
  5. <exclusions>
  6. <!--排除tomcat依赖 -->
  7. <exclusion>
  8. <artifactId>spring-boot-starter-tomcat</artifactId>
  9. <groupId>org.springframework.boot</groupId>
  10. </exclusion>
  11. </exclusions>
  12. </dependency>
  13. <dependency>
  14. <groupId>org.springframework.boot</groupId>
  15. <artifactId>spring-boot-starter-aop</artifactId>
  16. </dependency>
  17. <!--undertow容器 -->
  18. <dependency>
  19. <groupId>org.springframework.boot</groupId>
  20. <artifactId>spring-boot-starter-undertow</artifactId>
  21. </dependency>
  22. <!-- feign-okhttp -->
  23. <dependency>
  24. <groupId>io.github.openfeign</groupId>
  25. <artifactId>feign-okhttp</artifactId>
  26. </dependency>

配置pom,容器使用undertow，引入feign-okhttp

  1. feign:
  2. # Okhttp参数配置
  3. httpclient:
  4. enabled: false
  5. okhttp:
  6. enabled: true
  7. max-connections: 200 # 默认值
  8. max-connections-per-route: 50 # 默认值

application.yml文件配置okhttp参数

  1. import feign.Feign;
  2. import okhttp3.ConnectionPool;
  3. import org.springframework.boot.autoconfigure.AutoConfigureBefore;
  4. import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
  5. import org.springframework.cloud.openfeign.FeignAutoConfiguration;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import java.util.concurrent.TimeUnit;
  9. @Configuration
  10. @ConditionalOnClass(Feign.class)
  11. @AutoConfigureBefore(FeignAutoConfiguration.class)
  12. public class FeignOkHttpConfig {
  13. @Bean
  14. public okhttp3.OkHttpClient okHttpClient(){
  15. return new okhttp3.OkHttpClient.Builder()
  16. //设置连接超时
  17. .connectTimeout(60, TimeUnit.SECONDS)
  18. //设置读超时
  19. .readTimeout(60, TimeUnit.SECONDS)
  20. //设置写超时
  21. .writeTimeout(120,TimeUnit.SECONDS)
  22. //是否自动重连
  23. .retryOnConnectionFailure(true)
  24. .connectionPool(new ConnectionPool())
  25. .addInterceptor(new OkHttpLogInterceptor())
  26. //构建OkHttpClient对象
  27. .build();
  28. }
  29. }

创建FeignOkHttpConfig类文件

  1. import lombok.extern.log4j.Log4j2;
  2. import okhttp3.Interceptor;
  3. import okhttp3.Request;
  4. import okhttp3.Response;
  5. import okhttp3.ResponseBody;
  6. import java.io.IOException;
  7. @Log4j2
  8. public class OkHttpLogInterceptor implements Interceptor {
  9. @Override
  10. public Response intercept(Interceptor.Chain chain) throws IOException {
  11. //这个chain里面包含了request和response，所以你要什么都可以从这里拿
  12. Request request = chain.request();
  13. long t1 = System.nanoTime();//请求发起的时间
  14. log.info(String.format("发送请求 %s on %s%n%s",
  15. request.url(), chain.connection(), request.headers()));
  16. Response response = chain.proceed(request);
  17. long t2 = System.nanoTime();//收到响应的时间
  18. //这里不能直接使用response.body().string()的方式输出日志
  19. //因为response.body().string()之后，response中的流会被关闭，程序会报错，我们需要创建出一
  20. //个新的response给应用层处理
  21. ResponseBody responseBody = response.peekBody(1024 * 1024);
  22. log.info(String.format("接收响应: [%s] %n返回json:【%s】 %.1fms%n%s",
  23. response.request().url(),
  24. responseBody.string(),
  25. (t2 - t1) / 1e6d,
  26. response.headers()));
  27. return response;
  28. }
  29. }

创建OkHttpLogInterceptor日志拦截文件

注意FeignOkHttpConfig中添加

  1. @Bean
  2. public Contract feignContract() {
  3. return new feign.Contract.Default();
  4. }

feigin请求的@PostMapping @GetMapping等会不受支持

图一，使用默认http

SpringCloud Open feign 使用okhttp 优化详解

SpringCloud Open feign 使用okhttp 优化详解

图一，Feign通过jdk中的HttpURLConnection

图二，Feign使用okhttp请求

补充：Feign、httpclient、OkHttp3 结合使用

1 Feign 客户端实现 类型

前面介绍到了常用的Feign客户端实现类，大致如下：

（1） Client.Default类：默认的 feign.Client 客户端实现类，内部使用HttpURLConnnection 完成HTTP URL请求处理；

（2） ApacheHttpClient 类：内部使用 Apache httpclient 开源组件完成HTTP URL请求处理的feign.Client 客户端实现类；

（3） OkHttpClient类：内部使用 OkHttp3 开源组件完成HTTP URL请求处理的feign.Client 客户端实现类。

（4） LoadBalancerFeignClient 类：这是一个特殊的 feign.Client 客户端实现类。内部先使用 Ribbon 负载均衡算法计算server服务器，然后使用包装的 delegate 客户端实例，去完成 HTTP URL请求处理。

Feign 在启动的时候，有两个与feign.Client 客户端实例相关的自动配置类，根据多种条件组合，去创建不同类型的 客户端Spring IOC容器实例。

1.1.1 配置 LoadBalancerFeignClient 负载均衡容器实例

Feign有两个与Client相关的自动配置类：

（1）org.springframework.cloud.openfeign.ribbon.FeignRibbonClientAutoConfiguration

（2）org.springframework.cloud.openfeign.FeignAutoConfiguration

第一个自动配置类，能够配置具有负载均衡能力的FeignClient容器实例；第二自动配置类，只能配置最原始的FeignClient容器实例。

具备负载均衡能力的 FeignClient 容器实例，所对应的类型为 LoadBalancerFeignClient 类型。前面讲到，在SpringCloud中，为了达到高可用，一个微服务至少应该部署两个以上节点，从这个角度来说，LoadBalancerFeignClient 容器实例，已经成为事实上的标配。

事实上，第一个自动配置类 FeignRibbonClientAutoConfiguration，在容器的装配次序上，是优先于第二个自动配置类 FeignAutoConfiguration 的。具体可以参见其源码，节选如下：

  1. import com.netflix.loadbalancer.ILoadBalancer;
  2. //….
  3. @ConditionalOnClass({ILoadBalancer.class, Feign.class})
  4. @Configuration
  5. @AutoConfigureBefore({FeignAutoConfiguration.class}) // 本配置类具备优先权
  6. @EnableConfigurationProperties({FeignHttpClientProperties.class})
  7. @Import({
  8. HttpClientFeignLoadBalancedConfiguration.class, //配置：包装ApacheHttpClient实例的负载均衡客户端
  9. OkHttpFeignLoadBalancedConfiguration.class, //配置：包装OkHttpClient 实例的负载均衡客户端
  10. DefaultFeignLoadBalancedConfiguration.class //配置：包装Client.Default 实例的负载均衡客户端
  11. })
  12. public class FeignRibbonClientAutoConfiguration {
  13. //空的构造器
  14. public FeignRibbonClientAutoConfiguration() {
  15. }
  16. //….
  17. }

从源码中可以看到，FeignRibbonClientAutoConfiguration 的自动配置有两个前提条件：

（1）当前的类路径中，存在 ILoadBalancer.class 接口

（2）当前的类路径中，存在 Feign.class 接口

在这里，重点说一下 ILoadBalancer.class 接口，该接口处于 ribbon 的jar包中。如果需要在类路径中导入该jar包，则需要在Maven的pom.xml文件中，增加 ribbon 的相关依赖，具体如下：

  1. <!-- ribbon-->
  2. <dependency>
  3. <groupId>org.springframework.cloud</groupId>
  4. <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
  5. </dependency>

为了加深大家对客户端负载均衡的理解，这里将 ILoadBalancer.class 接口的两个重要的抽象方法列出来，具体如下：

  1. package com.netflix.loadbalancer;
  2. import java.util.List;
  3. public interface ILoadBalancer {
  4. // 通过负载均衡算法计算server服务器
  5. Server chooseServer(Object var1);
  6. // 取得全部的服务器
  7. List<Server> getAllServers();
  8. //…
  9. }

FeignRibbonClientAutoConfiguration 自动配置类，并没有直接配置LoadBalancerFeignClient 容器实例，而是使用@Import注解，通过导入其他配置类的方式，完成 LoadBalancerFeignClient 客户端容器实例的配置。

分别导入了以下三个自动配置类：

（1） HttpClientFeignLoadBalancedConfiguration.class

该配置类，负责配置一个包装 ApacheHttpClient 实例的 LoadBalancerFeignClient负载均衡客户端。

（2） OkHttpFeignLoadBalancedConfiguration.class

该配置类，负责配置一个包装 OkHttpClient 实例的 LoadBalancerFeignClient负载均衡客户端。

（3） DefaultFeignLoadBalancedConfiguration.class

该配置类，负责配置一个包装 Client.Default 实例的 LoadBalancerFeignClient负载均衡客户端。

1.1.2 包装 ApacheHttpClient 实例的负载均衡容器实例

首先来看如何配置一个包装 ApacheHttpClient 实例的负载均衡容器实例。这个IOC实例的配置，由 HttpClientFeignLoadBalancedConfiguration 自动配置类完成的，其源码节选如下：

  1. @Configuration
  2. @ConditionalOnClass({ApacheHttpClient.class})
  3. @ConditionalOnProperty(
  4. value = {"feign.httpclient.enabled"},
  5. matchIfMissing = true
  6. )
  7. class HttpClientFeignLoadBalancedConfiguration {
  8. //空的构造器
  9. HttpClientFeignLoadBalancedConfiguration() {
  10. }
  11. @Bean
  12. @ConditionalOnMissingBean({Client.class})
  13. public Client feignClient(
  14. CachingSpringLoadBalancerFactory cachingFactory,
  15. SpringClientFactory clientFactory, HttpClient httpClient)
  16. {
  17. ApacheHttpClient delegate = new ApacheHttpClient(httpClient);
  18. return new LoadBalancerFeignClient(delegate, cachingFactory, clientFactory); // 进行包装
  19. }
  20. //…省略不相干的代码
  21. }

首先，来看源码中的 feignClient(…)方法，分为两步：

（1）创建一个 ApacheHttpClient 类型的 feign.Client客户端实例，该实例的内部使用 Apache httpclient 开源组件完成HTTP URL请求处理；

（2）创建一个 LoadBalancerFeignClient 负载均衡客户端实例，将 ApacheHttpClient 实例包装起来，然后返回LoadBalancerFeignClient 客户端实例，作为 feign.Client 类型的Spring IOC 容器实例。

然后，再看类 HttpClientFeignLoadBalancedConfiguration 上的两个重要的注解：

（1）@ConditionalOnClass(ApacheHttpClient.class)

（2）@ConditionalOnProperty(value = “feign.httpclient.enabled”, matchIfMissing = true)

这两个条件的含义为：

（1）必须满足 ApacheHttpClient.class 在当前类路径中存在；

（2）必须满足工程配置文件中 feign.httpclient.enabled 配置项的值为 true ；

如果以上两个条件同时满足，则 HttpClientFeignLoadBalancedConfiguration 自动配置工作就会启动。

如何验证呢？

首先在工程配置文件中，将配置项 feign.httpclient.enabled 的值，设置为 false 。

然后，在 HttpClientFeignLoadBalancedConfiguration 的 feignClient(…)方法内的某行打上断点，重新启动项目，注意观察会发现，整个启动过程中，断点没有被命中。

接下来，将配置项 feign.httpclient.enabled 的值设置为 true，再一次启动项目，断点被命中。由此，可以验证 HttpClientFeignLoadBalancedConfiguration 自动配置类被启动。

为了满足 @ConditionalOnClass(ApacheHttpClient.class) 的条件要求，由于ApacheHttpClient类的位置处于feign-httpclient相关的jar包中，所以，需要在pom文件加上 feign-httpclient 以及httpclient 组件相关的 Maven 依赖，具体如下：

  1. <dependency>
  2. <groupId>io.github.openfeign</groupId>
  3. <artifactId>feign-httpclient</artifactId>
  4. <version>9.5.1</version>
  5. <!--<version>${feign-httpclient.version}</version>-->
  6. </dependency>
  7. <dependency>
  8. <groupId>org.apache.httpcomponents</groupId>
  9. <artifactId>httpclient</artifactId>
  10. <version>${httpclient.version}</version>
  11. </dependency>

对于 feign.httpclient.enabled 配置项设置，根据 @ConditionalOnProperty 注解的属性matchIfMissing=true 可知，这个可以不用配置，在默认的情况下就为 true。换句话说，如果不做特别的配置，feign.httpclient.enabled 配置项的值，默认为 true。

1.1.3 包装 OkHttpClient 实例的负载均衡容器实例

接下来，来看如何配置一个包装 OkHttpClient 实例的负载均衡容器实例。这个IOC实例的配置，由 OkHttpFeignLoadBalancedConfiguration 自动配置类完成的，其源码节选如下：

  1. @Configuration
  2. @ConditionalOnClass({OkHttpClient.class})
  3. @ConditionalOnProperty("feign.okhttp.enabled")
  4. class OkHttpFeignLoadBalancedConfiguration {
  5. //空的构造器
  6. OkHttpFeignLoadBalancedConfiguration () {
  7. }
  8. @Bean
  9. @ConditionalOnMissingBean({Client.class})
  10. public Client feignClient(
  11. CachingSpringLoadBalancerFactory cachingFactory,
  12. SpringClientFactory clientFactory, HttpClient httpClient)
  13. {
  14. OkHttpClient delegate = new OkHttpClient (httpClient);
  15. return new LoadBalancerFeignClient(delegate, cachingFactory, clientFactory); // 进行包装
  16. }
  17. //…省略不相干的代码
  18. }

首先，来看源码中的 feignClient(…)方法，分为两步：

（1）创建一个 OkHttpClient 类型的 feign.Client客户端实例，该实例的内部使用 OkHttp3 开源组件完成HTTP URL请求处理；

（2）创建一个 LoadBalancerFeignClient 负载均衡客户端实例，将 OkHttpClient实例包装起来，然后返回LoadBalancerFeignClient 客户端实例，作为 feign.Client 类型的Spring IOC 容器实例。

然后，再看类 OkHttpFeignLoadBalancedConfiguration 上的两个重要的注解：

（1）@ConditionalOnClass(OkHttpClient.class)

（2）@ConditionalOnProperty(“feign.okhttp.enabled”)

这两个条件的含义为：

（1）必须满足 OkHttpClient.class 在当前类路径中存在；

（2）必须满足工程配置文件中 feign.okhttp.enabled 配置项的值为 true 。

如果以上两个条件同时满足，则 OkHttpFeignLoadBalancedConfiguration 自动配置工作就会启动。

为了满足 @ConditionalOnClass(OkHttpClient.class) 的条件要求，由于OkHttpClient.class 类的位置处于 feign-okhttp 相关的jar包中，所以，需要在pom文件加上 feign-okhttp 以及 okhttp3 相关的 Maven 依赖。具体如下：

  1. <!-- OkHttp -->
  2. <dependency>
  3. <groupId>com.squareup.okhttp3</groupId>
  4. <artifactId>okhttp</artifactId>
  5. </dependency>
  6. <!-- feign-okhttp -->
  7. <dependency>
  8. <groupId>io.github.openfeign</groupId>
  9. <artifactId>feign-okhttp</artifactId>
  10. </dependency>

对于 feign.okhttp.enabled 配置项设置，在默认的情况下就为 false。也就是说，如果需要使用feign-okhttp，则一定需要做特别的配置，在工程配置文件中，加上 feign.okhttp.enabled 配置项的值，并且值必须为 true。

如果需要使用 feign-okhttp，工程配置文件的配置项大致如下：

  1. feign.httpclient.enabled=false
  2. feign.okhttp.enabled=true

1.1.4 包装 Client.Default 客户端实例的负载均衡容器实例

最后，来看如何配置一个包装默认Client.Default 客户端实例的负载均衡容器实例。这个IOC实例的配置，由 DefaultFeignLoadBalancedConfiguration 自动配置类所完成的。该配置类，也就是 FeignRibbonClientAutoConfiguration 配置类通过 @import 注解所导入的第3个配置类。

DefaultFeignLoadBalancedConfiguration 的源码节选如下：

  1. package org.springframework.cloud.openfeign.ribbon;
  2. //…省略import
  3. @Configuration
  4. class DefaultFeignLoadBalancedConfiguration {
  5. DefaultFeignLoadBalancedConfiguration() {
  6. }
  7. @Bean
  8. @ConditionalOnMissingBean
  9. public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
  10. SpringClientFactory clientFactory)
  11. {
  12. return new LoadBalancerFeignClient(
  13. new Default((SSLSocketFactory)null,
  14. (HostnameVerifier)null), cachingFactory, clientFactory);
  15. }
  16. }

通过源码可以看出，如果前面的两个配置类的条件没有满足，feign.Client 的 IOC 容器实例没有装配，则：

（1） 创建一个 Client.Default 默认客户端实例，该实例的内部，使用HttpURLConnnection 完成URL请求处理；

（2） 创建一个 LoadBalancerFeignClient 负载均衡客户端实例，将 Client.Default 实例包装起来，然后返回LoadBalancerFeignClient 客户端实例，作为 feign.Client 类型的Spring IOC 容器实例。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我们。如有错误或未考虑完全的地方，望不吝赐教。

原文链接：https://blog.csdn.net/sunlihuo/article/details/107359375

标签：

相关文章