一、ribbon如何集成在openfeign中使用
所有文章
https://www.cnblogs.com/lay2017/p/11908715.html
正文
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中获取服务列表等，有兴趣可以自己看看。
