SpringCloud 2025-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;
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;
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 {
18. @Bean(name = "myRandomRule")
19. public IRule myRule(){
20. return new RandomRule();//定义为随机
21. }
22. }

4、主启动类添加@RibbonClient

1. package com.liukai.springcloud;
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;
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 {
21. public static void main(String[] args) {
22. SpringApplication.run(OrderMain80.class);
23. }
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. }
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();
15. if ((upCount == 0) || (serverCount == 0)) {
16. log.warn("No up servers available from load balancer: " + lb);
17. return null;
18. }
20. int nextServerIndex = incrementAndGetModulo(serverCount);
21. server = allServers.get(nextServerIndex);
23. if (server == null) {
24. /* Transient. */
25. Thread.yield();
26. continue;
27. }
29. if (server.isAlive() && (server.isReadyToServe())) {
30. return (server);
31. }
33. // Next.
34. server = null;
35. }
37. if (count >= 10) {
38. log.warn("No available alive servers after 10 tries from load balancer: "
39. + lb);
40. }
41. return server;
42. }
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;
3. import org.springframework.cloud.client.ServiceInstance;
5. import java.util.List;
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;
3. import org.springframework.cloud.client.ServiceInstance;
4. import org.springframework.stereotype.Component;
6. import java.util.List;
7. import java.util.concurrent.atomic.AtomicInteger;
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 {
19. private AtomicInteger atomicInteger = new AtomicInteger(0);
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. }
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;
4. @Resource
5. private DiscoveryClient discoveryClient;
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负载均衡内容请搜索快网idc以前的文章或继续浏览下面的相关文章希望大家以后多多支持快网idc！

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