致虑
致虑

4-dubbo源码分析之集群设计

  • 先看官网一张图


    4-dubbo源码分析之集群设计_第1张图片
    image.png

    这就是dubbo的集群设计了，本章主要解析的就是图中的主要几个蓝色点，简单堆土做个说明：

  • Cluster对于dubbo集群整个管控，会有各种方案，比如快速失败、安全失败等

  • Directory在consumer章节中就已经接触过，主要维护的invoker的动态管理

  • Router一看名词就是路由相关了

  • LoadBalance讲的就是负载均衡

    整体结合起来就是：consumer去远程调用一个具体的provider时，会通过集群中路由、负载均衡等策略选取最终一个具体的服务完成具体调用。

具体解析

一.Cluster
  • 看下官网描述：

Cluster 将 Directory 中的多个 Invoker 伪装成一个 Invoker，对上层透明，伪装过程包含了容错逻辑，调用失败后，重试另一个

  • 具体接口

    /**
 * Cluster. (SPI, Singleton, ThreadSafe)
 * 
    
 * Cluster
 * Fault-Tolerant
 *
 * Cluster 将 Directory 中的多个 Invoker 伪装成一个 Invoker，对上层透明，伪装过程包含了容错逻辑，调用失败后，重试另一个
 * 应对出错情况采取的策略-9种实现
 */
@SPI(FailoverCluster.NAME)
public interface Cluster {

    /**
     * Merge the directory invokers to a virtual invoker.
     *
     * @param 
     * @param directory
     * @return cluster invoker
     * @throws RpcException
     */
    @Adaptive
     Invoker join(Directory directory) throws RpcException;

}

    很明显默认扩展是FailoverCluster，里面就一个很熟悉的方法，join，在consumer中已经出现过，那么跟踪一下；


    4-dubbo源码分析之集群设计_第2张图片
    image.png

    MockClusterInvoker里面构造的是FailoverClusterInvoker，因此最终的invoker不断调用下传，继续:


    4-dubbo源码分析之集群设计_第3张图片
    image.png
4-dubbo源码分析之集群设计_第4张图片
image.png

4-dubbo源码分析之集群设计_第5张图片
image.png

4-dubbo源码分析之集群设计_第6张图片
image.png

4-dubbo源码分析之集群设计_第7张图片
image.png

4-dubbo源码分析之集群设计_第8张图片
image.png

这个代码无非就是将相关的consumer调用信息进行构造封装，返回，但真正发挥作用的地方就是那个返回的Invoker: MockClusterInvoker-->FailoverClusterInvoker,为什么？因为这一步直接决定最终发起远程调用时所使用的ClusterInvoker，也就是如下的doInvoker方法：

  • 先看MockClusterInvoker

    /**
 * 降级处理方案
 * 原理就是改变注册在zookeeper上的节点信息.从而zookeeper通知重新生成invoker
 */
@Override
public Result invoke(Invocation invocation) throws RpcException {
    Result result = null;

    String value = directory.getUrl().getMethodParameter(invocation.getMethodName(), Constants.MOCK_KEY, Boolean.FALSE.toString()).trim();
    if (value.length() == 0 || value.equalsIgnoreCase("false")) {
        /**
         * 无降级: no mock
         * 这里的invoker是FailoverClusterInvoker
         */
        result = this.invoker.invoke(invocation);
    } else if (value.startsWith("force")) {
        if (logger.isWarnEnabled()) {
            logger.info("force-mock: " + invocation.getMethodName() + " force-mock enabled , url : " + directory.getUrl());
        }
        /**
         * 屏蔽: force:direct mock
         * mock=force:return+null
         * 表示消费方对方法的调用都直接返回null，不发起远程调用
         * 可用于屏蔽不重要服务不可用的时候，对调用方的影响
         */
        //
        result = doMockInvoke(invocation, null);
    } else {
        /**
         * 容错: fail-mock
         * mock=fail:return+null
         * 表示消费方对该服务的方法调用失败后，再返回null，不抛异常
         * 可用于对不重要服务不稳定的时候，忽略对调用方的影响 */
        try {
            result = this.invoker.invoke(invocation);
        } catch (RpcException e) {
            if (e.isBiz()) {
                throw e;
            } else {
                if (logger.isWarnEnabled()) {
                    logger.warn("fail-mock: " + invocation.getMethodName() + " fail-mock enabled , url : " + directory.getUrl(), e);
                }
                result = doMockInvoke(invocation, e);
            }
        }
    }
    return result;
}

    这里出现了consumer配置项中的一个重要配置:mock;代码逻辑很清楚，讲的是容器的容错与降级方案。

  • 继续跟着看FailoverClusterInvoker

    @Override
@SuppressWarnings({"unchecked", "rawtypes"})
public Result doInvoke(Invocation invocation, final List> invokers, LoadBalance loadbalance) throws RpcException {

    // Invoker列表
    List> 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> invoked = new ArrayList>(copyinvokers.size()); // invoked invokers.
    Set providers = new HashSet(len);
    for (int i = 0; i < len; i++) {
        //Reselect before retry to avoid a change of candidate `invokers`.
        //NOTE: if `invokers` changed, then `invoked` also lose accuracy.
        /**
         * 重试时，进行重新选择，避免重试时invoker列表已发生变化.
         * 注意：如果列表发生了变化，那么invoked判断会失效，因为invoker示例已经改变
         */
        if (i > 0) {
            checkWhetherDestroyed();
            copyinvokers = list(invocation);
            // check again
            //重新检查一下
            checkInvokers(copyinvokers, invocation);
        }

        /** 使用loadBalance选择一个Invoker返回 */
        Invoker invoker = select(loadbalance, invocation, copyinvokers, invoked);
        invoked.add(invoker);
        RpcContext.getContext().setInvokers((List) invoked);
        try {

            /** 使用选择的结果Invoker进行调用，返回结果 */
            Result result = invoker.invoke(invocation);
            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;
            }
            le = e;
        } catch (Throwable e) {
            le = new RpcException(e.getMessage(), e);
        } finally {
            providers.add(invoker.getUrl().getAddress());
        }
    }
    throw new RpcException(le != null ? le.getCode() : 0, "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 != null ? le.getMessage() : ""), le != null && le.getCause() != null ? le.getCause() : le);
}

    看看发起远程调用的debug情况:


    4-dubbo源码分析之集群设计_第9张图片
    image.png

    恩 确实进来了，既然FailoverCluster的策略是：失败自动切换，当出现失败，重试其它服务器，那么这个策略的体现逻辑就在这个doInvoker的for循环重试里


    4-dubbo源码分析之集群设计_第10张图片
    image.png

    len的取值就是配置项retries，即重试次数，默认是3次；注意：重试时，进行重新选择，避免重试时invoker列表已发生变化.
    至于当前invoker节点失败后重试的机制如何，就是select如何再次选择的问题了 
    Invoker invoker = select(loadbalance, invocation, copyinvokers, invoked);

    次实现在父类AbstractClusterInvoker中：

     /**
 *
 * 使用loadbalance选择invoker.
    
 * a)先lb选择，如果在selected列表中 或者 不可用且做检验时，进入下一步(重选),否则直接返回
    
 * b)重选验证规则：selected > available .保证重选出的结果尽量不在select中，并且是可用的
 *
 * @param selected 已选过的invoker.注意：输入保证不重复
 *
 * Select a invoker using loadbalance policy.
    
 * a)Firstly, select an invoker using loadbalance. If this invoker is in previously selected list, or, 
 * if this invoker is unavailable, then continue step b (reselect), otherwise return the first selected invoker
    
 * b)Reslection, the validation rule for reselection: selected > available. This rule guarantees that
 * the selected invoker has the minimum chance to be one in the previously selected list, and also 
 * guarantees this invoker is available.
 *
 * @param loadbalance load balance policy
 * @param invocation
 * @param invokers invoker candidates
 * @param selected  exclude selected invokers or not
 * @return
 * @throws RpcException
 */
