【源码解析】OpenFeign源码之发送Http请求

最新推荐文章于 2023-07-19 17:56:03 发布
最新推荐文章于 2023-07-19 17:56:03 发布
阅读量671 收藏 1
点赞数
分类专栏： 源码解析 文章标签： http java servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42985872/article/details/129579466
版权

阅读源码的背景

最近在使用 Feign的时候碰到了请求超时的问题，借着这个事儿好好的梳理下与 Feign 相关的客户端，以及客户端的配置。另外，如果想要用HttpClient代替HttpURLConnection来提升性能，通过阅读源码可以掌握Feign是如何实现Http请求发送的自动配置。Feign远程调用的整个框架的运行原理可以参考Feign远程调用的底层原理。

配置默认的连接时长

feign:
  client:
    config:
      default:
        connectTimeout: 10000 #单位毫秒
        readTimeout: 10000 #单位毫秒

配置指定服务的连接时长

feign:
  client:
    config:
      app-client: # app-client服务名
        connectTimeout: 10000 #单位毫秒
        readTimeout: 10000 #单位毫秒

实现原理

FeignRibbonClientAutoConfiguration

该类优先注入HttpClientFeignLoadBalancedConfiguration，其次注入OkHttpFeignLoadBalancedConfiguration，最后注入DefaultFeignLoadBalancedConfiguration。

@Import({HttpClientFeignLoadBalancedConfiguration.class, OkHttpFeignLoadBalancedConfiguration.class, DefaultFeignLoadBalancedConfiguration.class})
public class FeignRibbonClientAutoConfiguration {
    public FeignRibbonClientAutoConfiguration() {
    }

HttpClientFeignLoadBalancedConfiguration注入的条件是存在类ApacheHttpClient

@Configuration
@ConditionalOnClass({ApacheHttpClient.class})
@ConditionalOnProperty(
    value = {"feign.httpclient.enabled"},
    matchIfMissing = true
)
class HttpClientFeignLoadBalancedConfiguration {
    HttpClientFeignLoadBalancedConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean({Client.class})
    public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory, SpringClientFactory clientFactory, HttpClient httpClient) {
        ApacheHttpClient delegate = new ApacheHttpClient(httpClient);
        return new LoadBalancerFeignClient(delegate, cachingFactory, clientFactory);
    }
}

当项目中不存在HttpClient和OkHttp3的jar包的时候，会往容器中注入DefaultFeignLoadBalancedConfiguration中定义的Client，类型是LoadBalancerFeignClient。

@Configuration
class DefaultFeignLoadBalancedConfiguration {
    DefaultFeignLoadBalancedConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean
    public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory, SpringClientFactory clientFactory) {
        return new LoadBalancerFeignClient(new Default((SSLSocketFactory)null, (HostnameVerifier)null), cachingFactory, clientFactory);
    }
}

FeignClientFactoryBean

FeignClientFactoryBean#configureFeign，用来配置Feign。先用Feign的默认配置，后用Feign的定制化配置。

    protected void configureFeign(FeignContext context, Builder builder) {
        FeignClientProperties properties = (FeignClientProperties)this.applicationContext.getBean(FeignClientProperties.class);
        if (properties != null) {
            if (properties.isDefaultToProperties()) {
                this.configureUsingConfiguration(context, builder);
                this.configureUsingProperties((FeignClientConfiguration)properties.getConfig().get(properties.getDefaultConfig()), builder);
                this.configureUsingProperties((FeignClientConfiguration)properties.getConfig().get(this.contextId), builder);
            } else {
                this.configureUsingProperties((FeignClientConfiguration)properties.getConfig().get(properties.getDefaultConfig()), builder);
                this.configureUsingProperties((FeignClientConfiguration)properties.getConfig().get(this.contextId), builder);
                this.configureUsingConfiguration(context, builder);
            }
        } else {
            this.configureUsingConfiguration(context, builder);
        }

    }

    protected void configureUsingProperties(FeignClientConfiguration config, Builder builder) {
        if (config != null) {
            if (config.getLoggerLevel() != null) {
                builder.logLevel(config.getLoggerLevel());
            }

            if (config.getConnectTimeout() != null && config.getReadTimeout() != null) {
                builder.options(new Options(config.getConnectTimeout(), config.getReadTimeout()));
            }

            if (config.getRetryer() != null) {
                Retryer retryer = (Retryer)this.getOrInstantiate(config.getRetryer());
                builder.retryer(retryer);
            }

            if (config.getErrorDecoder() != null) {
                ErrorDecoder errorDecoder = (ErrorDecoder)this.getOrInstantiate(config.getErrorDecoder());
                builder.errorDecoder(errorDecoder);
            }

            if (config.getRequestInterceptors() != null && !config.getRequestInterceptors().isEmpty()) {
                Iterator var7 = config.getRequestInterceptors().iterator();

                while(var7.hasNext()) {
                    Class<RequestInterceptor> bean = (Class)var7.next();
                    RequestInterceptor interceptor = (RequestInterceptor)this.getOrInstantiate(bean);
                    builder.requestInterceptor(interceptor);
                }
            }

            if (config.getDecode404() != null && config.getDecode404()) {
                builder.decode404();
            }

            if (Objects.nonNull(config.getEncoder())) {
                builder.encoder((Encoder)this.getOrInstantiate(config.getEncoder()));
            }

            if (Objects.nonNull(config.getDecoder())) {
                builder.decoder((Decoder)this.getOrInstantiate(config.getDecoder()));
            }

            if (Objects.nonNull(config.getContract())) {
                builder.contract((Contract)this.getOrInstantiate(config.getContract()));
            }

        }
    }

