Spring Cloud LoadBalancer--自定义负载均衡策略--方法/实例

￡神魔★判官ぃ 2023-10-02 21:03 9阅读 0赞

原文网址：[Spring Cloud LoadBalancer--自定义负载均衡策略--方法/实例\_IT利刃出鞘的博客-CSDN博客][Spring Cloud LoadBalancer--_--_IT_-CSDN]

## 简介 ##

**说明**

本文用示例介绍Spring Cloud LoadBalancer如何自定义负载均衡策略。

Spring Cloud LoadBalancer的默认负载均衡策略为轮询策略。我们可以自定义负载均衡策略。自定义负载均衡策略可以用于：灰度发布、蓝绿发布等。

**相关网址**

[Spring Cloud LoadBalancer--默认的负载均衡策略\_IT利刃出鞘的博客-CSDN博客][Spring Cloud LoadBalancer--_IT_-CSDN]

[Spring Cloud LoadBalancer--指定负载均衡策略--方法/实例\_IT利刃出鞘的博客-CSDN博客][Spring Cloud LoadBalancer--_--_IT_-CSDN 1]

**本文目标**

本处的场景是：order（订单微服务）调用storage（库存微服务）扣减库存。

启动两个storage（库存微服务），将order的feign请求全部路由到IP为192.168.5.1，端口号为9211的实例上。

## 基础代码 ##

注意（本处为了简单，直接用@RequestParam传参）

**order的controller**

package com.knife.order.controller;
    
    import com.knife.common.entity.Result;
    import com.knife.order.entity.Order;
    import com.knife.storage.api.StorageFeignClient;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * http://localhost:9011/order/create/?userId=1&productId=1&count=10&money=100
     * http://localhost:9011/order/createFault/?userId=1&productId=1&count=10&money=100
     */
    
    @Slf4j
    @RestController
    @RequestMapping("order")
    public class OrderController {
        @Autowired
        private StorageFeignClient storageFeignClient;
    
        // 正常流程
        @PostMapping("create")
        public Result create(Order order) {
            log.info("订单服务：创建订单：{}", order);
    
            storageFeignClient.decreaseStorage(order.getProductId(), order.getCount());
    
            return new Result().message("创建订单成功");
        }
    }

**storage的feign定义**

package com.knife.storage.api;
    
    import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    
    @FeignClient("storage")
    public interface StorageFeignClient {
        @PostMapping("/feign/storage/decreaseStorage")
        void decreaseStorage(@RequestParam("productId") Long productId, @RequestParam("count") Integer count);
    }

**storage的controller**

package com.knife.storage.feign;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    @Slf4j
    @RestController
    public class FeignController {
        @PostMapping("/feign/storage/decreaseStorage")
        public void decreaseStorage(@RequestParam("productId")Long productId,
                                    @RequestParam("count")Integer count) {
            log.info("库存服务：减少库存。productId: {}, count: {}", productId, count);
        }
    }

## 自定义负载均衡策略 ##

### 自定义策略类 ###

/*
     * Copyright 2012-2020 the original author or authors.
     *
     * Licensed under the Apache License, Version 2.0 (the "License");
     * you may not use this file except in compliance with the License.
     * You may obtain a copy of the License at
     *
     *      https://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */
    
    package com.knife.order.config;
    
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.springframework.beans.factory.ObjectProvider;
    import org.springframework.cloud.client.ServiceInstance;
    import org.springframework.cloud.client.loadbalancer.DefaultResponse;
    import org.springframework.cloud.client.loadbalancer.EmptyResponse;
    import org.springframework.cloud.client.loadbalancer.Request;
    import org.springframework.cloud.client.loadbalancer.Response;
    import org.springframework.cloud.loadbalancer.core.NoopServiceInstanceListSupplier;
    import org.springframework.cloud.loadbalancer.core.ReactorServiceInstanceLoadBalancer;
    import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
    import reactor.core.publisher.Mono;
    
    import java.util.List;
    
    /**
     * 强制路由到某个实例
     */
    public class ForceLoadBalancer implements ReactorServiceInstanceLoadBalancer {
    
        private static final Log log = LogFactory.getLog(ForceLoadBalancer.class);
    
        private final String serviceId;
    
        private ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
    
        /**
         * @param serviceInstanceListSupplierProvider a provider of
         *                                            {@link ServiceInstanceListSupplier} that will be used to get available instances
         * @param serviceId                           id of the service for which to choose an instance
         */
        public ForceLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider,
                                 String serviceId) {
            this.serviceId = serviceId;
            this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
        }
    
        @Override
        public Mono<Response<ServiceInstance>> choose(Request request) {
            ServiceInstanceListSupplier supplier = serviceInstanceListSupplierProvider
                    .getIfAvailable(NoopServiceInstanceListSupplier::new);
    
            return supplier.get(request).next().map(this::getInstanceResponse);
        }
    
        private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> instances) {
            if (instances.isEmpty()) {
                if (log.isWarnEnabled()) {
                    log.warn("No servers available for service: " + serviceId);
                }
                return new EmptyResponse();
            }
    
            // 将特定应用的请求路由到指定实例
            String serviceId = "storage";
            String host = "192.168.5.1";
            int port = 9021;
    
            ServiceInstance instanceResult = null;
            for (ServiceInstance instance : instances) {
                if (serviceId.equals(instance.getInstanceId())
                        && host.equals(instance.getHost())
                        && port == instance.getPort()) {
                    instanceResult = instance;
                    break;
                }
            }
    
            // 如果指定的实例不可用，则随机取一个可用的服务
            if (instanceResult == null) {
                instanceResult = instances.get(0);
            }
    
            return new DefaultResponse(instanceResult);
        }
    
    }

