就这些吗
就这些吗

Dubbo集群容错——Cluster

本系列主要参考官网文档、芋道源码的源码解读和《深入理解Apache Dubbo与实战》一书。Dubbo版本为2.6.1。

文章内容顺序：

  1. 什么是集群容错
  • 1.1 集群容错以及Cluster概念的介绍
  • 1.2 集群容错的总体工作流程
  • 1.3 Directory的简单介绍
  1. Cluster和ClusterInvoker的结构及代码分析
  • 2.1 Cluster的UML图
  • 2.2 以FailoverCluster为例的Cluster介绍
  1. ClusterInvoker的代码分析
  • 3.1 ClusterInvoker的工作原理
  • 3.2 AbstractClusterInvoker#invoke
  • 3.3 FailoverClusterInvoker#doInvoke
  • 3.4 AbstractClusterInvoker#select
  • 3.5 AbstractClusterInvoker#doselect
  • 3.6 FailbackClusterInvoker
  • 3.7 FailfastClusterInvoker
  • 3.8 FailsafeClusterInvoker
  • 3.9 ForkingClusterInvoker
  • 3.10 BroadcastClusterInvoker

1. 什么是集群容错

1.1 集群容错以及Cluster概念的介绍

为了避免单点故障，现在的应用通常至少会部署在两台服务器上。对于一些负载比较高的服务，会部署更多的服务器。这样，在同一环境下的服务提供者数量会大于1。对于服务消费者来说，同一环境下出现了多个服务提供者。
这时会出现一个问题，服务消费者需要决定选择哪个服务提供者进行调用。另外服务调用失败时的处理措施也是需要考虑的，是重试呢，还是抛出异常，亦或是只打印异常等。
为了处理这些问题，Dubbo 定义了集群接口 Cluster 以及 Cluster Invoker。集群 Cluster 用途是将多个服务提供者合并为一个 Cluster Invoker，并将这个 Invoker 暴露给服务消费者。
这样一来，服务消费者只需通过这个 Invoker 进行远程调用即可，至于具体调用哪个服务提供者，以及调用失败后如何处理等问题，现在都交给集群模块去处理。集群模块是服务提供者和服务消费者的中间层，为服务消费者屏蔽了服务提供者的情况，这样服务消费者就可以专心处理远程调用相关事宜。比如发请求，接受服务提供者返回的数据等。这就是集群的作用。


image.png

这张图相信都看到过，这次要聊的就是Cluster层的这几个东西，也就是整套集群容错机制。

1.2 集群容错的总体工作流程

image.png

在这之前先说说Cluster的总体工作流程，

  • 1.先生成Invoker对象，根据不同的Cluster实现生成不同类型的ClusterInvoker（这个就是服务引用阶段）
  • 2.调用list从Directory中获取可用的服务列表（从这一步开始真正的调用流程）,接着使用Router接口根据路由规则过滤一部分服务后最终返回服务列表
  • 3.调用select做负载均衡，通过不同的负载均衡策略选出一个服务作为最后的调用
  • 4.调用invoke做RPC调用，对于调用出现异常、成功、失败等情况，每种容错机制会有不同的处理方式。

1.3 Directory的简单介绍

书接上文服务引用，在ReferenceConfig#createproxy或者在RegistryProtocol#doRefer中，会有Cluster 合并多个 Invoker的操作，如下，这些Invoker是同一个接口在不同Provider上的这个方法的实体，如我们上文提到的，服务通常是以集群的形式出现。下图中这个directory可以看成是一个Invoker的容器，在下面的Directory章节中会细讲。

image.png

2. Cluster结构及代码分析

2.1 Cluster的UML图

那么我们就来看看这个Cluster是何方神圣吧。


image.png

我们可以看到，每个 Cluster 实现类，对应一个专属于其的 Invoker 实现类。
有关Cluster的扩展包装类MockClusterWrapper会在Dubbo集群容错——Mock中细讲，这边只说包装类里面的各个Cluster实现。

下面，我们一个一个子类往下看。

2.2 以FailoverCluster为例的Cluster介绍

FailoverCluster

public class FailoverCluster implements Cluster {

    public final static String NAME = "failover";

    @Override
    public  Invoker join(Directory directory) throws RpcException {
// 创建并返回 FailoverClusterInvoker 对象
        return new FailoverClusterInvoker(directory);
    }

}

其他的Cluster实现也是一样，join方法就直接返回了一个XXXClusterInvoker
所以接下来，我们把重点放在各种 Cluster Invoker 上

3. ClusterInvoker的代码分析

3.1 ClusterInvoker的工作原理

我们首先从各种 Cluster Invoker 的父类 AbstractClusterInvoker 源码开始说起。前面说过，集群工作过程可分为两个阶段，

  • 第一个阶段是在服务消费者初始化期间的join。
  • 第二个阶段是在服务消费者进行远程调用时，此时 AbstractClusterInvoker 的 >invoke 方法会被调用。列举 Invoker，负载均衡等操作均会在此阶段被执行。也就是各种 Cluster Invoker的具体实现。
    因此下面先来看一下 invoke 方法的逻辑。

3.2 AbstractClusterInvoker#invoke

public Result invoke(final Invocation invocation) throws RpcException {
        // 校验是否销毁
        checkWhetherDestroyed();

        // 获得所有服务提供者 Invoker 集合
        List> invokers = list(invocation);

        // 获得 LoadBalance 对象
        LoadBalance loadbalance;
        if (invokers != null && !invokers.isEmpty()) {
            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);
        }
        // 若是异步调用，设置调用编号
        RpcUtils.attachInvocationIdIfAsync(getUrl(), invocation);

        // 执行调用
        return doInvoke(invocation, invokers, loadbalance);
    }

// 抽象方法，由子类实现
protected abstract Result doInvoke(Invocation invocation, List> invokers,
                                       LoadBalance loadbalance) throws RpcException;

AbstractClusterInvoker#invoke 方法主要用于列举 Invoker，以及加载 LoadBalance。最后再调用模板方法 doInvoke 进行后续操作。
Invoker 列举方法 list(Invocation) 的逻辑，主要就是调用Directory#list方法，留到Directory篇再做介绍。
接下来，我们把目光转移到 AbstractClusterInvoker 的各种实现类上，来看一下这些实现类是如何实现 doInvoke 方法逻辑的。

