前面我们总结了FeignClient代理对象的生成过程，这一节我们也直奔主题：FeignClient调用过程，了解FeignClient调用过程有利于我们提高分析与解决问题的能力！FeignClient的调用过程可以概括为两部分组成，前部分为Hystrix熔断，后部分为Ribbon负载均衡请求及响应返回值！
我们在Spring Cloud Feign 分析(五)之FeignClient代理生成过程中讲解过在生成代理对象的过程中，会给代理对象设置HystrixInvocationHandler动态代理方法，FeignClient接口触发的方法调用均会被这个动态代理方法拦截，所以我们分析下HystrixInvocationHandler这个动态代理方法做了什么事情？
HystrixInvocationHandler
final class HystrixInvocationHandler implements InvocationHandler {
......
@Override
public Object invoke(final Object proxy, final Method method, final Object[] args)
throws Throwable {
......
//创建Hystrix命令
HystrixCommand<Object> hystrixCommand =
new HystrixCommand<Object>(setterMethodMap.get(method)) {
@Override
protected Object run() throws Exception {
try {
//调用SynchronousMethodHandler#invoke(Object[] argv)方法
return HystrixInvocationHandler.this.dispatch.get(method).invoke(args);
} catch (Exception e) {
throw e;
} catch (Throwable t) {
throw (Error) t;
}
}
//熔断降级方法,默认new UnsupportedOperationException("No fallback available.");
@Override
protected Object getFallback() {......}
};
if (Util.isDefault(method)) {
return hystrixCommand.execute();
} else if (isReturnsHystrixCommand(method)) {
return hystrixCommand;
} else if (isReturnsObservable(method)) {
// Create a cold Observable
return hystrixCommand.toObservable();
} else if (isReturnsSingle(method)) {
// Create a cold Observable as a Single
return hystrixCommand.toObservable().toSingle();
} else if (isReturnsCompletable(method)) {
return hystrixCommand.toObservable().toCompletable();
} else if (isReturnsCompletableFuture(method)) {
return new ObservableCompletableFuture<>(hystrixCommand);
}
//通过Hystrix触发调用，让整个方法调用具备熔断能力
return hystrixCommand.execute();
}
......
}
这个代理方法，我们一眼望穿秋水，原来是创建了HystrixCommand命令来进行目标方法的调用分发，这样就使得我们的整个方法调用具备了熔断能力，我们接着看看dispatch.get(method).invoke(args)，这个分发器的定义是这样的Map<Method, MethodHandler> dispatch，方法及对应方法的Handler，看起来有点眼熟是吧，我们在分析五(代理生成过程)中ReflectiveFeign#newInstance()这个方法中通过targetToHandlersByName解析而来的，通过这个解析器我们即可得知这个MethodHandler对应SynchronousMethodHandler，所以我们接着分析SynchronousMethodHandler，看看这个同步方法Handler做了哪些事情
SynchronousMethodHandler
final class SynchronousMethodHandler implements MethodHandler {
......
@Override
public Object invoke(Object[] argv) throws Throwable {
RequestTemplate template = buildTemplateFromArgs.create(argv);
Options options = findOptions(argv);
Retryer retryer = this.retryer.clone();
while (true) {
try {
//执行目标方法
return executeAndDecode(template, options);
} catch (RetryableException e) {
......
continue;
}
}
}
Object executeAndDecode(RequestTemplate template, Options options) throws Throwable {
//创建目标Request
//内部会调用我们自定义的RequestInterceptor拦截方法，比如添加traceId头信息用于跟踪等等
Request request = targetRequest(template);
if (logLevel != Logger.Level.NONE) {
logger.logRequest(metadata.configKey(), logLevel, request);
}
Response response;
long start = System.nanoTime();
try {
//执行LoadBalancerFeignClient#execute()
response = client.execute(request, options);
//确保请求参数已设置
response = response.toBuilder()
.request(request)
.requestTemplate(template)
.build();
} catch (IOException e) {
if (logLevel != Logger.Level.NONE) {
logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime(start));
}
throw errorExecuting(request, e);
}
long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
//如果decoder有则使用
if (decoder != null)
return decoder.decode(response, metadata.returnType());
//异步响应处理器对结果response做最后的解析
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;
}
}
......
}
在SynchronousMethodHandler这个同步方法处理器中我们看到最终调用了这么一段response = client.execute(request, options);这个client从上下文方法传递中也能看出对应LoadBalancerFeignClient这个负载均衡client，至此我们前半段部分Hystrix熔断分析完毕，下文部分将接着讲解后半段部分Ribbon负载均衡请求相关的调用过程
FeignRibbonClientAutoConfiguration
@ConditionalOnClass({ ILoadBalancer.class, Feign.class })
@ConditionalOnProperty(value = "spring.cloud.loadbalancer.ribbon.enabled",matchIfMissing = true)
@Configuration(proxyBeanMethods = false)
@AutoConfigureBefore(FeignAutoConfiguration.class)
@EnableConfigurationProperties({ FeignHttpClientProperties.class })
@Import({ HttpClientFeignLoadBalancedConfiguration.class,
OkHttpFeignLoadBalancedConfiguration.class,
DefaultFeignLoadBalancedConfiguration.class })
public class FeignRibbonClientAutoConfiguration {
//无RetryTemplate则使用此FeignLoadBalancer实例缓存工厂
@Bean
@Primary
@ConditionalOnMissingBean
@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
public CachingSpringLoadBalancerFactory cachingLBClientFactory(
SpringClientFactory factory) {
return new CachingSpringLoadBalancerFactory(factory);
}
//有RetryTemplate则使用此FeignLoadBalancer实例缓存工厂
@Bean
@Primary
@ConditionalOnMissingBean
@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
public CachingSpringLoadBalancerFactory retryabeCachingLBClientFactory(
SpringClientFactory factory, LoadBalancedRetryFactory retryFactory) {
return new CachingSpringLoadBalancerFactory(factory, retryFactory);
}
//设置默认请求选项，从Ribbon的SpringClientFactory获取IClientConfig配置参数
@Bean
@ConditionalOnMissingBean
public Request.Options feignRequestOptions() {
return LoadBalancerFeignClient.DEFAULT_OPTIONS;
}
}
当前配置类会在FeignAutoConfiguration之前进行，CachingSpringLoadBalancerFactory工厂类会根据clientName创建FeignLoadBalancer并缓存供LoadBalancerFeignClient后续直接使用
DefaultFeignLoadBalancedConfiguration
@Configuration(proxyBeanMethods = false)
class DefaultFeignLoadBalancedConfiguration {
@Bean
@ConditionalOnMissingBean
public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
SpringClientFactory clientFactory) {
return new LoadBalancerFeignClient(new Client.Default(null, null), cachingFactory,
clientFactory);
}
}
创建一个默认的Client => LoadBalancerFeignClient，具备负载均衡功能的Client，是Feign负载均衡客户端的默认实现。
CachingSpringLoadBalancerFactory
public class CachingSpringLoadBalancerFactory {
private volatile Map<String, FeignLoadBalancer> cache = new ConcurrentReferenceHashMap<>();
......
public FeignLoadBalancer create(String clientName) {
//缓存中获取FeignLoadBalancer
FeignLoadBalancer client = this.cache.get(clientName);
if (client != null) {
return client;
}
//通过Ribbon的SpringClientFactory工厂类获取Ribbon客户端相关配置接口
IClientConfig config = this.factory.getClientConfig(clientName);
//通过Ribbon的SpringClientFactory工厂类获取负载均衡接口
ILoadBalancer lb = this.factory.getLoadBalancer(clientName);
//通过Ribbon的SpringClientFactory工厂类获取安全端口接口
ServerIntrospector serverIntrospector = this.factory.getInstance(clientName,
ServerIntrospector.class);
//创建FeignLoadBalancer
client = this.loadBalancedRetryFactory != null
? new RetryableFeignLoadBalancer(lb, config, serverIntrospector,
this.loadBalancedRetryFactory)
: new FeignLoadBalancer(lb, config, serverIntrospector);
//放入缓存
this.cache.put(clientName, client);
return client;
}
}
通过Ribbon对外提供的SpringClientFactory这个工厂类，我们可以获取各种Ribbon客户端相关的配置，Ribbon客户端配置详情介绍请参阅Spring Cloud Ribbon 分析(三)之RibbonClientConfiguration客户端配置
LoadBalancerFeignClient
public class LoadBalancerFeignClient implements Client {
......
@Override
public Response execute(Request request, Request.Options options) throws IOException {
try {
//转换为URI格式
URI asUri = URI.create(request.url());
//获取clientName
String clientName = asUri.getHost();
URI uriWithoutHost = cleanUrl(request.url(), clientName);
//创建RibbonRequest
FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(
this.delegate, request, uriWithoutHost);
//获取Ribbon IClientConfig
IClientConfig requestConfig = getClientConfig(options, clientName);
//创建FeignLoadBalancer并执行负载均衡方法
return lbClient(clientName)
.executeWithLoadBalancer(ribbonRequest, requestConfig).toResponse();
}
catch (ClientException e) {
IOException io = findIOException(e);
if (io != null) {
throw io;
}
throw new RuntimeException(e);
}
}
......
//如果有LoadBalancedRetryFactory则创建RetryableFeignLoadBalancer
private FeignLoadBalancer lbClient(String clientName) {
return this.lbClientFactory.create(clientName);
}
......
}
上文中lbClient(clientName).executeWithLoadBalancer(ribbonRequest, requestConfig).toResponse()执行过程可以参阅Spring Cloud Ribbon 分析(四)之Feign集成中的LoadBalancerFeignClient标题部分，其中会分析通过Ribbon发起负载均衡到获取返回值的过程，这里我们就不做重复阐述。
至此，Feign模块总结也告一段落，这里笔者只总结和分析了流程中比较重要的几个部分，如果想知道更多Feign原理则需要亲自分析相关的知识点，如果文章对你有所帮助，就点赞关注吧！
