三、搭建springCloudAlibaba2021.1版本分布式微服务-springcloud loadbalancer负载均衡

发布时间：2022-07-11 18:54:31 作者：yexindonglai@163.com 阅读（1539）

什么是负责均衡

Spring Cloud LoadBalancer是一个客户端负载均衡器，类似于Ribbon，但是由于Ribbon已经进入维护模式，并且Ribbon 2并不与Ribbon 1相互兼容，所以Spring Cloud全家桶在Spring Cloud Commons项目中，添加了Spring cloud Loadbalancer作为新的负载均衡器，并且做了向前兼容，就算你的项目中继续用 Spring Cloud Netflix 套装（包括Ribbon，Eureka，Zuul，Hystrix等等）让你的项目中有这些依赖，你也可以通过简单的配置，把ribbon替换成Spring Cloud LoadBalancer。

ribbon与LoadBalance区别

SpringCloud原有的客户端负载均衡方案Ribbon已经被废弃，取而代之的是SpringCloud LoadBalancer。本文介绍SpringCloud LoadBalancer的搭建和测试验证过程。

  1. ribbon和loadbalancer都是springcloud的负载均衡组件
  2. ribbon是Netflix开源的基于HTTP和TCP等协议负载均衡组件，loadBalancer是SpringCloud自己写的，根据服务id获取负载均衡器rpc地址。
  3. Ribbon的使用需要代码里手动调用目标服务，loadBalancer底层原理是默认调用ribbon的实现客户端负载均衡
  4. Ribbon从2019年5月份后就不维护了，后期loadbalancer会成为主流，目前还是ribbon用的多。Loadbalancer支持ribbon。
  5. ribbon 提供7中默认的负载均衡策略，常见的常见都有覆盖，一般我们都是使用 ZoneAvoidanceRule 复合判断server所在区域的性能和server的可用性选择server
  6. ribbon 支持超时、懒加载处理、重试及其和 hystrix整合高级属性等
  7. 目前spring-cloud-loadbalancer 仅支持 重试操作的配置

2021.x 注意事项

Spring cloud alibaba 的Nacos最新版中，有以下几个问题

  1. nacos 2021 版本已经没有自带ribbon的整合，所以需要引入另一个支持的jar包 loadbalancer
  2. nacos 2021 版本已经取消了对ribbon的支持，所以无法通过修改Ribbon负载均衡的模式来实现nacos提供的负载均衡模式

开始搭建

1、创建工程

首下创建一个名为 spring-cloud-alibaba-2021-loadbalancer 的工程，继承spring-cloud-alibaba-2021父项目

2、pom.xml 文件内容
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>spring-cloud-alibaba-2021</artifactId>
  7.         <groupId>org.example</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>spring-cloud-alibaba-2021-loadbalancer</artifactId>
  15.     <dependencies>
  16.         <!-- springweb 启动依赖 -->
  17.         <dependency>
  18.             <groupId>org.springframework.boot</groupId>
  19.             <artifactId>spring-boot-starter-web</artifactId>
  20.         </dependency>
  21.         <!-- nacos 服务注册发现（客户端）依赖 -->
  22.         <dependency>
  23.             <groupId>com.alibaba.cloud</groupId>
  24.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  25.         </dependency>
  26.         <!-- nacos-config 配置中心依赖 -->
  27.         <dependency>
  28.             <groupId>com.alibaba.cloud</groupId>
  29.             <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
  30.         </dependency>
  31.         <!--spring-cloud-dependencies 2020.0.0 版本不在默认加载bootstrap.yml 文件，如果需要加载bootstrap 文件需要手动添加依赖-->
  32.         <dependency>
  33.             <groupId>org.springframework.cloud</groupId>
  34.             <artifactId>spring-cloud-starter-bootstrap</artifactId>
  35.         </dependency>
  38.         <!--loadbalancer ，负载均衡，用来替代ribbon的组件 -->
  39.         <dependency>
  40.             <groupId>org.springframework.cloud</groupId>
  41.             <artifactId>spring-cloud-starter-loadbalancer</artifactId>
  42.         </dependency>
  44.     </dependencies>
  45. </project>
3、application.yml
  1. server:
  2.   port: 7001
  3. spring:
  4.   # 后面的bean会覆盖前面相同名称的bean
  5.   main:
  6.     allow-bean-definition-overriding: true
