快捷導(dǎo)航

SpringCloud自定義loadbalancer實現(xiàn)標簽路由的詳細方案

更新時間：2025年02月15日 08:50:13 作者：煙味i

本文介紹了通過標簽路由解決前端開發(fā)環(huán)境接口調(diào)用慢的問題,實現(xiàn)方案包括在本地服務(wù)注冊元數(shù)據(jù)、自定義負載均衡器、以及網(wǎng)關(guān)配置等步驟,通過環(huán)境變量設(shè)置標簽,網(wǎng)關(guān)根據(jù)請求頭中的標簽進行路由,從而實現(xiàn)前后端互不干擾的開發(fā)調(diào)試,感興趣的朋友一起看看吧

一、背景

最近前端反應(yīng)開發(fā)環(huán)境有時候調(diào)接口會很慢，原因是有開發(fā)圖方便將本地服務(wù)注冊到開發(fā)環(huán)境，請求路由到開發(fā)本地導(dǎo)致，

為了解決該問題想到可以通過標簽路由的方式避免該問題，實現(xiàn)前端聯(lián)調(diào)和開發(fā)自測互不干擾。

該方案除了用于本地調(diào)試，還可以用于用戶灰度發(fā)布。

二、實現(xiàn)方案

關(guān)于負載均衡，低版本的SpringCloud用的是Spring Cloud Ribbon，高版本用Spring Cloud LoadBalancer替代了，

Ribbon可以通過實現(xiàn)IRlue接口實現(xiàn)，這里只介紹高版本的實現(xiàn)方案。

實現(xiàn)方案：

idea在環(huán)境變量中設(shè)置tag，本地服務(wù)啟動時讀取環(huán)境變量將tag注冊到nacos的元數(shù)據(jù)
重寫網(wǎng)關(guān)的負載均衡算法，從請求頭中獲取到的request-tag和服務(wù)實例的元數(shù)據(jù)進行匹配，如果匹配到則返回對應(yīng)的

服務(wù)實例，否則提示服務(wù)未找到。

三、編碼實現(xiàn)

3.1 order服務(wù)

新建一個SpringCloud服務(wù)order-service，注冊元數(shù)據(jù)很簡單，只需要排除掉NacosDiscoveryClientConfiguration，再寫一個自己的NacosDiscoveryClientConfiguration配置類即可。

創(chuàng)建MyNacosDiscoveryClientConfiguration

/**
 * @Author: Ship
 * @Description:
 * @Date: Created in 2025/2/12
 */
@Configuration(
        proxyBeanMethods = false
)
@ConditionalOnDiscoveryEnabled
@ConditionalOnBlockingDiscoveryEnabled
@ConditionalOnNacosDiscoveryEnabled
@AutoConfigureBefore({SimpleDiscoveryClientAutoConfiguration.class, CommonsClientAutoConfiguration.class})
@AutoConfigureAfter({NacosDiscoveryAutoConfiguration.class})
public class MyNacosDiscoveryClientConfiguration {
    @Bean
    public DiscoveryClient nacosDiscoveryClient(NacosServiceDiscovery nacosServiceDiscovery) {
        return new NacosDiscoveryClient(nacosServiceDiscovery);
    }
    @Bean
    @ConditionalOnProperty(
            value = {"spring.cloud.nacos.discovery.watch.enabled"},
            matchIfMissing = true
    )
    public NacosWatch nacosWatch(NacosServiceManager nacosServiceManager, NacosDiscoveryProperties nacosDiscoveryProperties,
                                 ObjectProvider<ThreadPoolTaskScheduler> taskExecutorObjectProvider, Environment environment) {
        // 環(huán)境變量讀取標簽
        String tag = environment.getProperty("tag");
        nacosDiscoveryProperties.getMetadata().put("request-tag", tag);
        return new NacosWatch(nacosServiceManager, nacosDiscoveryProperties, taskExecutorObjectProvider);
    }
}

這里代碼基本與NacosDiscoveryClientConfiguration一致，只是加上了設(shè)置元數(shù)據(jù)的邏輯。

@SpringBootApplication(exclude = NacosDiscoveryClientConfiguration.class)
public class OrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
}

啟動類上需要排除默認的NacosDiscoveryClientConfiguration，不然啟動會報bean重復(fù)注冊的錯誤，或者配置添加spring.main.allow-bean-definition-overriding=true允許重復(fù)注冊也行。

寫一個測試接口，方便后面測試

/**
 * @Author: Ship
 * @Description:
 * @Date: Created in 2025/2/12
 */
@RequestMapping("test")
@RestController
public class TestController {
    @GetMapping("")
    public String sayHello(){
        return "hello";
    }
}

3.2 gateway服務(wù)

