Dubbo中集群Cluster,负载均衡,容错,路由解析

Dubbo中的Cluster可以将多个服务提供方伪装成一个提供方,具体也就是将Directory中的多个Invoker伪装成一个Invoker,在伪装的过程中包含了容错的处理,负载均衡的处理和路由的处理。这篇文章介绍下集群相关的东西,开始先对着文档解释下容错模式,负载均衡,路由等概念,然后解析下源码的处理。(稍微有点乱,心情不太好,不适合分析源码。)

集群的容错模式

Failover Cluster

这是dubbo中默认的集群容错模式

  • 失败自动切换,当出现失败,重试其它服务器。
  • 通常用于读操作,但重试会带来更长延迟。
  • 可通过retries=”2”来设置重试次数(不含第一次)。

Failfast Cluster

  • 快速失败,只发起一次调用,失败立即报错。
  • 通常用于非幂等性的写操作,比如新增记录。

Failsafe Cluster

  • 失败安全,出现异常时,直接忽略。
  • 通常用于写入审计日志等操作。

Failback Cluster

    • 失败自动恢复,后台记录失败请求,定时重发。
  • 通常用于消息通知操作。

Forking Cluster

  • 并行调用多个服务器,只要一个成功即返回。
  • 通常用于实时性要求较高的读操作,但需要浪费更多服务资源。
  • 可通过forks=”2”来设置最大并行数。

Broadcast Cluster

  • 广播调用所有提供者,逐个调用,任意一台报错则报错。(2.1.0开始支持)
  • 通常用于通知所有提供者更新缓存或日志等本地资源信息。

负载均衡

dubbo默认的负载均衡策略是random,随机调用。

Random LoadBalance

  • 随机,按权重设置随机概率。
  • 在一个截面上碰撞的概率高,但调用量越大分布越均匀,而且按概率使用权重后也比较均匀,有利于动态调整提供者权重。

RoundRobin LoadBalance

  • 轮循,按公约后的权重设置轮循比率。
  • 存在慢的提供者累积请求问题,比如:第二台机器很慢,但没挂,当请求调到第二台时就卡在那,久而久之,所有请求都卡在调到第二台上。

LeastActive LoadBalance

  • 最少活跃调用数,相同活跃数的随机,活跃数指调用前后计数差。
  • 使慢的提供者收到更少请求,因为越慢的提供者的调用前后计数差会越大。

ConsistentHash LoadBalance

  • 一致性Hash,相同参数的请求总是发到同一提供者。
  • 当某一台提供者挂时,原本发往该提供者的请求,基于虚拟节点,平摊到其它提供者,不会引起剧烈变动。
  • 缺省只对第一个参数Hash。
  • 缺省用160份虚拟节点。

集群相关源码解析

回想一下在服务消费者初始化的过程中,在引用远程服务的那一步,也就是RegistryProtocol的refer方法中,调用了doRefer方法,doRefer方法中第一个参数就是cluster,我们就从这里开始解析。RegistryProtocol的refer方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
url = url.setProtocol(url.getParameter(Constants.REGISTRY_KEY, Constants.DEFAULT_REGISTRY)).removeParameter(Constants.REGISTRY_KEY);
//根据url获取注册中心实例
//这一步连接注册中心,并把消费者注册到注册中心
Registry registry = registryFactory.getRegistry(url);
//对注册中心服务的处理
if (RegistryService.class.equals(type)) {
return proxyFactory.getInvoker((T) registry, type, url);
}
//以下是我们自己定义的业务的服务处理
// group="a,b" or group="*"
Map<String, String> qs = StringUtils.parseQueryString(url.getParameterAndDecoded(Constants.REFER_KEY));
String group = qs.get(Constants.GROUP_KEY);
//服务需要合并不同实现
if (group != null && group.length() > 0 ) {
if ( ( Constants.COMMA_SPLIT_PATTERN.split( group ) ).length > 1
|| "*".equals( group ) ) {
return doRefer( getMergeableCluster(), registry, type, url );
}
}
//这里参数cluster是集群的适配类,代码在下面
return doRefer(cluster, registry, type, url);
}

接着看doRefer,真正去做服务引用的方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
private <T> Invoker<T> doRefer(Cluster cluster, Registry registry, Class<T> type, URL url) {
//Directory中是Invoker的集合,相当于一个List
//也就是说这里面存放了多个Invoker,那么我们该调用哪一个呢?
//该调用哪一个Invoker的工作就是Cluster来处理的
RegistryDirectory<T> directory = new RegistryDirectory<T>(type, url);
directory.setRegistry(registry);
directory.setProtocol(protocol);
URL subscribeUrl = new URL(Constants.CONSUMER_PROTOCOL, NetUtils.getLocalHost(), 0, type.getName(), directory.getUrl().getParameters());
if (! Constants.ANY_VALUE.equals(url.getServiceInterface())
&& url.getParameter(Constants.REGISTER_KEY, true)) {

//到注册中心注册服务 registry.register(subscribeUrl.addParameters(Constants.CATEGORY_KEY, Constants.CONSUMERS_CATEGORY,
Constants.CHECK_KEY, String.valueOf(false)));
}

//订阅服务,注册中心会推送服务消息给消费者,消费者会再次进行服务的引用。 directory.subscribe(subscribeUrl.addParameter(Constants.CATEGORY_KEY,
Constants.PROVIDERS_CATEGORY
+ "," + Constants.CONFIGURATORS_CATEGORY
+ "," + Constants.ROUTERS_CATEGORY));
//服务的引用和变更全部由Directory异步完成
//Directory中可能存在多个Invoker
//而Cluster会把多个Invoker伪装成一个Invoker
//这一步就是做这个事情的
return cluster.join(directory);
}

集群处理的入口

入口就是在doRefer的时候最后一步:cluster.join(directory);

首先解释下cluster,这个是根据dubbo的扩展机制生成的,在RegistryProtocol中有一个setCluster方法,根据扩展机制可以知道,这是注入Cluster的地方,代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import com.alibaba.dubbo.common.extension.ExtensionLoader;
public class Cluster$Adpative implements com.alibaba.dubbo.rpc.cluster.Cluster {

public com.alibaba.dubbo.rpc.Invoker join(com.alibaba.dubbo.rpc.cluster.Directory arg0) throws com.alibaba.dubbo.rpc.cluster.Directory {
if (arg0 == null) throw new IllegalArgumentException("com.alibaba.dubbo.rpc.cluster.Directory argument == null");

if (arg0.getUrl() == null) throw new IllegalArgumentException("com.alibaba.dubbo.rpc.cluster.Directory argument getUrl() == null");com.alibaba.dubbo.common.URL url = arg0.getUrl();

String extName = url.getParameter("cluster", "failover");
if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.cluster.Cluster) name from url(" + url.toString() + ") use keys([cluster])");

com.alibaba.dubbo.rpc.cluster.Cluster extension = (com.alibaba.dubbo.rpc.cluster.Cluster)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.cluster.Cluster.class).getExtension(extName);

return extension.join(arg0);
}
}

可以看到,如果我们没有配置集群策略的话,默认是用failover模式,在Cluster接口的注解上@SPI(FailoverCluster.NAME)也可以看到默认是failover。

继续执行cluster.join方法,会首先进入MockClusterWrapper的join方法:

1
2
3
4
5
6
public <T> Invoker<T> join(Directory<T> directory) throws RpcException {
//先执行FailoverCluster的join方法处理
//然后将Directory和返回的Invoker封装成一个MockCluster
return new MockClusterInvoker<T>(directory,
this.cluster.join(directory));
}

看下Failover的join方法:

1
2
3
4
public <T> Invoker<T> join(Directory<T> directory) throws RpcException {
//直接返回一个FailoverClusterInvoker的实例
return new FailoverClusterInvoker<T>(directory);
}

到这里就算把Invoker都封装好了,返回的Invoker是一个MockClusterInvoker,MockClusterInvoker内部包含一个Directory和一个FailoverClusterInvoker。

Invoker都封装好了之后,就是创建代理,然后使用代理调用我们的要调用的方法。

调用方法时集群的处理

在进行具体方法调用的时候,代理中会invoker.invoke(),这里Invoker就是我们上面封装好的MockClusterInvoker,所以首先进入MockClusterInvoker的invoke方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public Result invoke(Invocation invocation) throws RpcException {
Result result = null;
//我们没配置mock,所以这里为false
//Mock通常用于服务降级
String value = directory.getUrl().getMethodParameter(invocation.getMethodName(), Constants.MOCK_KEY, Boolean.FALSE.toString()).trim();
//没有使用mock
if (value.length() == 0 || value.equalsIgnoreCase("false")){
//这里的invoker是FailoverClusterInvoker
result = this.invoker.invoke(invocation);
} else if (value.startsWith("force")) {
//mock=force:return+null
//表示消费方对方法的调用都直接返回null,不发起远程调用
//可用于屏蔽不重要服务不可用的时候,对调用方的影响
//force:direct mock
result = doMockInvoke(invocation, null);
} else {
//mock=fail:return+null
//表示消费方对该服务的方法调用失败后,再返回null,不抛异常
//可用于对不重要服务不稳定的时候,忽略对调用方的影响
//fail-mock
try {
result = this.invoker.invoke(invocation);
}catch (RpcException e) {
if (e.isBiz()) {
throw e;
} else {
result = doMockInvoke(invocation, e);
}
}
}
return result;
}