4、bootstrap.yml
  1. spring:
  2.   application:
  3.     name: ribbon-demo
  4.   profiles:
  5.     active: yexindong_active
  6.   cloud:
  7.     nacos:
  8.       discovery:
  9.         server-addr: chn520.cn:8848 # 服务注册中心地址
  10.         namespace: public # 注册到nacos的名称空间，默认为public
  11.       config:
  12.         prefix: yexindong_nacos_prefix
  13.         file-extension: yaml  # 指定yaml格式的配置, 必须要放到bootstrao.yml 才会生效，放到application下不会生效
  14.         server-addr: chn520.cn:8848 #配置中心地址
  15.         group: DEFAULT_GROUP
5、启动类 RibbonApp.java
  1. package com.alibaba.cloud;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
  7. @SpringBootApplication
  8. @EnableDiscoveryClient
  9. public class RibbonApp {
  10.     public static void main(String[] args) {
  11.         SpringApplication.run(RibbonApp.class, args);
  12.     }
  13. }
6、控制层 RibbonController.java
  1. package com.alibaba.cloud.controller;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.beans.factory.annotation.Value;
  5. import org.springframework.cloud.context.config.annotation.RefreshScope;
  6. import org.springframework.web.bind.annotation.RequestMapping;
  7. import org.springframework.web.bind.annotation.RestController;
  8. import org.springframework.web.client.RestTemplate;
  10. @RestController
  11. @RequestMapping("/ribbon")
  12. public class RibbonController {
  14.     @Autowired
  15.     private RestTemplate restTemplate;
  17.     /**
  18.      * 远程调用订单服务的接口
  19.      * @return
  20.      */
  21.     @RequestMapping("/getRibbon")
  22.     public String getRibbon(){
  23.         // 以下2种方式都都可以调用远程服务
  24.         String url  = "http://order-demo/order/getOrderById";
  25. //        String url  = "http://localhost:8088/order/getOrderById";
  26.         String res = restTemplate.getForObject(url, String.class);
  27.         return "restTemplate 响应："+res;
  28.     }
  29. }
7、自定义负载均衡配置

SpringBeanConfiguration.java 内容如下

  1. package com.alibaba.cloud.config;
  3. import org.springframework.boot.web.client.RestTemplateBuilder;
  4. import org.springframework.cloud.client.loadbalancer.LoadBalanced;
  5. import org.springframework.cloud.loadbalancer.annotation.LoadBalancerClients;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.web.client.RestTemplate;
  10. /**
  11.  * @program: my-town
  12.  * @author: 洛天
  13.  * @create: 2021-12-13 16:27
  14.  **/
  15. @Configuration
  16. // 在这里配置我们自定义的LoadBalancer策略，注：这里的类为注入Bean的类，而非负载均衡的实现类
  17. @LoadBalancerClients(defaultConfiguration = {NacosSameClusterConfiguration.class})
  18. public class SpringBeanConfiguration {
  20.     @Bean
  21.     @LoadBalanced // 开启负载均衡，必须的
  22.     public RestTemplate restTemplate(RestTemplateBuilder restTemplateBuilder){
  23.         return restTemplateBuilder.build();
  24.     }
  25. }

NacosSameClusterConfiguration.java 调用负载均衡算法，选取其中的一个节点

  1. package com.alibaba.cloud.config;
  2. import org.springframework.cloud.client.ServiceInstance;
  3. import org.springframework.cloud.loadbalancer.core.ReactorLoadBalancer;
  4. import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
  5. import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.core.env.Environment;
  9. //这里不用写Configuration
  10. public class NacosSameClusterConfiguration{
  11.     @Bean
  12.     ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment environment,
  13.                                                             LoadBalancerClientFactory loadBalancerClientFactory) {
  14.         // 获取远程调用的服务名称
  15.         String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
  17.         // 返回内容为自定义负载均衡的配置类
  18.         return new NacosSameClusterWeightedRule(loadBalancerClientFactory
  19.                 .getLazyProvider(name, ServiceInstanceListSupplier.class),
  20.                 name);
  21.     }
  22. }

