入门介绍

Spring Cloud Ribbon是基于 Netflix Ribbon实现的一套客户端负载均衡的工具。

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

Ribbon目前也进入维护模式

Ribbon未来替换方案

是springcloud LoadBalancer

能做什么

负载均衡

LB负载均衡(Load Balance)是什么
简单的说就是将用户的请求平摊的分配到多个服务上,从而达到系统的HA(高可用)。
常见的负载均衡有软件 Nginx,LVS,硬件F5等。
Ribbon本地负载均衡客户端 VS Nginx服务端负载均衡区别
- Nginx是服务器负载均衡,客户端所有请求都会交给 nginx,然后由 nginx实现转发请求。即负载均衡是由服务端实现的。
- Ribbon本地负载均衡,在调用微服务接口时候,会在注册中心上获取注册信息服务列表之后缓存到M本地,从而在本地实现RPC远
  程服务调用技术。

总结一句话

负载均衡+ RestTemplate进行Rpc远程调用

负载均衡和Rest调用

架构说明

总结: Ribbon其实就是一个软负载均衡的客户端组件,他可以和其他所需请求的客户端结合使用,和 eureka结合只是其中的一个实例。

Ribbon在工作时分成两步

第一步先选择 EurekaServer,它优先选择在同一个区域内负载较少的 server.
第二步再根据用户指定的策略,在从 server取到的服务注册列表中选择一个地址。
其中 Ribbon提供了多种策略:比如轮询、随机和根据响应时间加权。

pom

之前写样例时候没有引入 spring-cloud-starter-ribbon也可以使用

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

猜测 spring-cloud-starter-netflix-eureka-client自带了spring-cloud-start-ribbon引用。

`RestTemplate`使用

官网

https://docs.spring.io/spring-framework/docs/5.2.2.RELEASE/javadoc-api/org/springframework/web/client/RestTemplate.html

postForObject和postForEntity使用

返回对象为响应体中数据转化成的对象,基本上可以理解为son

@GetMapping("/consumer/payment/create")
public R create(@RequestBody Payment payment) {
    return restTemplate.postForObject(PATMEMT_URL + "/payment/create",payment,R.class);
}

返回对象为 ResponseEntity对象,包含了响应中的一些重要信息,比如响应头、响应状态码、响应体等

@GetMapping("/consumer/payment/postForEntity/create")
public R createV2(@RequestBody Payment payment) {
    ResponseEntity<R> entity = restTemplate.postForEntity(PATMEMT_URL + "/payment/create", payment, R.class);
    if (entity.getStatusCode().is2xxSuccessful()) {
        log.info("状态码: {} " + "\t" + "请求头: {}",entity.getStatusCode(),entity.getHeaders());
        return entity.getBody();
    }
    return new R().error("创建订单失败");
}

Ribbon默认自带的负载规则

Ribbon核心组件IRule

IRule: 根据特定算法中从服务列表中选取一个要访问的服务

Ribbon提供了多种策略

如轮询、随机、根据响应时间加权。

RoundRobbinRule：轮询
RandomRule：随机
AvailavilityFilterRule：先过滤掉由于多次访问故障而处于断路器跳闸的服务，还有并发的连接数量超过阈值的服务，然后对剩余的服务列表按照轮询的策略进行访问
WeightedResponseTimeRule：根据响应时间计算权重，响应速度越快，被选中的几率越高。
RetryRule：先按照RoundRobinRule的策略获取服务，如果失败会重试
BestAviailableRule：会过滤到由于多次访问故障而处于断路器处于跳闸的状态的服务，然后选择一个并发量最小的服务
ZoneAvoidanceRule：默认规则，复合判断server所在区域的性能和server的可用性选择服务器

如何替换负载规则？

注意

在自定义配置类的时候不能放在 @ComponentScan 所扫描的当前包下以及子包下，否则我们自定义的这个配置类就会被所有的 Ribbon 客户端所共享，这样达不到特殊化定制的目的了

这话什么意思呢？因为 @SpringBootApplication 注解包含了 @ComponentScan 这个注解

简单地说，就是我们自定义的配置类不能放在与启动类同一子包下

新建规则类

package com.sgy.myrule;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MySelfRule {
    @Bean
    public IRule myRule() {
        // 返回随机
        return new RandomRule();
    }
}

修改启动类

/**
 * Created by AaronShen on 2020/5/26
 */