我们这里么有配置mock属性。首先进入的是AbstractClusterInvoker的incoke方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public Result invoke(final Invocation invocation) throws RpcException {
//检查是否已经被销毁
checkWheatherDestoried();
//可以看到这里该处理负载均衡的问题了
LoadBalance loadbalance;
//根据invocation中的信息从Directory中获取Invoker列表
//这一步中会进行路由的处理
List<Invoker<T>> invokers = list(invocation);
if (invokers != null && invokers.size() > 0) {
//使用扩展机制,加载LoadBalance的实现类,默认使用的是random
//我们这里得到的就是RandomLoadBalance
loadbalance = ExtensionLoader.getExtensionLoader(LoadBalance.class).getExtension(invokers.get(0).getUrl()
.getMethodParameter(invocation.getMethodName(),Constants.LOADBALANCE_KEY, Constants.DEFAULT_LOADBALANCE));
} else {
loadbalance = ExtensionLoader.getExtensionLoader(LoadBalance.class).getExtension(Constants.DEFAULT_LOADBALANCE);
}
//异步操作默认添加invocation id
RpcUtils.attachInvocationIdIfAsync(getUrl(), invocation);
//调用具体的实现类的doInvoke方法,这里是FailoverClusterInvoker
return doInvoke(invocation, invokers, loadbalance);
}

看下FailoverClusterInvoker的invoke方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public Result doInvoke(Invocation invocation, final List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
//Invoker列表
List<Invoker<T>> copyinvokers = invokers;
//确认下Invoker列表不为空
checkInvokers(copyinvokers, invocation);
//重试次数
int len = getUrl().getMethodParameter(invocation.getMethodName(), Constants.RETRIES_KEY, Constants.DEFAULT_RETRIES) + 1;
if (len <= 0) {
len = 1;
}
// retry loop.
RpcException le = null; // last exception.
List<Invoker<T>> invoked = new ArrayList<Invoker<T>>(copyinvokers.size()); // invoked invokers.
Set<String> providers = new HashSet<String>(len);
for (int i = 0; i < len; i++) {
//重试时,进行重新选择,避免重试时invoker列表已发生变化.
//注意:如果列表发生了变化,那么invoked判断会失效,因为invoker示例已经改变
if (i > 0) {
checkWheatherDestoried();
copyinvokers = list(invocation);
//重新检查一下
checkInvokers(copyinvokers, invocation);
}
//使用loadBalance选择一个Invoker返回
Invoker<T> invoker = select(loadbalance, invocation, copyinvokers, invoked);
invoked.add(invoker);
RpcContext.getContext().setInvokers((List)invoked);
try {
//使用选择的结果Invoker进行调用,返回结果
Result result = invoker.invoke(invocation);
return result;
} catch (RpcException e) {。。。} finally {
providers.add(invoker.getUrl().getAddress());
}
}
throw new RpcException(。。。);
}

先看下使用loadbalance选择invoker的select方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
protected Invoker<T> select(LoadBalance loadbalance, Invocation invocation, List<Invoker<T>> invokers, List<Invoker<T>> selected) throws RpcException {
if (invokers == null || invokers.size() == 0)
return null;
String methodName = invocation == null ? "" : invocation.getMethodName();

//sticky,滞连接用于有状态服务,尽可能让客户端总是向同一提供者发起调用,除非该提供者挂了,再连另一台。
boolean sticky = invokers.get(0).getUrl().getMethodParameter(methodName,Constants.CLUSTER_STICKY_KEY, Constants.DEFAULT_CLUSTER_STICKY) ;
{
//ignore overloaded method
if ( stickyInvoker != null && !invokers.contains(stickyInvoker) ){
stickyInvoker = null;
}
//ignore cucurrent problem
if (sticky && stickyInvoker != null && (selected == null || !selected.contains(stickyInvoker))){
if (availablecheck && stickyInvoker.isAvailable()){
return stickyInvoker;
}
}
}
Invoker<T> invoker = doselect(loadbalance, invocation, invokers, selected);

if (sticky){
stickyInvoker = invoker;
}
return invoker;
}