NacosSameClusterWeightedRule.java 自定义负载均衡的实现类

  1. package com.alibaba.cloud.config;
  3. import com.alibaba.cloud.nacos.NacosDiscoveryProperties;
  4. import org.springframework.beans.factory.ObjectProvider;
  5. import org.springframework.cloud.client.ServiceInstance;
  6. import org.springframework.cloud.client.loadbalancer.DefaultResponse;
  7. import org.springframework.cloud.client.loadbalancer.EmptyResponse;
  8. import org.springframework.cloud.client.loadbalancer.Request;
  9. import org.springframework.cloud.client.loadbalancer.Response;
  10. import org.springframework.cloud.loadbalancer.core.NoopServiceInstanceListSupplier;
  11. import org.springframework.cloud.loadbalancer.core.ReactorServiceInstanceLoadBalancer;
  12. import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
  13. import reactor.core.publisher.Mono;
  15. import javax.annotation.Resource;
  16. import java.util.List;
  17. import java.util.Random;
  20. // 自定义负载均衡实现需要实现 ReactorServiceInstanceLoadBalancer 接口 以及重写choose方法
  21. public class NacosSameClusterWeightedRule implements ReactorServiceInstanceLoadBalancer {
  23.     // 注入当前服务的nacos的配置信息
  24.     @Resource
  25.     private NacosDiscoveryProperties nacosDiscoveryProperties;
  27.     // loadbalancer 提供的访问当前服务的名称
  28.     final String serviceId;
  30.     // loadbalancer 提供的访问的服务列表
  31.     ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
  33.     public NacosSameClusterWeightedRule(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider, String serviceId) {
  34.         this.serviceId = serviceId;
  35.         this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
  36.     }
  38.     /**
  39.      * 服务器调用负载均衡时调的放啊
  40.      * 此处代码内容与 RandomLoadBalancer 一致
  41.      */
  42.     @Override
  43.     public Mono<Response<ServiceInstance>> choose(Request request) {
  44.         ServiceInstanceListSupplier supplier = this.serviceInstanceListSupplierProvider.getIfAvailable(NoopServiceInstanceListSupplier::new);
  45.         Mono<Response<ServiceInstance>> map1 = supplier.get(request).next().map((list) -> {
  46.             Response<ServiceInstance> serviceInstanceResponse = this.getInstanceResponse(list);
  47.             ;
  48.             return serviceInstanceResponse;
  49.         });
  50.         return map1;
  52.     }
  54.     /**
  55.      * 对负载均衡的服务进行筛选的方法
  56.      * 自定义
  57.      * 此处的 instances 实例列表  只会提供健康的实例  所以不需要担心如果实例无法访问的情况
  58.      */
  59.     private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> instances) {
  60.         if (instances.isEmpty()) {
  61.             return new EmptyResponse();
  62.         }
  63.         // 获取当前服务所在的集群名称
  64. //        String currentClusterName = nacosDiscoveryProperties.getClusterName();
  65.         // 过滤在同一集群下注册的服务 根据集群名称筛选的集合
  66. //        List<ServiceInstance> sameClusterNameInstList  = instances.stream().filter(i-> StringUtils.equals(i.getMetadata().get("nacos.cluster"),currentClusterName)).collect(Collectors.toList());
  67. //        ServiceInstance sameClusterNameInst;
  68. //        if (sameClusterNameInstList.isEmpty()) {
  69. //            // 如果为空，则根据权重直接过滤所有服务列表
  70. //            sameClusterNameInst = getHostByRandomWeight(instances);
  71. //        } else {
  72. //            // 如果不为空，则根据权重直接过滤所在集群下的服务列表
  73. //            sameClusterNameInst = getHostByRandomWeight(sameClusterNameInstList);
  74. //        }
  76.         // 随机选择一个节点
  77.         int size = instances.size();
  78.         int index = new Random().nextInt(size);  // 如果size为2，生成 0-1之间的随机数；如果为10，生成0-9之间的随机数
  79.         System.out.println("生成的随机数为：" + index);
  80.         ServiceInstance serviceInstance = instances.get(index);
  81.         return new DefaultResponse(serviceInstance);
  82.     }
  83. }
8、父工程加入 module

在 父项目（spring-cloud-alibaba-2021）加入以下内容

  1.     <modules>
  2.         <module>spring-cloud-alibaba-2021-loadbalancer</module>
  3.     </modules>
9、搭建完成

此时工程目录如下图

测试

在浏览器输入http://127.0.0.1:7001/ribbon/getRibbon后回车，显示以下内容，表示测试成功

关键字： SpringCloud

上一篇： maven 指定jdk版本

下一篇： 五、搭建springCloudAlibaba2021.1版本分布式微服务-gateway网关

评论区
导航
博主信息
博客搜索
热门推荐
点击排行
扫我关注
响应式图片
隔壁邻居
叶新东老师的博客-CSDN 所得皆惊喜的博客 java小虚竹的博客 小雨青年的博客 我爱画图