Spring cloud之Ribbon组件集成

---

一、Ribbon是什么？

Ribbon是Netflix发布的云中间层服务开源项目，其主要功能是提供客户端实现负载均衡算法。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，Ribbon是一个客户端负载均衡器，我们可以在配置文件中Load Balancer后面的所有机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机连接等）去连接这些机器，我们也很容易使用Ribbon实现自定义的负载均衡算法。

关于负载均衡有这两个分类：
一种是集中式的负载均衡，比如nginx（软件），F5（硬件），集中式的负载均衡其实一种前置的负载均衡，其实在请求到达服务之前就将它按照规定好的负载均衡规则转发指定的服务上去。
一种是进程内的负载均衡，比如Ribbon。进程内的负载均衡是指请求已经到达微服务，一般来说，请求方从注册中心获取可用的微服务调用地址，然后根据负载均衡规则选取合适的微服务，进行调用。

下面主要讲解基于Eureka的Ribbon集成。

二、依赖引入

由于eureka客户端组件已经整合Ribbon，所以只需要将eureka客户端依赖引入即可。（下图中红框就是eureka客户端对Ribbon的整合）

三、设置Ribbon负载均衡规则

这里是Ribbon的基于Eureka的架构图

由此可以发现Ribbon的机制就是从注册中心获取可用的服务列表到本地，然后利用对应的负载均衡规则将请求发送到对应的服务提供者上去。

那么Ribbon再结合RestTemplate使用时需要设置对应的负载均衡规则。

新建RestTemplate配置类

默认的负载均衡规则就是轮询。

如果需要设置其他的Ribbon所提供的负载均衡规则，则需要添加新的配置类

注意：该配置需要放在@ComponentScan可以扫描到包之外，或者说需要放在@SpringBootApplication所在的路径之外。

上面提到过Ribbon是将注册到注册中心的可用服务表进行相应的负载均衡规则之后，选择某一个服务将请求发送，而IRule接口中的choose就是Ribbon负载均衡选取服务的规则。
以上就是IRule接口的实现类，下面简单介绍几种规则，大家可以根据自身的需要自己选择。

四、修改启动类

！！！若是不选择IRule所提供的其他的负责均衡规则，只是选用默认轮询的方式，此步骤可以省略。

在启动类上面添加@RibbonClient(name = “CLOUD-PAYMENT-SERVICE”,configuration = RibbonRuleConfig.class)注解，表明在使用restremplate调用CLOUD-PAYMENT-SERVICE微服务接口时，使用的负载均衡规则来源于RibbonRuleConfig.class所定义的规则。

五、测试。

1.测试默认规则，仅配置RestTemplate实例，不配置RibbonRuleConfig，不添加@RibbonClient，使用默认负载均衡规则。结果如下：

默认为轮询规则，测试通过。

2.测试随机规则，配置RestTemplate实例，配置RibbonRuleConfig，添加@RibbonClient，使用随机负载均衡规则。结果如下

测试通过。

六、轮询规则源码解读

public Server choose(ILoadBalancer lb, Object key) {
        //ILoadBalancer用来从注册中心获取服务
        if (lb == null) {
            log.warn("no load balancer");
            return null;
        } else {
            Server server = null;//需要通过负载均衡选取的服务实例
            int count = 0;//重试次数，10次重试

            while(true) {//循环获取服务
                if (server == null && count++ < 10) {//10次重试
                    List reachableServers = lb.getReachableServers();//获取存活的服务
                    List allServers = lb.getAllServers();//获取所有服务
                    int upCount = reachableServers.size();//存活服务的数量
                    int serverCount = allServers.size();//所有服务数量
                    if (upCount != 0 && serverCount != 0) {//若是存活服务或者所有服务数量为0，则不选取服务，进行重试
                        int nextServerIndex = this.incrementAndGetModulo(serverCount);//nextServerIndex为所选择服务的下标
                        server = (Server)allServers.get(nextServerIndex);//获得服务
                        if (server == null) {
                            Thread.yield();//若是服务为null，当前线程让出资源。
                        } else {
                            if (server.isAlive() && server.isReadyToServe()) {//若是当前服务正常则返回。
                                return server;
                            }

                            server = null;
                        }
                        continue;
                    }
                    //10次重试之后没有获取到服务，就返回null
                    log.warn("No up servers available from load balancer: " + lb);
                    return null;
                }

                if (count >= 10) {
                    log.warn("No available alive servers after 10 tries from load balancer: " + lb);
                }

                return server;
            }
        }
    };

下面解析如何选择出下标。

private int incrementAndGetModulo(int modulo) {
        //modulo为所有服务数量
        int current;
        int next;
        /*利用自旋锁，先获取nextServerCyclicCounte当前值，注意nextServerCyclicCounte是一个AtomicInteger类型变量，
        所以保证了原子性，将当前值加一之后对所有服务的数量取余获取所选择服务的下标，
        若是在取余过程中nextServerCyclicCounte被篡改，那么就重新取值，重新取余，直到取到为止。
        （其实AtomicInteger有一个最大值为2147483647，理论上存在一直取不到值的情况，但实际中不会出现，个人见解，欢迎指正）*/
        do {
            current = this.nextServerCyclicCounter.get();
            next = (current + 1) % modulo;
        } while(!this.nextServerCyclicCounter.compareAndSet(current, next));

        return next;
    }

七、总结

此篇文章作为自己学习记录使用，里面有一些为自己的见解，欢迎大家指正交流。有兴趣的同学可以根据负载均衡规则，自行编写适用于自己的负载均衡规则。