3.3 FailoverClusterInvoker#doInvoke

 public Result doInvoke(Invocation invocation, final List> invokers, LoadBalance loadbalance) throws RpcException {
        List> copyinvokers = invokers;
        // 检查copyinvokers即可用Invoker集合是否为空，如果为空，那么抛出异常
        checkInvokers(copyinvokers, invocation);
        // 得到最大可调用次数：最大可重试次数+1，默认最大可重试次数Constants.DEFAULT_RETRIES=2
        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.
        // 保存已经调用过的Invoker
        List> invoked = new ArrayList>(copyinvokers.size()); // invoked invokers.
        Set providers = new HashSet(len);
        // failover机制核心实现：如果出现调用失败，那么重试其他服务器
        for (int i = 0; i < len; i++) {
            // 在进行重试前重新列举 Invoker，这样做的好处是，如果某个服务挂了，
                // 通过调用 list 可得到最新可用的 Invoker 列表
            if (i > 0) {
                checkWhetherDestroyed();
                // 根据Invocation调用信息从Directory中获取所有可用Invoker
                copyinvokers = list(invocation);
                // 对 copyinvokers 进行判空检查
                checkInvokers(copyinvokers, invocation);
            }
            // 根据负载均衡机制从copyinvokers中选择一个Invoker
            Invoker invoker = select(loadbalance, invocation, copyinvokers, invoked);
            // 保存每次调用的Invoker
            invoked.add(invoker);
            // 设置已经调用的 Invoker 集合到RPC 上下文中
            RpcContext.getContext().setInvokers((List) invoked);
            try {
                // RPC 调用得到 Result
                Result result = invoker.invoke(invocation);
                // 重试过程中，将最后一次调用的异常信息以 warn 级别日志输出
                if (le != null && logger.isWarnEnabled()) {
                    logger.warn("Although retry the method " + invocation.getMethodName()
                            + " in the service " + getInterface().getName()
                            + " was successful by the provider " + invoker.getUrl().getAddress()
                            + ", but there have been failed providers " + providers
                            + " (" + providers.size() + "/" + copyinvokers.size()
                            + ") from the registry " + directory.getUrl().getAddress()
                            + " on the consumer " + NetUtils.getLocalHost()
                            + " using the dubbo version " + Version.getVersion() + ". Last error is: "
                            + le.getMessage(), le);
                }
                return result;
            } catch (RpcException e) {
                // 如果是业务性质的异常，不再重试，直接抛出
                if (e.isBiz()) { // biz exception.
                    throw e;
                }
                // 其他性质的异常统一封装成RpcException
                le = e;
            } catch (Throwable e) {
                le = new RpcException(e.getMessage(), e);
            } finally {
                providers.add(invoker.getUrl().getAddress());
            }
        }
        // 最大可调用次数用完还得到Result的话，抛出RpcException异常：重试了N次还是失败，并输出最后一次异常信息
        throw new RpcException(le.getCode(), "Failed to invoke the method " + invocation.getMethodName()
                + " in the service " + getInterface().getName()
                + ". Tried " + len + " times of the providers "
                + providers + " (" + providers.size() + "/" + copyinvokers.size()
                + ") from the registry " + directory.getUrl().getAddress()
                + " on the consumer " + NetUtils.getLocalHost()
                + " using the dubbo version " + Version.getVersion()
                + ". Last error is: " + le.getMessage(), le.getCause() != null ? le.getCause() : le);
    }

}

FailoverClusterInvoker#doInvoke 方法首先是获取重试次数，然后根据重试次数进行循环调用，失败后进行重试。
在 for 循环内，首先是通过负载均衡组件选择一个Invoker，然后再通过这个 Invoker 的invoke 方法进行远程调用。
如果失败了，记录下异常，并进行重试。重试时会再次调用AbstractClusterInvoker#list 方法列举 Invoker。（这个方法会调用到Directory#list）
注意上面代码中有调用一个select方法来通过负载均衡选择 Invoker
这个select是写在父类AbstractClusterInvoker里的，来看看他是怎么负载均衡的。

3.4 AbstractClusterInvoker#select

protected Invoker select(LoadBalance loadbalance, Invocation invocation, List> invokers, List> selected) throws RpcException {
        if (invokers == null || invokers.isEmpty()) {
            return null;
        }
        // 获得 sticky 配置项，方法级
        String methodName = invocation == null ? "" : invocation.getMethodName();
 // 获取 sticky 配置，sticky 表示粘滞连接。所谓粘滞连接是指让服务消费者尽可能的
    // 调用同一个服务提供者，除非该提供者挂了再进行切换
        boolean sticky = invokers.get(0).getUrl().getMethodParameter(methodName, Constants.CLUSTER_STICKY_KEY, Constants.DEFAULT_CLUSTER_STICKY);
        {
          // 检测 invokers 列表是否包含 stickyInvoker，如果不包含，
        // 说明 stickyInvoker 代表的服务提供者挂了，此时需要将其置空
            if (stickyInvoker != null && !invokers.contains(stickyInvoker)) {
                stickyInvoker = null;
            }
         // 在 sticky 为 true，且 stickyInvoker != null 的情况下。如果 selected 不包含 
        // stickyInvoker，表明 stickyInvoker 对应的服务提供者可能因网络原因未能成功提供服务。
        // 但是该提供者并没挂，此时 invokers 列表中仍存在该服务提供者对应的 Invoker。
            if (sticky && stickyInvoker != null && (selected == null || !selected.contains(stickyInvoker))) {
             // availablecheck 表示是否开启了可用性检查，如果开启了，则调用 stickyInvoker 的 
            // isAvailable 方法进行检查，如果检查通过，则直接返回 stickyInvoker。
                if (availablecheck && stickyInvoker.isAvailable()) {
                    return stickyInvoker;
                }
            }
        }

       // 如果线程走到当前代码处，说明前面的 stickyInvoker 为空，或者不可用。
    // 此时继续调用 doSelect 选择 Invoker
        Invoker invoker = doselect(loadbalance, invocation, invokers, selected);

         // 如果 sticky 为 true，则将负载均衡组件选出的 Invoker 赋值给 stickyInvoker
        if (sticky) {
            stickyInvoker = invoker;
        }
        return invoker;
    }

粘滞连接的概念：粘滞连接用于有状态服务，尽可能让客户端总是向同一提供者发起调用，除非该提供者挂了，再连另一台。
粘滞连接将自动开启延迟连接，以减少长连接数。

  • select 方法的主要逻辑集中在了对粘滞连接特性的支持上。首先是获取 sticky 配置，然后再检测 invokers列表中是否包含 stickyInvoker，如果不包含，则认为该 stickyInvoker 不可用，此时将其置空。
  • 这里的invokers列表可以看做是存活着的服务提供者列表，如果这个列表不包含 stickyInvoker，那自然而然的认为 stickyInvoker挂了，所以置空。
  • 如果 stickyInvoker存在于invokers列表中，此时要进行下一项检测 — 检测 selected 中是否包含 stickyInvoker。如果包含的话，说明 stickyInvoker在此之前没有成功提供服务（但其仍然处于存活状态）。此时我们认为这个服务不可靠，不应该在重试期间内再次被调用，因此这个时候不会返回该 stickyInvoker。
  • 如果 selected 不包含 stickyInvoker，此时还需要进行可用性检测，比如检测服务提供者网络连通性等。
  • 当可用性检测通过，才可返回 stickyInvoker，否则调用 doSelect方法选择 Invoker。如果 sticky 为 true，此时会将doSelect 方法选出的 Invoker 赋值给 stickyInvoker。

来看一下他doSelect 选择 Invoker是怎么做的

3.5 AbstractClusterInvoker#doselect