Feign.Builder#build，建造者模式，根据builder对象生成ReflectiveFeign。

        public Feign build() {
            Factory synchronousMethodHandlerFactory = new Factory(this.client, this.retryer, this.requestInterceptors, this.logger, this.logLevel, this.decode404, this.closeAfterDecode, this.propagationPolicy);
            ParseHandlersByName handlersByName = new ParseHandlersByName(this.contract, this.options, this.encoder, this.decoder, this.queryMapEncoder, this.errorDecoder, synchronousMethodHandlerFactory);
            return new ReflectiveFeign(handlersByName, this.invocationHandlerFactory, this.queryMapEncoder);
        }

ReflectiveFeign.ParseHandlersByName#apply，给FeignClient中的每一个方法进行解析，并且创造MethodHandler来作为方法的代理。

        public Map<String, MethodHandler> apply(Target key) {
            List<MethodMetadata> metadata = this.contract.parseAndValidatateMetadata(key.type());
            Map<String, MethodHandler> result = new LinkedHashMap();

            MethodMetadata md;
            Object buildTemplate;
            for(Iterator var4 = metadata.iterator(); var4.hasNext(); result.put(md.configKey(), this.factory.create(key, md, (Factory)buildTemplate, this.options, this.decoder, this.errorDecoder))) {
                md = (MethodMetadata)var4.next();
                if (!md.formParams().isEmpty() && md.template().bodyTemplate() == null) {
                    buildTemplate = new ReflectiveFeign.BuildFormEncodedTemplateFromArgs(md, this.encoder, this.queryMapEncoder);
                } else if (md.bodyIndex() != null) {
                    buildTemplate = new ReflectiveFeign.BuildEncodedTemplateFromArgs(md, this.encoder, this.queryMapEncoder);
                } else {
                    buildTemplate = new ReflectiveFeign.BuildTemplateByResolvingArgs(md, this.queryMapEncoder);
                }
            }

            return result;
        }
    }

SynchronousMethodHandler.Factory#create，创造方法维度的代理类。

        public MethodHandler create(Target<?> target, MethodMetadata md, feign.RequestTemplate.Factory buildTemplateFromArgs, Options options, Decoder decoder, ErrorDecoder errorDecoder) {
            return new SynchronousMethodHandler(target, this.client, this.retryer, this.requestInterceptors, this.logger, this.logLevel, md, buildTemplateFromArgs, options, decoder, errorDecoder, this.decode404, this.closeAfterDecode, this.propagationPolicy);
        }

SynchronousMethodHandler

SynchronousMethodHandler#executeAndDecode，调用client的execute方法，该client对象是LoadBalancerFeignClient。

    Object executeAndDecode(RequestTemplate template) throws Throwable {
        Request request = this.targetRequest(template);
        if (this.logLevel != Level.NONE) {
            this.logger.logRequest(this.metadata.configKey(), this.logLevel, request);
        }

        long start = System.nanoTime();

        Response response;
        try {
            response = this.client.execute(request, this.options);
        } catch (IOException var15) {
            if (this.logLevel != Level.NONE) {
                this.logger.logIOException(this.metadata.configKey(), this.logLevel, var15, this.elapsedTime(start));
            }

            throw FeignException.errorExecuting(request, var15);
        }
        //...
    }

