上一节给大家分享了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<Method, MethodHandler>
意思是，可以通过方法找到对应的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<String, Collection<String>> 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<Object> resultFuture = new CompletableFuture<>();
asyncResponseHandler.handleResponse(resultFuture, metadata.configKey(), response,
metadata.returnType(),
elapsedTime);
try {
if (!resultFuture.isDone())
throw new IllegalStateException("Response handling not done");
return resultFuture.join();
} catch (CompletionException e) {
Throwable cause = e.getCause();
if (cause != null)
throw cause;
throw e;
}
这里是通过 CompletableFuture，来装配响应结果。
feign.AsyncResponseHandler#handleResponse，这个方法就也就是处理Http响应结果的入口。
比如要判断状态码，获取结果，关闭输入流等。
响应结果解码
解码流程如下：
feign.AsyncResponseHandler#decode
→ org.springframework.cloud.openfeign.support.ResponseEntityDecoder#decode
→ org.springframework.cloud.openfeign.support.SpringDecoder#decode
→ org.springframework.cloud.openfeign.support.SpringDecoder.FeignResponseAdapter#FeignResponseAdapter
→ org.springframework.web.client.HttpMessageConverterExtractor#extractData
→ org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter#read
为什么需要解码呢？
http响应的结果类型是String，而我们需要的是一个对象，比如：
@FeignClient(
value = "openfeign-goods-service",
path = "/goods"
)
public interface IGoodsFeignClient {
@GetMapping("/list")
ResultTemplate<ListTemplate<GoodsModel>> list();
}