private Invoker doselect(LoadBalance loadbalance, Invocation invocation, List> invokers, List> selected) throws RpcException {
        if (invokers == null || invokers.isEmpty()) {
            return null;
        }
        // 【第一种】如果只有一个 Invoker ，直接选择
        if (invokers.size() == 1) {
            return invokers.get(0);
        }
        // 【第二种】如果只有两个 Invoker ，退化成轮循
        // If we only have two invokers, use round-robin instead.
        if (invokers.size() == 2 && selected != null && !selected.isEmpty()) {
            return selected.get(0) == invokers.get(0) ? invokers.get(1) : invokers.get(0);
        }

        // 【第三种】使用 Loadbalance ，选择一个 Invoker 对象。
        Invoker invoker = loadbalance.select(invokers, getUrl(), invocation);

        // If the `invoker` is in the  `selected` or invoker is unavailable && availablecheck is true, reselect.
        // 如果 selected中包含（优先判断） 或者 不可用&&availablecheck=true 则重试.
        if ((selected != null && selected.contains(invoker))
                || (!invoker.isAvailable() && getUrl() != null && availablecheck)) {
            try {
                //【第四种】重选一个 Invoker 对象
                Invoker rinvoker = reselect(loadbalance, invocation, invokers, selected, availablecheck);
                if (rinvoker != null) {
                    invoker = rinvoker;
                } else {
                    // Check the index of current selected invoker, if it's not the last one, choose the one at index+1.
                    // 【第五种】看下第一次选的位置，如果不是最后，选+1位置.
                    int index = invokers.indexOf(invoker);
                    try {
                        // Avoid collision
                        // 最后在避免碰撞
                        invoker = index < invokers.size() - 1 ? invokers.get(index + 1) : invoker;
                    } catch (Exception e) {
                        logger.warn(e.getMessage() + " may because invokers list dynamic change, ignore.", e);
                    }
                }
            } catch (Throwable t) {
                logger.error("clustor relselect fail reason is :" + t.getMessage() + " if can not slove ,you can set cluster.availablecheck=false in url", t);
            }
        }
        return invoker;
    }

reselect 方法总结下来其实只做了两件事情，第一是查找可用的 Invoker，并将其添加到 reselectInvokers 集合中。第二，如果 reselectInvokers 不为空，则通过负载均衡组件再次进行选择。
第一种：如果只有一个候选的 Invoker 对象，直接选择返回
第二种：如果只有两个候选的 Invoker 集合，退化为轮询。此处存在一个 BUG ：
转载自我飞哥，《dubbo 源码 - 负载均衡》

这里退化成轮询的实现有问题，对应源码return selected.get(0) == invokers.get(0) ? invokers.get(1) : invokers.get(0)；如果retries=4，即最多调用5次，且两个可选invoke分别为：

10.0.0.1:20884，10.0.0.1:20886；

那么5次选择的invoke为：

  • 10.0.0.1:20884
  • 10.0.0.1:20886
  • 10.0.0.1:20886
  • 10.0.0.1:20886
  • 10.0.0.1:20886，

即除了第1次外后面的选择都是选择第二个invoker;

因次需要把selected.get(0)修改为：selected.get(selected.size()-1)；

即每次拿前一次选择的invoker与 invokers.get(0)比较，如果相同，则选则另一个invoker；否则就选 invokers.get(0)；

第三种：调用Loadbalance#select(invokers, url, invocation)方法，使用 Loadbalance ，选择一个 Invoker 对象。
第四种：调用 #reselect(loadbalance, invocation, invokers, selected, availablecheck)方法，重新选择一个 Invoker 对象。
第五种：顺序从候选的 invokers 集合中，选择一个 Invoker 对象，不考虑是否可用，或者已经选择过

这个loadbalance对象，从AbstractClusterInvoker#invoke通过SPI加载以来，在各个方法里传了这么久，终于在AbstractClusterInvoker#doselect里调用了，我们会在Dubbo集群容错——LoadBalance中详细分析
FailoverClusterInvoker就此也讲的差不多了，接下来看看其他的ClusterInvoker

3.6 FailbackClusterInvoker

ublic class FailbackClusterInvoker extends AbstractClusterInvoker {

    private static final long RETRY_FAILED_PERIOD = 5 * 1000;

    private final ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2,
            new NamedInternalThreadFactory("failback-cluster-timer", true));

    private final ConcurrentMap> failed = new ConcurrentHashMap>();
    private volatile ScheduledFuture retryFuture;

    @Override
    protected Result doInvoke(Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
        try {
  // 检查 invokers 即可用Invoker集合是否为空，如果为空，那么抛出异常
            checkInvokers(invokers, invocation);
           // 根据负载均衡机制从 invokers 中选择一个Invoker
            Invoker invoker = select(loadbalance, invocation, invokers, null);
            // RPC 调用得到 Result
            return invoker.invoke(invocation);
        } catch (Throwable e) {
            // 如果调用过程中发生异常，此时仅打印错误日志，不抛出异常
            logger.error("Failback to invoke method ...");
            
            // 记录调用信息
            addFailed(invocation, this);
            // 返回一个空结果给服务消费者
            return new RpcResult();
        }
    }

    private void addFailed(Invocation invocation, AbstractClusterInvoker router) {
        if (retryFuture == null) {
            synchronized (this) {
                if (retryFuture == null) {
                    // 创建定时任务，每隔5秒执行一次
                    retryFuture = scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {

                        @Override
                        public void run() {
                            try {
                                // 对失败的调用进行重试
                                retryFailed();
                            } catch (Throwable t) {
                                // 如果发生异常，仅打印异常日志，不抛出
                                logger.error("Unexpected error occur at collect statistic", t);
                            }
                        }
                    }, RETRY_FAILED_PERIOD, RETRY_FAILED_PERIOD, TimeUnit.MILLISECONDS);
                }
            }
        }
        
        // 添加 invocation 和 invoker 到 failed 中
        failed.put(invocation, router);
    }

    void retryFailed() {
        if (failed.size() == 0) {
            return;
        }
        
        // 遍历 failed，对失败的调用进行重试
        for (Map.Entry> entry : new HashMap>(failed).entrySet()) {
            Invocation invocation = entry.getKey();
            Invoker invoker = entry.getValue();
            try {
                // 再次进行调用
                invoker.invoke(invocation);
                // 调用成功后，从 failed 中移除 invoker
                failed.remove(invocation);
            } catch (Throwable e) {
                // 仅打印异常，不抛出
                logger.error("Failed retry to invoke method ...");
            }
        }
    }
}

这个类主要由3个方法组成，首先是 doInvoker，该方法负责初次的远程调用。若远程调用失败，则通过addFailed方法将调用信息存入到failed中，等待定时重试。
addFailed 在开始阶段会根据retryFuture 为空与否，来决定是否开启定时任务。
retryFailed方法则是包含了失败重试的逻辑，该方法会对failed 进行遍历，然后依次对 Invoker进行调用。调用成功则将 Invoker 从 failed 中移除，调用失败则忽略失败原因。

3.7 FailfastClusterInvoker

public class FailfastClusterInvoker extends AbstractClusterInvoker {

    @Override
    public Result doInvoke(Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
        checkInvokers(invokers, invocation);
          // 检查 invokers 即可用Invoker集合是否为空，如果为空，那么抛出异常
        Invoker invoker = select(loadbalance, invocation, invokers, null);
        try {
            // RPC 调用得到 Result
            return invoker.invoke(invocation);
        } catch (Throwable e) {
            if (e instanceof RpcException && ((RpcException) e).isBiz()) {
                // 若是业务性质的异常，直接抛出
                throw (RpcException) e;
            }
             // 封装 RpcException 异常，并抛出
            throw new RpcException(..., "Failfast invoke providers ...");
        }
    }
}

FailfastClusterInvoker 只会进行一次调用，失败后立即抛出异常。适用于幂等操作，比如新增记录。

3.8 FailsafeClusterInvoker


public class FailsafeClusterInvoker extends AbstractClusterInvoker {