protected Invoker select(LoadBalance loadbalance, Invocation invocation, List> invokers, List> selected) throws RpcException {
    if (invokers == null || invokers.isEmpty()) 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 concurrency problem
        if (sticky && stickyInvoker != null && (selected == null || !selected.contains(stickyInvoker))) {
            if (availablecheck && stickyInvoker.isAvailable()) {
                return stickyInvoker;
            }
        }
    }
    Invoker invoker = doSelect(loadbalance, invocation, invokers, selected);

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

    继续看核心方法: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);

    if (loadbalance == null) {
        loadbalance = ExtensionLoader.getExtensionLoader(LoadBalance.class).getExtension(Constants.DEFAULT_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 {

            /**
             * 重新选择
             * 先从非selected的列表中选择，没有在从selected列表中选择
             */
            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) : invokers.get(0);
                } catch (Exception e) {
                    logger.warn(e.getMessage() + " may because invokers list dynamic change, ignore.", e);
                }
            }
        } catch (Throwable t) {
            logger.error("cluster reselect fail reason is :" + t.getMessage() + " if can not solve, you can set cluster.availablecheck=false in url", t);
        }
    }
    return invoker;
}

    大致如下:

    • 通过具体的负载均衡的算法得到一个invoker(后面详细说负债均衡)
    • 如果 selected中包含（优先判断） 或者 不可用&&availablecheck=true 则重试

    这里有个重要的细节：sticky配置


    4-dubbo源码分析之集群设计_第11张图片
    image.png

    看代码就知道其作用：

    滞连接用于有状态服务，尽可能让客户端总是向同一提供者发起调用，除非该提供者挂了，再连另一台。

    FailoverCluster失败重试策略就差不多讲完了，大概回顾下:

  • 选择Cluster

  • 决定ClusterInvoker

  • 执行doInvoker时实现具体策略

    这里不是很难，下面各种策略几乎类似方式处理，就简单根据官网介绍下其实现的效果:

  • FailfastCluster

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

   public class FailfastClusterInvoker extends AbstractClusterInvoker {

   public FailfastClusterInvoker(Directory directory) {
       super(directory);
   }

   @Override
   public Result doInvoke(Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
       checkInvokers(invokers, invocation);
       Invoker 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 instanceof RpcException ? ((RpcException) e).getCode() : 0, "Failfast invoke providers " + invoker.getUrl() + " " + loadbalance.getClass().getSimpleName() + " select from all providers " + invokers + " for service " + getInterface().getName() + " method " + invocation.getMethodName() + " on consumer " + NetUtils.getLocalHost() + " use dubbo version " + Version.getVersion() + ", but no luck to perform the invocation. Last error is: " + e.getMessage(), e.getCause() != null ? e.getCause() : e);
       }
     }
   }

代码逻辑一目俩然

  • FailsafeCluster

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

public class FailsafeClusterInvoker extends AbstractClusterInvoker {
       private static final Logger logger = LoggerFactory.getLogger(FailsafeClusterInvoker.class);
   
       public FailsafeClusterInvoker(Directory directory) {
           super(directory);
       }
   
