0
0

【SpringCloud系列】开发环境下重写Loadbalancer实现自定义负载均衡

前言

  1.     spring-cloud-starter-netflix-ribbon已经不再更新了，最新版本是2.2.10.RELEASE，最后更新时间是2021年11月18日，详细信息可以看maven官方仓库：https://search.maven.org/artifact/org.springframework.cloud/spring-cloud-starter-netflix-ribbon，SpringCloud官方推荐使用spring-cloud-starter-loadbalancer进行负载均衡。我们在开发的时候，多人开发同一个微服务，都注册到同一个nacos，前端请求的时候，网关Gateway默认轮训请求注册中心的服务，OpenFeign也会轮询请求注册中心的服务，这样就会导致前端有时会无法请求到我们本地写的接口，而是请求到别人的服务中。所以我们可以重写Loadbalancer默认的负载均衡策略，实现自定义负载均衡策略，不管是Gateway还是OpenFeign都只能请求到我们自己本地的服务。
  3.     我的版本如下：
  5.     <spring-boot.version>2.7.3</spring-boot.version>
  6.      <spring-cloud.version>2021.0.4</spring-cloud.version>
  7.      <spring-cloud-alibaba.version>2021.0.4.0</spring-cloud-alibaba.version>

一、添加负载方式配置

  1.     1、定义负载均衡方式的枚举
  1. public enum LoadBalancerTypeEnum {
  3.     /**
  4.      * 开发环境，获取自己的服务
  5.      */
  6.     DEV,
  8.     /**
  9.      * 网关，根据请求地址获取对应的服务
  10.      */
  11.     GATEWAY,
  13.     /**
  14.      * 轮循
  15.      */
  16.     ROUND_ROBIN,
  18.     /**
  19.      * 随机
  20.      */
  21.     RANDOM;
  23. }
  1.     2、添加配置类，默认使用轮训方式
  1. import lombok.Data;
  2. import org.springframework.boot.context.properties.ConfigurationProperties;
  4. /**
  5.  * 负载均衡配置项
  6.  */
  7. @Data
  8. @ConfigurationProperties(prefix = "spring.cloud.loadbalancer")
  9. public class LoadBalanceProperties {
  11.     private LoadBalancerTypeEnum type = LoadBalancerTypeEnum.ROUND_ROBIN;
  13. }

二、参考默认实现自定义

  1.     默认的负载均衡策略是这个类：