    @Override
    public Result doInvoke(Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
        try {
      // 检查 invokers 即可用Invoker集合是否为空，如果为空，那么抛出异常
            checkInvokers(invokers, invocation);
          // 根据负载均衡机制从 invokers 中选择一个Invoker
            Invoker invoker = select(loadbalance, invocation, invokers, null);
            // 进行远程调用
            return invoker.invoke(invocation);
        } catch (Throwable e) {
            // 打印错误日志，但不抛出
            logger.error("Failsafe ignore exception: " + e.getMessage(), e);
            // 返回空结果忽略错误
            return new RpcResult();
        }
    }
}

FailsafeClusterInvoker 是一种失败安全的 Cluster Invoker。所谓的失败安全是指，当调用过程中出现异常时，FailsafeClusterInvoker仅会打印异常，而不会抛出异常。适用于写入审计日志等操作。

3.9 ForkingClusterInvoker

public class ForkingClusterInvoker extends AbstractClusterInvoker {
    public Result doInvoke(final Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
        // 检查 invokers 即可用Invoker集合是否为空，如果为空，那么抛出异常
        checkInvokers(invokers, invocation);
        // 保存选择的 Invoker 集合
        final List> selected;
        // 得到最大并行数，默认为 Constants.DEFAULT_FORKS = 2
        final int forks = getUrl().getParameter(Constants.FORKS_KEY, Constants.DEFAULT_FORKS);
        // 获得调用超时时间，默认为 DEFAULT_TIMEOUT = 1000 毫秒
        final int timeout = getUrl().getParameter(Constants.TIMEOUT_KEY, Constants.DEFAULT_TIMEOUT);
        // 若最大并行书小于等于 0，或者大于 invokers 的数量，直接使用 invokers
        if (forks <= 0 || forks >= invokers.size()) {
            selected = invokers;
        } else {
            // 循环，根据负载均衡机制从 invokers，中选择一个个Invoker ，从而组成 Invoker 集合。
            // 注意，因为增加了排重逻辑，所以不能保证获得的 Invoker 集合的大小，小于最大并行数
            selected = new ArrayList>();
            for (int i = 0; i < forks; i++) {
                // 在invoker列表(排除selected)后,如果没有选够,则存在重复循环问题.见select实现.
                Invoker invoker = select(loadbalance, invocation, invokers, selected);
                if (!selected.contains(invoker)) { //Avoid add the same invoker several times. //防止重复添加invoker
                    selected.add(invoker);
                }
            }
        }
        // 设置已经调用的 Invoker 集合，到 Context 中
        RpcContext.getContext().setInvokers((List) selected);
        // 异常计数器
        final AtomicInteger count = new AtomicInteger();
        // 创建阻塞队列
        final BlockingQueue ref = new LinkedBlockingQueue();
        // 循环 selected 集合，提交线程池，发起 RPC 调用
        for (final Invoker invoker : selected) {
            executor.execute(new Runnable() {
                public void run() {
                    try {
                        // RPC 调用，获得 Result 结果
                        Result result = invoker.invoke(invocation);
                        // 添加 Result 到 `ref` 阻塞队列
                        ref.offer(result);
                    } catch (Throwable e) {
                        // 异常计数器 + 1
                        int value = count.incrementAndGet();
                        // 若 RPC 调结果都是异常，则添加异常到 `ref` 阻塞队列
                        if (value >= selected.size()) {
                            ref.offer(e);
                        }
                    }
                }
            });
        }
        try {
            // 从 `ref` 队列中，阻塞等待结果
            Object ret = ref.poll(timeout, TimeUnit.MILLISECONDS);
            // 若是异常结果，抛出 RpcException 异常
            if (ret instanceof Throwable) {
                Throwable e = (Throwable) ret;
                throw new RpcException(e instanceof RpcException ? ((RpcException) e).getCode() : 0, "Failed to forking invoke provider " + selected + ", but no luck to perform the invocation. Last error is: " + e.getMessage(), e.getCause() != null ? e.getCause() : e);
            }
            // 若是正常结果，直接返回
            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);
        }
    }

}
 
 
 
  
ForkingClusterInvoker 会在运行时通过线程池创建多个线程，并发调用多个服务提供者。只要有一个服务提供者成功返回了结果，doInvoke 方法就会立即结束运行。ForkingClusterInvoker 的应用场景是在一些对实时性要求比较高读操作（注意是读操作，并行写操作可能不安全）下使用，但这将会耗费更多的资源。
 
 
 
 
注意这一段代码
 
 
catch (Throwable e) {
                        // 异常计数器 + 1
                        int value = count.incrementAndGet();
                        // 若 RPC 调结果都是异常，则添加异常到 `ref` 阻塞队列
                        if (value >= selected.size()) {
                            ref.offer(e);
                        }
                    }

 
 
 
  
在并行调用多个服务提供者的情况下，只要有一个服务提供者能够成功返回结果，而其他全部失败。此时ForkingClusterInvoker 仍应该返回成功的结果，而非抛出异常。在value >= selected.size()时将异常对象放入阻塞队列中，可以保证异常对象不会出现在正常结果的前面，这样可从阻塞队列中优先取出正常的结果。
 
 
 
 
3.10 BroadcastClusterInvoker
 
 
public class BroadcastClusterInvoker extends AbstractClusterInvoker {
    public Result doInvoke(final Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
        // 检查 invokers 即可用Invoker集合是否为空，如果为空，那么抛出异常
        checkInvokers(invokers, invocation);
        // 设置已经调用的 Invoker 集合，到 Context 中
        RpcContext.getContext().setInvokers((List) invokers);
        // 保存最后一次调用的异常
        RpcException exception = null;
        // 保存最后一次调用的结果
        Result result = null;
        // 循环候选的 Invoker 集合，调用所有 Invoker 对象。
        for (Invoker invoker : invokers) {
            try {
                // 发起 RPC 调用
                result = invoker.invoke(invocation);
            } catch (RpcException e) {
                exception = e;
                logger.warn(e.getMessage(), e);
            } catch (Throwable e) {
                exception = new RpcException(e.getMessage(), e); // 封装成 RpcException 异常
                logger.warn(e.getMessage(), e);
            }
        }
        // 若存在一个异常，抛出该异常
        if (exception != null) {
            throw exception;
        }
        return result;
    }

}

 
 
 
  
BroadcastClusterInvoker 会逐个调用每个服务提供者，如果其中一台报错，在循环调用结束后，BroadcastClusterInvoker 会抛出异常。该类通常用于通知所有提供者更新缓存或日志等本地资源信息。
 
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Dubbo集群容错——Cluster)

        

            

                
    
                    
  • 四章-32-点要素的聚合
                        彩云飘过

                        
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    
                    
    • 
                    
  • MongoDB知识概括
                        GeorgeLin98
持久层mongodb
                        
    MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
    
                    
    • 
                    
  • 02-Cesium聚合分析EntityCluster完整代码
                        fxshy
