Spring Cloud Nacos 2021 放弃Ribbon后使用LoadBalancer + Nacos做负载均衡实现同集群优先调用以及权重算法

2022-06-14 12:37:55

最近在倒腾SpringBoot整合Nacos最新版，暂时发现以下几个问题

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

以上仅为个人观点，下面为我的实现方式

第一个问题，使用nacos 2021.1 版本实现负载均衡

nacos最新版 2021.1版本中

<dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId><version>2021.1</version></dependency>

这个包已经不提供ribbon支持，需要引入另一个jar包

<dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-loadbalancer</artifactId></dependency>

使用这个包来实现负载均衡

具体实现方式和先前版本一样

@Bean@LoadBalanced//负载均衡注解publicRestTemplaterestTemplate(){returnnewRestTemplate();}

注册bean的同时，添加LoadBalanced负载均衡注解，到这一步为止，可以实现基本的负载均衡功能，负载均衡默认配置为轮询配置

那么接下来，第二个问题，需要实现基于Nacos的负载均衡模式，需要通过自定义loadbalancer负载均衡的方式进行实现，以下内容是经过查阅多方文档进行整合，最终使用自己的代码实现的内容

1.首先需要实现 loadbalancer 自定义负载均衡模式进行注入

一共有两种写法，可以直接在Spring配置文件中注入Bean，但是这样的话，在 LoadBalancerClients 提供的类里需要写为Spring的配置文件类

importorg.springframework.cloud.client.ServiceInstance;importorg.springframework.cloud.client.loadbalancer.LoadBalanced;importorg.springframework.cloud.loadbalancer.annotation.LoadBalancerClients;importorg.springframework.cloud.loadbalancer.core.ReactorLoadBalancer;importorg.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;importorg.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;importorg.springframework.context.annotation.Bean;importorg.springframework.context.annotation.ComponentScan;importorg.springframework.context.annotation.Configuration;importorg.springframework.core.env.Environment;importorg.springframework.web.client.RestTemplate;/**
 * @program: my-town
 * @author: 洛天
 * @create: 2021-12-13 16:27
 **/@Configuration@LoadBalancerClients(defaultConfiguration={SpringBeanConfiguration.class})publicclassSpringBeanConfiguration{@Bean@LoadBalancedpublicRestTemplaterestTemplate(){returnnewRestTemplate();}@BeanReactorLoadBalancer<ServiceInstance>randomLoadBalancer(Environment environment,LoadBalancerClientFactory loadBalancerClientFactory){String name= environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);returnnewNacosSameClusterWeightedRule(loadBalancerClientFactory.getLazyProvider(name,ServiceInstanceListSupplier.class),
                name);}}

或，新建一个类

importorg.springframework.cloud.client.ServiceInstance;importorg.springframework.cloud.loadbalancer.core.ReactorLoadBalancer;importorg.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;importorg.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;importorg.springframework.context.annotation.Bean;importorg.springframework.core.env.Environment;//这里不用写ConfigurationpublicclassNacosSameClusterConfiguration{@BeanReactorLoadBalancer<ServiceInstance>randomLoadBalancer(Environment environment,LoadBalancerClientFactory loadBalancerClientFactory){String name= environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);// 返回内容为自定义负载均衡的配置类returnnewNacosSameClusterWeightedRule(loadBalancerClientFactory.getLazyProvider(name,ServiceInstanceListSupplier.class),
                name);}}

importorg.springframework.cloud.client.loadbalancer.LoadBalanced;importorg.springframework.cloud.loadbalancer.annotation.LoadBalancerClients;importorg.springframework.context.annotation.Bean;importorg.springframework.context.annotation.ComponentScan;importorg.springframework.context.annotation.Configuration;importorg.springframework.web.client.RestTemplate;/**
 * @program: my-town
 * @author: 洛天
 * @create: 2021-12-13 16:27
 **/@Configuration// 在这里配置我们自定义的LoadBalancer策略，注：这里的类为注入Bean的类，而非负载均衡的实现类@LoadBalancerClients(defaultConfiguration={NacosSameClusterConfiguration.class})publicclassSpringBeanConfiguration{@Bean@LoadBalancedpublicRestTemplaterestTemplate(){returnnewRestTemplate();}}

接下来，就是实现自定义的负载均衡，基于nacos的同集群优先调用以及基于权重调用 思想实现

以下代码参考部分网络文档，以及官方的RandomLoadBalancer实现类

