[享学Ribbon] 二十四、Ribbon具有负载均衡能力的客户端：AbstractLoadBalancerAwareClient

梦里梦外; 2023-07-17 09:56 54阅读 0赞

> 当你想在你的代码中找到一个错误时，这很难；当你认为你的代码是不会有错误时,这就更难了。

[–> 返回Netflix OSS套件专栏汇总 <–][_Netflix OSS_]  
代码下载地址：[https://github.com/f641385712/netflix-learning][https_github.com_f641385712_netflix-learning]

### 目录 ###

*   *  前言
     *  正文
     *   *  AbstractLoadBalancerAwareClient
         *   *  初始化方法
             *  buildLoadBalancerCommand() 构建负载均衡命令
             *  executeWithLoadBalancer() 带有负载均衡能力的执行
         *  ClientFactory
     *  总结
 *  关注A哥

## 前言 ##

Ribbon不仅仅是负载均衡，负载均衡只是它的一个最核心、最出名的模块而已。在聊`ribbon-core`的时候我们知道它有个核心API是`IClient`，它表示发送一个请求得到一个响应，不规定发送方式、协议等。

因为Ribbon最核心的功能就是负载均衡，因此本文我们将了解到它这个具有负载均衡能力的客户端：`AbstractLoadBalancerAwareClient`，它所在的jar是：`ribbon-loadbalancer`。

--------------------

## 正文 ##

### AbstractLoadBalancerAwareClient ###

因为我们不太可能把Ribbon当其它用，而只用作负载均衡，因此你可以简单粗暴理解为：**`AbstractLoadBalancerAwareClient`是所有的客户端实现的顶级父类**，而实际上也确实如此。

需要注意的是，该抽象类不仅实现了接口`IClient`，并且还继承自`LoadBalancerContext`，所以它自己不仅仅是个Client，还拥有着负载均衡上下文。

该抽象类无任何成员属性，提供了一些方法：

--------------------

#### 初始化方法 ####

它提供两个构造器用于初始化。

public abstract class AbstractLoadBalancerAwareClient<S extends ClientRequest, T extends IResponse> extends LoadBalancerContext implements IClient<S, T>, IClientConfigAware { 
    
        public AbstractLoadBalancerAwareClient(ILoadBalancer lb) { 
            super(lb);
        }
        public AbstractLoadBalancerAwareClient(ILoadBalancer lb, IClientConfig clientConfig) { 
            super(lb, clientConfig);        
        }
    
    }

作为一个和负载均衡相关的Client，负载均衡器`ILoadBalancer`是必不可少的喽。

--------------------

#### buildLoadBalancerCommand() 构建负载均衡命令 ####

Ribbon执行所有的请求都是基于命令模式去执行的，因此均需要包装成一个`LoadBalancerCommand`命令：

AbstractLoadBalancerAwareClient：
    
    	// 抽象方法：提供一个RequestSpecificRetryHandler重试处理器
    	// 因为重试方案父类定不了：有些是超时重试，有些是异常重试，因此交给子类去决定为好
    	// 但请保证是RequestSpecificRetryHandler的子类：因为它已经帮你实现了写基本逻辑
    	// 一般使用包装器模式，给RequestSpecificRetryHandler.fallback赋值了就好
    	public abstract RequestSpecificRetryHandler getRequestSpecificRetryHandler(S request, IClientConfig requestConfig);
    	// 毕竟LoadBalancerCommand的属性众多，默认只给其设置必要的属性，其它的交给调用者去个性化吧
    	// 比如常用的：增加监听器来监听必要的执行过程
    	protected void customizeLoadBalancerCommandBuilder(S request, IClientConfig config, LoadBalancerCommand.Builder<T> builder) { 
    		// 空实现，交给子类去定制
    	}
    
    	// request请求对象，提供URI（注意不是URL，因为不一定是网络请求）
        protected LoadBalancerCommand<T> buildLoadBalancerCommand(S request, IClientConfig config) { 
        	// 得到重试处理器：因为重试处理器对LoadBalancerCommand的行为特别重要
    		RequestSpecificRetryHandler handler = getRequestSpecificRetryHandler(request, config);
    		LoadBalancerCommand.Builder<T> builder = LoadBalancerCommand.<T>builder()
    				.withLoadBalancerContext(this)
    				.withRetryHandler(handler)
    				.withLoadBalancerURI(request.getUri());
    		customizeLoadBalancerCommandBuilder(request, config, builder);
    		return builder.build();
    	}

它留下一个抽象方法和一个钩子方法给`AbstractLoadBalancerAwareClient`去完成定制化~

--------------------

#### executeWithLoadBalancer() 带有负载均衡能力的执行 ####

它不是接口方法：因为接口方法不具备负载均衡的能力。但是它是更为重要的方法：包装了`execute()`接口方法，放在`LoadBalancerCommand`里执行从而就具有负载均衡的能力了。

AbstractLoadBalancerAwareClient：
    
    	// 注意：接口方法只有execute，这是在外层套了一个负载均衡器，均由负载均衡的能力
        public T executeWithLoadBalancer(S request) throws ClientException { 
            return executeWithLoadBalancer(request, null);
        }
    
        public T executeWithLoadBalancer(final S request, final IClientConfig requestConfig) throws ClientException { 
        	// 构建一个执行命令：command
        	LoadBalancerCommand<T> command = buildLoadBalancerCommand(request, requestConfig);
    
    
    		// 提交目标操作/目标请求 -> 执行目标方法
        	return command.submit(server -> { 
        		// 根据LB选中的Server，构建出一个最终的URI
        		// 因为你的URI可能没有host、port等是不完整的
        		URI finalUri = reconstructURIWithServer(server, request.getUri());
        		// 给request重新制定一个新的URI
        		S requestForServer = (S) request.replaceUri(finalUri);
        		
        		// execute执行目标方法：一般是发送http请求，当然这不是一定的~
        		return Observable.just(AbstractLoadBalancerAwareClient.this.execute(requestForServer, requestConfig));
        	})
        	// 阻塞的，顺序执行 使用RxJava是为了编程方便、优美
    		.toBlocking()
    		.single();
        }
    }