       @Override
       public Result doInvoke(Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
           try {
               checkInvokers(invokers, invocation);
               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(); // ignore
           }
       }
}
  • FailbackCluster

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

   public class FailbackClusterInvoker extends AbstractClusterInvoker {

       private static final Logger logger = LoggerFactory.getLogger(FailbackClusterInvoker.class);
   
       private static final long RETRY_FAILED_PERIOD = 5 * 1000;
   
       /**
        * Use {@link NamedInternalThreadFactory} to produce {@link com.alibaba.dubbo.common.threadlocal.InternalThread}
        * which with the use of {@link com.alibaba.dubbo.common.threadlocal.InternalThreadLocal} in {@link RpcContext}.
        */
       private final ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2,
               new NamedInternalThreadFactory("failback-cluster-timer", true));
   
       private final ConcurrentMap> failed = new ConcurrentHashMap>();
       private volatile ScheduledFuture retryFuture;
   
       public FailbackClusterInvoker(Directory directory) {
           super(directory);
       }
   
       private void addFailed(Invocation invocation, AbstractClusterInvoker router) {
           if (retryFuture == null) {
               synchronized (this) {
                   if (retryFuture == null) {
                       retryFuture = scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
   
                           @Override
                           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> entry : new HashMap>(failed).entrySet()) {
               Invocation invocation = entry.getKey();
               Invoker invoker = entry.getValue();
               try {
                   invoker.invoke(invocation);
                   failed.remove(invocation);
               } catch (Throwable e) {
                   logger.error("Failed retry to invoke method " + invocation.getMethodName() + ", waiting again.", e);
               }
           }
       }
   
       @Override
       protected Result doInvoke(Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
           try {
               checkInvokers(invokers, invocation);
               Invoker 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(); // ignore
           }
       }
}
  • ForkingCluster

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

public class ForkingClusterInvoker extends AbstractClusterInvoker {
       /**
        * Use {@link NamedInternalThreadFactory} to produce {@link com.alibaba.dubbo.common.threadlocal.InternalThread}
        * which with the use of {@link com.alibaba.dubbo.common.threadlocal.InternalThreadLocal} in {@link RpcContext}.
        */
       private final ExecutorService executor = Executors.newCachedThreadPool(new NamedInternalThreadFactory("forking-cluster-timer", true));
   
       public ForkingClusterInvoker(Directory directory) {
           super(directory);
       }
   
       @Override
       @SuppressWarnings({"unchecked", "rawtypes"})
       public Result doInvoke(final Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
           checkInvokers(invokers, invocation);
           final List> 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>();
               for (int i = 0; i < forks; i++) {
                   // TODO. Add some comment here, refer chinese version for more details.
                   Invoker 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 ref = new LinkedBlockingQueue();
           for (final Invoker 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(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);
           }
       }
}
 
 
     
  
  • BroadcastCluster 
   
     
    
    广播调用所有提供者，逐个调用，任意一台报错则报错。通常用于通知所有提供者更新缓存或日志等本地资源信息。
     
   
     
    •  
 
 
 
   public class BroadcastClusterInvoker extends AbstractClusterInvoker {

       private static final Logger logger = LoggerFactory.getLogger(BroadcastClusterInvoker.class);
   
       public BroadcastClusterInvoker(Directory directory) {
           super(directory);
       }
   
       @Override
       @SuppressWarnings({"unchecked", "rawtypes"})
       public Result doInvoke(final Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
           checkInvokers(invokers, invocation);
           RpcContext.getContext().setInvokers((List) invokers);
           RpcException exception = null;
           Result result = null;
           for (Invoker 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;
       }
}

 
 
 
 
2.LoadBalance
 
 
     
  
  • 看下主接口
    •  
 
 
 
   /**
* 负载均衡-四种负载均衡策略
* LoadBalance. (SPI, Singleton, ThreadSafe)
* 

* Load-Balancing
*
* @see com.alibaba.dubbo.rpc.cluster.Cluster#join(Directory)
*/
@SPI(RandomLoadBalance.NAME)
public interface LoadBalance {

       /**
        * select one invoker in list.
        *
        * @param invokers   invokers.
        * @param url        refer url
        * @param invocation invocation.
        * @return selected invoker.
        */
       @Adaptive("loadbalance")
        Invoker select(List> invokers, URL url, Invocation invocation) throws RpcException;
}

 
 
默认取的是RandomLoadBalance，那我们就以消费流程去详细解析下这个负债均衡策略。
 
 
     
  
  •  
    RandomLoadBalance
     既然是负债均衡，那就是发起远程调用时选择provider服务时发挥作用，那我们从默认的FailoverClusterInvoker.doInvoke进入：
     
     
   
     
    
     
     
     
      4-dubbo源码分析之集群设计_第12张图片 
     
     
    
     
    
    
      image.png 
    
     
   
     
     
    出现了loadbalance，那就继续跟踪
     
     
   
     
    
     
     
     
      4-dubbo源码分析之集群设计_第13张图片 
     
     
    
     
    
    
      image.png 
    
     
   
     
     
   
     
    
     
     
     
      4-dubbo源码分析之集群设计_第14张图片 
     
     
    
     
    
    
      image.png 
    
     
   
     
     因为我本地就启了一个provider，因此就无需走负债均衡了，直接返回，但这里如果provider大于1的话，看上面画出的重点:
     先找到AbstractLoadBalance的select方法:
    •  
 
 
 
@Override
   public  Invoker select(List> invokers, URL url, Invocation invocation) {

       if (invokers == null || invokers.isEmpty()) return null;

       if (invokers.size() == 1) return invokers.get(0);

       // 进行选择，具体的子类实现，我们这里是RandomLoadBalance
       return doSelect(invokers, url, invocation);
   }

 
 
又是钩子，具体就顺其到子类了:
 
 
   /**
* random load balance.
* 默认的策略
*
* 随机，按权重设置随机概率。
* 在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重。
*
* 1.获取invokers的个数,并遍历累加权重
* 2.若不为第0个,则将当前权重与上一个进行比较,只要有一个不等则认为不等,即:sameWeight=false
* 3.若总权重>0 且 sameWeight=false 按权重获取随机数,根据随机数合权重相减确定调用节点
* 4.sameWeight=true,则均等随机调用
*
* eg:假设有四个集群节点A,B,C,D,对应的权重分别是1,2,3,4,那么请求到A节点的概率就为1/(1+2+3+4) = 10%.B,C,D节点依次类推为20%,30%,40%.
*/
public class RandomLoadBalance extends AbstractLoadBalance {

   public static final String NAME = "random";

   private final Random random = new Random();

   @Override
   protected  Invoker doSelect(List> invokers, URL url, Invocation invocation) {
       int length = invokers.size(); // Number of invokers 总个数
       int totalWeight = 0; // The sum of weights 总权重
       boolean sameWeight = true; // Every invoker has the same weight? 权重是否都一样
       for (int i = 0; i < length; i++) {
           int weight = getWeight(invokers.get(i), invocation);
           totalWeight += weight; // Sum 累计总权重
           if (sameWeight && i > 0 && weight != getWeight(invokers.get(i - 1), invocation)) {
               sameWeight = false; // 计算所有权重是否都一样
           }
       }

       // eg: 总权重为10(1+2+3+4),那么怎么做到按权重随机呢?根据10随机出一个整数,假如为随机出来的是2.然后依次和权重相减,比如2(随机数)-1(A的权重) = 1,然后1(上一步计算的结果)-2(B的权重) = -1,此时-1 < 0,那么则调用B,其他的以此类推
       if (totalWeight > 0 && !sameWeight) {
           // 如果权重不相同且权重大于0.则按总权重数随机
           // If (not every invoker has the same weight & at least one invoker's weight>0), select randomly based on totalWeight.
           int offset = random.nextInt(totalWeight);
           // 确定随机值落在那个片段上
           // Return a invoker based on the random value.
           for (int i = 0; i < length; i++) {
               offset -= getWeight(invokers.get(i), invocation);
               if (offset < 0) {
                   return invokers.get(i);
               }
           }
       }
       // 如果权重相同或权重为0则均等随机
       // If all invokers have the same weight value or totalWeight=0, return evenly.
       return invokers.get(random.nextInt(length));
   }
}

 
 
当前策略的算法在注释中很清楚了，这里不在细说。其他三种负债均衡其实处理方式大致相同，简单列一下:
 
 
     
  
  • RoundRobinLoadBalance
    •  
 
 
 
 
  
轮循，按公约后的权重设置轮循比率。
 
 
 
 
   @Override
   protected  Invoker doSelect(List> invokers, URL url, Invocation invocation) {
       String key = invokers.get(0).getUrl().getServiceKey() + "." + invocation.getMethodName();
       int length = invokers.size(); // Number of invokers invokers的个数
       int maxWeight = 0; // The maximum weight // 最大权重
       int minWeight = Integer.MAX_VALUE; // The minimum weight 最小权重
       final LinkedHashMap, IntegerWrapper> invokerToWeightMap = new LinkedHashMap, IntegerWrapper>();
       int weightSum = 0;
       for (int i = 0; i < length; i++) {
           int weight = getWeight(invokers.get(i), invocation);
           maxWeight = Math.max(maxWeight, weight); // Choose the maximum weight  累计最大权重
           minWeight = Math.min(minWeight, weight); // Choose the minimum weight  累计最小权重
           if (weight > 0) {
               invokerToWeightMap.put(invokers.get(i), new IntegerWrapper(weight));
               weightSum += weight;
           }
       }
       AtomicPositiveInteger sequence = sequences.get(key);
       if (sequence == null) {
           sequences.putIfAbsent(key, new AtomicPositiveInteger());
           sequence = sequences.get(key);
       }
       int currentSequence = sequence.getAndIncrement();
       if (maxWeight > 0 && minWeight < maxWeight) {  // 如果权重不一样
           int mod = currentSequence % weightSum;
           for (int i = 0; i < maxWeight; i++) {
               for (Map.Entry, IntegerWrapper> each : invokerToWeightMap.entrySet()) {
                   final Invoker k = each.getKey();
                   final IntegerWrapper v = each.getValue();
                   if (mod == 0 && v.getValue() > 0) {
                       return k;
                   }
                   if (v.getValue() > 0) {
                       v.decrement();
                       mod--;
                   }
               }
           }
       }
       // Round robin 取模循环
       return invokers.get(currentSequence % length);
   }

 
 
     
  
  • LeastActiveLoadBalance
    •  
 
 
 
 
  
最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。
 使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大
 
 
 
 
举个实际的例子:
 A请求接受一个请求时计数+1，请求完再-1；B请求接受一个请求时，计数+1,请求完计数-1；按照这种逻辑，如果请求中的节点肯定比没有请求的计数低，因此找计数低的服务处理。场景就是:处理越慢的服务，计数越容易高，因此将后面请求分发给计数低的服务会更加友好。
 
 
   @Override
   protected  Invoker doSelect(List> invokers, URL url, Invocation invocation) {
       int length = invokers.size(); // Number of invokers ,invoker总数
       int leastActive = -1; // The least active value of all invokers ,所有invoker的最小活跃数
       int leastCount = 0; // The number of invokers having the same least active value (leastActive)  拥有最小活跃数的Invoker是的个数
       int[] leastIndexs = new int[length]; // The index of invokers having the same least active value (leastActive)  拥有最小活跃数的Invoker的下标,也就是将最小活跃的invoker集中放入新数组,以便后续遍历
       int totalWeight = 0; // The sum of weights  总权重
       int firstWeight = 0; // Initial value, used for comparision  初始权重,用于计算是否相同
       boolean sameWeight = true; // Every invoker has the same weight value?  是否所有invoker的权重都相同
       for (int i = 0; i < length; i++) {
           Invoker invoker = invokers.get(i);
           int active = RpcStatus.getStatus(invoker.getUrl(), invocation.getMethodName()).getActive(); // Active number 活跃数
           int weight = invoker.getUrl().getMethodParameter(invocation.getMethodName(), Constants.WEIGHT_KEY, Constants.DEFAULT_WEIGHT); // Weight
           if (leastActive == -1 || active < leastActive) { // Restart, when find a invoker having smaller least active value.  如果发现更小的活跃数则重新开始
               leastActive = active; // Record the current least active value 记录下最小的活跃数
               leastCount = 1; // Reset leastCount, count again based on current leastCount 重新统计最小活跃数的个数
               leastIndexs[0] = i; // Reset  重置小标
               totalWeight = weight; // Reset
               firstWeight = weight; // Record the weight the first invoker 重置第一个权重
               sameWeight = true; // Reset, every invoker has the same weight value?  重置是否权重相同标识
           } else if (active == leastActive) { // If current invoker's active value equals with leaseActive, then accumulating.  累计相同的最小活跃数
               leastIndexs[leastCount++] = i; // Record index number of this invoker  累计相同的最小活跃invoker的小标
               totalWeight += weight; // Add this invoker's weight to totalWeight. 累加总权重
               // If every invoker has the same weight?  是否所有权重一样
               if (sameWeight && i > 0
                       && weight != firstWeight) {
                   sameWeight = false;
               }
           }
       }
       // assert(leastCount > 0)
       if (leastCount == 1) {
           // 如果只有一个最小则直接返回
           // If we got exactly one invoker having the least active value, return this invoker directly.
           return invokers.get(leastIndexs[0]);
       }
       if (!sameWeight && totalWeight > 0) {
           // 如果权重不相同且总权重大于0,则按总权重随机
           // If (not every invoker has the same weight & at least one invoker's weight>0), select randomly based on totalWeight.
           int offsetWeight = random.nextInt(totalWeight);
           // 按随机数去值
           // Return a invoker based on the random value.
           for (int i = 0; i < leastCount; i++) {
               int leastIndex = leastIndexs[i];
               offsetWeight -= getWeight(invokers.get(leastIndex), invocation);
               if (offsetWeight <= 0)
                   return invokers.get(leastIndex);
           }
       }
       // 如果权重相同或总权重为0,则均等随机
       // If all invokers have the same weight value or totalWeight=0, return evenly.
       return invokers.get(leastIndexs[random.nextInt(leastCount)]);
   }

 
 
     
  
  • ConsistentHashLoadBalance
    •  
 
 
 
 
  
一致性 Hash，相同参数的请求总是发到同一提供者。当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点，平摊到其它提供者，不会引起剧烈变动。
 
 
 
 
   protected  Invoker doSelect(List> invokers, URL url, Invocation invocation) {
       String key = invokers.get(0).getUrl().getServiceKey() + "." + invocation.getMethodName();
       int identityHashCode = System.identityHashCode(invokers);
       ConsistentHashSelector selector = (ConsistentHashSelector) selectors.get(key);
       if (selector == null || selector.identityHashCode != identityHashCode) {
           selectors.put(key, new ConsistentHashSelector(invokers, invocation.getMethodName(), identityHashCode));
           selector = (ConsistentHashSelector) selectors.get(key);
       }
       return selector.select(invocation);
   }

 
 
具体相关算法:
 http://en.wikipedia.org/wiki/Consistent_hashing
 
 
 
 
3.Router
 
 
     
  
  • 请求被路由到哪个服务器，靠的就是路由啦，先看下主接口:
    •  
 
 
 
   /**
* Router. (SPI, Prototype, ThreadSafe)
* 

* Routing
*
* @see com.alibaba.dubbo.rpc.cluster.Cluster#join(Directory)
* @see com.alibaba.dubbo.rpc.cluster.Directory#list(Invocation)
*/
public interface Router extends Comparable {

       /**
        * get the router url.
        *
        * @return url
        */
       URL getUrl();
   
       /**
        * route.
        *
        * @param invokers
        * @param url        refer url
        * @param invocation
        * @return routed invokers
        * @throws RpcException
        */
        List> route(List> invokers, URL url, Invocation invocation) throws RpcException;
}

 
 
核心方法已经出现了。我们还是按照原有思路debug一下：

 
 
 
  
 
   
 
    4-dubbo源码分析之集群设计_第15张图片 
   
 
  
 
  

    image.png 
  
 
 
 
 
 
  
 
   
 
     
   
 
  
 
  

    image.png 
  
 
 
 
 
 
 
 
  
 
   
 
    4-dubbo源码分析之集群设计_第16张图片 
   
 
  
 
  

    image.png 
  
 
 
 
 
 
 
OK ，路由核心出现了，上面方法做了两件事:
 - 1.RegistryDirectory doList(invocation)将所有可用的invokers根据参数条件筛选出来；
 - 2.根据路由规则，将directory中筛选出来的invokers进行过滤，比如MockInvokersSelector将所有mock invokers过滤掉。
 
 
 
  
 
   
 
    4-dubbo源码分析之集群设计_第17张图片 
   
 
  
 
  

    image.png 
  
 
 
 
 
 
 
 
  
 
   
 
    4-dubbo源码分析之集群设计_第18张图片 
   
 
  
 
  

    image.png 
  
 
 
 
 
 
 
过滤出来的invokers再返回即完成路由操作。路由执行大体流程就是如此，接下来列一下几个路由策略：
 
 
     
  
  •  
    ScriptRouter
     
   
     
    
    脚本路由规则 支持 JDK 脚本引擎的所有脚本，比如：javascript, jruby, groovy 等，通过 type=javascript 参数设置脚本类型，缺省为 javascript。
     
   
     
    @Override
@SuppressWarnings("unchecked")
public  List> route(List> invokers, URL url, Invocation invocation) throws RpcException {
    try {
        List> invokersCopy = new ArrayList>(invokers);
        Compilable compilable = (Compilable) engine;
        Bindings bindings = engine.createBindings();
        bindings.put("invokers", invokersCopy);
        bindings.put("invocation", invocation);
        bindings.put("context", RpcContext.getContext());
        CompiledScript function = compilable.compile(rule);
        Object obj = function.eval(bindings);
        if (obj instanceof Invoker[]) {
            invokersCopy = Arrays.asList((Invoker[]) obj);
        } else if (obj instanceof Object[]) {
            invokersCopy = new ArrayList>();
            for (Object inv : (Object[]) obj) {
                invokersCopy.add((Invoker) inv);
            }
        } else {
            invokersCopy = (List>) obj;
        }
        return invokersCopy;
    } catch (ScriptException e) {
        //fail then ignore rule .invokers.
        logger.error("route error , rule has been ignored. rule: " + rule + ", method:" + invocation.getMethodName() + ", url: " + RpcContext.getContext().getUrl(), e);
        return invokers;
    }
}

     
    •  
  
  • ConditionRouter
    •  
 
 
 
 
  
条件路由: 根据dubbo管理控制台配置的路由规则来过滤相关的invoker,这里会实时触发RegistryDirectory类的notify方法，通知本地重建invokers
 
 
 
 
```
@Override
public  List> route(List> invokers, URL url, Invocation invocation) throws RpcException {
    if (invokers == null || invokers.isEmpty()) {
        return invokers;
    }
    try {
        if (!matchWhen(url, invocation)) {
            return invokers;
        }
        List> result = new ArrayList>();
        if (thenCondition == null) {
            logger.warn("The current consumer in the service blacklist. consumer: " + NetUtils.getLocalHost() + ", service: " + url.getServiceKey());
            return result;
        }
        for (Invoker invoker : invokers) {
            if (matchThen(invoker.getUrl(), url)) {
                result.add(invoker);
            }
        }
        if (!result.isEmpty()) {
            return result;
        } else if (force) {
            logger.warn("The route result is empty and force execute. consumer: " + NetUtils.getLocalHost() + ", service: " + url.getServiceKey() + ", router: " + url.getParameterAndDecoded(Constants.RULE_KEY));
            return result;
        }
    } catch (Throwable t) {
        logger.error("Failed to execute condition router rule: " + getUrl() + ", invokers: " + invokers + ", cause: " + t.getMessage(), t);
    }
    return invokers;
}
```

 
 
OK 路由基本就分析到这里；
 
 
 
 
4.Directory
 
 
     
  
  •  
    这个在consumer中已经分析过了，简单看看官网描述:
     
   
     
    
    Directory 代表多个 Invoker，可以把它看成 List ,但与 List 不同的是，它的值可能是动态变化的，比如注册中心推送变更
     
   
     
    •  
 
 
 
   /**
* Directory. (SPI, Prototype, ThreadSafe)
* 

* Directory Service
*
* Directory 代表多个 Invoker，可以把它看成 List ，但与 List 不同的是，它的值可能是动态变化的，比如注册中心推送变更
*
* @see com.alibaba.dubbo.rpc.cluster.Cluster#join(Directory)
*/
public interface Directory extends Node {

       /**
        * get service type.
        *
        * @return service type.
        */
       Class getInterface();
   
       /**
        * list invokers.
        *
        * @return invokers
        */
       List> list(Invocation invocation) throws RpcException;
}

 
 
而此处list方法的核心逻辑也是在分析Route中就已经见过了，不在分析；
 Directory能够动态根据注册中心维护Invokers列表，是因为相关Listener在被notify之后会触发methodInvokerMap和urlInvokerMap等缓存的相关变动；最后在list方法中也就实时取出了最新的invokers；看下之前的流程就清楚了；
 
 
     
  
  • StaticDirectory
    •  
 
 
 
 
  
构造方法传入invokers,因此这个Directory的invokers是不会动态变化的,使用场景不多；
 
 
 
 
public StaticDirectory(List> invokers) {
       this(null, invokers, null);
   }

   public StaticDirectory(List> invokers, List routers) {
       this(null, invokers, routers);
   }

   public StaticDirectory(URL url, List> invokers) {
       this(url, invokers, null);
   }

   public StaticDirectory(URL url, List> invokers, List routers) {
       super(url == null && invokers != null && !invokers.isEmpty() ? invokers.get(0).getUrl() : url, routers);
       if (invokers == null || invokers.isEmpty())
           throw new IllegalArgumentException("invokers == null");
       this.invokers = invokers;
   }

 
 
     
  
  • RegistryDirectory
    •  
 
 
 
 
  
根据注册中心的推送变更，动态维护invokers列表；
 
 
 
 
整个集群大致模块就到这里。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(4-dubbo源码分析之集群设计)

        

            

                
    
                    
  • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    
                    
    • 
                    
  • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    
                    
    • 
                    
  • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    
                    
    • 
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • c++ 的iostream 和 c++的stdio的区别和联系
                        黄卷青灯77
c++算法开发语言iostreamstdio
                        
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
    
                    
    • 
                    
  • 扫地机类清洁产品之直流无刷电机控制
                        悟空胆好小
清洁服务机器人单片机人工智能
                        
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
    
                    
    • 
                    
  • 消息中间件有哪些常见类型
                        xmh-sxh-1314
java
                        
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
    
                    
    • 
                    
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿
                        小鹿_33

                        
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
    
                    
    • 
                    
  • 《大清方方案》| 第二话
                        谁佐清欢

                        
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • 《庄子.达生9》
                        钱江潮369

                        
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
    
                    
    • 
                    
  • Google earth studio 简介
                        陟彼高冈yu
旅游
                        
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 高端密码学院笔记285
                        柚子_b4b4

                        
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
    
                    
    • 
                    
  • 2020-04-12每天三百字之连接与替代
                        冷眼看潮

                        
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
    
                    
    • 
                    
  • 东南林氏之九牧林候选父系
                        祖缘树TheYtree

                        
    渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • 121. 买卖股票的最佳时机
                        薄荷糖的味道_fb40

                        
    给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
    
                    
    • 
                    
  • 大伟说成语之唉声叹气
                        求索大伟

                        
    ＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
    
                    
    • 
                    
  • libyuv之linux编译
                        jaronho
Linuxlinux运维服务器
                        
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
    
                    
    • 
                    
  • CX8836：小体积大功率升降压方案推荐（附Demo设计指南）
                        诚芯微科技
社交电子
                        
    CX8836是一颗同步四开关单向升降压控制器，在4.5V-40V宽输入电压范围内稳定工作，持续负载电流10A，能够在输入高于或低于输出电压时稳定调节输出电压，可适用于USBPD快充、车载充电器、HUB、汽车启停系统、工业PC电源等多种升降压应用场合，为大功率TYPE-CPD车载充电器提供最优解决方案。提供CX8836Demo测试、CX8836样品申请及CX8836方案开发技术支持。CX8836同升
    
                    
    • 
                    
  • 怎么做淘客赚钱(2022最新免费淘客盈利的方法)
                        高省_飞智666600

                        
    很多人都不知道什么是淘宝客，今天小编为大家解答一下吧。淘宝客，现在简称淘客，是时下比较流行的一个词语，特质为淘宝店推广商品获取提成的人，这些人没有自己的产品，只是在淘宝里面选择适合自己的产品，在自己比较熟悉的领域推广，把产品卖出去之后，会从淘宝店家那里获得百分之五到百分之五十左右的佣金。淘宝客付出的是什么呢？时间。你需要花时间去选适合自己推广的产品，需要花时间去选自己的推广方法，如果你打算自己做个
    
                    
    • 
                    
  • 数据仓库——维度表一致性
                        墨染丶eye
背诵数据仓库
                        
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
    
                    
    • 
                    
  • 高级 ECharts 技巧：自定义图表主题与样式
                        SnowMan1993
echarts信息可视化数据分析
                        
    ECharts是一个强大的数据可视化库，提供了多种内置主题和样式，但你也可以根据项目的设计需求，自定义图表的主题与样式。本文将介绍如何使用ECharts自定义图表主题，以提升数据可视化的吸引力和一致性。1.什么是ECharts主题？ECharts的主题是指定义图表样式的配置项，包括颜色、字体、线条样式等。通过预设主题，你可以快速更改图表的整体风格，而自定义主题则允许你在此基础上进行个性化设置。2.
    
                    
    • 
                    
  • Python爬虫解析工具之xpath使用详解
                        eqa11
python爬虫开发语言
                        
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
    
                    
    • 
                    
  • Redis系列：Geo 类型赋能亿级地图位置计算
                        Ly768768
redisbootstrap数据库
                        
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    
                    
    • 
                    
  • 锁之缘
                        尘缘诗词原创作品

                        
    是谁追寻梦的足迹，是谁在偷偷的哭泣，日月隔离在黑白天地情感在心中蔓延的痕迹天与地的距离有多远流失的星晨落入哪片空间不要让泪水模糊双眼心牢中一样充满温暖谁说爱情没有永远白娘子又为何爱许仙蝴蝶墓地展翅翩翩轻歌慢舞袖卷人间传奇千古留爱万年…………月落星飞徘徊是选择不去问自已为合舍不得寂寞本就是痛苦的不在追寻梦中的痕迹才不会失去真实的自已
    
                    
    • 
                    
  • ARM驱动学习之基础小知识
                        JT灬新一
ARM嵌入式arm开发学习
                        
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    
                    
    • 
                    
  • ARM驱动学习之5 LEDS驱动
                        JT灬新一
嵌入式C底层arm开发学习单片机
                        
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
    
                    
    • 
                                
  • 如何用ruby来写hadoop的mapreduce并生成jar包
                                    wudixiaotie
mapreduce
                                    
    ruby来写hadoop的mapreduce，我用的方法是rubydoop。怎么配置环境呢： 
1.安装rvm： 
    不说了 网上有 
2.安装ruby： 
    由于我以前是做ruby的，所以习惯性的先安装了ruby，起码调试起来比jruby快多了。 
3.安装jruby： 
    rvm install jruby然后等待安
    
                                
    • 
                                
  • java编程思想 -- 访问控制权限
                                    百合不是茶
java访问控制权限单例模式
                                    
    访问权限是java中一个比较中要的知识点,它规定者什么方法可以访问,什么不可以访问 
  
一:包访问权限; 
  
自定义包: 
package com.wj.control;
//包
public class Demo {
  //定义一个无参的方法
	public void DemoPackage(){
		System.out.println("调用
    
                                
    • 
                                
  • [生物与医学]请审慎食用小龙虾
                                    comsci
生物
                                    
     
     现在的餐馆里面出售的小龙虾,有一些是在野外捕捉的,这些小龙虾身体里面可能带有某些病毒和细菌,人食用以后可能会导致一些疾病,严重的甚至会死亡..... 
 
     所以,参加聚餐的时候,最好不要点小龙虾...就吃养殖的猪肉,牛肉,羊肉和鱼,等动物蛋白质 
    
    
                                
    • 
                                
  • org.apache.jasper.JasperException: Unable to compile class for JSP:
                                    商人shang
maven2.2jdk1.8
                                    
    环境： jdk1.8    maven  tomcat7-maven-plugin  2.0 
原因： tomcat7-maven-plugin  2.0 不知吃 jdk 1.8，换成 tomcat7-maven-plugin  2.2就行，即 
  
  
<plugin>
				
    
                                
    • 
                                
  • 你的垃圾你处理掉了吗?GC
                                    oloz
GC
                                    
    前序:本人菜鸟，此文研究学习来自网络，各位牛牛多指教　 
 
 
 
1.垃圾收集算法的核心思想 
　　Java语言建立了垃圾收集机制，用以跟踪正在使用的对象和发现并回收不再使用(引用)的对象。该机制可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽，以及不恰当的内存释放所造成的内存非法引用。 
　　垃圾收集算法的核心思想是：对虚拟机可用内存空间，即堆空间中的对象进行识别
    
                                
    • 
                                
  • shiro 和 SESSSION
                                    杨白白
shiro
                                    
    shiro 在web项目里默认使用的是web容器提供的session，也就是说shiro使用的session是web容器产生的，并不是自己产生的，在用于非web环境时可用其他来源代替。在web工程启动的时候它就和容器绑定在了一起，这是通过web.xml里面的shiroFilter实现的。通过session.getSession()方法会在浏览器cokkice产生JESSIONID，当关闭浏览器，此
    
                                
    • 
                                
  • 移动互联网终端 淘宝客如何实现盈利
                                    小桔子
移動客戶端淘客淘寶App
                                    
           2012年淘宝联盟平台为站长和淘宝客带来的分成收入突破30亿元，同比增长100%。而来自移动端的分成达1亿元，其中美丽说、蘑菇街、果库、口袋购物等App运营商分成近5000万元。 可以看出，虽然目前阶段PC端对于淘客而言仍旧是盈利的大头，但移动端已经呈现出爆发之势。而且这个势头将随着智能终端(手机，平板)的加速普及而更加迅猛
    
                                
    • 
                                
  • wordpress小工具制作
                                    aichenglong
wordpress小工具
                                    
    wordpress 使用侧边栏的小工具，很方便调整页面结构 
小工具的制作过程 
1 在自己的主题文件中新建一个文件夹(如widget)，在文件夹中创建一个php(AWP_posts-category.php) 
小工具是一个类,想侧边栏一样，还得使用代码注册，他才可以再后台使用，基本的代码一层不变 
<?php 
 class AWP_Post_Category extends WP_Wi
    
                                
    • 
                                
  • JS微信分享
                                    AILIKES
js
                                    
    // 所有功能必须包含在 WeixinApi.ready 中进行 
   WeixinApi.ready(function(Api) { 
       // 微信分享的数据 
           var wxData = { 
      &nb
    
                                
    • 
                                
  • 封装探讨
                                    百合不是茶
JAVA面向对象 封装
                                    
    //封装   属性 方法 将某些东西包装在一起，通过创建对象或使用静态的方法来调用，称为封装；封装其实就是有选择性地公开或隐藏某些信息，它解决了数据的安全性问题，增加代码的可读性和可维护性 
  
在 Aname类中申明三个属性，将其封装在一个类中：通过对象来调用 
  
例如   1： 
	//属性 将其设为私有
	姓名 name 可以公开

    
                                
    • 
                                
  • jquery radio/checkbox change事件不能触发的问题
                                    bijian1013
JavaScriptjquery
                                    
    我想让radio来控制当前我选择的是机动车还是特种车，如下所示：  
<html> 
<head> 
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js" type="text/javascript"><
    
                                
    • 
                                
  • AngularJS中安全性措施
                                    bijian1013
JavaScriptAngularJS安全性XSRFJSON漏洞
                                    
            在使用web应用中，安全性是应该首要考虑的一个问题。AngularJS提供了一些辅助机制，用来防护来自两个常见攻击方向的网络攻击。 
一.JSON漏洞 
        当使用一个GET请求获取JSON数组信息的时候（尤其是当这一信息非常敏感，
    
                                
    • 
                                
  • [Maven学习笔记九]Maven发布web项目
                                    bit1129
maven
                                    
    基于Maven的web项目的标准项目结构 
user-project 
    user-core 
    user-service 
    user-web 
       src 
     
    
                                
    • 
                                
  • 【Hive七】Hive用户自定义聚合函数(UDAF)
                                    bit1129
hive
                                    
    用户自定义聚合函数，用户提供的多个入参通过聚合计算(求和、求最大值、求最小值)得到一个聚合计算结果的函数。 
问题：UDF也可以提供输入多个参数然后输出一个结果的运算，比如加法运算add(3，5)，add这个UDF需要实现UDF的evaluate方法,那么UDF和UDAF的实质分别究竟是什么？ 
  
Double evaluate(Double a, Double b) 
 
    
                                
    • 
                                
  • 通过 nginx-lua 给 Nginx 增加 OAuth 支持
                                    ronin47

                                    
    前言：我们使用Nginx的Lua中间件建立了OAuth2认证和授权层。如果你也有此打算，阅读下面的文档，实现自动化并获得收益。SeatGeek 在过去几年中取得了发展，我们已经积累了不少针对各种任务的不同管理接口。我们通常为新的展示需求创建新模块，比如我们自己的博客、图表等。我们还定期开发内部工具来处理诸如部署、可视化操作及事件处理等事务。在处理这些事务中，我们使用了几个不同的接口来认证： 
&n
    
                                
    • 
                                
  • 利用tomcat-redis-session-manager做session同步时自定义类对象属性保存不上的解决方法
                                    bsr1983
session
                                    
    在利用tomcat-redis-session-manager做session同步时，遇到了在session保存一个自定义对象时，修改该对象中的某个属性，session未进行序列化，属性没有被存储到redis中。   在 tomcat-redis-session-manager的github上有如下说明：   Session Change Tracking 
As noted in the &qu
    
                                
    • 
                                
  • 《代码大全》表驱动法-Table Driven Approach-1
                                    bylijinnan
java算法
                                    
    关于Table Driven Approach的一篇非常好的文章： 
 
http://www.codeproject.com/Articles/42732/Table-driven-Approach 
 
 
package com.ljn.base;

import java.util.Random;

public class TableDriven {

    public 
    
                                
    • 
                                
  • Sybase封锁原理
                                    chicony
Sybase
                                    
           昨天在操作Sybase IQ12.7时意外操作造成了数据库表锁定，不能删除被锁定表数据也不能往其中写入数据。由于着急往该表抽入数据，因此立马着手解决该表的解锁问题。     无奈此前没有接触过Sybase IQ12.7这套数据库产品，加之当时已属于下班时间无法求助于支持人员支持，因此只有借助搜索引擎强大的
    
                                
    • 
                                
  • java异常处理机制
                                    CrazyMizzz
java
                                    
    java异常关键字有以下几个，分别为 try catch final throw throws 
他们的定义分别为 
try：    Opening exception-handling statement. 
catch：  Captures the exception. 
finally： Runs its code before terminating
    
                                
    • 
                                
  • hive 数据插入DML语法汇总
                                    daizj
hiveDML数据插入
                                    
    Hive的数据插入DML语法汇总1、Loading files into tables语法：1) LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE] INTO TABLE tablename [PARTITION (partcol1=val1, partcol2=val2 ...)]解释：1)、上面命令执行环境为hive客户端环境下： hive>l
    
                                
    • 
                                
  • 工厂设计模式
                                    dcj3sjt126com
设计模式
                                    
      使用设计模式是促进最佳实践和良好设计的好办法。设计模式可以提供针对常见的编程问题的灵活的解决方案。  工厂模式 
工厂模式（Factory）允许你在代码执行时实例化对象。它之所以被称为工厂模式是因为它负责“生产”对象。工厂方法的参数是你要生成的对象对应的类名称。  
Example #1 调用工厂方法（带参数）   
<?phpclass Example{ 
    
                                
    • 
                                
  • mysql字符串查找函数
                                    dcj3sjt126com
mysql
                                    
      
FIND_IN_SET(str,strlist) 
假如字符串str 在由N 子链组成的字符串列表strlist 中，则返回值的范围在1到 N 之间。一个字符串列表就是一个由一些被‘,’符号分开的自链组成的字符串。如果第一个参数是一个常数字符串，而第二个是type SET列，则   FIND_IN_SET() 函数被优化，使用比特计算。如果str不在strlist 或st
    
                                
    • 
                                
  • jvm内存管理
                                    easterfly
jvm
                                    
    一、JVM堆内存的划分 
 分为年轻代和年老代。年轻代又分为三部分：一个eden,两个survivor。 
 工作过程是这样的：e区空间满了后，执行minor gc，存活下来的对象放入s0, 对s0仍会进行minor gc，存活下来的的对象放入s1中，对s1同样执行minor gc，依旧存活的对象就放入年老代中； 
 年老代满了之后会执行major gc，这个是stop the word模式，执行
    
                                
    • 
                                
  • CentOS-6.3安装配置JDK-8
                                    gengzg
centos
                                    
    JAVA_HOME=/usr/java/jdk1.8.0_45
JRE_HOME=/usr/java/jdk1.8.0_45/jre
PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin
CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib
export JAVA_HOME
    
                                
    • 
                                
  • 【转】关于web路径的获取方法
                                    huangyc1210
Web路径
                                    
    假定你的web application 名称为news,你在浏览器中输入请求路径：  http://localhost:8080/news/main/list.jsp  则执行下面向行代码后打印出如下结果：  1、 System.out.println(request.getContextPath()); //可返回站点的根路径。也就是项
    
                                
    • 
                                
  • php里获取第一个中文首字母并排序
                                    远去的渡口
数据结构PHP
                                    
    很久没来更新博客了，还是觉得工作需要多总结的好。今天来更新一个自己认为比较有成就的问题吧。 最近在做储值结算，需求里结算首页需要按门店的首字母A-Z排序。我的数据结构原本是这样的： 
Array
(
    [0] => Array
        (
            [sid] => 2885842
            [recetcstoredpay] =&g
    
                                
    • 
                                
  • java内部类
                                    hm4123660
java内部类匿名内部类成员内部类方法内部类
                                    
         　在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。内部类可以间接解决多继承问题,可以使用内部类继承一个类，外部类继承一个类，实现多继承。 
     &nb
    
                                
    • 
                                
  • Caused by: java.lang.IncompatibleClassChangeError: class org.hibernate.cfg.Exten
                                    zhb8015

                                    
    maven pom.xml关于hibernate的配置和异常信息如下，查了好多资料，问题还是没有解决。只知道是包冲突，就是不知道是哪个包....遇到这个问题的分享下是怎么解决的。。 
  
maven pom: 
  
		<dependency>
			<groupId>org.hibernate</groupId>
			<ar
    
                                
    • 
                                
  • Spark 性能相关参数配置详解－任务调度篇
                                    Stark_Summer
sparkcachecpu任务调度yarn
                                    
    随着Spark的逐渐成熟完善, 越来越多的可配置参数被添加到Spark中来, 本文试图通过阐述这其中部分参数的工作原理和配置思路, 和大家一起探讨一下如何根据实际场合对Spark进行配置优化。 
  
由于篇幅较长，所以在这里分篇组织，如果要看最新完整的网页版内容，可以戳这里：http://spark-config.readthedocs.org/，主要是便
    
                                
    • 
                                
  • css3滤镜
                                    wangkeheng
htmlcss
                                    
    经常看到一些网站的底部有一些灰色的图标，鼠标移入的时候会变亮，开始以为是js操作src或者bg呢，搜索了一下，发现了一个更好的方法：通过css3的滤镜方法。 
 
html代码： 
 
<a href='' class='icon'><img src='utv.jpg' /></a> 
css代码： 
 
.icon{-webkit-filter: graysc
    
                                
    •