Client.Default

Client接口的默认实现类。创造HttpURLConnection对象后，设置连接时长和超时时长。

        public Response execute(Request request, Options options) throws IOException {
            HttpURLConnection connection = this.convertAndSend(request, options);
            return this.convertResponse(connection, request);
        }

        HttpURLConnection convertAndSend(Request request, Options options) throws IOException {
            HttpURLConnection connection = (HttpURLConnection)(new URL(request.url())).openConnection();
            if (connection instanceof HttpsURLConnection) {
                HttpsURLConnection sslCon = (HttpsURLConnection)connection;
                if (this.sslContextFactory != null) {
                    sslCon.setSSLSocketFactory(this.sslContextFactory);
                }

                if (this.hostnameVerifier != null) {
                    sslCon.setHostnameVerifier(this.hostnameVerifier);
                }
            }

            connection.setConnectTimeout(options.connectTimeoutMillis());
            connection.setReadTimeout(options.readTimeoutMillis());
            connection.setAllowUserInteraction(false);
            connection.setInstanceFollowRedirects(options.isFollowRedirects());
            connection.setRequestMethod(request.httpMethod().name());
            Collection<String> contentEncodingValues = (Collection)request.headers().get("Content-Encoding");
            boolean gzipEncodedRequest = contentEncodingValues != null && contentEncodingValues.contains("gzip");
            boolean deflateEncodedRequest = contentEncodingValues != null && contentEncodingValues.contains("deflate");
            boolean hasAcceptHeader = false;
            Integer contentLength = null;
            Iterator var9 = request.headers().keySet().iterator();

            while(var9.hasNext()) {
                String field = (String)var9.next();
                if (field.equalsIgnoreCase("Accept")) {
                    hasAcceptHeader = true;
                }

                Iterator var11 = ((Collection)request.headers().get(field)).iterator();

                while(var11.hasNext()) {
                    String value = (String)var11.next();
                    if (field.equals("Content-Length")) {
                        if (!gzipEncodedRequest && !deflateEncodedRequest) {
                            contentLength = Integer.valueOf(value);
                            connection.addRequestProperty(field, value);
                        }
                    } else {
                        connection.addRequestProperty(field, value);
                    }
                }
            }

            if (!hasAcceptHeader) {
                connection.addRequestProperty("Accept", "*/*");
            }

            if (request.requestBody().asBytes() != null) {
                if (contentLength != null) {
                    connection.setFixedLengthStreamingMode(contentLength);
                } else {
                    connection.setChunkedStreamingMode(8196);
                }

                connection.setDoOutput(true);
                OutputStream out = connection.getOutputStream();
                if (gzipEncodedRequest) {
                    out = new GZIPOutputStream((OutputStream)out);
                } else if (deflateEncodedRequest) {
                    out = new DeflaterOutputStream((OutputStream)out);
                }

                try {
                    ((OutputStream)out).write(request.requestBody().asBytes());
                } finally {
                    try {
                        ((OutputStream)out).close();
                    } catch (IOException var18) {
                    }

                }
            }

            return connection;
        }

总结一下

  1. 在FeignClientFactoryBean生成代理类的时候，会将连接时长和超时时间封装成Options对象，在执行Feign.Builder#build的时候，组装ParseHandlersByName对象构建ReflectiveFeign对象。
  2. 封装@FeignClient对象的每一个方法，用到了SynchronousMethodHandler，该对象是SynchronousMethodHandler.Factory#create通过Options来创建的。
  3. 当请求进来的时候，会执行SynchronousMethodHandler#executeAndDecode方法，把SynchronousMethodHandler的Options对象的数据，传入到client中封装HttpURLConnection对象。
  4. 而Client的自动配置，是根据FeignRibbonClientAutoConfiguration引入的三个配置类来决定的。如果项目中有HttpClient的类，会自动引入HttpClientFeignLoadBalancedConfiguration，从而引入有HttpClient代理的LoadBalancerFeignClient。

在这里插入图片描述

