SpringCloud FeignClient+Ribbon 底层实现原理(三)

137 阅读 0 评论 91 点赞

我是靠谱客的博主长情时光，最近开发中收集的这篇文章主要介绍SpringCloud FeignClient+Ribbon 底层实现原理(三)，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

SpringCloud FeignClient+Ribbon 底层实现原理(三)

说实话上一篇文章确实内容比较少，所用在开一篇文章彻底将Feign和Ribbon怎么结合的讲下在上一篇文章中我们讲到了jdk的动态代理，我们重点看下invocationHanlder类SynchronousMethodHandler
主要分析invoke方法和executeAndDecode，invoke方法是代理类调用方法的入口，通过该方法调用executeAndDecode方法，executeAndDecode方法中真正实现调用的的code为,其中client为LoadBalancerFeignClient，调用带有负载均衡的client请求了服务提供者

response = this.client.execute(request, options);

public Object invoke(Object[] argv) throws Throwable {
RequestTemplate template = this.buildTemplateFromArgs.create(argv);
Options options = this.findOptions(argv);
Retryer retryer = this.retryer.clone();
while(true) {
try {
return this.executeAndDecode(template, options);
} catch (RetryableException var9) {
RetryableException e = var9;
try {
retryer.continueOrPropagate(e);
} catch (RetryableException var8) {
Throwable cause = var8.getCause();
if (this.propagationPolicy == ExceptionPropagationPolicy.UNWRAP && cause != null) {
throw cause;
}
throw var8;
}
if (this.logLevel != Level.NONE) {
this.logger.logRetry(this.metadata.configKey(), this.logLevel);
}
}
}
}
Object executeAndDecode(RequestTemplate template, Options options) 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, options);
response = response.toBuilder().request(request).requestTemplate(template).build();
} catch (IOException var13) {
if (this.logLevel != Level.NONE) {
this.logger.logIOException(this.metadata.configKey(), this.logLevel, var13, this.elapsedTime(start));
}
throw FeignException.errorExecuting(request, var13);
}
long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
if (this.decoder != null) {
return this.decoder.decode(response, this.metadata.returnType());
} else {
CompletableFuture<Object> resultFuture = new CompletableFuture();
this.asyncResponseHandler.handleResponse(resultFuture, this.metadata.configKey(), response, this.metadata.returnType(), elapsedTime);
try {
if (!resultFuture.isDone()) {
throw new IllegalStateException("Response handling not done");
} else {
return resultFuture.join();
}
} catch (CompletionException var12) {
Throwable cause = var12.getCause();
if (cause != null) {
throw cause;
} else {
throw var12;
}
}
}
}

接着我们分析LoadBalancerFeignClient的execute方法，看看负载均衡的逻辑是如何实现的,首先看下RibbonRequest的构造，发现this.delegate这个参数其实就是真正运行client的引用如果你配置OkHttpClient那么此处就是OkHttpClient，剩下两个参数就是请求参数和只带有服务名的url

FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(this.delegate, request, uriWithoutHost);
构造完RibbonRequst后接下来就开始进行负载均衡请求了

lbClient(clientName).executeWithLoadBalancer(ribbonRequest, requestConfig).toResponse();

@Override
public Response execute(Request request, Request.Options options) throws IOException {
try {
URI asUri = URI.create(request.url());
String clientName = asUri.getHost();
URI uriWithoutHost = cleanUrl(request.url(), clientName);
FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(this.delegate, request, uriWithoutHost);
IClientConfig requestConfig = getClientConfig(options, clientName);
return lbClient(clientName).executeWithLoadBalancer(ribbonRequest, requestConfig).toResponse();
}
catch (ClientException e) {
IOException io = findIOException(e);
if (io != null) {
throw io;
}
throw new RuntimeException(e);
}
}

executeWithLoadBalancer方法在AbstractLoadBalancerAwareClient一个抽象类中,executeWithLoadBalancer中通过一个命令模式进行请求，重点分析下command中几个重要方法

