Spring Cloud OpenFeign调用流程

上一节给大家分享了Spring Cloud OpenFeign的启动流程，接下来给大家分享一下调用流程。话不多说，咱们直接开始。

视频：https://www.bilibili.com/video/BV1A84y1C7XD/

调用流程

xxxFeignClient

→ feign.ReflectiveFeign.FeignInvocationHandler#invoke

→ feign.InvocationHandlerFactory.MethodHandler#invoke

→ feign.SynchronousMethodHandler#invoke

→ feign.SynchronousMethodHandler#executeAndDecode

→ org.springframework.cloud.openfeign.loadbalancer.FeignBlockingLoadBalancerClient#execute

→ feign.Client.Default#execute

→ feign.AsyncResponseHandler#handleResponse

动态代理

feign.ReflectiveFeign.FeignInvocationHandler#invoke

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  return dispatch.get(method).invoke(args);
}

这里说一下 dispatch 属性，它的类型是Map意思是，可以通过方法找到对应的Handler，这样就可以进入到 SynchronousMethodHandler#invoke。

feign.SynchronousMethodHandler#executeAndDecode

从这个方法的名称也能看出来，这个是执行请求，并且实现解码的功能，这是一个核心的方法。

负载均衡

org.springframework.cloud.openfeign.loadbalancer.FeignBlockingLoadBalancerClient#execute

这个是实现均衡，实现将URL中服务名转成 真实的IP。

下面我们看看它是如何被自动注入的。

首先在 spring.factories 文件中，做了配置

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.cloud.openfeign.loadbalancer.FeignLoadBalancerAutoConfiguration

FeignLoadBalancerAutoConfiguration 中引入 DefaultFeignLoadBalancerConfiguration

@ConditionalOnClass(Feign.class)
@ConditionalOnBean({ LoadBalancerClient.class, LoadBalancerClientFactory.class })
@AutoConfigureBefore(FeignAutoConfiguration.class)
@AutoConfigureAfter({ BlockingLoadBalancerClientAutoConfiguration.class, LoadBalancerAutoConfiguration.class })
@EnableConfigurationProperties(FeignHttpClientProperties.class)
@Configuration(proxyBeanMethods = false)
// Order is important here, last should be the default, first should be optional
// see
// https://github.com/spring-cloud/spring-cloud-netflix/issues/2086#issuecomment-316281653
@Import({ HttpClientFeignLoadBalancerConfiguration.class, OkHttpFeignLoadBalancerConfiguration.class,
        HttpClient5FeignLoadBalancerConfiguration.class, DefaultFeignLoadBalancerConfiguration.class })
public class FeignLoadBalancerAutoConfiguration {

}

new FeignBlockingLoadBalancerClient，并且注入到 Spring Bean 中

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(LoadBalancerClientsProperties.class)
class DefaultFeignLoadBalancerConfiguration {

    @Bean
    @ConditionalOnMissingBean
    @Conditional(OnRetryNotEnabledCondition.class)
    public Client feignClient(LoadBalancerClient loadBalancerClient,
            LoadBalancerClientFactory loadBalancerClientFactory) {
        return new FeignBlockingLoadBalancerClient(new Client.Default(null, null), loadBalancerClient,
                loadBalancerClientFactory);
    }

}

Http请求

下面我们看看 feign 是如何实现 Http 请求的。

feign.Client.Default#execute

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

主要就是在这个方法中，默认使用 jdk 实现 http请求。

convertAndSend，这个方法做了两件事，一是，打开 Http 连接，获取到 HttpURLConnection ，并设置相关属性；二是，如果有参数，就通过输出流（OutputStream）写入参数。

convertResponse，这个方法返回的是 feign.Response ，我们它有哪些属性：

public final class Response implements Closeable {

  private final int status;
  private final String reason;
  private final Map> headers;
  private final Body body;
  private final Request request;
  private final ProtocolVersion protocolVersion;

}

首先，这里实现 Closeable 接口，所以必然有 close 方法，我们看一下：

@Override
public void close() {
  Util.ensureClosed(body);
}

好了，明白了，body实际上是写入流（InputStream）。

总结一下：这里实现了Http请求，上传了参数，或获得了输入流。

Http响应处理

看完了请求，我们再回到 feign.SynchronousMethodHandler#executeAndDecode，看下面的代码

CompletableFuture