importjava.math.BigDecimal;importjava.util.*;importjava.util.stream.Collectors;importcom.alibaba.cloud.nacos.NacosDiscoveryProperties;importcom.alibaba.nacos.api.naming.pojo.Instance;importcom.alibaba.nacos.api.utils.StringUtils;importcom.alibaba.nacos.client.naming.core.Balancer;importlombok.extern.slf4j.Slf4j;importorg.springframework.beans.factory.ObjectProvider;importorg.springframework.cloud.client.ServiceInstance;importorg.springframework.cloud.client.loadbalancer.DefaultResponse;importorg.springframework.cloud.client.loadbalancer.EmptyResponse;importorg.springframework.cloud.client.loadbalancer.Request;importorg.springframework.cloud.client.loadbalancer.Response;importorg.springframework.cloud.loadbalancer.core.NoopServiceInstanceListSupplier;importorg.springframework.cloud.loadbalancer.core.ReactorServiceInstanceLoadBalancer;importorg.springframework.cloud.loadbalancer.core.SelectedInstanceCallback;importorg.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;importreactor.core.publisher.Mono;importjavax.annotation.Resource;@Slf4j// 自定义负载均衡实现需要实现 ReactorServiceInstanceLoadBalancer 接口 以及重写choose方法publicclassNacosSameClusterWeightedRuleimplementsReactorServiceInstanceLoadBalancer{// 注入当前服务的nacos的配置信息@ResourceprivateNacosDiscoveryProperties nacosDiscoveryProperties;// loadbalancer 提供的访问当前服务的名称finalString serviceId;// loadbalancer 提供的访问的服务列表ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;publicNacosSameClusterWeightedRule(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider,String serviceId){this.serviceId= serviceId;this.serviceInstanceListSupplierProvider= serviceInstanceListSupplierProvider;}/**
     * 服务器调用负载均衡时调的放啊
     * 此处代码内容与 RandomLoadBalancer 一致
     */publicMono<Response<ServiceInstance>>choose(Request request){ServiceInstanceListSupplier supplier=this.serviceInstanceListSupplierProvider.getIfAvailable(NoopServiceInstanceListSupplier::new);return supplier.get(request).next().map((serviceInstances)->{returnthis.processInstanceResponse(supplier, serviceInstances);});}/**
     * 对负载均衡的服务进行筛选的方法
     * 此处代码内容与 RandomLoadBalancer 一致
     */privateResponse<ServiceInstance>processInstanceResponse(ServiceInstanceListSupplier supplier,List<ServiceInstance> serviceInstances){Response<ServiceInstance> serviceInstanceResponse=this.getInstanceResponse(serviceInstances);if(supplierinstanceofSelectedInstanceCallback&& serviceInstanceResponse.hasServer()){((SelectedInstanceCallback)supplier).selectedServiceInstance((ServiceInstance)serviceInstanceResponse.getServer());}return serviceInstanceResponse;}/**
     * 对负载均衡的服务进行筛选的方法
     * 自定义
     * 此处的 instances 实例列表  只会提供健康的实例  所以不需要担心如果实例无法访问的情况
     */privateResponse<ServiceInstance>getInstanceResponse(List<ServiceInstance> instances){if(instances.isEmpty()){returnnewEmptyResponse();}// 获取当前服务所在的集群名称String currentClusterName= nacosDiscoveryProperties.getClusterName();// 过滤在同一集群下注册的服务 根据集群名称筛选的集合List<ServiceInstance> sameClusterNameInstList= instances.stream().filter(i->StringUtils.equals(i.getMetadata().get("nacos.cluster"),currentClusterName)).collect(Collectors.toList());ServiceInstance sameClusterNameInst;if(sameClusterNameInstList.isEmpty()){// 如果为空，则根据权重直接过滤所有服务列表
            sameClusterNameInst=getHostByRandomWeight(instances);}else{// 如果不为空，则根据权重直接过滤所在集群下的服务列表
            sameClusterNameInst=getHostByRandomWeight(sameClusterNameInstList);}returnnewDefaultResponse(sameClusterNameInst);}privateServiceInstancegetHostByRandomWeight(List<ServiceInstance> sameClusterNameInstList){List<Instance> list=newArrayList<>();Map<String,ServiceInstance> dataMap=newHashMap<>();// 此处将 ServiceInstance 转化为 Instance 是为了接下来调用nacos中的权重算法，由于入参不同，所以需要转换，此处建议打断电进行参数调试，以下是我目前为止所用到的参数，转化为map是为了最终方便获取取值到的服务对象
        sameClusterNameInstList.forEach(i->{Instance ins=newInstance();Map<String,String> metadata= i.getMetadata();

            ins.setInstanceId(metadata.get("nacos.instanceId"));
            ins.setWeight(newBigDecimal(metadata.get("nacos.weight")).doubleValue());
            ins.setClusterName(metadata.get("nacos.cluster"));
            ins.setEphemeral(Boolean.parseBoolean(metadata.get("nacos.ephemeral")));
            ins.setHealthy(Boolean.parseBoolean(metadata.get("nacos.healthy")));
            ins.setPort(i.getPort());
            ins.setIp(i.getHost());
            ins.setServiceName(i.getServiceId());

            ins.setMetadata(metadata);

            list.add(ins);// key为服务ID，值为服务对象
            dataMap.put(metadata.get("nacos.instanceId"),i);});// 调用nacos官方提供的负载均衡权重算法Instance hostByRandomWeightCopy=ExtendBalancer.getHostByRandomWeightCopy(list);// 根据最终ID获取需要返回的实例对象return dataMap.get(hostByRandomWeightCopy.getInstanceId());}}classExtendBalancerextendsBalancer{/**
     * 根据权重选择随机选择一个
     */publicstaticInstancegetHostByRandomWeightCopy(List<Instance> hosts){returngetHostByRandomWeight(hosts);}}

以上就是目前我对于不使用ribbon，使用loadBalancer时候的解决方案，已经通过结果验证，可以实现只访问同一集群下的服务，如果有其他问题，请在品论区留言告知，我会对文档进行适当的修改