所有文章
正文
ribbon是springcloud封装的一个基于http客户端负载均衡的组件。springcloud的openfeign集成使用了ribbon。所以如果你使用openfeign，那么也会很轻易得使用到ribbon。本文将从openfeign切入，看看它是怎么来使用到ribbon这个客户端负载均衡组件的。
LoadBalancerFeignClient提供openfeign的负载均衡实现
在讲openfeign的时候我们说到，最后代理类其实就是发起http请求，并解码返回的字节码内容。回顾一下代码
Object executeAndDecode(RequestTemplate template, Options options) throws Throwable {
Request request = targetRequest(template);
Response response;
try {
response = client.execute(request, options);
} catch (IOException e) {
}
boolean shouldClose = true;
try {
if (Response.class == metadata.returnType()) {
//
}
if (response.status() >= 200 && response.status() < 300) {
// 返回空
if (void.class == metadata.returnType()) {
return null;
} else {
// 返回解码结果对象
Object result = decode(response);
return result;
}
} else if (decode404 && response.status() == 404 && void.class != metadata.returnType()) {
//
} else {
//
}
} catch (IOException e) {
//
} finally {
//
}
}可以看到，client提交了一个http的request，然后获得了response响应对象，处理后并返回。ribbon的接入将从这里开始，我们看看client接口
public interface Client {
Response execute(Request request, Options options) throws IOException;
}接口很简单，就是一个请求响应模型。那么，我们再向下看看Client关于负载均衡这个方面有什么实现呢？
LoadBalancerFeignClient作为Client在负载均衡方面的实现类，我们跟进它的execute方法，看看做了些啥
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);
// 构造ribbon的request对象
FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(this.delegate, request, uriWithoutHost);
IClientConfig requestConfig = getClientConfig(options, clientName);
// 执行ribbon的request对象
return lbClient(clientName).executeWithLoadBalancer(ribbonRequest, requestConfig).toResponse();
} catch (ClientException e) {
//
}
}可以看到，关于负载均衡方面openfeign直接构造了ribbon的请求，并执行。
构造ribbon的IClient
lbClient(clientName)构造了一个ribbon的http客户端实现，打开该方法
private FeignLoadBalancer lbClient(String clientName) {
return this.lbClientFactory.create(clientName);
}一个简单工厂模式，跟进create方法
public FeignLoadBalancer create(String clientName) {
FeignLoadBalancer client = this.cache.get(clientName);
if (client != null) {
return client;
}
IClientConfig config = this.factory.getClientConfig(clientName);
ILoadBalancer lb = this.factory.getLoadBalancer(clientName);
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;
}这里瞄一眼FeignLoadBalancer的类图吧
FeignLoadBalancer实现了IClient接口，所以它会负责提交并执行Ribbon的request请求
提交执行ribbon的request请求
lbClient方法构建了FeignLoadBalancer，下面该调用它的executeWithLoadBalancer方法了，跟进方法（方法在父类AbstractLoadBalancerAwareClient中）
public T executeWithLoadBalancer(final S request, final IClientConfig requestConfig) throws ClientException {
LoadBalancerCommand<T> command = buildLoadBalancerCommand(request, requestConfig);
try {
return command.submit(
new ServerOperation<T>() {
@Override
public Observable<T> call(Server server) {
// 回调返回选择好的Server对象，并重新构造uri地址
URI finalUri = reconstructURIWithServer(server, request.getUri());
S requestForServer = (S) request.replaceUri(finalUri);
try {
// 执行ribbon的request请求
return Observable.just(AbstractLoadBalancerAwareClient.this.execute(requestForServer, requestConfig));
}
catch (Exception e) {
return Observable.error(e);
}
}
})
.toBlocking()
.single();
} catch (Exception e) {
//
}
}如果不关心负载均衡的情况，这里其实就是直接执行ribbon的request请求了。也就是IClient这个接口类定义的内容。不过FeignLoadBalancer需要进行一次负载选择Server，然后才回调这里的call来发起请求。
跟进submit方法看看，submit方法先是进行了一次选择获得了一个Server对象，然后回调了上面说的ribbon的request执行
public Observable<T> submit(final ServerOperation<T> operation) {
// ...
// Use the load balancer
Observable<T> o =
// 选择Server
(server == null ? selectServer() : Observable.just(server))
.concatMap(new Func1<Server, Observable<T>>() {
@Override
// Called for each server being selected
public Observable<T> call(Server server) {
context.setServer(server);
//
// Called for each attempt and retry
Observable<T> o = Observable
.just(server)
.concatMap(new Func1<Server, Observable<T>>() {
@Override
public Observable<T> call(final Server server) {
// ...
// 回调ribbon的request请求
return operation.call(server).doOnEach(
// ...
);
}
});
if (maxRetrysSame > 0)
o = o.retry(retryPolicy(maxRetrysSame, true));
return o;
}
});
// ...
}
ILoadBalancer负载均衡器
继续跟进selectServer，看看如何选择服务的
private Observable<Server> selectServer() {
return Observable.create(new OnSubscribe<Server>() {
@Override
public void call(Subscriber<? super Server> next) {
try {
// 从上下文中获取
Server server = loadBalancerContext.getServerFromLoadBalancer(loadBalancerURI, loadBalancerKey);
next.onNext(server);
next.onCompleted();
} catch (Exception e) {
next.onError(e);
}
}
});
}托付给了getServerFromLoadBalancer来实现，继续跟进
public Server getServerFromLoadBalancer(@Nullable URI original, @Nullable Object loadBalancerKey) throws ClientException {
// ...
ILoadBalancer lb = getLoadBalancer();
if (host == null) {
if (lb != null){
Server svc = lb.chooseServer(loadBalancerKey);
// ...
return svc;
} else {
// ...
}
} else {
// ...
}
// ...
}getLoadBalancer方法先是获取了一个ILoadBalancer接口的实现，然后调用了chooseServer来选择一个Server。
先跟进getLoadBalancer方法，直接返回了上下文中的设置的ILoadBalancer负载均衡器
private ILoadBalancer lb;
public ILoadBalancer getLoadBalancer() {
return lb;
}我们看一下ILoadBalancer的的类图，RibbonClientConfiguration配置ILoadBalancer的时候配置的是ZoneAwareLoadBalancer的Bean
getLoadBalancer返回的ILoadBalancer负载均衡器也将是ZoneAwareLoadBalancer的实例对象
IRule负载均衡算法
有了ILoadBalancer负载均衡器，再看看chooseServer方法。这里忽略一些细节，直接看BaseLoadBalancer的chooseServer这个核心的实现
public Server chooseServer(Object key) {
if (counter == null) {
counter = createCounter();
}
counter.increment();
if (rule == null) {
return null;
} else {
try {
return rule.choose(key);
} catch (Exception e) {
logger.warn("LoadBalancer [{}]: Error choosing server for key {}", name, key, e);
return null;
}
}
}可以看看，直接调用了IRule接口的choose方法。IRule接口则负责相关的负载均衡算法实现，我们看看IRule接口有哪些实现吧
常见的随机算法、轮询算法...等
总结
到这里，本文就结束了。我们再回顾一下文章的接口和流程
1、先是openfeign开放了一个Client接口用于http请求，并且LoadBalancerFeignClient作为负载均衡的实现类
2、LoadBalancerFeignClient则直接构造了一个ribbon的IClient接口的实现FeignLoadBalancer
3、执行ribbon的request之前，先委托ILoadBalancer负载均衡器选择一个Server，然后回调执行request请求
4、ILoadBalancer会选择IRule实现的负载均衡算法来获取一个Server，并返回。
总体逻辑比较简单，本文忽略了一些细节内容，比如一些自动配置的东西、如果从Eureka中获取服务列表等，有兴趣可以自己看看。
