1. 在springcloud中，使用的是ribbon来解决负载均很的问题，而常见的负载均衡策略包括有：轮询，随机， 一致性哈希，哈希，加权。
  2. 在ribbon中提供了ILoadBalance接口用来代表负责均衡的操作，它提供了增加服务器，选择服务器，标记服务器状态为down，获得可用服务器以及获得所有服务器的操作。
public interface ILoadBalancer {
    void addServers(List<Server> var1);
 
    Server chooseServer(Object var1);
 
    void markServerDown(Server var1);
 
    /** @deprecated */
    @Deprecated
    List<Server> getServerList(boolean var1);
 
    List<Server> getReachableServers();
 
    List<Server> getAllServers();
}
  1. ribbon中具体实现负载均衡的策略是通过IRule这个接口来实现的，接口实现结构图
  2. ribbon默认是使用的是zoneAvoidanceRule规则
@Bean
    @ConditionalOnMissingBean
    public IRule ribbonRule(IClientConfig config) {
        if (this.propertiesFactory.isSet(IRule.class, this.name)) {
            return (IRule)this.propertiesFactory.get(IRule.class, config, this.name);
        } else {
            ZoneAvoidanceRule rule = new ZoneAvoidanceRule();
            rule.initWithNiwsConfig(config);
            return rule;
        }
  1. 自定义负载规则，通过yml配置文件
    格式如下.ribbon.
service-provider-user:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule



策略名

策略声明

策略描述

实现说明

BestAvailableRule

public class BestAvailableRule extends ClientConfigEnabledRoundRobinRule

选择一个最小的并发请求的serve

逐个考察Server，如果Server被tripped了，则忽略，在选择其中ActiveRequestsCount最小的server

AvailabilityFilteringRule

public class AvailabilityFilteringRule extends PredicateBasedRule

过滤掉那些因为一直连接失败的被标记为circuit tripped的后端server，并过滤掉那些高并发的的后端server（active connections 超过配置的阈值）

使用一个AvailabilityPredicate来包含过滤server的逻辑，其实就就是检查status里记录的各个server的运行状态

WeightedResponseTimeRule

public class WeightedResponseTimeRule extends RoundRobinRule

根据相应时间分配一个weight，相应时间越长，weight越小，被选中的可能性越低。

一个后台线程定期的从status里面读取评价响应时间，为每个server计算一个weight。Weight的计算也比较简单responsetime 减去每个server自己平均的responsetime是server的权重。当刚开始运行，没有形成statas时，使用roubine策略选择server。

RetryRule

public class RetryRule extends AbstractLoadBalancerRule

对选定的负载均衡策略机上重试机制。

在一个配置时间段内当选择server不成功，则一直尝试使用subRule的方式选择一个可用的server

RoundRobinRule

public class RoundRobinRule extends AbstractLoadBalancerRule

roundRobin方式轮询选择server

轮询index，选择index对应位置的server

RandomRule

public class RandomRule extends AbstractLoadBalancerRule

随机选择一个server

在index上随机，选择index对应位置的server

ZoneAvoidanceRule

public class ZoneAvoidanceRule extends PredicateBasedRule

复合判断server所在区域的性能和server的可用性选择server

使用ZoneAvoidancePredicate和AvailabilityPredicate来判断是否选择某个server，前一个判断判定一个zone的运行性能是否可用，剔除不可用的zone（的所有server），AvailabilityPredicate用于过滤掉连接数过多的Server。

如果ribbon的这些规则都不满足需求，可以定义自己的规则，继承AbstractLoadBalancerRule类，重写choose方法，参考随机规则。

package com.netflix.loadbalancer;

import com.netflix.client.config.IClientConfig;

import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

/**
 * A loadbalacing strategy that randomly distributes traffic amongst existing
 * servers.
 * 
 * @author stonse
 * 
 */
public class RandomRule extends AbstractLoadBalancerRule {

    /**
     * Randomly choose from all living servers
     */
    @edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE")
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        }
        Server server = null;

        while (server == null) {
            if (Thread.interrupted()) {
                return null;
            }
            List<Server> upList = lb.getReachableServers();
            List<Server> allList = lb.getAllServers();

            int serverCount = allList.size();
            if (serverCount == 0) {
                /*
                 * No servers. End regardless of pass, because subsequent passes
                 * only get more restrictive.
                 */
                return null;
            }

            int index = chooseRandomInt(serverCount);
            server = upList.get(index);

            if (server == null) {
                /*
                 * The only time this should happen is if the server list were
                 * somehow trimmed. This is a transient condition. Retry after
                 * yielding.
                 */
                Thread.yield();
                continue;
            }

            if (server.isAlive()) {
                return (server);
            }

            // Shouldn't actually happen.. but must be transient or a bug.
            server = null;
            Thread.yield();
        }

        return server;

    }

    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }

	@Override
	public Server choose(Object key) {
		return choose(getLoadBalancer(), key);
	}

	@Override
	public void initWithNiwsConfig(IClientConfig clientConfig) {
		// TODO Auto-generated method stub
		
	}
}