org.springframework.cloud.loadbalancer.core.RoundRobinLoadBalancer

  1.     我们参考这个类实现自己的负载均衡策略即可，RoundRobinLoadBalancer实现了ReactorServiceInstanceLoadBalancer这个接口，实现了choose这个方法，如下图：

  1.     在choose方法中调用了processInstanceResponse方法，processInstanceResponse方法中调用了getInstanceResponse方法，所以我们我们可以复制RoundRobinLoadBalancer整个类，只修改getInstanceResponse这个方法里的内容就可以实现自定义负载均衡策略。
  3.     在自定义的类中，我们实现了四种负载均衡策略
  5.     1、getRoundRobinInstance方法是直接复制的RoundRobinLoadBalancer类中的实现；
  7.     2、getRandomInstance方法参考org.springframework.cloud.loadbalancer.core.RandomLoadBalancer类中的实现；
  9.     3、getDevelopmentInstance方法是返回所有服务中和当前机器ip一致的服务，如果没有，则轮训返回；
  11.     4、getGatewayDevelopmentInstance方法是返回所有服务中和网关请求头中ip一致的服务。
  1. import cn.hutool.core.convert.Convert;
  2. import cn.hutool.core.lang.TypeReference;
  3. import com.ruoyi.common.core.utils.StringUtils;
  4. import com.ruoyi.common.core.utils.ip.IpUtils;
  5. import com.ruoyi.common.loadbalance.config.LoadBalancerTypeEnum;
  6. import lombok.extern.slf4j.Slf4j;
  7. import org.springframework.beans.factory.ObjectProvider;
  8. import org.springframework.cloud.client.ServiceInstance;
  9. import org.springframework.cloud.client.loadbalancer.DefaultRequest;
  10. import org.springframework.cloud.client.loadbalancer.DefaultResponse;
  11. import org.springframework.cloud.client.loadbalancer.EmptyResponse;
  12. import org.springframework.cloud.client.loadbalancer.Request;
  13. import org.springframework.cloud.client.loadbalancer.RequestData;
  14. import org.springframework.cloud.client.loadbalancer.RequestDataContext;
  15. import org.springframework.cloud.client.loadbalancer.Response;
  16. import org.springframework.cloud.loadbalancer.core.NoopServiceInstanceListSupplier;
  17. import org.springframework.cloud.loadbalancer.core.ReactorServiceInstanceLoadBalancer;
  18. import org.springframework.cloud.loadbalancer.core.SelectedInstanceCallback;
  19. import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
  20. import org.springframework.http.HttpHeaders;
  21. import reactor.core.publisher.Mono;
  23. import java.util.List;
  24. import java.util.Objects;
  25. import java.util.Random;
  26. import java.util.concurrent.ThreadLocalRandom;
  27. import java.util.concurrent.atomic.AtomicInteger;
  29. /**
  30.  * 自定义 SpringCloud 负载均衡算法
  31.  * 负载均衡算法的默认实现是 {@link org.springframework.cloud.loadbalancer.core.RoundRobinLoadBalancer}
  32.  *
  33.  */
  34. @Slf4j
  35. public class CustomSpringCloudLoadBalancer implements ReactorServiceInstanceLoadBalancer {
  37.     private final String serviceId;
  38.     private final AtomicInteger position;
  39.     private final LoadBalancerTypeEnum type;
  40.     private final ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
  42.     public CustomSpringCloudLoadBalancer(String serviceId,
  43.                                          LoadBalancerTypeEnum type,
  44.                                          ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider) {
  45.         this(serviceId, new Random().nextInt(1000), type, serviceInstanceListSupplierProvider);
  46.     }
  48.     public CustomSpringCloudLoadBalancer(String serviceId,
  49.                                          int seedPosition,
  50.                                          LoadBalancerTypeEnum type,
  51.                                          ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider) {
  52.         this.serviceId = serviceId;
  53.         this.position = new AtomicInteger(seedPosition);
  54.         this.type = type;
  55.         this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
  56.     }
  58.     @Override
  59.     public Mono<Response<ServiceInstance>> choose(Request request) {
  60.         ServiceInstanceListSupplier supplier = serviceInstanceListSupplierProvider.getIfAvailable(NoopServiceInstanceListSupplier::new);
  61.         return supplier.get(request).next().map(serviceInstances -> processInstanceResponse(request, supplier, serviceInstances));
  62.     }
  64.     private Response<ServiceInstance> processInstanceResponse(Request request,
  65.                                                               ServiceInstanceListSupplier supplier,
  66.                                                               List<ServiceInstance> serviceInstances) {
  67.         Response<ServiceInstance> serviceInstanceResponse = getInstanceResponse(request, serviceInstances);
  68.         if (supplier instanceof SelectedInstanceCallback && serviceInstanceResponse.hasServer()) {
  69.             ((SelectedInstanceCallback) supplier).selectedServiceInstance(serviceInstanceResponse.getServer());
  70.         }
  71.         return serviceInstanceResponse;
  72.     }
  74.     private Response<ServiceInstance> getInstanceResponse(Request request, List<ServiceInstance> instances) {
  75.         if (instances.isEmpty()) {
  76.             if (log.isWarnEnabled()) {
  77.                 log.warn("No servers available for service: " + serviceId);
  78.             }
  79.             return new EmptyResponse();
  80.         }
  82.         if (Objects.equals(type, LoadBalancerTypeEnum.ROUND_ROBIN)){
  83.             return this.getRoundRobinInstance(instances);
  84.         }else if (Objects.equals(type, LoadBalancerTypeEnum.RANDOM)){
  85.             return this.getRandomInstance(instances);
  86.         }else if (Objects.equals(type, LoadBalancerTypeEnum.DEV)){
  87.             return this.getDevelopmentInstance(instances);
  88.         }else if (Objects.equals(type, LoadBalancerTypeEnum.GATEWAY)){
  89.             return this.getGatewayDevelopmentInstance(request, instances);
  90.         }
  91.         return this.getRoundRobinInstance(instances);
  92.     }
  94.     /**
  95.      * 获取网关本机实例
  96.      *
  97.      * @param instances 实例
  98.      * @return {@link Response }<{@link ServiceInstance }>
  99.      * @author : lwq
  100.      * @date : 2022-12-15 14:22:13
  101.      */
  102.     private Response<ServiceInstance> getGatewayDevelopmentInstance(Request request, List<ServiceInstance> instances) {
  104.         //把request转为默认的DefaultRequest，从request中拿到请求的ip信息，再选择ip一样的微服务
  105.         DefaultRequest<RequestDataContext> defaultRequest = Convert.convert(new TypeReference<DefaultRequest<RequestDataContext>>() {}, request);
  106.         RequestDataContext context = defaultRequest.getContext();
  107.         RequestData clientRequest = context.getClientRequest();
  108.         HttpHeaders headers = clientRequest.getHeaders();
  109.         String requestIp = IpUtils.getIpAddressFromHttpHeaders(headers);
  110.         log.debug("客户端请求gateway的ip:{}", requestIp);
  112.         //先取得和本地ip一样的服务，如果没有则按默认来取
  113.         for (ServiceInstance instance : instances) {
  114.             String currentServiceId = instance.getServiceId();
  115.             String host = instance.getHost();
  116.             log.debug("注册服务：{}，ip：{}", currentServiceId, host);
  117.             if (StringUtils.isNotEmpty(host) && StringUtils.equals(requestIp, host)) {
  118.                 return new DefaultResponse(instance);
  119.             }
  120.         }
  121.         return getRoundRobinInstance(instances);
  122.     }
  124.     /**
  125.      * 获取本机实例
  126.      *
  127.      * @param instances 实例
  128.      * @return {@link Response }<{@link ServiceInstance }>
  129.      * @author : lwq
  130.      * @date : 2022-12-15 14:22:13
  131.      */
  132.     private Response<ServiceInstance> getDevelopmentInstance(List<ServiceInstance> instances) {
  133.         //获取本机ip
  134.         String hostIp = IpUtils.getHostIp();
  135.         log.debug("本机Ip:{}", hostIp);
  137.         //先取得和本地ip一样的服务，如果没有则按默认来取
  138.         for (ServiceInstance instance : instances) {
  139.             String currentServiceId = instance.getServiceId();
  140.             String host = instance.getHost();
  141.             log.debug("注册服务：{}，ip：{}", currentServiceId, host);
  142.             if (StringUtils.isNotEmpty(host) && StringUtils.equals(hostIp, host)) {
  143.                 return new DefaultResponse(instance);
  144.             }
  145.         }
  146.         return getRoundRobinInstance(instances);
  147.     }
  149.     /**
  150.      * 使用随机算法
  151.      * 参考{link {@link org.springframework.cloud.loadbalancer.core.RandomLoadBalancer}}
  152.      *
  153.      * @param instances 实例
  154.      * @return {@link Response }<{@link ServiceInstance }>
  155.      * @author : lwq
  156.      * @date : 2022-12-15 13:32:11
  157.      */
  158.     private Response<ServiceInstance> getRandomInstance(List<ServiceInstance> instances) {
  159.         int index = ThreadLocalRandom.current().nextInt(instances.size());
  160.         ServiceInstance instance = instances.get(index);
  161.         return new DefaultResponse(instance);
  162.     }
  164.     /**
  165.      * 使用RoundRobin机制获取节点
  166.      *
  167.      * @param instances 实例
  168.      * @return {@link Response }<{@link ServiceInstance }>
  169.      * @author : lwq
  170.      * @date : 2022-12-15 13:28:31
  171.      */
  172.     private Response<ServiceInstance> getRoundRobinInstance(List<ServiceInstance> instances) {
  173.         // 每一次计数器都自动+1，实现轮询的效果
  174.         int pos = this.position.incrementAndGet() & Integer.MAX_VALUE;
  175.         ServiceInstance instance = instances.get(pos % instances.size());
  176.         return new DefaultResponse(instance);
  177.     }
  179. }
  1.     其中的工具类如下：
  1. import java.net.InetAddress;
  2. import java.net.URL;
  3. import java.net.UnknownHostException;
  4. import java.util.List;
  5. import java.util.Objects;
  6. import javax.servlet.http.HttpServletRequest;
  8. import cn.hutool.core.collection.CollectionUtil;
  9. import cn.hutool.core.util.URLUtil;
  10. import org.springframework.http.HttpHeaders;
  12. /**
  13.  * 获取IP方法
  14.  */
  15. public class IpUtils{
  17.     /**
  18.      * 获取IP地址
  19.      *
  20.      * @return 本地IP地址
  21.      */
  22.     public static String getHostIp(){
  23.         try{
  24.             return InetAddress.getLocalHost().getHostAddress();
  25.         }catch (UnknownHostException e){
  26.         }
  27.         return "127.0.0.1";
  28.     }
  30.     /**
  31.      * 获取客户端IP
  32.      *
  33.      * @param httpHeaders 请求头
  34.      * @return IP地址
  35.      */
  36.     public static String getIpAddressFromHttpHeaders(HttpHeaders httpHeaders){
  37.         if (httpHeaders == null){
  38.             return "unknown";
  39.         }
  40.         //前端请求自定义请求头，转发到哪个服务
  41.         List<String> ipList = httpHeaders.get("forward-to");
  42.         String ip = CollectionUtil.get(ipList, 0);
  43.         //请求自带的请求头
  44.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)){
  45.             ipList = httpHeaders.get("x-forwarded-for");
  46.             ip = CollectionUtil.get(ipList, 0);
  47.         }
  48.         //从referer获取请求的ip地址
  49.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)){
  50.             //从referer中获取请求的ip地址
  51.             List<String> refererList = httpHeaders.get("referer");
  52.             String referer = CollectionUtil.get(refererList, 0);
  53.             URL url = URLUtil.url(referer);
  54.             if (Objects.nonNull(url)){
  55.                 ip = url.getHost();
  56.             }else {
  57.                 ip = "unknown";
  58.             }
  59.         }
  60.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)){
  61.             ipList = httpHeaders.get("Proxy-Client-IP");
  62.             ip = CollectionUtil.get(ipList, 0);
  63.         }
  64.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)){
  65.             ipList = httpHeaders.get("X-Forwarded-For");
  66.             ip = CollectionUtil.get(ipList, 0);
  67.         }
  68.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)){
  69.             ipList = httpHeaders.get("WL-Proxy-Client-IP");
  70.             ip = CollectionUtil.get(ipList, 0);
  71.         }
  72.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)){
  73.             ipList = httpHeaders.get("X-Real-IP");
  74.             ip = CollectionUtil.get(ipList, 0);
  75.         }
  76.         return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : getMultistageReverseProxyIp(ip);
  77.     }
  78. }
  1.     getIpAddressFromHttpHeaders方法中，是从请求头总拿到了自定义的请求头forward-to，要想实现此功能，就需要前端发送请求的时候携带这个请求头，例如
  3.     在若依的request.js中可以这么写： config.headers['forward-to'] = '192.168.0.145'