> 说明：为了代码结构清晰，内嵌的很多try…catch均省略了

该方法的核心要义是：使用`LoadBalancerCommand`包装`execute`目标方法，从而使得其具有了负载均衡的能力。因此在实际应用中：请勿直接调用`execute`方法，而是使用更加上层、功能更强的`executeWithLoadBalancer()`方法。

--------------------

如果仅是在`ribbon-loadbalancer`这个jar内，`IClient`体系有且仅有这一个子类`AbstractLoadBalancerAwareClient`，并且它还是抽象类。由于负载均衡器它并不限定具体协议，比如http、tcp、udp等都是可以做负载均衡的，所以在此jar内**并无任何具体的Client实现类**。

但是在Spring Cloud环境下，一片繁荣：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70_pic_center]  
![在这里插入图片描述][2020032217032627.png_pic_center]  
本文并不会介绍Spring Cloud里对它的实现，而是把它放在和Spring Cloud整合的相关章节中。

--------------------

### ClientFactory ###

既然Client如此重要，为了快速、方便的得到一个Client实例，Ribbon提供了`ClientFactory`这个工厂类。该类用于快速创建`IClient`客户端、`ILoadBalancer`、`IClientConfig`等的工厂。并且它内部还维护了全局的Map，缓存来提高获取效率。

public class ClientFactory { 
    
    	// key是ClientName value是Client实例
    	private static Map<String, IClient<?,?>> simpleClientMap = new ConcurrentHashMap<>();
    	// key是Lb的名称 value是LB实例
    	private static Map<String, ILoadBalancer> namedLBMap = new ConcurrentHashMap<>();
    	// key是ClientName value是该client对应的配置（含默认配置）
    	private static ConcurrentHashMap<String, IClientConfig> namedConfig = new ConcurrentHashMap<>();
    
    	// ==========工具方法们=========
    	
    	// 反射创建一个实例，并且调用其initWithNiwsConfig()方法把config传递给它
    	public static Object instantiateInstanceWithClientConfig(String className, IClientConfig clientConfig) { 
    		...
    		IClientConfigAware obj = (IClientConfigAware) clazz.newInstance();
    		obj.initWithNiwsConfig(clientConfig);
    		return obj;
    	}
    
    	// 反射创建一个clientConfigClass类型的配置。IClientConfig接口的自带实现仅有DefaultClientConfigImpl
    	// 注意config.loadProperties(name)方法会被调用哦（配置会被加载进来）
    	// 最后放进缓存（缓存里就返回缓存里的）
    	public static IClientConfig getNamedConfig(String name, Class<? extends IClientConfig> clientConfigClass) { 
            IClientConfig config = namedConfig.get(name);
            if (config != null) { 
                return config;
            } 
            config = (IClientConfig) clientConfigClass.newInstance();
            config.loadProperties(name);
            ...
            return config;
    	}
        public static IClientConfig getNamedConfig(String name) { 
            return 	getNamedConfig(name, DefaultClientConfigImpl.class);
        }
    
    	... // 创建`ILoadBalancer`实例的方法几乎一模一样，略
    
    	// 提供名称和客户端配置的实用程序方法来创建客户端和负载均衡器(如果在客户端配置中启用)
    	// InitializeNFLoadBalancer默认配置值是true，开启负载均衡器的
    	public static synchronized IClient<?, ?> registerClientFromProperties(String restClientName, IClientConfig clientConfig) throws ClientException { 
        	IClient<?, ?> client = null;
        	ILoadBalancer loadBalancer = null;
        	// 如果同名的Client已经创建过了，在调用此方法就抛错，而并非把缓存里的返回给你
        	if (simpleClientMap.get(restClientName) != null) { 
        		throw new ClientException(ClientException.ErrorType.GENERAL, "A Rest Client with this name is already registered. Please use a different name");
        	}
        	... // 反射创建Client、LB的实例
    		simpleClientMap.put(restClientName, client);
    		return client;
    	}
    
    	// 它木有传入配置：所以全部使用外部化配置
        public static synchronized IClient getNamedClient(String name) { 
            return getNamedClient(name, DefaultClientConfigImpl.class);
        }
        public static synchronized IClient getNamedClient(String name, Class<? extends IClientConfig> configClass) { 
        	if (simpleClientMap.get(name) != null) { 
        	    return simpleClientMap.get(name);
        	}
        	return createNamedClient(name, configClass);
        }
    }

其中`ClientFactory.instantiateInstanceWithClientConfig()`方法是最为通用的：它可以实例化帮你实例化任何实例，包括五大核心组件等。它的优点是初始化完成后自动帮你调用`initWithNiwsConfig()`方法完成属性赋值~

--------------------

## 总结 ##

关于Ribbon具有负载均衡能力的客户端：AbstractLoadBalancerAwareClient就先介绍到这，虽然本文木有提及具体实现类和给出代码示例，但是只要理解了它（其实核心是`LoadBalancerCommand`）你会觉得其它都是小儿科，这在后面讲解整合时将会继续说明。

至此，关于Ribbon最最最核心部分（包含core和loadbalancer）就全部介绍完了，虽然此项目目前已经停更，但**停更不停用**，目前仍然是主流的（甚至是唯一的）客户端负载均衡器。学习了它不仅可以用在Spring Cloud体系下运用自如，对于理解dubbo等框架负载均衡机制都易如反掌，另外据我了解深入了解Ribbon，以及有能力使用它来实现多区域部署的人并不多，因此若你掌握了这不就是你升职加薪的砝码了麽~

当然，这不是Ribbon系列的全部，后面还要讲整合、在Spring Cloud下的实战。有了强大的理论做支撑，实战讲解将非常的快。

--------------------

# 关注A哥 #

<table> 
 <thead> 
  <tr> 
   <th>Author</th> 
   <th><a href="https://www.yourbatman.cn/about" rel="nofollow">A哥(YourBatman)</a></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>个人站点</td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow">www.yourbatman.cn</a></td> 
  </tr> 
  <tr> 
   <td>E-mail</td> 
   <td>yourbatman@qq.com</td> 
  </tr> 
  <tr> 
   <td><strong>微 信</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat.png" rel="nofollow">fsx641385712</a></td> 
  </tr> 
  <tr> 
   <td><strong><code>活跃平台</code></strong></td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow"><img src="https://img-blog.csdnimg.cn/2020071015182276.png" alt=""></a> <a href="https://fangshixiang.blog.csdn.net/" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151913394.png" alt=""></a><a href="https://yourbatman.cnblogs.com" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151929355.png" alt=""></a><a href="https://juejin.im/user/5b44d178f265da0fa1220efe/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151938937.png" alt=""></a><a href="https://www.zhihu.com/people/fangshixiang/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151950629.png" alt=""></a><a href="https://www.jianshu.com/u/8740f1fdd684" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152000530.png" alt=""></a><a href="https://segmentfault.com/u/yourbatman/articles" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152008726.png" alt=""></a><a href="https://github.com/yourbatman" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152015895.png" alt=""></a></td> 
  </tr> 
  <tr> 
   <td><strong>公众号</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat_channel.jpg" rel="nofollow">BAT的乌托邦（ID：BAT-utopia）</a></td> 
  </tr> 
  <tr> 
   <td>知识星球</td> 
   <td><a href="https://t.zsxq.com/nQBi66I" rel="nofollow">BAT的乌托邦</a></td> 
  </tr> 
  <tr> 
   <td>每日文章推荐</td> 
   <td><a href="https://github.com/yourbatman/reading/issues" rel="nofollow">每日文章推荐</a></td> 
  </tr> 
 </tbody> 