htmlcssjavascript
                        
    1.完整代码Document-->-->Cesium.Ion.defaultAccessToken='eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJhZjZkZDAwZC1mNTFhLTRhOTEtOGExNi00MzRhNGIzMDdlNDQiLCJpZCI6MTA1MTUzLCJpYXQiOjE2NjA4MDg0Njd9.qajeJtc4-kp
    
                    
    • 
                    
  • 98_es生产集群部署之针对集群重启时的shard恢复耗时过长问题定制的重要参数
                        小山居

                        
    98_es生产集群部署之针对集群重启时的shard恢复耗时过长问题定制的重要参数shardrecovery配置以及集群重启时的无意义shard重分配问题在集群重启的时候，有一些配置会影响shard恢复的过程。首先，我们需要理解默认配置下，shard恢复过程会发生什么事情。如果我们有10个node，每个node都有一个shard，可能是primaryshard或者replicashard，你有一个i
    
                    
    • 
                    
  • Hadoop
                        傲雪凌霜，松柏长青
后端大数据hadoop大数据分布式
                        
    ApacheHadoop是一个开源的分布式计算框架，主要用于处理海量数据集。它具有高度的可扩展性、容错性和高效的分布式存储与计算能力。Hadoop核心由四个主要模块组成，分别是HDFS（分布式文件系统）、MapReduce（分布式计算框架）、YARN（资源管理）和HadoopCommon（公共工具和库）。1.HDFS（HadoopDistributedFileSystem）HDFS是Hadoop生
    
                    
    • 
                    
  • 【Kubernetes】常见面试题汇总（十一）
                        summer.335
Kuberneteskubernetes容器云原生
                        
    目录33.简述Kubernetes外部如何访问集群内的服务？34.简述Kubernetesingress？35.简述Kubernetes镜像的下载策略？33.简述Kubernetes外部如何访问集群内的服务？（1）对于Kubernetes，集群外的客户端默认情况，无法通过Pod的IP地址或者Service的虚拟IP地址：虚拟端口号进行访问。（2）通常可以通过以下方式进行访问Kubernetes集群
    
                    
    • 
                    
  • k8s中Service暴露的种类以及用法
                        听说唐僧不吃肉
K8Skubernetes容器云原生
                        
    一、说明在Kubernetes中，有几种不同的方式可以将服务（Service）暴露给外部流量。这些方式通过定义服务的spec.type字段来确定。二、详解1.ClusterIP定义：默认类型，服务只能在集群内部访问。作用：通过集群内部IP地址暴露服务。示例：spec:type:ClusterIPports:-port:80targetPo
    
                    
    • 
                    
  • Kubernetes 自定义控制器开发
                        IT回忆录
