Ribbon负载均衡

服务消费方（客户端）

Ribbon是基于Netflix，实现的一套客户端负载均衡的工具，只需修改客户端代码即可

导入依赖

        <!--Ribbon-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

配合RestTemplate使用

只需要在RestTemplate的bean上加@LoadBalanced注解，即可实现默认（轮询）模式负载均衡

@Configuration
public class ConfigBean {//@Configuration -- spring applicationContext.xml

    // 配置负载均衡实现RestTemplate
    // IRule
    // RoundRobinRule：轮询
    // RandomRule：随机
    // AbstractLoadBalancerRule：会先过滤掉，跳闸、访问故障的服务，对剩下的进行轮询
    // RetryRule：会先按照轮询获取服务，如果服务获取失败，则会在指定时间内进行重试
    @Bean
    @LoadBalanced//Ribbon
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }

}

更改负载均衡策略

需要在spring启动类的上级目录的同级目录下创建配置类（如果不需要自定义配置类的话，此操作可省略）

@Configuration
public class SongRule  {

    @Bean
    public IRule myRule() {
//        return new SongRandomRule();//默认是轮询，现在是Ribbon提供的随机策略
        return new RoundRobinRule();//默认是轮询，现在是自定义的SongRandomRule
    }

}

自定义负载均衡策略

继承AbstractLoadBalancerRule类，重写其方法即可实现

public class SongRandomRule extends AbstractLoadBalancerRule {

    /*
     * 每个服务，访问5次，换下一个服务（3个）
     */
    // total=0，默认=0，如果=5，我们指向下一个服务节点
    // index=0，默认=0，如果total=5，index+1，
    private int total = 0;//被调用的次数
    private int currentIndex = 0;//当前是谁在提供服务

//    @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) {
                return null;
            }

//            int index = chooseRandomInt(serverCount);//生成区间随机数
//            server = upList.get(index);//从活着服务中随机获取一个

            // ===========================================

            if (total < 5) {
                server = upList.get(currentIndex);
                total++;
            }else{
                total = 0;
                currentIndex++;
                if (currentIndex > upList.size()) {
                    currentIndex = 0;
                }
                server = upList.get(currentIndex);//从活着的服务中，获取指定的服务进行操作
            }

            // ===========================================

            if (server == null) {
                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

	}
}

标签：负载,total,return,server,currentIndex,均衡,null,public,Ribbon
来源： https://www.cnblogs.com/singob/p/16692514.html