新建一個網(wǎng)關(guān)服務(wù)，pom文件如下：

 <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>2020.0.3</spring-cloud.version>
        <spring-cloud-alibaba.version>2021.1</spring-cloud-alibaba.version>
        <spring-boot.version>2.5.1</spring-boot.version>
        <maven-compiler-plugin.version>3.1</maven-compiler-plugin.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-loadbalancer</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>${spring-boot.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>${spring-boot.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
            <version>${spring-cloud-alibaba.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <version>${spring-cloud-alibaba.version}</version>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-bootstrap</artifactId>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${maven-compiler-plugin.version}</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

Spring-Cloud-loadBalancer默認使用輪詢的算法，即org.springframework.cloud.loadbalancer.core.RoundRobinLoadBalancer類實現(xiàn)，因此可以參考RoundRobinLoadBalancer實現(xiàn)一個TagLoadBalancer，代碼如下：

/**
 * @Author: Ship
 * @Description:
 * @Date: Created in 2025/2/12
 */
public class TagLoadBalancer implements ReactorServiceInstanceLoadBalancer {
    private static final String TAG_HEADER = "request-tag";
    private static final Log log = LogFactory.getLog(TagLoadBalancer.class);
    final AtomicInteger position;
    final String serviceId;
    ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
    public TagLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider, String serviceId) {
        this(serviceInstanceListSupplierProvider, serviceId, (new Random()).nextInt(1000));
    }
    public TagLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider, String serviceId, int seedPosition) {
        this.serviceId = serviceId;
        this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
        this.position = new AtomicInteger(seedPosition);
    }
    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        ServiceInstanceListSupplier supplier = (ServiceInstanceListSupplier) this.serviceInstanceListSupplierProvider.getIfAvailable(NoopServiceInstanceListSupplier::new);
        return supplier.get(request).next().map((serviceInstances) -> {
            return this.processInstanceResponse(supplier, serviceInstances, request);
        });
    }
    private Response<ServiceInstance> processInstanceResponse(ServiceInstanceListSupplier supplier, List<ServiceInstance> serviceInstances, Request request) {
        Response<ServiceInstance> serviceInstanceResponse = this.getInstanceResponse(serviceInstances, request);
        if (supplier instanceof SelectedInstanceCallback && serviceInstanceResponse.hasServer()) {
            ((SelectedInstanceCallback) supplier).selectedServiceInstance((ServiceInstance) serviceInstanceResponse.getServer());
        }
        return serviceInstanceResponse;
    }
    private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> instances, Request request) {
        if (instances.isEmpty()) {
            if (log.isWarnEnabled()) {
                log.warn("No servers available for service: " + this.serviceId);
            }
            return new EmptyResponse();
        }
        if (request instanceof DefaultRequest) {
            DefaultRequest<RequestDataContext> defaultRequest = (DefaultRequest) request;
            // 上下文獲取請求頭
            HttpHeaders headers = defaultRequest.getContext().getClientRequest().getHeaders();
            List<String> list = headers.get(TAG_HEADER);
            if (!CollectionUtils.isEmpty(list)) {
                String requestTag = list.get(0);
                for (ServiceInstance instance : instances) {
                    String str = instance.getMetadata().getOrDefault(TAG_HEADER, "");
                    if (requestTag.equals(str)) {
                        return new DefaultResponse(instance);
                    }
                }
                log.error(String.format("No servers available for service:%s,tag:%s ", this.serviceId, requestTag));
                return new EmptyResponse();
            }
        }
        int pos = Math.abs(this.position.incrementAndGet());
        ServiceInstance instance = instances.get(pos % instances.size());
        return new DefaultResponse(instance);
    }
}

這里需要實現(xiàn)ReactorServiceInstanceLoadBalancer接口，如果請求頭帶有標簽則根據(jù)標簽路由，否則使用默認的輪詢算法。

還要把TagLoadBalancer用起來，所以需要定義一個配置類TagLoadBalancerConfig，并通過@LoadBalancerClients注解添加默認配置，代碼如下：

/**
 * @Author: Ship
 * @Description:
 * @Date: Created in 2025/2/12
 */
public class TagLoadBalancerConfig {
    @Bean
    public ReactorLoadBalancer reactorTagLoadBalancer(Environment environment, LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        return new TagLoadBalancer(loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
    }
}
@LoadBalancerClients(defaultConfiguration = {TagLoadBalancerConfig.class})
@SpringBootApplication
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
}

最后在application.yml文件添加網(wǎng)關(guān)路由配置

spring:
  application:
    name: gateway
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848
        namespace: dev
        group: DEFAULT_GROUP
      discovery:
        server-addr: 127.0.0.1:8848
        namespace: dev
    gateway:
      routes:
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/order/**
          filters:
            - StripPrefix=1
server:
  port: 9000

3.3 代碼測試

本地啟動nacos后啟動order（注意需要在idea設(shè)置環(huán)境變量tag=ship）和gateway服務(wù)，可以看到order服務(wù)已經(jīng)成功注冊了元數(shù)據(jù)

然后用Postman請求網(wǎng)關(guān)http://localhost:9000/order/test

可以看到請求成功路由到了order服務(wù)，說明根據(jù)tag路由成功了。

去掉環(huán)境變量tag后重新啟動Order服務(wù)，再次請求響應(yīng)報文如下：

{
"timestamp": "2025-02-14T12:10:44.294+00:00",
"path": "/order/test",
"status": 503,
"error": "Service Unavailable",
"requestId": "41651188-4"
}

說明根據(jù)requst-tag找不到對應(yīng)的服務(wù)實例，代碼邏輯生效了。

四、總結(jié)

聰明的人已經(jīng)發(fā)現(xiàn)了，本文只實現(xiàn)了網(wǎng)關(guān)路由到下游服務(wù)這部分的標簽路由，下游服務(wù)A調(diào)服務(wù)B的標簽路由并未實現(xiàn)，其實現(xiàn)方案也不難，只需要通過上下文傳遞+feign攔截器就可以做到全鏈路的標簽路由，有興趣的可以自己試試。

本文代碼已上傳github，順便推廣下前段時間寫的idea插件CodeFaster（快速生成常用流操作的代碼，Marketplace搜索下載即可體驗）??。

到此這篇關(guān)于SpringCloud自定義loadbalancer實現(xiàn)標簽路由的詳細方案的文章就介紹到這了,更多相關(guān)SpringCloud標簽路由內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: