Dubbo源码：集群容错

大致流程

消费者在生成代理对象后，调用RPC服务的方法，会执行代理对象的方法，因为创建代理对象的时候会传入一个InvocationHandler对象，这个对象是代理对象的一个属性，并且这个对象持有Invoker对象，Invoker对象是Dubbo领域模型中的核心模型，是实体域，包含这个RPC服务的所有信息。
代理对象对象中其实就是调用这个Invoker的invoker()方法，所以就会执行到AbstractClusterInvoker类的invoker()方法，这个方法是集群容错的父类，里面封装了集群容错会用到的一些公共方法，比如调用list()从RegistryDirectory中获取到获取Invoker列表，选择一个负载均衡器（LoadBalance），还有select()也就是负载均衡方法等等。

AbstractClusterInvoker还有一个doInvoke()的模板方法，具体实现调用逻辑和容错逻辑子类实现。下面就来看下它的几个主要实现类。

FailoverClusterInvoker：失败切换

是默认的容错机制，会先根据配置获取配置的重试次数，默认是3次。然后循环调用，如果不是第一次调用会调用list()重选列举服务目录。然后负载均衡选择Invoker，并且把选中后的Invoker记录下来，当失败重试的时候如果再次选到，会重新选择一次。最后调用Invoker的invoker()，成功则返回结果。如果调用失败会记录异常信息，然后重试。直到超出重试次数后，会抛出异常，告诉服务调用失败了。
通常用于读操作，但重试会带来更长延迟。 可通过retries="2"来设置重试次数（不含第一次）。

public Result doInvoke(Invocation invocation, final List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
        List<Invoker<T>> copyinvokers = invokers;
        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++) {
           
            if (i > 0) {
                checkWhetherDestroyed();
                // 在进行重试前重新列举 Invoker，这样做的好处是，如果某个服务挂了，
                // 通过调用 list 可得到最新可用的 Invoker 列表
                copyinvokers = list(invocation);
                // check again
                checkInvokers(copyinvokers, invocation);
            }
            // 通过负载均衡选择 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()) { // biz exception.
                    throw e;
                }
                le = e;
            } catch (Throwable e) {
                le = new RpcException(e.getMessage(), e);
            } finally {
                providers.add(invoker.getUrl().getAddress());
            }
        }
        // 若重试失败，则抛出异常
        throw new RpcException("....");
    }

FailbackClusterInvoker：失败恢复

会在调用失败后，把任务放入到一个ConcurrentMap中，并启动一个延时任务去消费这个Map，最后返回一个空结果给服务消费者。适合执行消息通知等操作。

    protected Result doInvoke(Invocation invocation, List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
        try {
            checkInvokers(invokers, invocation);
            // 负载均衡算法，选择Invoker
            Invoker<T> invoker = select(loadbalance, invocation, invokers, null);
            // 调用
            return invoker.invoke(invocation);
        } catch (Throwable e) {
            // 如果调用过程中发生异常，此时仅打印错误日志，不抛出异常
            logger.error("...");
            // 添加到失败列表中，定时重试
            addFailed(invocation, this);
            // 返回空结果
            return new RpcResult(); // ignore
        }
    }
private void addFailed(Invocation invocation, AbstractClusterInvoker<?> router) {
        if (retryFuture == null) {
            synchronized (this) {
                if (retryFuture == null) {
                    retryFuture = scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {

                        public void run() {
                            // collect retry statistics
                            try {
                                // 五秒重试
                                retryFailed();
                            } catch (Throwable t) { // Defensive fault tolerance
                                logger.error("Unexpected error occur at collect statistic", t);
                            }
                        }
                    }, RETRY_FAILED_PERIOD, RETRY_FAILED_PERIOD, TimeUnit.MILLISECONDS);
                }
            }
        }
        failed.put(invocation, router);
    }

    void retryFailed() {
        if (failed.size() == 0) {
            return;
        }
        // 重试失败列表
        for (Map.Entry<Invocation, AbstractClusterInvoker<?>> entry : new HashMap<Invocation, AbstractClusterInvoker<?>>(failed).entrySet()) {
            Invocation invocation = entry.getKey();
            Invoker<?> invoker = entry.getValue();
            try {
                invoker.invoke(invocation);
                failed.remove(invocation);
            } catch (Throwable e) {
                logger.error("....");
            }
        }
    }

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()) { // biz exception.
                throw (RpcException) e;
            }
            throw new RpcException(e);
        }
    }

FailsafeClusterInvoker：失败安全

当调用过程中出现异常时，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(); // ignore
        }
    }

ForkingClusterInvoker：并行调用多个服务提供者

会在运行时通过线程池创建多个线程，并发调用多个服务提供者，然后把结果放入BlockingQueue中，如果所有都调用失败，Queue中放的就是失败的异常信息。只要有一个服务提供者成功返回了，Queue中放的就是结果，最后从阻塞队列中取结果，如果取到的结果是异常就抛出，是结果就正常返回。
主要应用场景是在一些对实时性要求比较高读操作。

public Result doInvoke(final Invocation invocation, List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
        checkInvokers(invokers, invocation);
        final List<Invoker<T>> selected;
        final int forks = getUrl().getParameter(Constants.FORKS_KEY, Constants.DEFAULT_FORKS);
        final int timeout = getUrl().getParameter(Constants.TIMEOUT_KEY, Constants.DEFAULT_TIMEOUT);
        if (forks <= 0 || forks >= invokers.size()) {
            selected = invokers;
        } else {
            selected = new ArrayList<Invoker<T>>();
            for (int i = 0; i < forks; i++) {
                // TODO. Add some comment here, refer chinese version for more details.
                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() {
                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(e);
            }
            return (Result) ret;
        } catch (InterruptedException e) {
            throw new RpcException("");
        }
    }

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;
    }