三、配置负载均衡策略

  1.    默认的配置在这里：

org.springframework.cloud.loadbalancer.annotation.LoadBalancerClientConfiguration

  1.     我们参考这个配置，实现自己的配置。启用上面写好的配置类LoadBalanceProperties，然后传到自定义的负载均衡策略类CustomSpringCloudLoadBalancer，其他的复制就可以。
  1. import com.ruoyi.common.loadbalance.core.CustomSpringCloudLoadBalancer;
  2. import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
  3. import org.springframework.boot.context.properties.EnableConfigurationProperties;
  4. import org.springframework.cloud.client.ServiceInstance;
  5. import org.springframework.cloud.loadbalancer.core.ReactorLoadBalancer;
  6. import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
  7. import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  10. import org.springframework.core.env.Environment;
  12. /**
  13.  * 自定义负载均衡客户端配置
  14.  *
  15.  */
  16. @SuppressWarnings("all")
  17. @Configuration(proxyBeanMethods = false)
  18. @EnableConfigurationProperties(LoadBalanceProperties.class)
  19. public class CustomLoadBalanceClientConfiguration {
  21.     @Bean
  22.     @ConditionalOnBean(LoadBalancerClientFactory.class)
  23.     public ReactorLoadBalancer<ServiceInstance> customLoadBalancer(LoadBalanceProperties loadBalanceProperties,
  24.                                                                    Environment environment,
  25.                                                                    LoadBalancerClientFactory loadBalancerClientFactory) {
  26.         String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
  27.         return new CustomSpringCloudLoadBalancer(name, loadBalanceProperties.getType(),
  28.                 loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class));
  29.     }
  31. }
  1.     然后使用LoadBalancerClients注解加载一下配置
  1. import org.springframework.cloud.loadbalancer.annotation.LoadBalancerClients;
  3. /**
  4.  * 自定义负载均衡自动配置
  5.  *
  6.  */
  7. @LoadBalancerClients(defaultConfiguration = CustomLoadBalanceClientConfiguration.class)
  8. public class CustomLoadBalanceAutoConfiguration {
  10. }

四、使用

  1.     将以上代码独立成一个模块，然后再其他微服务中的pom文件中引入，然后添加对应的配置就可以实现自定义负载均衡了
  3.     1、在微服务中配置如下即可实现调用其他服务时，调用自己本地开发环境的微服务
  1. spring.cloud.loadbalancer.type=dev
  1.     2、在网关中配置如下即可实现调用固定某个服务

spring.cloud.loadbalancer.type=gateway

写在最后的话

  1.     最开始只有想法，但是不知道怎么实现，百度也没找到合适的方案。所以就开始看源码，研究了一下，然后照着源码写，测试了一下真的就实现了。所以，多看看源码还是有好处的。
标签： spring cloud java spring
本文转载自: https://blog.csdn.net/WayneLee0809/article/details/128557770
版权归原作者 红藕香残玉簟秋 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【SpringCloud系列】开发环境下重写Loadbalancer实现自定义负载均衡”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？