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