</table>

![BAT的乌托邦][BAT]

![往期精选][20200211101926949.gif_pic_center]

*  [\[享学Ribbon\] 一、源生Ribbon介绍 — 客户端负载均衡器][Ribbon_ _Ribbon_ _]
 *  [\[享学Ribbon\] 二、Ribbon核心API源码解析：ribbon-core（一）IClient请求客户端][Ribbon_ _Ribbon_API_ribbon-core_IClient]
 *  [\[享学Ribbon\] 三、Ribbon核心API源码解析：ribbon-core（二）IClientConfig配置详解][Ribbon_ _Ribbon_API_ribbon-core_IClientConfig]
 *  [\[享学Ribbon\] 四、Ribbon核心API源码解析：ribbon-core（三）RetryHandler重试处理器][Ribbon_ _Ribbon_API_ribbon-core_RetryHandler]
 *  [\[享学Ribbon\] 五、Ribbon核心API源码解析：ribbon-core（四）ClientException及常用工具][Ribbon_ _Ribbon_API_ribbon-core_ClientException]
 *  [\[享学Ribbon\] 六、Ribbon的LoadBalancer五大组件之：IPing心跳检测][Ribbon_ _Ribbon_LoadBalancer_IPing]
 *  [\[享学Ribbon\] 七、Ribbon的LoadBalancer五大组件之：ServerList服务列表][Ribbon_ _Ribbon_LoadBalancer_ServerList]
 *  [\[享学Ribbon\] 八、netflix-statistics详解，手把手教你写个超简版监控系统][Ribbon_ _netflix-statistics]
 *  [\[享学Ribbon\] 九、Ribbon服务器状态：ServerStats及其断路器原理][Ribbon_ _Ribbon_ServerStats]
 *  [\[享学Ribbon\] 十、Ribbon负载均衡策略服务器状态总控：LoadBalancerStats][Ribbon_ _Ribbon_LoadBalancerStats]
 *  [\[享学Ribbon\] 十一、Ribbon多区域选择：ZoneAvoidanceRule.getAvailableZones()获取可用区][Ribbon_ _Ribbon_ZoneAvoidanceRule.getAvailableZones]
 *  [\[享学Ribbon\] 十二、Ribbon服务器过滤逻辑的基础组件：AbstractServerPredicate][Ribbon_ _Ribbon_AbstractServerPredicate]
 *  [\[享学Ribbon\] 十三、Ribbon的LoadBalancer五大组件之：ServerListFilter服务列表过滤器][Ribbon_ _Ribbon_LoadBalancer_ServerListFilter]
 *  [\[享学Ribbon\] 十四、Ribbon的LoadBalancer五大组件之：ServerListUpdater服务列表更新器][Ribbon_ _Ribbon_LoadBalancer_ServerListUpdater]
 *  [\[享学Ribbon\] 十五、Ribbon的LoadBalancer五大组件之：IRule（一）轮询和加权轮询][Ribbon_ _Ribbon_LoadBalancer_IRule]
 *  [\[享学Ribbon\] 十六、Ribbon的LoadBalancer五大组件之：IRule（二）应用于大规模集群的可配置规则][Ribbon_ _Ribbon_LoadBalancer_IRule 1]
 *  [\[享学Ribbon\] 十七、Ribbon的LoadBalancer五大组件之：IRule（三）随机和重试，所有IRule实现总结][Ribbon_ _Ribbon_LoadBalancer_IRule_IRule]
 *  [\[享学Ribbon\] 十八、Ribbon启动连接操作：IPrimeConnection检测Server是否能够提供服务][Ribbon_ _Ribbon_IPrimeConnection_Server]
 *  [\[享学Ribbon\] 十九、Ribbon负载均衡器执行上下文：LoadBalancerContext][Ribbon_ _Ribbon_LoadBalancerContext]
 *  [\[享学Ribbon\] 二十、Ribbon负载均衡器ILoadBalancer（一）：BaseLoadBalancer][Ribbon_ _Ribbon_ILoadBalancer_BaseLoadBalancer]
 *  [\[享学Ribbon\] 二十一、Ribbon负载均衡器ILoadBalancer（二）：ZoneAwareLoadBalancer具备区域意识、动态服务列表的负载均衡器][Ribbon_ _Ribbon_ILoadBalancer_ZoneAwareLoadBalancer]
 *  [\[享学Ribbon\] 二十二、Ribbon负载均衡命令：LoadBalancerCommand（一）基础类打点][Ribbon_ _Ribbon_LoadBalancerCommand]
 *  [\[享学Ribbon\] 二十三、Ribbon负载均衡命令：LoadBalancerCommand（二）执行目标请求][Ribbon_ _Ribbon_LoadBalancerCommand 1]

