springcloud gateway网关定制负载均衡

喜欢ヅ旅行 2023-06-19 05:26 23阅读 0赞

背景：开发，测试环境都使用了一个注册中心，所以在开发，测试环境不想进行负载均衡，原因1：自己本地调试方便，原因2：不想测试环境负载到自己的机器上（代码不一致）

注册中心使用nacos

实现原理：使用ThreadLocal保存本机唯一信息，在进行负载时，从多个服务取相关信息和本机信息进行对比，如果一致就使用该服务进行调用，也就确保了所有请求都是在同一个机器上进行

1：网关层定制负载均衡

//ThreadLocal
    public class RuleThreadLocal {
    
        private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>(){
            @Override
            protected String initialValue() {
                return "";
            }
        };
    
        public static void setRule(String type){
            contextHolder.set(type);
        }
    
        public static String getRule(){
            return contextHolder.get();
        }
    
        /**
         * 清除上下文数据
         */
        public static void clearRule() {
            contextHolder.remove();
        }
    }

// 自定义负载策略
    @Slf4j
    public class MyRibbonRule extends AbstractLoadBalancerRule {
    
        @Override
        public void initWithNiwsConfig(IClientConfig iClientConfig) {
        }
    
        @Override
        public Server choose(Object key) {
            Server server = null;
            try {
    
                ILoadBalancer lb = getLoadBalancer();
    
                int count = 0;
                while (server == null && count++ < 10) {
                    List<Server> reachableServers = lb.getReachableServers();
                    List<Server> allServers = lb.getAllServers();
                    int upCount = reachableServers.size();
                    int serverCount = allServers.size();
    
                    if ((upCount == 0) || (serverCount == 0)) {
                        log.warn("No up servers available from load balancer: " + lb);
                        return null;
                    }
    
                    for (Server server1 : reachableServers) {
                        NacosServer nacosServer = (NacosServer) server1;
                        Map<String, String> metadata = nacosServer.getMetadata();
                        // 获取服务器标识信息
                        String hostname = metadata.get("hostname");
                        String rule = getRule();
                        if (rule.equals(hostname)) {
    
                            if (server1.isAlive() && (server1.isReadyToServe())) {
                                return server1;
                            }
                        }
                    }
    
                    if (server == null) {
                        /* Transient. */
                        Thread.yield();
                        continue;
                    }
    
                    if (server.isAlive() && (server.isReadyToServe())) {
                        return (server);
                    }
    
                    // Next.
                    server = null;
                }
    
                if (count >= 10) {
                    log.warn("No available alive servers after 10 tries from load balancer: "
                            + lb);
                }
            } catch (Exception e) {
                log.error("rule error", e);
                throw new CommonException("rule error");
            } finally {
                RuleThreadLocal.clearRule();
            }
    
            return server;
        }
    
        private String getRule() {
           return RuleThreadLocal.getRule();
        }
    
    }

// Ribbon配置文件，使用我们自己的负载策略
    @Configuration
    public class RibbonConfig {
    
        @Profile({"dev", "test"})
        @Bean
        public IRule ribbonRule() {
            return new MyRibbonRule();
        }
    }

// 自定义gateway的负载过滤器
    public class UserLoadBalancerClientFilter extends LoadBalancerClientFilter {
    
        @Value("${spring.cloud.nacos.discovery.metadata.hostname:root}")
        String rule;
    
        public UserLoadBalancerClientFilter(LoadBalancerClient loadBalancer, LoadBalancerProperties properties) {
            super(loadBalancer, properties);
        }
    
        @Override
        protected ServiceInstance choose(ServerWebExchange exchange) {
            // 在选择服务之前设置本机的服务器标识信息
            RuleThreadLocal.setRule(rule);
            if (this.loadBalancer instanceof RibbonLoadBalancerClient) {
                RibbonLoadBalancerClient client = (RibbonLoadBalancerClient) this.loadBalancer;
                String serviceId = ((URI) exchange.getAttribute(GATEWAY_REQUEST_URL_ATTR)).getHost();
               
                return client.choose(serviceId);
            }
            return super.choose(exchange);
        }
    
    }

// 配置自定义负载过滤器
    @Profile({"dev", "test"})
    @Bean
    public UserLoadBalancerClientFilter userLoadBalanceClientFilter(LoadBalancerClient client, LoadBalancerProperties properties) {
        return new UserLoadBalancerClientFilter(client, properties);
    }

bootstrap.yml 配置

spring:
      cloud:
        nacos:
          config:
            file-extension: properties
            server-addr: xxxx
            namespace: xxxx
          discovery:
            server-addr: xxxxx
            namespace: xxxxx
            metadata:
              hostname: ${USER:root} #指定服务器名称，每个机器上应该是不一样的

// RibbonClients配置,xxxx为你自己的服务
    @RibbonClients({
            @RibbonClient(value = "xxxx", configuration = RibbonConfig.class),
            @RibbonClient(value = "xxxx", configuration = RibbonConfig.class)
    })
    public class GateWayServerApplication {
        public static void main(String[] args) {
            SpringApplication.run(GateWayServerApplication.class, args);
        }
    }