前言
在上一章节,我们曾提到这样一个问题:
当调用服务失败后,我们怎么处理当前的请求?抛出异常亦或是重试?
为了解决这个问题,Dubbo 定义了集群接口 Cluster 以及 Cluster Invoker。集群 Cluster 用途是将多个服务提供者合并为一个 Cluster Invoker,并将这个 Invoker 暴露给服务消费者。这样一来,服务消费者只需通过这个 Invoker 进行远程调用即可,至于具体调用哪个服务提供者,以及调用失败后如何处理等问题,现在都交给集群模块去处理。
一、合并
在服务引用的过程中,我们最终会将一个或多个服务提供者Invoker封装成服务目录对象,但最后还要将它合并转换成Cluster Invoker对象。Invoker invoker = cluster.join(directory);
这里的cluster就是扩展点自适应类,在Dubbo中默认是Failover,所以上面代码会调用到:
public class FailoverCluster implements Cluster {
public final static String NAME = "failover";
public <T> Invoker<T> join(Directory<T> directory) throws RpcException {
return new FailoverClusterInvoker<T>(directory);
}
}
上面的代码很简单,所以最后的Invoker对象指向的是FailoverClusterInvoker
实例。它也是一个Invoker,它继承了抽象的AbstractClusterInvoker
。
我们看下AbstractClusterInvoker
类中的invoke方法。
public abstract class AbstractClusterInvoker<T> implements Invoker<T> {
public Result invoke(final Invocation invocation) throws RpcException {
LoadBalance loadbalance = null;
//调用服务目录,获取所有的服务提供者Invoker对象
List<Invoker<T>> invokers = directory.list(invocation);
if (invokers != null && !invokers.isEmpty()) {
//加载负载均衡组件
loadbalance = ExtensionLoader.getExtensionLoader(LoadBalance.class).
getExtension(invokers.get(0).getUrl().
getMethodParameter(invocation.getMethodName(), "loadbalance", "random"));
}
RpcUtils.attachInvocationIdIfAsync(getUrl(), invocation);
//调用子类实现 ,不同的集群容错机制
return doInvoke(invocation, invokers, loadbalance);
}
}
以上代码也很简单,我们分为三个步骤来看
- 调用服务目录,获取所有的服务提供者列表
- 加载负载均衡组件
- 调用子类实现,转发请求
关于负载均衡我们后续再深入了解,这是只知道它负责从多个Invoker中选取一个返回就行。
二、集群容错策略
Dubbo为我们提供了多种集群容错机制。主要如下:
- Failover Cluster - 失败自动切换
FailoverClusterInvoker在调用失败时,会自动切换 Invoker 进行重试。默认配置下,Dubbo 会使用这个类作为缺省 Cluster Invoker。
- Failfast Cluster - 快速失败
FailfastClusterInvoker 只会进行一次调用,失败后立即抛出异常。
- Failsafe Cluster - 失败安全
FailsafeClusterInvoker 当调用过程中出现异常时,仅会打印异常,而不会抛出异常。
- Failback Cluster - 失败自动恢复
FailbackClusterInvoker 会在调用失败后,返回一个空结果给服务提供者。并通过定时任务对失败的调用进行重传,适合执行消息通知等操作。
- Forking Cluster - 并行调用多个服务提供者
ForkingClusterInvoker 会在运行时通过线程池创建多个线程,并发调用多个服务提供者。只要有一个服务提供者成功返回了结果,doInvoke 方法就会立即结束运行。ForkingClusterInvoker 的应用场景是在一些对实时性要求比较高读操作(注意是读操作,并行写操作可能不安全)下使用,但这将会耗费更多的资源。
- BroadcastClusterInvoker - 广播
BroadcastClusterInvoker 会逐个调用每个服务提供者,如果其中一台报错,在循环调用结束后,BroadcastClusterInvoker 会抛出异常。该类通常用于通知所有提供者更新缓存或日志等本地资源信息。
三、自动切换
FailoverClusterInvoker 在调用失败时,会自动切换 Invoker 进行重试。我们重点看它的doInvoke
方法。
public Result doInvoke(Invocation invocation,
final List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
List<Invoker<T>> copyinvokers = invokers;
//检查invokers是否为空
checkInvokers(copyinvokers, invocation);
//获取重试次数 这里默认是3次
int len = getUrl().getMethodParameter(invocation.getMethodName(), "retries",2) + 1;
if (len <= 0) {
len = 1;
}
//异常信息对象
RpcException le = null; // last exception.
List<Invoker<T>> invoked = new ArrayList<Invoker<T>>(copyinvokers.size());
Set<String> providers = new HashSet<String>(len);
//循环调用 失败重试len次
for (int i = 0; i < len; i++) {
if (i > 0) {
checkWhetherDestroyed();
//重新获取服务提供者列表
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 {
//调用服务
Result result = invoker.invoke(invocation);
if (le != null && logger.isWarnEnabled()) {
logger.warn("");
}
return result;
} catch (RpcException e) {
if (e.isBiz()) {
throw e;
}
le = e;
} catch (Throwable e) {
le = new RpcException(e.getMessage(), e);
} finally {
providers.add(invoker.getUrl().getAddress());
}
}
//重试失败
throw new RpcException("");
}
我们可以看到,它的重点是invoker的调用是在一个循环方法中。只要不return,就会一直调用,重试 len 次。我们总结下它的过程:
- 检查invokers是否为空
- 获取重试次数,默认为3
- 进入循环
- 如果是重试,再次获取服务提供者列表,并校验
- 选取Invoker,并调用
- 无异常,返回结果,循环结束
- 捕获到异常,继续循环调用直至重试最大次数
四、快速失败
FailfastClusterInvoker就很简单了,它只会进行一次调用,失败后立即抛出异常。
public Result doInvoke(Invocation invocation,
List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
checkInvokers(invokers, invocation);
Invoker<T> invoker = select(loadbalance, invocation, invokers, null);
try {
return invoker.invoke(invocation);
} catch (Throwable e) {
if (e instanceof RpcException && ((RpcException) e).isBiz()) {
throw (RpcException) e;
}
throw new RpcException("....");
}
}
五、失败安全
FailsafeClusterInvoker跟上面这个差异不大,它调用失败后并不抛出异常。而是打印异常信息并返回一个空的结果对象。
public Result doInvoke(Invocation invocation,
List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
try {
checkInvokers(invokers, invocation);
Invoker<T> invoker = select(loadbalance, invocation, invokers, null);
return invoker.invoke(invocation);
} catch (Throwable e) {
logger.error("Failsafe ignore exception: " + e.getMessage(), e);
return new RpcResult();
}
}
六、自动恢复
FailbackClusterInvoker 会在调用失败后,也是打印异常信息并返回一个空的结果对象,但是还没结束,它还会偷偷开启一个定时任务,再次去调用。
protected Result doInvoke(Invocation invocation,
List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
try {
checkInvokers(invokers, invocation);
Invoker<T> invoker = select(loadbalance, invocation, invokers, null);
return invoker.invoke(invocation);
} catch (Throwable e) {
logger.error("Failback to invoke method " + invocation.getMethodName() + ",
wait for retry in background. Ignored exception: "
+ e.getMessage() + ", ", e);
//添加失败信息
addFailed(invocation, this);
return new RpcResult();
}
}
我们可以看到,调用失败后,除了打印异常信息和返回空结果对象之外,还有一个方法addFailed
它就是开启定时任务的地方。
1、开启定时任务
首先,定义一个包含2个线程的线程池对象。
Executors.newScheduledThreadPool(2, new NamedThreadFactory("failback-cluster-timer", true));
然后,延迟5秒后,每隔5秒调用retryFailed
方法,直到调用成功。
private void addFailed(Invocation invocation, AbstractClusterInvoker<?> router) {
if (retryFuture == null) {
synchronized (this) {
if (retryFuture == null) {
retryFuture = scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
public void run() {
try {
//重试方法
retryFailed();
} catch (Throwable t) {
logger.error("Unexpected error occur at collect statistic", t);
}
}
}, 5000, 5000, TimeUnit.MILLISECONDS);
}
}
}
//ConcurrentHashMap 添加失败任务
failed.put(invocation, router);
}
最后,我们需要注意failed.put(invocation, router);
它将当前失败的任务添加到failed,它是一个ConcurrentHashMap对象。
2、重试
重试的逻辑也不复杂,从failed对象中获取失败的记录,调用即可。
void retryFailed() {
//如果为空,说明已经没有了失败的任务
if (failed.size() == 0) {
return;
}
//遍历failed,对失败的调用进行重试
Set<Entry<Invocation, AbstractClusterInvoker<?>>> failedSet = failed.entrySet();
for (Entry<Invocation, AbstractClusterInvoker<?>> entry : failedSet) {
Invocation invocation = entry.getKey();
Invoker<?> invoker = entry.getValue();
try {
// 再次进行调用
invoker.invoke(invocation);
// 调用成功后,从 failed 中移除 invoker
failed.remove(invocation);
} catch (Throwable e) {
logger.error("......", e);
}
}
}
如上代码,其中的重点是调用成功后,要将invocation移除。当再次调用到这个方法,开头的条件判断成立,就直接返回,不再继续调用。
3、问题
实际上,这套自动恢复的机制是有点小问题的。只要有一次调用失败,就会开启定时任务不断重试调用,直至成功。但问题是,即便重试调用成功后,定时任务并不会关闭,会持续的调用retryFailed
方法。虽然这个方法有个判断,会直接返回。
如果服务调用失败次数多了之后,就会有大量的线程以5s的间隔,不断调用这个方法。
这句话不严谨。当时笔者是新开的消费者端项目,才看到有大量的新建线程;但如果是同一个服务中,自始至终就是一开始创建的2个线程在运行。不过空跑的情况依然存在。
笔者建议,如果有此类需求,不要直接用Dubbo中的这个Cluster。最好利用SPI机制重写一个方法来实现。
七、并行调用
ForkingClusterInvoker 会在运行时通过线程池创建多个线程,并发调用多个服务提供者。只要有一个服务提供者成功返回了结果,doInvoke 方法就会立即结束运行。
public Result doInvoke(final Invocation invocation,
List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
final List<Invoker<T>> selected;
//获取最大并行数 默认为2
final int forks = getUrl().getParameter("forks", 2);
//超时时间
final int timeout = getUrl().getParameter("timeout", 1000);
if (forks <= 0 || forks >= invokers.size()) {
selected = invokers;
} else {
selected = new ArrayList<Invoker<T>>();
//选择Invoker 并添加到selected
for (int i = 0; i < forks; i++) {
Invoker<T> invoker = select(loadbalance, invocation, invokers, selected);
if (!selected.contains(invoker)) {//Avoid add the same invoker several times.
selected.add(invoker);
}
}
}
RpcContext.getContext().setInvokers((List) selected);
final AtomicInteger count = new AtomicInteger();
//阻塞队列 先进先出
final BlockingQueue<Object> ref = new LinkedBlockingQueue<Object>();
for (final Invoker<T> invoker : selected) {
executor.execute(new Runnable() {
@Override
public void run() {
try {
//调用服务 将结果放入队列
Result result = invoker.invoke(invocation);
ref.offer(result);
} catch (Throwable e) {
//如果异常调用次数大于等于最大并行数
int value = count.incrementAndGet();
if (value >= selected.size()) {
ref.offer(e);
}
}
}
});
}
try {
//从队列中获取结果
Object ret = ref.poll(timeout, TimeUnit.MILLISECONDS);
if (ret instanceof Throwable) {
Throwable e = (Throwable) ret;
throw new RpcException("....");
}
return (Result) ret;
} catch (InterruptedException e) {
throw new RpcException(e.getMessage(), e);
}
}
以上代码的重点就是阻塞队列LinkedBlockingQueue。如果有结果放入,poll方法会立即返回,完成整个调用。我们再总结下整体流程:
- 获取最大并行数,默认为2;获取超时时间
- 选择Invoker,并添加到selected
- 通过newCachedThreadPool创建多个线程,调用服务。
- 正常返回后,将结果offer到队列。此时调用流程结束,返回正常信息。
- 调用服务异常后,判断异常次数是否大于等于最大并行数,条件成立则将异常信息offer到队列,此时调用流程结束,返回异常信息。
八、广播
BroadcastClusterInvoker 会逐个调用每个服务提供者,如果其中一台报错,在循环调用结束后,BroadcastClusterInvoker 会抛出异常。
public Result doInvoke(final Invocation invocation,
List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
checkInvokers(invokers, invocation);
RpcContext.getContext().setInvokers((List) invokers);
RpcException exception = null;
Result result = null;
//循环调用服务
for (Invoker<T> invoker : invokers) {
try {
result = invoker.invoke(invocation);
} catch (RpcException e) {
exception = e;
logger.warn(e.getMessage(), e);
} catch (Throwable e) {
exception = new RpcException(e.getMessage(), e);
logger.warn(e.getMessage(), e);
}
}
//异常
if (exception != null) {
throw exception;
}
return result;
}