[_Netflix OSS_]: https://fangshixiang.blog.csdn.net/article/details/105610114
[https_github.com_f641385712_netflix-learning]: https://github.com/f641385712/netflix-learning
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70_pic_center]: /images/20230528/a99ab5bbc73d4ce6baaaa1fc40ec0464.png
[2020032217032627.png_pic_center]: /images/20230528/6199a15a3a184c8b8641ea248fd82a01.png
[BAT]: /images/20230528/1207fbddaac947ea980cd66b400b17a1.png
[20200211101926949.gif_pic_center]: /images/20230528/8bad9472001a42c4adc11444639551ff.png
[Ribbon_ _Ribbon_ _]: https://blog.csdn.net/f641385712/article/details/104761814
[Ribbon_ _Ribbon_API_ribbon-core_IClient]: https://fangshixiang.blog.csdn.net/article/details/104806463
[Ribbon_ _Ribbon_API_ribbon-core_IClientConfig]: https://fangshixiang.blog.csdn.net/article/details/104871585
[Ribbon_ _Ribbon_API_ribbon-core_RetryHandler]: https://fangshixiang.blog.csdn.net/article/details/104875799
[Ribbon_ _Ribbon_API_ribbon-core_ClientException]: https://blog.csdn.net/f641385712/article/details/104882126
[Ribbon_ _Ribbon_LoadBalancer_IPing]: https://fangshixiang.blog.csdn.net/article/details/104809962
[Ribbon_ _Ribbon_LoadBalancer_ServerList]: https://fangshixiang.blog.csdn.net/article/details/104885950
[Ribbon_ _netflix-statistics]: https://fangshixiang.blog.csdn.net/article/details/104895744
[Ribbon_ _Ribbon_ServerStats]: https://fangshixiang.blog.csdn.net/article/details/104890298
[Ribbon_ _Ribbon_LoadBalancerStats]: https://fangshixiang.blog.csdn.net/article/details/104912207
[Ribbon_ _Ribbon_ZoneAvoidanceRule.getAvailableZones]: https://fangshixiang.blog.csdn.net/article/details/104926520
[Ribbon_ _Ribbon_AbstractServerPredicate]: https://fangshixiang.blog.csdn.net/article/details/104923271
[Ribbon_ _Ribbon_LoadBalancer_ServerListFilter]: https://fangshixiang.blog.csdn.net/article/details/104890138
[Ribbon_ _Ribbon_LoadBalancer_ServerListUpdater]: https://blog.csdn.net/f641385712/article/details/104955068
[Ribbon_ _Ribbon_LoadBalancer_IRule]: https://blog.csdn.net/f641385712/article/details/104853741
[Ribbon_ _Ribbon_LoadBalancer_IRule 1]: https://fangshixiang.blog.csdn.net/article/details/104970813
[Ribbon_ _Ribbon_LoadBalancer_IRule_IRule]: https://fangshixiang.blog.csdn.net/article/details/104976057
[Ribbon_ _Ribbon_IPrimeConnection_Server]: https://fangshixiang.blog.csdn.net/article/details/104995069
[Ribbon_ _Ribbon_LoadBalancerContext]: https://fangshixiang.blog.csdn.net/article/details/104999023
[Ribbon_ _Ribbon_ILoadBalancer_BaseLoadBalancer]: https://fangshixiang.blog.csdn.net/article/details/104835170
[Ribbon_ _Ribbon_ILoadBalancer_ZoneAwareLoadBalancer]: https://fangshixiang.blog.csdn.net/article/details/105018224
[Ribbon_ _Ribbon_LoadBalancerCommand]: https://fangshixiang.blog.csdn.net/article/details/105027272
[Ribbon_ _Ribbon_LoadBalancerCommand 1]: https://fangshixiang.blog.csdn.net/article/details/104849753