Dubbo Cluster这个版本有 10 种容错机制每个具体的 Cluster 实现都是创建一个对应的 Invoke

Cluster 层

集群容错层、该层中包含 Cluster、Directory、Router、LoadBalance几大核心接口

CoderLi

这个版本有 10 种容错机制

每个具体的 Cluster 实现都是创建一个对应的 Invoker、然后直接返回

Failover

CoderLi

list(invocation) 从 Directory 中获取提供者的列表
initLoadBalance(invokers, invocation); 选择出负载均衡策略
doInvoke(invocation, invokers, loadbalance) 调用子类具体实现

很明显、这个是一个模板方法

CoderLi

checkInvokers(copyInvokers, invocation) 判断 Invoker 列表是否为空、为空则抛出异常
int len = getUrl().getMethodParameter(methodName, RETRIES_KEY, DEFAULT_RETRIES) + 1; 获取用户配置的重试次数、如果没有则默认是重试 2 次、这里 +1 是因为正常调用
invoked 变脸用于存储已经发起调用过的 Invoker、也就是存在于这个集合里面的、都是调用过发生RPC异常的
当你第一次调用失败之后、那么每一次循环都会重新从 Diretory 中获取最新的 Invoker 列表、因为调用次数是死的、已经失败过一次了、尽可能保证被调用的 Invoker 的质量
select(loadbalance, invocation, copyInvokers, invoked) 根据具体的负载均衡算法算出一个 Invoker

Failfast

CoderLi

Failsafe

CoderLi

Failback

CoderLi

这个后续的调度重试涉及到时间轮的设计、但是我们在这里只要知道它也会重试、这里默认重试的次数是三次

Forking

同时调用多个相同的服务、只要其中一个返回、则立即返回结果。用户可以配置 forking 参数、来确定最大并行调用的服务数量。

通常使用在对接口实时性要求极高的调用上、但会浪费更多的资源

 @Override
 @SuppressWarnings({"unchecked", "rawtypes"})
 public Result doInvoke(final Invocation invocation, List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
     try {
         checkInvokers(invokers, invocation);
         final List<Invoker<T>> selected;
         final int forks = getUrl().getParameter(FORKS_KEY, DEFAULT_FORKS);
         final int timeout = getUrl().getParameter(TIMEOUT_KEY, DEFAULT_TIMEOUT);
         if (forks <= 0 || forks >= invokers.size()) {
             selected = invokers;
         } else {
             selected = new ArrayList<>(forks);
             while (selected.size() < forks) {
                 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<>();
         for (final Invoker<T> invoker : selected) {
             executor.execute(() -> {
                 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("Failed to forking invoke provider " + selected + ", but no luck to perform the invocation. Last error is: " + e.getMessage(), e);
         }
     } finally {
         // clear attachments which is binding to current thread.
         RpcContext.getContext().clearAttachments();
     }
 }