Kubeneteskubernetes
                        
    目录前言一、CRD二、创建数据库表（Mysql）二、控制器开发1.使用kubernetes的examplecontroller模板2.在controller.go中新增数据表监听方法3.修改tools工具生成资源对象结构体定义这里记录开发k8s控制器的一般方式，controller开发主要使用k8s提供的client-go库进行。前言Controller监听集群内部资源对象的变化，编辑资源对象(增
    
                    
    • 
                    
  • 【K8s】专题十一：Kubernetes 集群证书过期处理方法
                        行者Sun1989
Kuberneteskubernetes云原生容器
                        
    本文内容均来自个人笔记并重新梳理，如有错误欢迎指正！如果对您有帮助，烦请点赞、关注、转发、订阅专栏！专栏订阅入口Linux专栏|Docker专栏|Kubernetes专栏往期精彩文章【Docker】（全网首发）KylinV10下MySQL容器内存占用异常的解决方法【Docker】（全网首发）KylinV10下MySQL容器内存占用异常的解决方法（续）【Docker】MySQL源码构建Docker镜
    
                    
    • 
                    
  • 华为云分布式缓存服务DCS与开源服务差异对比
                        hcinfo_18
redis使用华为云Redis5.0分布式缓存服务Redis客户端
                        
    分布式缓存服务DCS提供单机、主备、集群等丰富的实例类型，满足用户高读写性能及快速数据访问的业务诉求。支持丰富的实例管理操作，帮助用户省去运维烦恼。用户可以聚焦于业务逻辑本身，而无需过多考虑部署、监控、扩容、安全、故障恢复等方面的问题。DCS基于开源Redis、Memcached向用户提供一定程度定制化的缓存服务，因此，除了拥有开源服务缓存数据库的优秀特性，DCS提供更多实用功能。一、与开源Red
    
                    
    • 
                    
  • 在服务器计算节点中使用 jupyter Lab
                        ranshan567
程序人生
                        
    JupyterLab是一个基于网页的交互式开发环境,用于科学计算、数据分析和机器学.jupyterlab是jupyternotebook的下一代产品,集成了更多功能,使用起来更方便.在进行数据分析及可视化时，个人电脑不能满足大数据的分析需求，就需要用到高性能计算机集群资源，然而计算机集群的计算节点往往没有联网功能，所以在计算机集群中使用jupyterLab需要进行一些配置。具体的步骤如下：
    
                    
    • 
                    
  • Dubbo架构概览：服务注册与发现、远程调用、监控与管理
                        木南曌
dubbo架构
                        
    Dubbo是一个成熟的、高性能的、基于Java的微服务开发框架，它主要用于解决分布式系统中的服务治理问题，包括服务的注册与发现、远程过程调用（RPC）、服务监控与管理等多个关键环节。以下是Dubbo架构概览的详细介绍：服务注册与发现Dubbo的服务注册与发现机制是其核心功能之一，它依赖于注册中心来管理服务的生命周期和定位服务提供者。1.服务提供者（Provider）服务提供者是实际提供服务的节点，
    
                    
    • 
                    
  • 老生常谈：MySQL高可用架构
                        我有一头小花驴
mysql架构数据库
                        
    引言“高可用”是互联网一个永恒的话题，先避开MySQL不谈，为了保证各种服务的高可用有几种常用的解决方案。服务冗余：把服务部署多份，当某个节点不可用时，切换到其他节点。服务冗余对于无状态的服务是相对容易的。服务备份：有些服务是无法同时存在多个运行时的，比如说：Nginx的反向代理，一些集群的leader节点。这时可以存在一个备份服务，处于随时待命状态。自动切换：服务冗余之后，当某个节点不可用时，要
    
                    
    • 
                    
  • 重读《新生-七年就是一辈子》- 26 不能容错的系统肯定是脆弱的
                        greenorchid

                        
    读后感想：我觉得自己的容错能力在学生，同事、朋友方面都还好，毕竟我很少和他们交流。但是，我对家人有时做的不好，容错能力反而较差，因此，有时会影响心情、注意力等。看了这篇文章，我能做到平心静气，不乱发脾气吗？我觉得有时能做到，很多时候可能还是做不到。读书笔记：今天的计算机科学里（包括它的“邻居”工程学里），都有一个重要的概念：容错（Faulttolerance）如果一个系统不能容错，那么它就是脆弱的
    
                    
    • 
                    
  • MySQL MHA
                        pokemon..
mysql数据库
                        
    一、MySQLMHA高可用环境概述1.什么是MHAMHA（MasterHighAvailability）是一款用于MySQL数据库集群的高可用解决方案，主要解决MySQL单点故障问题。在MySQL集群的主服务器发生故障时，MHA可以自动执行故障切换，将一个从服务器提升为新的主服务器，最大限度地保证数据的一致性。MHA的切换时间通常在0-30秒之间，极大提高了MySQL集群的可用性。2.MHA的组成
    
                    
    • 
                    
  • 关于Redis集群同步/持久化/淘汰机制的详解
                        尾巴尖上的阳光
大数据redis数据库
                        
    Redis是非常常用的KV数据库,使用内存以及HashMap进行存储的特点带来了高效的查询.本文将围绕Redis的常见开发使用场景,阐述在Redis集群中各个节点是如何进行数据同步,每个节点如何进行持久化以及在长期使用中如何对数据进行更新和淘汰.如果对Redis有更多的兴趣,可以查看我的技术博客:https://dingyuqi.com下面是Redis在开发过程中常用的几种使用场景.集群Redis
    
                    
    • 
                    
  • ETCD 六 etcd总体架构
                        wanghaichao1234
etcdetcd架构数据库
                        
    etcd源码结构etcd项目代码的目录结构：包名用途apiprotobuf定义client/v3客户端sdkcontribraftexample实现etcdctl命令行客户端实现，用于网路的操作etcdutl命令行管理工具，直接操作etcd数据文件。hack基准测试、测试集群、k8s部署、分支管理、证书等pkg实用程序包的集合raftraft实现server.auth角色身份验证server.em
    
                    
    • 
                    
  • 主流行架构
                        rainbowcheng
架构架构
                        
    nexus，gitlab,svn,jenkins,sonar,docker，apollo，catteambition，axure，蓝湖，禅道,WCP；redis，kafka，es，zookeeper，dubbo，shardingjdbc，mysql，InfluxDB，Telegraf，Grafana，Nginx，xxl-job，Neo4j,NebulaGraph是一个高性能的,NOSQL图形数据库
    
                    
    • 
                    
  • 【YashanDB知识库】YashanDB 开机自启
                        YashanDB
YashanDB知识库数据库数据库系统崖山数据库YashanDBoracle
                        
    【问题分类】YashanDB开机自启【关键字】开机自启，依赖包【问题描述】数据库所在服务器重启后只拉起monit、yasom、yasom进程，缺少yasdb进程：【问题原因分析】数据库安装的时候未启动守护进程【解决/规避方法】进入数据库之前的安装目录，启动守护进程：Shellcd/home/yashan/install./bin/yasbootmonitstart--clusteryashandb
    
                    
    • 
                    
  • 深入解析 Dubbo 的 attachments 机制及其应用场景
                        molashaonian
dubboattachments隐式传参
                        
    背景在分布式系统中，服务之间的调用（RPC调用）是非常常见的。而在这种服务调用过程中，常常需要在不同服务之间传递一些上下文信息，比如用户身份信息、请求追踪ID、客户端IP等。Dubbo提供的attachments机制，能够帮助开发者在RPC调用时隐式传递这些数据，而不需要修改接口方法签名。通过分析架构图，我们可以看到，在服务调用链路中，使用Dubbo的attachments机制可以简化上下文信息的
    
                    
    • 
                    
  • 【K8S】kubernetes集群架构与组件
                        奇奇怪怪^
云LinuxIT运维服务器linux
                        
    文章目录【K8S】kubernetes集群架构与组件kubernetes组件**master组件**node组件整体流程POD终止过程【K8S】kubernetes集群架构与组件kubernetes组件K8S是属于主从设备模型(Master-slave架构)，即有Master节点负责集群的调度、管理和运维，Slave节点是集群中的运算工作负载节点在K8S中，主节点一般被称为Master节点，而从节
    
                    
    • 
                    
  • Kubernetes——组件
                        窒息う
Kuberneteskubernetes容器
                        
    文章目录K8S的优势核心架构角色与功能集群图例K8S的优势能管理大量跨主机容器快速部署应用快速扩展应用无缝对接新的应用节省资源，优化硬件资源的使用核心架构master（管理节点）node（计算节点）images（镜像节点）角色与功能Master功能提供集群的控制对集群进行全局决策检测和响应集群事件Master节点核心组件APIServer是整个系统的对外接口，提供客户端和其他组件调用后端元数据存储
    
                    
    • 
                    
  • Kubernetes组件
                        汉只只
网络docker大数据分布式hadoop
                        
    Kubernetes核心组件Kubernetes定义了一组构建块，它们可以共同提供部署、维护和扩展应用程序的机制。组成Kubernetes的组件设计为松耦合和可扩展的，这样可以满足多种不同的工作负载。可扩展性在很大程度上由KubernetesAPI提供——它被作为扩展的内部组件以及Kubernetes上运行的容器等使用。Kubernetes主要由以下几个核心组件组成：etcd保存了整个集群的状态；
    
                    
    • 
                    
  • 【Linux 从基础到进阶】Kubernetes 集群搭建与管理
                        爱技术的小伙子
Linux从基础到进阶linuxkubernetes运维
                        
    Kubernetes集群搭建与管理Kubernetes（简称K8s）是一个用于自动化部署、扩展和管理容器化应用程序的开源平台。它提供了容器编排功能，能够管理大量的容器实例，并支持应用的自动扩展、高可用性和自愈能力。本文将详细介绍如何在CentOS和Ubuntu系统上安装和配置Kubernetes集群，并讲解Kubernetes的基本概念和管理操作。1.Kubernetes基础概念在了解如何搭建Ku
    
                    
    • 
                    
  • Spark集群的三种模式
                        MelodyYN
#Sparksparkhadoopbigdata
                        
    文章目录1、Spark的由来1.1Hadoop的发展1.2MapReduce与Spark对比2、Spark内置模块3、Spark运行模式3.1Standalone模式部署配置历史服务器配置高可用运行模式3.2Yarn模式安装部署配置历史服务器运行模式4、WordCount案例1、Spark的由来定义：Hadoop主要解决，海量数据的存储和海量数据的分析计算。Spark是一种基于内存的快速、通用、可
    
                    
    • 
                    
  • 【集群架构中的故障集合】_nfs connection reset by peer
                        2024云技术
2024年程序员学习架构javalinux
                        
    3.Connectionrefused连接拒绝检查是否能ping通对应服务器[12:41root@backup~]#rsync-avz/etc176.16.1.31:/tmpssh:connecttohost176.16.1.31port22:Connectionrefusedrsync:connectionunexpectedlyclosed(0bytesreceivedsofar)[sende
    
                    
    • 
                    
  • 自己实现一个简易RPC调用框架
                        殷俊杰

                        
    最近在看dubbo，去创始人之一梁飞大神的博客搂了几眼，找到这个demo自己实现了一下，关于dubbo就不再介绍了，快速开始、框架设计、设计原则官网都有，有兴趣可以自己看Dubbo官网1.服务接口packagecom.yjj.my.api;/***@Description:*@Author:yinjunjie*@CreateDate:2018/8/713:16*@Version:1.0*/publ
    
                    
    • 
                    
  • Redis 集群
                        確定饿的猫
redislinux
                        
    目录Redis主从复制Redis主从复制简介Redis主从复制的作用Redis主从复制流程搭建Redis主从复制master节点slave节点验证哨兵故障转移机制部署哨兵Redis集群作用数据分区高可用Redis集群Redis高可用实现的方式有持久化、主从复制、哨兵、集群，与持久化不同，另外三种方式都是属于集群，之前已经分析了解过两种持久化模式了，现在了解另外几种方式Redis主从复制Redis主
    
                    
    • 
                    
  • 为什么需要DDos高防服务器呢？
                        666IDCaaa
ddos服务器网络
                        
    在当今信息化快速发展的时代，网络安全问题显得尤为重要。DDoS攻击是一种耗尽系统资源的攻击方式，可以导致正常服务请求无法得到响应。这种攻击不仅影响用户体验，还可能导致企业声誉受损、经济损失以及客户流失等严重后果。因此，选择有效的DDoS高防服务对于保护网络安全至关重要。DDoS高防服务可以通过云端清洗集群、数据库监控牵引系统等技术进行有效的削弱。这些技术能够识别并过滤恶意流量，确保正常用户能够顺利
    
                    
    • 
                    
  • 论文分享系列（二）——论微服务架构及其应用
                        马斯洛金字塔下的小灵猴儿
#软考高项架构师论微服务架构及其应用论文
                        
    论微服务架构及其应用摘要2023年5月，我司启动了精彩购电商系统的开发工作，该项目组中我担任系统架构师岗位，主要负责整体架构设计与中间件选型。本文以该电商平台为例，将介绍微服务架构的特点、应用场景以及实现方法。系统以SpringCloud微服务框架开发，分为前端Web服务、平台保障服务、业务服务三部分。前端Web服务由负载均衡与服务器集群结合，实现高并发的前台界面；平台保障服务以Eureka为中心
    
                    
    • 
                                
  • 深入浅出Java Annotation(元注解和自定义注解）
                                    Josh_Persistence
Java Annotation元注解自定义注解
                                    
    一、基本概述 
  
  
　　 Annontation是Java5开始引入的新特征。中文名称一般叫注解。它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。 
  
　　更通俗的意思是为程序的元素（类、方法、成员变量）加上更直观更明了的说明，这些说明信息是与程序的业务逻辑无关，并且是供指定的工具或
    
                                
    • 
                                
  • mysql优化特定类型的查询
                                    annan211
java工作mysql
                                    
    

本节所介绍的查询优化的技巧都是和特定版本相关的，所以对于未来mysql的版本未必适用。

1 优化count查询
  对于count这个函数的网上的大部分资料都是错误的或者是理解的都是一知半解的。在做优化之前我们先来看看
  真正的count()函数的作用到底是什么。
  count()是一个特殊的函数，有两种非常不同的作用，他可以统计某个列值的数量，也可以统计行数。
  在统
    
                                
    • 
                                
  • MAC下安装多版本JDK和切换几种方式
                                    棋子chessman
jdk
                                    
    环境： 
MAC AIR,OS X 10.10,64位 
  
历史： 
过去 Mac 上的 Java 都是由 Apple 自己提供，只支持到 Java 6，并且OS X 10.7 开始系统并不自带（而是可选安装）（原自带的是1.6）。 
后来 Apple 加入 OpenJDK 继续支持 Java 6，而 Java 7 将由 Oracle 负责提供。 
  
在终端中输入jav
    
                                
    • 
                                
  • javaScript （1）
                                    Array_06
JavaScriptjava浏览器
                                    
    JavaScript 
 
1、运算符 
　　运算符就是完成操作的一系列符号，它有七类： 　　赋值运算符（=,+=,-=,*=,/=,%=,<<=,>>=,|=,&=）、算术运算符(+,-,*,/,++,--,%)、比较运算符(>,<,<=,>=,==,===,!=,!==)、逻辑运算符(||,&&,!)、条件运算(?:)、位
    
                                
    • 
                                
  • 国内顶级代码分享网站
                                    袁潇含
javajdkoracle.netPHP
                                    
           现在国内很多开源网站感觉都是为了利益而做的 
  
        
       当然利益是肯定的,否则谁也不会免费的去做网站 
  
   &
    
                                
    • 
                                
  • Elasticsearch、MongoDB和Hadoop比较
                                    随意而生
mongodbhadoop搜索引擎
                                    
        
IT界在过去几年中出现了一个有趣的现象。很多新的技术出现并立即拥抱了“大数据”。稍微老一点的技术也会将大数据添进自己的特性，避免落大部队太远，我们看到了不同技术之间的边际的模糊化。假如你有诸如Elasticsearch或者Solr这样的搜索引擎，它们存储着JSON文档，MongoDB存着JSON文档，或者一堆JSON文档存放在一个Hadoop集群的HDFS中。你可以使用这三种配
    
                                
    • 
                                
  • mac os 系统科研软件总结
                                    张亚雄
mac os
                                    
    1.1 Microsoft Office for Mac 2011 
     大客户版，自行搜索。 
     1.2 Latex （MacTex）: 
     系统环境：https://tug.org/mactex/ 
    &nb
    
                                
    • 
                                
  • Maven实战（四）生命周期
                                    AdyZhang
maven
                                    
    1. 三套生命周期     Maven拥有三套相互独立的生命周期，它们分别为clean，default和site。 每个生命周期包含一些阶段，这些阶段是有顺序的，并且后面的阶段依赖于前面的阶段，用户和Maven最直接的交互方式就是调用这些生命周期阶段。 以clean生命周期为例，它包含的阶段有pre-clean, clean 和 post
    
                                
    • 
                                
  • Linux下Jenkins迁移
                                    aijuans
Jenkins
                                    
    1. 将Jenkins程序目录copy过去       源程序在/export/data/tomcatRoot/ofctest-jenkins.jd.com下面                tar -cvzf jenkins.tar.gz ofctest-jenkins.jd.com &
    
                                
    • 
                                
  • request.getInputStream()只能获取一次的问题
                                    ayaoxinchao
requestInputstream
                                    
    问题：在使用HTTP协议实现应用间接口通信时，服务端读取客户端请求过来的数据，会用到request.getInputStream()，第一次读取的时候可以读取到数据，但是接下来的读取操作都读取不到数据        
原因：   1. 一个InputStream对象在被读取完成后，将无法被再次读取，始终返回-1；   2. InputStream并没有实现reset方法（可以重
    
                                
    • 
                                
  • 数据库SQL优化大总结之 百万级数据库优化方案
                                    BigBird2012
SQL优化
                                    
    网上关于SQL优化的教程很多，但是比较杂乱。近日有空整理了一下，写出来跟大家分享一下，其中有错误和不足的地方，还请大家纠正补充。 
这篇文章我花费了大量的时间查找资料、修改、排版，希望大家阅读之后，感觉好的话推荐给更多的人，让更多的人看到、纠正以及补充。 
1.对查询进行优化，要尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。 
2.应尽量避免在 where 
    
                                
    • 
                                
  • jsonObject的使用
                                    bijian1013
javajson
                                    
            在项目中难免会用java处理json格式的数据，因此封装了一个JSONUtil工具类。 
JSONUtil.java 
package com.bijian.json.study;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
    
                                
    • 
                                
  • [Zookeeper学习笔记之六]Zookeeper源代码分析之Zookeeper.WatchRegistration
                                    bit1129
zookeeper
                                    
    Zookeeper类是Zookeeper提供给用户访问Zookeeper service的主要API，它包含了如下几个内部类 
  
  
首先分析它的内部类，从WatchRegistration开始，为指定的znode path注册一个Watcher， 
  
    /**
     * Register a watcher for a particular p
    
                                
    • 
                                
  • 【Scala十三】Scala核心七：部分应用函数
                                    bit1129
scala
                                    
    何为部分应用函数？ 
Partially applied function: A function that’s used in an expression and that misses some of its arguments.For instance, if function f has type Int => Int => Int, then f and f(1) are p
    
                                
    • 
                                
  • Tomcat Error listenerStart 终极大法
                                    ronin47
tomcat
                                    
    Tomcat报的错太含糊了，什么错都没报出来，只提示了Error listenerStart。为了调试，我们要获得更详细的日志。可以在WEB-INF/classes目录下新建一个文件叫logging.properties，内容如下 
 
Java代码  
handlers = org.apache.juli.FileHandler, java.util.logging.ConsoleHa
    
                                
    • 
                                
  • 不用加减符号实现加减法
                                    BrokenDreams
实现
                                    
            今天有群友发了一个问题，要求不用加减符号(包括负号)来实现加减法。 
        分析一下，先看最简单的情况，假设1+1，按二进制算的话结果是10，可以看到从右往左的第一位变为0，第二位由于进位变为1。 
   
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-状态模式-State
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 




/*

当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类
状态模式主要解决的是当控制一个对象状态的条件表达式过于复杂时的情况
把状态的判断逻辑转移到表示不同状态的一系列类中，可以把复杂的判断逻辑简化

如果在
    
                                
    • 
                                
  • CUDA程序block和thread超出硬件允许值时的异常
                                    cherishLC
CUDA
                                    
    调用CUDA的核函数时指定block 和 thread大小，该大小可以是dim3类型的（三维数组），只用一维时可以是usigned int型的。 
以下程序验证了当block或thread大小超出硬件允许值时会产生异常！！！GPU根本不会执行运算！！！ 
所以验证结果的正确性很重要！！！ 
在VS中创建CUDA项目会有一个模板，里面有更详细的状态验证。 
 
 
以下程序在K5000GPU上跑的。
    
                                
    • 
                                
  • 诡异的超长时间GC问题定位
                                    chenchao051
jvmcmsGChbaseswap
                                    
    HBase的GC策略采用PawNew+CMS, 这是大众化的配置，ParNew经常会出现停顿时间特别长的情况，有时候甚至长到令人发指的地步，例如请看如下日志： 
2012-10-17T05:54:54.293+0800: 739594.224: [GC 739606.508: [ParNew: 996800K->110720K(996800K), 178.8826900 secs] 3700
    
                                
    • 
                                
  • maven环境快速搭建
                                    daizj
安装mavne环境配置
                                    
    一 下载maven 
 
安装maven之前，要先安装jdk及配置JAVA_HOME环境变量。这个安装和配置java环境不用多说。 
 
maven下载地址：http://maven.apache.org/download.html，目前最新的是这个apache-maven-3.2.5-bin.zip，然后解压在任意位置，最好地址中不要带中文字符，这个做java 的都知道，地址中出现中文会出现很多
    
                                
    • 
                                
  • PHP网站安全，避免PHP网站受到攻击的方法
                                    dcj3sjt126com
PHP
                                    
      
对于PHP网站安全主要存在这样几种攻击方式:1、命令注入(Command Injection)2、eval注入(Eval Injection)3、客户端脚本攻击(Script Insertion)4、跨网站脚本攻击(Cross Site Scripting, XSS)5、SQL注入攻击(SQL injection)6、跨网站请求伪造攻击(Cross Site Request Forgerie
    
                                
    • 
                                
  • yii中给CGridView设置默认的排序根据时间倒序的方法
                                    dcj3sjt126com
GridView
                                    
    public function searchWithRelated() { 
        $criteria = new CDbCriteria; 
 
        $criteria->together = true; //without th
    
                                
    • 
                                
  • Java集合对象和数组对象的转换
                                    dyy_gusi
java集合
                                    
        在开发中，我们经常需要将集合对象（List，Set）转换为数组对象，或者将数组对象转换为集合对象。Java提供了相互转换的工具，但是我们使用的时候需要注意，不能乱用滥用。 
1、数组对象转换为集合对象 
    最暴力的方式是new一个集合对象，然后遍历数组，依次将数组中的元素放入到新的集合中，但是这样做显然过
    
                                
    • 
                                
  • nginx同一主机部署多个应用
                                    geeksun
nginx
                                    
    近日有一需求，需要在一台主机上用nginx部署2个php应用，分别是wordpress和wiki，探索了半天，终于部署好了，下面把过程记录下来。 
1.   在nginx下创建vhosts目录，用以放置vhost文件。 
mkdir vhosts 
  
2.   修改nginx.conf的配置， 在http节点增加下面内容设置，用来包含vhosts里的配置文件 
#
    
                                
    • 
                                
  • ubuntu添加admin权限的用户账号
                                    hongtoushizi
ubuntuuseradd
                                    
    ubuntu创建账号的方式通常用到两种：useradd 和adduser .   本人尝试了useradd方法，步骤如下：  
1:useradd 
   使用useradd时，如果后面不加任何参数的话，如：sudo useradd sysadm 创建出来的用户将是默认的三无用户：无home directory ,无密码,无系统shell。 
顾应该如下操作： 
  
    
                                
    • 
                                
  • 第五章 常用Lua开发库2-JSON库、编码转换、字符串处理
                                    jinnianshilongnian
nginxlua
                                    
       JSON库 
  
在进行数据传输时JSON格式目前应用广泛，因此从Lua对象与JSON字符串之间相互转换是一个非常常见的功能；目前Lua也有几个JSON库，本人用过cjson、dkjson。其中cjson的语法严格（比如unicode \u0020\u7eaf），要求符合规范否则会解析失败（如\u002），而dkjson相对宽松，当然也可以通过修改cjson的源码来完成
    
                                
    • 
                                
  • Spring定时器配置的两种实现方式OpenSymphony Quartz和java Timer详解
                                    yaerfeng1989
timerquartz定时器
                                    
    原创整理不易，转载请注明出处：Spring定时器配置的两种实现方式OpenSymphony Quartz和java Timer详解 
代码下载地址：http://www.zuidaima.com/share/1772648445103104.htm 
有两种流行Spring定时器配置：Java的Timer类和OpenSymphony的Quartz。 
1.Java Timer定时 
首先继承jav
    
                                
    • 
                                
  • Linux下df与du两个命令的差别？
                                    pda158
linux
                                    
    　一、df显示文件系统的使用情况，与du比較，就是更全盘化。   　　最经常使用的就是 df -T，显示文件系统的使用情况并显示文件系统的类型。   　　举比例如以下：   　　[root@localhost ~]# df -T   　　Filesystem                   Type &n
    
                                
    • 
                                
  • [转]SQLite的工具类 ---- 通过反射把Cursor封装到VO对象
                                    ctfzh
VOandroidsqlite反射Cursor
                                    
    在写DAO层时，觉得从Cursor里一个一个的取出字段值再装到VO(值对象)里太麻烦了，就写了一个工具类，用到了反射，可以把查询记录的值装到对应的VO里，也可以生成该VO的List。 
  
使用时需要注意：   
考虑到Android的性能问题，VO没有使用Setter和Getter，而是直接用public的属性。  
表中的字段名需要和VO的属性名一样，要是不一样就得在查询的SQL中
    
                                
    • 
                                
  • 该学习笔记用到的Employee表
                                    vipbooks
oraclesql工作
                                    
        这是我在学习Oracle是用到的Employee表，在该笔记中用到的就是这张表，大家可以用它来学习和练习。 
 
 

drop table Employee;
-- 员工信息表
create table Employee(
       -- 员工编号
       EmpNo number(3) primary key,
       -- 姓
    
                                
    •