doselect方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
private Invoker<T> doselect(LoadBalance loadbalance, Invocation invocation, List<Invoker<T>> invokers, List<Invoker<T>> selected) throws RpcException {
if (invokers == null || invokers.size() == 0)
return null;
//只有一个invoker,直接返回,不需要处理
if (invokers.size() == 1)
return invokers.get(0);
// 如果只有两个invoker,退化成轮循
if (invokers.size() == 2 && selected != null && selected.size() > 0) {
return selected.get(0) == invokers.get(0) ? invokers.get(1) : invokers.get(0);
}
//使用loadBalance进行选择
Invoker<T> invoker = loadbalance.select(invokers, getUrl(), invocation);

//如果 selected中包含(优先判断) 或者 不可用&&availablecheck=true 则重试.
if( (selected != null && selected.contains(invoker))
||(!invoker.isAvailable() && getUrl()!=null && availablecheck)){
try{
//重新选择
Invoker<T> rinvoker = reselect(loadbalance, invocation, invokers, selected, availablecheck);
if(rinvoker != null){
invoker = rinvoker;
}else{
//看下第一次选的位置,如果不是最后,选+1位置.
int index = invokers.indexOf(invoker);
try{
//最后在避免碰撞
invoker = index <invokers.size()-1?invokers.get(index+1) :invoker;
}catch (Exception e) {。。。 }
}
}catch (Throwable t){。。。}
}
return invoker;
}

接着看使用loadBalance进行选择,首先进入AbstractLoadBalance的select方法:

1
2
3
4
5
6
7
8
 public <T> Invoker<T> select(List<Invoker<T>> invokers, URL url, Invocation invocation) {
if (invokers == null || invokers.size() == 0)
return null;
if (invokers.size() == 1)
return invokers.get(0);
// 进行选择,具体的子类实现,我们这里是RandomLoadBalance
return doSelect(invokers, url, invocation);
}

接着去RandomLoadBalance中查看:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
int length = invokers.size(); // 总个数
int totalWeight = 0; // 总权重
boolean sameWeight = true; // 权重是否都一样
for (int i = 0; i < length; i++) {
int weight = getWeight(invokers.get(i), invocation);
totalWeight += weight; // 累计总权重
if (sameWeight && i > 0
&& weight != getWeight(invokers.get(i - 1), invocation)) {
sameWeight = false; // 计算所有权重是否一样
}
}
if (totalWeight > 0 && ! sameWeight) {
// 如果权重不相同且权重大于0则按总权重数随机
int offset = random.nextInt(totalWeight);
// 并确定随机值落在哪个片断上
for (int i = 0; i < length; i++) {
offset -= getWeight(invokers.get(i), invocation);
if (offset < 0) {
return invokers.get(i);
}
}
}
// 如果权重相同或权重为0则均等随机
return invokers.get(random.nextInt(length));
}

上面根据权重之类的来进行选择一个Invoker返回。接下来reselect的方法不在说明,是先从非selected的列表中选择,没有在从selected列表中选择。

选择好了Invoker之后,就回去FailoverClusterInvoker的doInvoke方法,接着就是根据选中的Invoker调用invoke方法进行返回结果,接着就是到具体的Invoker进行调用的过程了。这部分的解析在消费者和提供者请求响应过程已经解析过了,不再重复。

路由

回到AbstractClusterInvoker的invoke方法中,这里有一步是List<Invoker<T>> invokers = list(invocation);获取Invoker列表,这里同时也进行了路由的操作,看下list方法:

1
2
3
4
protected  List<Invoker<T>> list(Invocation invocation) throws RpcException {
List<Invoker<T>> invokers = directory.list(invocation);
return invokers;
}

接着看AbstractDirectory的list方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public List<Invoker<T>> list(Invocation invocation) throws RpcException {
if (destroyed){
throw new RpcException("Directory already destroyed .url: "+ getUrl());
}
//RegistryDirectory中的doList实现
List<Invoker<T>> invokers = doList(invocation);
List<Router> localRouters = this.routers; // local reference
if (localRouters != null && localRouters.size() > 0) {
for (Router router: localRouters){
try {
if (router.getUrl() == null || router.getUrl().getParameter(Constants.RUNTIME_KEY, true)) {
//路由选择
//MockInvokersSelector中
invokers = router.route(invokers, getConsumerUrl(), invocation);
}
} catch (Throwable t) {。。。}
}
}
return invokers;
}

路由来过滤之后,进行负载均衡的处理。

坚持原创技术分享,您的支持将鼓励我继续创作!
Fork me on GitHub