秋装什么
关注
专栏目录
【OpenFeign 介绍、使用、发送请求、处理响应】
学无止境
03-30 1825
在这个示例中，@FeignClient注解表示这是一个Feign客户端接口，name属性表示服务的名称，url属性表示服务的地址，@GetMapping注解表示调用远程服务的HTTP请求方式和路径，@RequestParam注解表示传递的参数。它的主要作用是为了简化微服务架构中的服务间调用，因为在微服务架构中，服务间的调用比较频繁，而且可能需要调用多个不同的服务才能完成一个业务流程，这就需要在服务之间建立良好的通信机制。注入Feign客户端接口并调用远程服务。创建一个Feign客户端接口。
OpenFeign源码精解
最新发布
li350328320的专栏
05-20 1693
SpringCloud框架的OpenFeign源码精解，带你走进OpenFeign的实现世界，更好的理解其原理
OpenFeign发送http请求
weixin_49162086的博客
04-13 512
1.在pom.xml引入 <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-openfeign --> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spri...
springcloud学习第四天之OpenFeign发送http调用其他微服务
weixin_44710155的博客
04-10 545
有点小烦躁，这次就记录重点了，具体的创建父工程和子项目我就跳过了，请参考springcloud学习第三天之Consul服务治理中心创建父工程和子项目 1. 首先导入OpenFeign的依赖 在子项目的pom文件导入如下依赖，如图 <!-- 使用这个发送http --> <dependency> <groupId>org.springframework.cloud</groupId> &lt.
两个月学习springcloud(7):使用openfeign+eureka优雅的发送请求
DazedMen的博客
11-12 378
openfeign作为springcloud框架子项目之一，是一种声明式、模板化的HTTP客户端，openfeign为为服务架构中服务间的调用提供了解决方案。 openfeign是如何工作的呢？ Feign通过将注释处理为模板化请求来工作。在输出之前，参数以简单的方式应用于这些模板。尽管Feign仅限于支持基于文本的API，但它极大地简化了系统方面，例如重播请求。 官方解释: How do...
SpringCloud组件OpenFeign——默认HTTP请求方式
Luffy的博客
12-24 2969
OpenFeign相较于Feign新增了对SpringMvc的支持，通过以下方式可以调用服务端对应的方法。 但是如果使用@RequestMapping注解不指定请求方式时，通过客户端打印的OpenFein日志可以看出，客户端都是使用的GET请求。只有使用@PostMapping或者@RequestMapping中指定请求类型@RequestMapping(method = RequestMethod.POST)发送的才是POST请求。 那么使用@RequestMapping()时OpenFiegn.
spring cloud openfeign 源码实例解析
08-25
"Spring Cloud OpenFeign 源码实例解析" Spring Cloud OpenFeign 是基于 Spring Boot 和 Netflix 的 OpenFeign 框架实现的客户端负载均衡器，本文将对 Spring Cloud OpenFeign 源码进行实例解析，通过示例代码对其...
openFeign 源码注释版 2.2.1 版本
05-18
2. **动态代理**：OpenFeign使用Java的动态代理机制，在运行时创建实现了定义接口的类，这个类会自动处理HTTP请求的构建、发送和响应的解析。 3. **模板化HTTP客户端**：支持多种HTTP客户端，如OkHttp和Apache ...
OpenFeign的使用及源码分析
wp120453的博客
06-26 1701
前言  本文从使用者的角度入手，通过对其前置知识点网络客户端和代理模式及原理等相关知识作为切入点，逐步深入到OpenFeign的内部，从反（启动加载过程）正（核心调用链路）两个方向分析了其实现原理，最后简单的总结了下组件中涉及到的设计模式（部分），欢迎大家补充修正。  如果你对网络客户端和代理模式原理比较熟悉，可跳过一二小节直接进入到第三小节的阅读。 一、网络连接方式  常见的网络连接实现方式有以...
Spring Cloud 源码分析之OpenFeign
wdjnb的博客
02-11 1053
OpenFeign是一个远程客户端请求代理，它的基本作用是让开发者能够以面向接口的方式来实现远程调用，从而屏蔽底层通信的复杂性，它的具体原理如下图所示。 在今天的内容中，我们需要详细分析OpenFeign它的工作原理及源码，我们继续回到这段代码。 @Slf4j @RestController @RequestMapping("/order") public class OrderController { @Autowired IGoodsServiceFeignClient go
Feign如何对静态服务发起Http请求？
程序员麦冬的博客（公众号同名）
09-11 809
Feign单独使用时，可以对配置的静态服务发起Http调用；当Feign结合Ribbon时，对配置的静态服务可以根据负载均衡策略进行调用；再结合Eureka，可以配合注册中心以及负载均衡策略动态发起调用。本篇分析Feign对配置的静态服务是如何发起Http调用的 一、 Maven依赖 <dependencyManagement> <dependencies> <dependency>
【OpenFeign】实现远程HTTP调用
GuLuZaizzz的博客
07-19 833
是一个http请求调用的轻量级框架，是以Java接口注解的方式调用Http请求，而不用像Java中通过封装HTTP请求报文的方式直接调用。Feign通过处理注解，将请求模板化，当实际调用的时候，传入参数，根据参数再应用到请求上，进而转化成真正的请求。方式一:让父子上下文ComponentScan重叠（强烈不建议使用）/*** 日志级别* 通过源码可以看到日志等级有 4 种，分别是：* NONE：不输出日志。* BASIC：只输出请求方法的 URL 和响应的状态码以及接口执行的时间。
使用Feign发送http请求以及源码分析
漂泊的程序猿
01-15 1606
使用Feign发送http请求以及源码分析 简介 Feign是一个http请求调用的轻量级框架，可以用Java接口注解的方式调用Http请求，而不用像Java中通过封装HTTP请求报文的方式直接调用。 注解(Annotation) 注解 作用域 用法 @RequestLine 方法 定义HttpMethod和UriTemplate请求。 {expression}使用大括号括起来的值...
feign源码分析
qq_38016945的博客
02-20 142
feign源码分析 注入对象为@FeignClient接口的代理对象。
【云原生&微服务十】SpringCloud之OpenFeign实现服务间请求头数据传递（OpenFeign拦截器RequestInterceptor的使用）
m0_67392273的博客
07-31 377
我们聊了OpenFeign的概述、为什么会使用Feign代替Ribbon、Feign和OpenFeign的区别、以及详细的OpenFeign实现声明式客户端负载均衡案例。在一些业务场景中，微服务间相互调用需要做鉴权，以保证我们服务的安全性。即服务A调用服务B的时候需要将服务B的一些鉴权信息传递给服务B，从而保证服务B的调用也可以通过鉴权，进而保证整个服务调用链的安全。本文我们就讨论如果通过openfeign的拦截器实现服务调用链中上下游服务请求头数据的传递。...
Feign源码解析
qq_35219329的博客
09-27 692
目录 前言 一、EnableFeignClients 二、FeignClientsRegistrar 三、FeignClientFactoryBean 四、FeignInvocationHandler 五、动态URI参数 总结 前言 Feign作为调用http请求的工具，在java后端编程中有广泛的应用，能够简化代码书写，但同时也隐藏了大量的处理细节，作为开发者，应当适当了解其源码，解决开发中的问题。 一、EnableFeignClients ...
Feign核心源码解析
06-08 2595
Feign作为一个声明式的Http服务客户端，通过接口加注解的方式，就能够完成对服务提供方接口的调用，极大的简化了我们在调用服务时的工作。 那么在只有接口的条件下，Feign是如何基于接口实现服务调用的呢？在之前的代理模式及mybatis实现原理的文章中，我们知道了可以通过动态代理的方式生成代理对象。Feign是否这样实现的呢，我们从源码角度进行分析。 1、初始化阶段 首先看一下Feign的开启注解@EnableFeignClients： @Retention(RetentionPolicy.RU
Feign之源码剖析
猎户星座
01-07 203
附：SpringCloud之系列教程汇总跳转地址 什么是Feign Feign是由Retrofit，JAXRS-2.0和WebSocket启发的一个java到http客户端绑定。 Feign的主要目标是将Java Http Clients变得简单。 写一个Feign 简单的实现一个Feign客户端，首先通过@FeignClient，客户端，其中value为调用其他服务的名称，FeignCo...
feign基础源码解析（初始化，调用过程）
qq_38331730的博客
08-28 874
实例调用过程feign的核心主要分两块：1，初始化feign通过Feign.builder() 构造器构建传递初始化参数，如：发起http的工具，序列化工具，目标类，生产者地址等参数然后解析目标类注解为每个方法生成对应的MethodHandler ，然后使用jdk动态代理为目标类生成代理实例ReflectiveFeign.FeignInvocationHandler2，调用过程。...
J2ME浏览器源码解析与HTTP请求示例
"这是一个基于J2ME的简单浏览器源码，主要功能是实现HTTP连接和页面加载。" 在J2ME（Java 2 Micro Edition）环境中，开发轻量级移动应用时，由于硬件和内存限制，通常需要使用特定的API来处理网络通信。此代码示例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值