@SpringBootApplication
@EnableEurekaClient
// name 是服务提供者的实例名称
@RibbonClient(name = "CLOUD-PAYMENT-SERVER",configuration = MySelfRule.class)
public class OrderMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderMain80.class,args);
    }
}

访问页面

下面是连续刷新页面返回的结果，可以发现端口号并不是默认的轮询了

Ribbon默认负载轮询算法原理和源码

负载均衡算法：轮询

rest 接口第几次请求数 % 服务器集群总数量 = 实际调用服务器位置下标
每次服务器重启后rest接口数从1开始

List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PROVIDER-SERVICE")

如：

List[0] instances = 127.0.0.1:8002
List[1] instances = 127.0.0.1:8001

8001 + 8002 组合成为集群，它们共计2台机器，集群总数为2，按照轮询算法原理：

总请求数	对应下标	获得服务器地址
1	1 % 2 = 1	`127.0.0.1:8001`
2	2 % 2 = 0	`127.0.0.1:8002`
3	3 % 2 = 1	`127.0.0.1:8001`
4	4 % 2 = 0	`127.0.0.1:8002`
如此类推	….	….

源码

//IRule接口
public interface IRule{
    /*
     * choose one alive server from lb.allServers or
     * lb.upServers according to key
     * 
     * @return choosen Server object. NULL is returned if none
     *  server is available 
     */
    //选择哪个服务实例
    public Server choose(Object key);

    public void setLoadBalancer(ILoadBalancer lb);

    public ILoadBalancer getLoadBalancer();    
}

这块使用到了java中JUC（CAS和自旋锁知识）

public class RoundRobinRule extends AbstractLoadBalancerRule {

    private AtomicInteger nextServerCyclicCounter;
    private static final boolean AVAILABLE_ONLY_SERVERS = true;
    private static final boolean ALL_SERVERS = false;

    private static Logger log = LoggerFactory.getLogger(RoundRobinRule.class);

    public RoundRobinRule() {
        nextServerCyclicCounter = new AtomicInteger(0);
    }

    public RoundRobinRule(ILoadBalancer lb) {
        this();
        setLoadBalancer(lb);
    }

    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            log.warn("no load balancer");
            return null;
        }

        Server server = null;
        int count = 0;
        while (server == null && count++ < 10) {
            List<Server> reachableServers = lb.getReachableServers();
            List<Server> allServers = lb.getAllServers();
            int upCount = reachableServers.size();
            int serverCount = allServers.size();

            if ((upCount == 0) || (serverCount == 0)) {
                log.warn("No up servers available from load balancer: " + lb);
                return null;
            }

            int nextServerIndex = incrementAndGetModulo(serverCount);
            server = allServers.get(nextServerIndex);

            if (server == null) {
                /* Transient. */
                Thread.yield();
                continue;
            }

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

            // Next.
            server = null;
        }

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

    /**
     * Inspired by the implementation of {@link AtomicInteger#incrementAndGet()}.
     *
     * @param modulo The modulo to bound the value of the counter.
     * @return The next value.
     */
    private int incrementAndGetModulo(int modulo) {
        for (;;) {
            int current = nextServerCyclicCounter.get();
            int next = (current + 1) % modulo;
            if (nextServerCyclicCounter.compareAndSet(current, next))
                return next;
        }
    }

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

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

springcloud

Ribbon远程调用

入门介绍

Ribbon未来替换方案

能做什么

负载均衡

总结一句话

负载均衡和Rest调用

架构说明

pom

`RestTemplate`使用

Ribbon默认自带的负载规则

Ribbon核心组件IRule

Ribbon提供了多种策略

如何替换负载规则？

注意

新建规则类

修改启动类

访问页面

Ribbon默认负载轮询算法原理和源码

负载均衡算法：轮询

源码

手写轮询算法 (待学习)

Ribbon远程调用

入门介绍

Ribbon未来替换方案

能做什么

负载均衡

总结一句话

负载均衡和Rest调用

架构说明

pom

RestTemplate使用

Ribbon默认自带的负载规则

Ribbon核心组件IRule

Ribbon提供了多种策略

如何替换负载规则？

注意

新建规则类

修改启动类

访问页面

Ribbon默认负载轮询算法原理和源码

负载均衡算法： 轮询

源码

手写轮询算法 (待学习)

`RestTemplate`使用

负载均衡算法：轮询