服务调用之Ribbon-吉桂权的个人主

一、Ribbon入门介绍

1、Ribbon是什么？

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

简单地说，Ribbon是netflix公司发布的开源项目，主要功能是提供 客户端的软件负载均衡算法和服务调用。

Ribbon客户端组件提供一系列完善的配置项如连接超时、重试等；

就是在配置文件中列出 Load Balancer（简称LB）后面所有的机器，Ribbon会自动地帮助你基于某种规则（如简单轮询、随机连接等）去连接这些机器。

我们很容易使用Ribbon实现自定义的负载均衡算法。

2、Ribbon已经进入了维护期；

——当前在实际生产中，还在大规模的使用；

替换方案：Loadbalancer

3、Load Balancer负载均衡介绍

负载均衡就是将用户的请求分摊到多个服务提供者上，从而实现整体系统的HA高可用；常见的负载均衡有软件Nginx、LVS、硬件F5等；

集中式LB：在服务的消费方和提供方之间使用独立的LB设施（可以使软件NGinx、LVS，也可以是硬件F5等），由该设施负责把访问请求通过某种策略转发到服务的提供方；
进程内LB：将LB的逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择出一个合适的服务器；（故而，应该在消费方服务中实现）；

Ribbon本地负载均衡 vs Nginx服务端负载均衡 的区别：

Nginx服务端负载均衡：客户端所有的请求都会交给Nginx，然后由Nginx实现转发请求，即负载均衡是由服务端Nginx软件实现的；
Ribbon本地负载均衡：在调用微服务接口的时候，会在注册中心上获取注册信息服务列表之后缓存到JVM本地，次你个人在本地实现RPC远程服务调用技术；

4、Ribbon和Eureka结合使用的架构：

当我们引入eureka-client后，ribbon就已经自动被引入了，由dependencies可知：

所以我们在使用eureka-client的时候，可以直接使用ribbon；

Ribbon = 负载均衡 + RestTemplate

二、再说RestTemplate

RestTemplate主要有（Entity和Object两大类）：

getForObject、getForEntity、postForObject、postForEntity等方法；

1、修改OrderController，使用getForEntity代替原来的getForObject：

@RestController
@Slf4j
public class OrderController {
//    private static final String PAYMENT_URL = "http://localhost:8001";
    private static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/consumer/payment/getForEntity/{id}")
    public CommonResult<Payment> getPayment2(@PathVariable("id") Long id){
        ResponseEntity<CommonResult> entity = restTemplate.getForEntity(PAYMENT_URL + "/payment/get/" + id, CommonResult.class);
        if (entity.getStatusCode().is2xxSuccessful()){
            return entity.getBody();
        } else {
            return new CommonResult<>(444, "操作失败");
        }
    }
}

2、重启后，访问 http://localhost/consumer/payment/getForEntity/6

三、Ribbon自带的默认的负载规则替换

1、Ribbon的核心组件IRule：

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

IRule是一个接口，有很多落地的实现，每一个落地实现都是一种对应的负载均衡算法；

Ribbon自带的常见常用的大概有以下七种负载均衡规则：

RoundRobinRule：轮询；
RandomRule：随机；
RetryRule：先按照RoundRobinRule的策略获取服务，如果获取服务失败，则在指定时间内会进行重试；
WeightedResponseTimeRule：对RoundRobinRule的扩展，响应速度越快的实例被选择权重越大，越容易被选择；
BestAvailableRule：会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务（熔断），然后选择一个并发量最小的服务；
AvailabilityFilteringRule：先过滤掉故障实例，在悬着并发较小的实例；
ZoneAvoidanceRule：默认规则，复合判断server所在区域的性能和server的可用性选择服务器；

2、如何替换默认的负载均衡策略：——出厂默认是轮询

2.1、新建package包：com.jiguiquan.myrule：

注意：官方文档明确给出警告：

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

2.2、在上面新建的包下，新建MySelfRule规则类：