public T executeWithLoadBalancer(final S request, final IClientConfig requestConfig) throws ClientException {
LoadBalancerCommand command = this.buildLoadBalancerCommand(request, requestConfig);
try {
return (IResponse)command.submit(new ServerOperation<T>() {
public Observable<T> call(Server server) {
URI finalUri = AbstractLoadBalancerAwareClient.this.reconstructURIWithServer(server, request.getUri());
ClientRequest requestForServer = request.replaceUri(finalUri);
try {
return Observable.just(AbstractLoadBalancerAwareClient.this.execute(requestForServer, requestConfig));
} catch (Exception var5) {
return Observable.error(var5);
}
}
}).toBlocking().single();
} catch (Exception var6) {
Throwable t = var6.getCause();
if (t instanceof ClientException) {
throw (ClientException)t;
} else {
throw new ClientException(var6);
}
}
}

第一个方法就是selectServer方法,该方法将获取server的信息然后进行负载均衡算法选择满足条件的server

private Observable<Server> selectServer() {
return Observable.create(new OnSubscribe<Server>() {
public void call(Subscriber<? super Server> next) {
try {
Server server = LoadBalancerCommand.this.loadBalancerContext.getServerFromLoadBalancer(LoadBalancerCommand.this.loadBalancerURI, LoadBalancerCommand.this.loadBalancerKey);
next.onNext(server);
next.onCompleted();
} catch (Exception var3) {
next.onError(var3);
}
}
});
}

第二个方法是getServerFromLoadBalancer中通过getLoadBalancer方法来获取带有Ribbon规则的负载均衡，前提是你配置了ribbon否则默认为ZoneAvoidanceZule，至此主要流程已经分析完成，具体细节可以debug调试分析具体逻辑

ILoadBalancer lb = this.getLoadBalancer();

 public Server getServerFromLoadBalancer(@Nullable URI original, @Nullable Object loadBalancerKey) throws ClientException {
String host = null;
int port = -1;
if (original != null) {
host = original.getHost();
}
if (original != null) {
Pair<String, Integer> schemeAndPort = this.deriveSchemeAndPortFromPartialUri(original);
port = (Integer)schemeAndPort.second();
}
ILoadBalancer lb = this.getLoadBalancer();
if (host == null) {
if (lb != null) {
Server svc = lb.chooseServer(loadBalancerKey);
if (svc == null) {
throw new ClientException(ErrorType.GENERAL, "Load balancer does not have available server for client: " + this.clientName);
}
host = svc.getHost();
if (host == null) {
throw new ClientException(ErrorType.GENERAL, "Invalid Server for :" + svc);
}
logger.debug("{} using LB returned Server: {} for request {}", new Object[]{this.clientName, svc, original});
return svc;
}
if (this.vipAddresses != null && this.vipAddresses.contains(",")) {
throw new ClientException(ErrorType.GENERAL, "Method is invoked for client " + this.clientName + " with partial URI of (" + original + ") with no load balancer configured. Also, there are multiple vipAddresses and hence no vip address can be chosen to complete this partial uri");
}
if (this.vipAddresses == null) {
throw new ClientException(ErrorType.GENERAL, this.clientName + " has no LoadBalancer registered and passed in a partial URL request (with no host:port). Also has no vipAddress registered");
}
try {
Pair<String, Integer> hostAndPort = this.deriveHostAndPortFromVipAddress(this.vipAddresses);
host = (String)hostAndPort.first();
port = (Integer)hostAndPort.second();
} catch (URISyntaxException var8) {
throw new ClientException(ErrorType.GENERAL, "Method is invoked for client " + this.clientName + " with partial URI of (" + original + ") with no load balancer configured.
Also, the configured/registered vipAddress is unparseable (to determine host and port)");
}
} else {
boolean shouldInterpretAsVip = false;
if (lb != null) {
shouldInterpretAsVip = this.isVipRecognized(original.getAuthority());
}
if (shouldInterpretAsVip) {
Server svc = lb.chooseServer(loadBalancerKey);
if (svc != null) {
host = svc.getHost();
if (host == null) {
throw new ClientException(ErrorType.GENERAL, "Invalid Server for :" + svc);
}
logger.debug("using LB returned Server: {} for request: {}", svc, original);
return svc;
}
logger.debug("{}:{} assumed to be a valid VIP address or exists in the DNS", host, port);
} else {
logger.debug("Using full URL passed in by caller (not using load balancer): {}", original);
}
}
if (host == null) {
throw new ClientException(ErrorType.GENERAL, "Request contains no HOST to talk to");
} else {
return new Server(host, port);
}
}