ribbon

ribbon是什么?

. Spring Cloud Ribbon是基于Netflix Ribbon实现的一套==客户端负载均衡的工具
·简单的说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将NetFlix的中间层服务连接在一起。Ribbon的客户端组件提供一系列完整的配置项如:连接超时、重试等等。简单的说，就是在配置文件中列出LoadBalancer(简称LB:负载均衡）后面所有的机器，Ribbon会自动的帮助你基于某种规则(如简单轮询，随机连接等等）去连接这些机器。我们也很容易使用Ribbon实现自定义的负载均衡算法!

负载均衡图

ribbon能干嘛?

1. LB，即负载均衡(Load Balance)，在微服务或分布式集群中经常用的一种应用。
   2.负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA(高可用)
   3.常见的负载均衡软件有Nginx,`LvsT 等等
   4.dubbo、SpringCloud中均给我们提供了负载均衡，SpringCloud的负载均衡算法可以自定义
   5.负载均衡简单分类:
   5.1集中式LB
   即在服务的消费方和提供方之间使用独立的LB设施，如Nginx，由该设 施负责把访问请求通过某种策略转发至服务的提供方!
   5.2 进程式LB
   (1)将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选出一个合适的服务器。
   (2)Ribbon就属于进程内LB，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址!

均衡负载图

自定义Bean

@RestController
public class DeptConsumerController {
@RibbonClient(name = "SPRINGCLOUE-PEOVIDER-DEPT" , configuration = JiangRule.class)

-------------------------------------------------
    //配置负载均衡实现RestTemplate
    /*  IRule
     * AvailabilityFilteringRule : 会先过滤掉，跳闸，访问故障的服务，对身下的轮询
     * RoundRobinRule：轮询
     * RandomRule ：随机
     * RetryRule：会先按照轮询获取服务，如果
     * */
@Configuration
public class JiangRule {
    @Bean
    public IRule myRule() {
        return new RandomRule();
    }
}
-----------------------------------------
package com.example.myrule;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;

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

public class JiangRandomRule extends AbstractLoadBalancerRule {
    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

    }
}