@Configuration
public class MySelfRule {
    @Bean
    public IRule myRule(){
        return new RandomRule();  //定义为随机策略
    }
}

2.3、主启动类上添加注解 @RibbonClient()

@SpringBootApplication
@EnableEurekaClient
//即MySelfRule策略只对CLOUD-PAYMENT-SERVICE服务的调用生效
@RibbonClient(name = "CLOUD-PAYMENT-SERVICE", configuration = MySelfRule.class)
public class OrderMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderMain80.class, args);
    }
}

2.4、重启、测试：访问 http://localhost/consumer/payment/get/6

可以正常访问，且不再是简单轮询，而是变为了随机策略；

四、Ribbon默认轮询RoundRobinRule算法原理及源码分析

默认的轮询RoundRobinRule负载均衡算法原理——经典：

rest接口第几次请求数 % 服务器集群总数量 = 实际调用服务器位置下标；

每次服务器重启后rest接口调用计数从1开始，执行过程描述如下：

五、手写一个负载均衡算法

原理 + JUC （CAS比较并交换 + 自旋锁的复习）

尝试写一个本地负载均衡器

1、payment8001和payment8002服务改造：在PaymentController中增加getPaymentLB方法：

//只需要简单的返回端口号的功能即可
@GetMapping(value = "/payment/lb")
public String getPaymentLB(){
    return serverPort;
}

2、开始修改order80服务，将ApplicationContextConfig配置类中@LoadBalanced注解去掉

这样，如果待会新的负载均衡起效了，必定是我们自己实现的负载均衡器！

3、创建新的接口： com.jiguiquan.springcloud.lb.LoadBalancer

public interface LoadBalancer {
    //根据传值，返回将要访问的ServiceInstance
    ServiceInstance instances(List<ServiceInstance> serviceInstances);
}

4、创建上面自定义的LoadBalancer的实现类 MyLB.java

注意此类需要加上注解 @Component 注解，以使我们的Spring容器能够扫描得到这个类；

@Component
public class MyLB implements LoadBalancer {
    //可以模仿轮询算法RoundRobinRule的写法，需要一个atomicInteger原子整醒了变量
    private AtomicInteger atomicInteger = new AtomicInteger(0);

    //自旋锁 + CAS 线程安全的方式获得下一个计数值
    public final int getAndIncrement(){
        int current;
        int next;
        //自旋锁，同RoundRobinRule
        do {
            current = this.atomicInteger.get();
            next = current >= Integer.MAX_VALUE ? 0 : current + 1;
        } while (!this.atomicInteger.compareAndSet(current,next));  //CAS基础，期望值是current，修改值为next，如果current被修改过，那么就自旋
        System.out.println("*******第几次访问，次数next: " + next);
        return next;
    }

    @Override
    public ServiceInstance instances(List<ServiceInstance> serviceInstances) {
        int index = getAndIncrement() % serviceInstances.size();
        return serviceInstances.get(index);
    }
}

5、修改OrderController，在其中映入我们自定义的LoadBalancer（别引入错误了）

@RestController
@Slf4j
public class OrderController {
//    private static final String PAYMENT_URL = "http://localhost:8001";
//    private static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";

    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private LoadBalancer loadBalancer;
    @Autowired
    private DiscoveryClient discoveryClient;

    @GetMapping(value = "/consumer/payment/lb")
    public String getPaymentLB(){
        List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
        if (CollectionUtils.isEmpty(instances)){
            return null;
        }
        ServiceInstance serviceInstance = loadBalancer.instances(instances);
        URI uri = serviceInstance.getUri();
        return restTemplate.getForObject(uri + "/payment/lb", String.class);
    }
}

6、重启Order80服务，访问： http://localhost/consumer/payment/lb

访问正常，并且实现的效果和默认轮询算法一致：console控制台输出如下：

到这里 Ribbon 的基本使用就结束了！

个人此项目代码地址（持续更新）：

https://github.com/jiguiquan/cloud2020