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

时间:2022-08-26 17:16:29

1、概述

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

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

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

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

LB(负载均衡

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

集中式LB

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

进程内LB

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

Ribbon就是负载均衡+RestTemplate调用

2、Ribbon负载均衡演示

1、架构说明

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

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

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

3、二说RestTemplate的使用

官网
修改cloud-consumer-order80

getForObject方法/getForEntity方法

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

postForObject/postForEntity

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

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

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

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

3、Ribbon核心组件IRule

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

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

Ribbon自带负载均衡算法:

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

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

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

2、新建package

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

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
多方问几次,可以发现查询的端口号是随机的,而不是交替出现了

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

4、Ribbon负载均衡算法

4.1 原理 + 源码

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

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

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 2020-Ribbon负载均衡服务调用的实现

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

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