SpringCloud 2020-Ribbon负载均衡服务调用的实现

1、概述

官网：https://github.com/Netflix/ribbon/wiki/Getting-Started

Ribbon目前也进入维护模式，未来替换方案：

LB（负载均衡）

集中式LB

进程内LB

Ribbon就是负载均衡+RestTemplate调用

2、Ribbon负载均衡演示

1、架构说明

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

3、二说RestTemplate的使用

官网
修改cloud-consumer-order80

getForObject方法/getForEntity方法

postForObject/postForEntity

• GET请求方法
• POST请求方法

4、依次2启动7001，7002，8001，8002，80。访问：http://localhost/consumer/payment/getForEntity/31

3、Ribbon核心组件IRule

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

Ribbon自带负载均衡算法：

如何替换负载均衡算法：修改cloud-consumer-order80
1、注意配置细节

2、新建package

3、在myrule下面新建配置类MySelfRule

1. package com.liukai.myrule;
2.  
3. import com.netflix.loadbalancer.IRule;
4. import com.netflix.loadbalancer.RandomRule;
5. import org.springframework.context.annotation.Bean;
6. import org.springframework.context.annotation.Configuration;
7.  
8. /**
9. * @author liukai
10. * @version 1.0.0
11. * @ClassName MySelfRule.java
12. * @Description TODO
13. * @createTime 2021年03月21日 11:50:00
14. */
15. @Configuration
16. public class MySelfRule {
17.  
18. @Bean(name = "myRandomRule")
19. public IRule myRule(){
20. return new RandomRule();//定义为随机
21. }
22. }

4、主启动类添加@RibbonClient

1. package com.liukai.springcloud;
2.  
3. import com.liukai.myrule.MySelfRule;
4. import org.springframework.boot.SpringApplication;
5. import org.springframework.boot.autoconfigure.SpringBootApplication;
6. import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
7. import org.springframework.cloud.netflix.ribbon.RibbonClient;
8.  
9. /**
10. * @author liukai
11. * @version 1.0.0
12. * @ClassName OrderMain80.java
13. * @Description TODO
14. * @createTime 2021年03月19日 18:27:00
15. */
16. @SpringBootApplication
17. @EnableEurekaClient
18. @RibbonClient(name = "CLOUD-PAYMENT-SERVICE",configuration = MySelfRule.class)
19. public class OrderMain80 {
20.  
21. public static void main(String[] args) {
22. SpringApplication.run(OrderMain80.class);
23. }
24.  
25. }

5、测试：依次启动7001，7002，8001，8002，cloud-consumer-order80
访问：http://localhost/consumer/payment/get/31
多方问几次，可以发现查询的端口号是随机的，而不是交替出现了

4、Ribbon负载均衡算法

4.1 原理 + 源码

1、注释掉cloud-consumer-order80主启动类的@RibbonClient
2、原理

3、源码：

1. public Server choose(ILoadBalancer lb, Object key) {
2. if (lb == null) {
3. log.warn("no load balancer");
4. return null;
5. }
6.  
7. Server server = null;
8. int count = 0;
9. while (server == null && count++ < 10) {
10. List<Server> reachableServers = lb.getReachableServers();
11. List<Server> allServers = lb.getAllServers();
12. int upCount = reachableServers.size();
13. int serverCount = allServers.size();
14.  
15. if ((upCount == 0) || (serverCount == 0)) {
16. log.warn("No up servers available from load balancer: " + lb);
17. return null;
18. }
19.  
20. int nextServerIndex = incrementAndGetModulo(serverCount);
21. server = allServers.get(nextServerIndex);
22.  
23. if (server == null) {
24. /* Transient. */
25. Thread.yield();
26. continue;
27. }
28.  
29. if (server.isAlive() && (server.isReadyToServe())) {
30. return (server);
31. }
32.  
33. // Next.
34. server = null;
35. }
36.  
37. if (count >= 10) {
38. log.warn("No available alive servers after 10 tries from load balancer: "
39. + lb);
40. }
41. return server;
42. }
43.  
44. /**
45. * Inspired by the implementation of {@link AtomicInteger#incrementAndGet()}.
46. *
47. * @param modulo The modulo to bound the value of the counter.
48. * @return The next value.
49. */
50. private int incrementAndGetModulo(int modulo) {
51. for (;;) {
52. int current = nextServerCyclicCounter.get();
53. int next = (current + 1) % modulo;
54. if (nextServerCyclicCounter.compareAndSet(current, next))
55. return next;
56. }
57. }