### 配置类（不要加@Configuration） ###

package com.knife.order.config;
    
    import org.springframework.cloud.client.ServiceInstance;
    import org.springframework.cloud.loadbalancer.core.ReactorLoadBalancer;
    import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
    import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.env.Environment;
    
    @Configuration
    public class LoadBalancerConfiguration {
        @Bean
        public ReactorLoadBalancer<ServiceInstance> reactorServiceInstanceLoadBalancer(Environment environment,
                                                                                       LoadBalancerClientFactory loadBalancerClientFactory) {
            String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
            return new ForceLoadBalancer(
                    loadBalancerClientFactory
                            .getLazyProvider(name, ServiceInstanceListSupplier.class), name);
        }
    }

### 注册策略配置 ###

package com.knife.order;
    
    import com.knife.common.annotation.CommonApplication;
    import com.knife.order.config.LoadBalancerClientConfiguration;
    import org.springframework.boot.SpringApplication;
    import org.springframework.cloud.loadbalancer.annotation.LoadBalancerClient;
    
    @SpringBootApplication
    @EnableDiscoveryClient
    @EnableFeignClients("com.knife.**.api")
    @LoadBalancerClients(defaultConfiguration = {LoadBalancerConfiguration.class})
    public class OrderApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(OrderApplication.class, args);
        }
    
    }

## 测试 ##

启动两个storage实例，端口号分别为90211和9022。Idea可以一个应用启动多个实例，方法见[这里][Link 1]。

Post方式访问：[http://localhost:9011/order/create/?userId=1&productId=1&count=10&money=100][http_localhost_9011_order_create_userId_1_productId_1_count_10_money_100]

### 1.默认的负载均衡策略 ###

默认情况下，是轮询策略，调用10次接口的结果如下（每个实例都是5次请求）：

![29c3f65ad2214ecfb6acb86dead4d2bb.png][]

![b927cfa539204de48468b46219718c2c.png][]

### 2.自定义的负载均衡策略 ###

可以发现，所有请求全部路由到了我们指定的9021实例。

![ec9285d742cb41a9997689bf9de81276.png][]

![df116cb2d19d4dadbc760f44ba1cbc22.png][]

[Spring Cloud LoadBalancer--_--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/126842218
[Spring Cloud LoadBalancer--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/126820809
[Spring Cloud LoadBalancer--_--_IT_-CSDN 1]: https://knife.blog.csdn.net/article/details/126823676
[Link 1]: https://knife.blog.csdn.net/article/details/125468410
[http_localhost_9011_order_create_userId_1_productId_1_count_10_money_100]: http://localhost:9011/order/create/?userId=1&productId=1&count=10&money=100
[29c3f65ad2214ecfb6acb86dead4d2bb.png]: https://img-blog.csdnimg.cn/29c3f65ad2214ecfb6acb86dead4d2bb.png
[b927cfa539204de48468b46219718c2c.png]: https://img-blog.csdnimg.cn/b927cfa539204de48468b46219718c2c.png
[ec9285d742cb41a9997689bf9de81276.png]: https://img-blog.csdnimg.cn/ec9285d742cb41a9997689bf9de81276.png
[df116cb2d19d4dadbc760f44ba1cbc22.png]: https://img-blog.csdnimg.cn/df116cb2d19d4dadbc760f44ba1cbc22.png