4.2 手写负载均衡算法

1、修改8001，8002的controller

1. // 手写负载均衡需要用到
2. @GetMapping(value = "/payment/lb")
3. public String getPaymentLB(){
4. return serverPort;
5. }

2、cloud-consumer-order80的ApplicationContextBean去掉@LoadBalanced
3、新建接口LoadBalancer

1. package com.liukai.springcloud.lb;
2.  
3. import org.springframework.cloud.client.ServiceInstance;
4.  
5. import java.util.List;
6.  
7. /**
8. * @author liukai
9. * @version 1.0.0
10. * @ClassName LoadBalancer.java
11. * @Description TODO
12. * @createTime 2021年03月21日 12:24:00
13. */
14. public interface LoadBalancer {
15. //收集服务器总共有多少台能够提供服务的机器，并放到list里面
16. ServiceInstance instances(List<ServiceInstance> serviceInstances);
17. }

4、新建实现类MyLB

1. package com.liukai.springcloud.lb;
2.  
3. import org.springframework.cloud.client.ServiceInstance;
4. import org.springframework.stereotype.Component;
5.  
6. import java.util.List;
7. import java.util.concurrent.atomic.AtomicInteger;
8.  
9. /**
10. * @author liukai
11. * @version 1.0.0
12. * @ClassName MyLB.java
13. * @Description TODO
14. * @createTime 2021年03月21日 12:27:00
15. */
16. @Component
17. public class MyLB implements LoadBalancer {
18.  
19. private AtomicInteger atomicInteger = new AtomicInteger(0);
20.  
21. //坐标
22. private final int getAndIncrement() {
23. int current;
24. int next;
25. do {
26. current = this.atomicInteger.get();
27. next = current >= 2147483647 ? 0 : current + 1;
28. } while (!this.atomicInteger.compareAndSet(current, next)); //第一个参数是期望值，第二个参数是修改值是
29. System.out.print("*******第几次访问，次数next: " + next);
30. return next;
31. }
32.  
33. @Override
34. public ServiceInstance instances(List<ServiceInstance> serviceInstances) { //得到机器的列表
35. int index = getAndIncrement() % serviceInstances.size(); //得到服务器的下标位置
36. System.out.println(" ====>端口：" + serviceInstances.get(index).getPort());
37. return serviceInstances.get(index);
38. }
39. }

5、修改OrderController

1. @Resource
2. private LoadBalancer loadBalancer;
3.  
4. @Resource
5. private DiscoveryClient discoveryClient;
6.  
7. @GetMapping(value = "/consumer/payment/lb")
8. public String getPaymentLB(){
9. List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
10. if (instances == null || instances.size() <= 0){
11. return null;
12. }
13. // instances.forEach(System.out::println);
14. // 使用手写的负载均衡算法获取服务
15. ServiceInstance serviceInstance = loadBalancer.instances(instances);
16. // 获取服务的地址
17. URI uri = serviceInstance.getUri();
18. // 拼接地址访问
19. return restTemplate.getForObject(uri+"/payment/lb",String.class);
20. }

6、测试：访问 http://localhost/consumer/payment/lb
发现访问的端口号开始轮询出现，手写负载均衡轮询算法成功

到此这篇关于SpringCloud 2020-Ribbon负载均衡服务调用的实现的文章就介绍到这了,更多相关SpringCloud Ribbon负载均衡内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/Cool_Boy23955/article/details/115044624