SpringCloud通过服务逻辑分组实现灰度功能

济南大飞哥

已于 2024-03-25 11:22:05 修改

阅读量496

点赞数

分类专栏： SpringCloud 文章标签： spring cloud spring boot java

于 2021-02-07 16:18:08 首次发布

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/flyfeifei66/article/details/113743030

版权

SpringCloud 专栏收录该内容

6 篇文章 1 订阅

订阅专栏

声明：内容来自AI，未经验证，仅供参考!

1、原理

服务注册到注册中心时，我们可以添加额外的信息对服务进行打标/染色，从而实现逻辑分组。当有调用时，我们根据HTTP头信息（约定好头）来决定转发到那个分组，从而能实现灰度功能，当然这样只实现了接口的灰度，其他中间件像MQ、Redis需要根据情况来决定要不要灰度，还是和非灰度共用。

假设用户发起一个访问，服务的调用路径为：用户--> ZUUL -->app-consumer-->app-provider，那么我们在ZUUL和SERVICE里都需要实现自定义的访问路由。

2、网关实现服务分组

2.1 ZUUL网关

首先，假设服务实例在注册到Eureka时带有元数据，如版本信息：

eureka:
  instance:
    metadata-map:
      version: "version1"

然后，在Spring Cloud Gateway中，可以编写一个自定义的GlobalFilter来实现基于元数据的路由规则：

import com.netflix.appinfo.InstanceInfo;
import com.netflix.config.DynamicPropertyFactory;
import com.netflix.discovery.EurekaClient;
import com.netflix.discovery.shared.Application;
import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.netflix.zuul.filters.support.FilterConstants;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.util.List;

@Component
public class DynamicRoutingFilter extends ZuulFilter {

    @Autowired
    private EurekaClient discoveryClient;

    @Override
    public String filterType() {
        return FilterConstants.ROUTE_TYPE;
    }

    @Override
    public int filterOrder() {
        // 在RibbonRoutingFilter之前执行
        return FilterConstants.RIBBON_ROUTING_FILTER_ORDER - 1;
    }

    @Override
    public boolean shouldFilter() {
        // 根据需要决定是否执行过滤器的逻辑
        return true;
    }

    @Override
    public Object run() {
        RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletRequest request = ctx.getRequest();

        // 从请求URI中提取服务名称
        String serviceName = extractServiceName(request);
        String targetVersion = request.getHeader("Target-Version");

        // 从注册中心获取服务实例
        Application application = discoveryClient.getApplication(serviceName.toUpperCase());
        if (application != null) {
            List<InstanceInfo> instances = application.getInstances();
            // 根据目标版本筛选服务实例
            InstanceInfo instanceInfo = instances.stream()
                    .filter(instance -> targetVersion.equals(instance.getMetadata().get("version")))
                    .findFirst()
                    .orElse(null);

            if (instanceInfo != null) {
                // 构建目标URL
                String targetUrl = instanceInfo.getHomePageUrl();
                // 更新请求的URI，使之指向特定的服务实例
                String newRequestUri = buildNewRequestUri(request, targetUrl);
                ctx.set(FilterConstants.REQUEST_URI_KEY, newRequestUri);
                
                // 确保不设置serviceId，这会导致Zuul使用SimpleHostRoutingFilter而不是RibbonRoutingFilter
                ctx.set(FilterConstants.SERVICE_ID_KEY, null);
            } else {
                // 如果没有找到合适的实例，可以设置错误状态或者直接抛出异常
                // ctx.setResponseStatusCode(404);
                // throw new ZuulException("No matching instances found", 404, "No matching version");
            }
        }

        return null;
    }

    private String extractServiceName(HttpServletRequest request) {
        // 假设服务名称是路径的第一个部分（即"/"之后的部分）
        String path = request.getRequestURI();
        if (path.startsWith("/")) {
            path = path.substring(1);
        }
        String[] parts = path.split("/");
        return (parts.length > 0) ? parts[0] : null;
    }

    private String buildNewRequestUri(HttpServletRequest request, String targetUrl) {
        String serviceName = extractServiceName(request);
        // 使用正则表达式替换掉原始URI中的服务名称部分
        String regex = "http[s]?://[^/]+/" + serviceName;
        String requestUri = request.getRequestURI();
        // 如果原始URI包含查询参数，则一并携带
        String query = request.getQueryString() != null ? "?" + request.getQueryString() : "";
        // 确保目标URL以斜杠结尾以便正确拼接
        targetUrl = targetUrl.endsWith("/") ? targetUrl : targetUrl + "/";
        return requestUri.replaceFirst(regex, targetUrl) + query;
}

}

在上面的代码中，DynamicRoutingFilter首先从请求中提取服务名称和目标版本信息。然后，它查询Eureka注册中心，找到符合版本元数据条件的服务实例。如果存在匹配的实例，就构建一个新的请求URI，并通过set()方法将其设置到请求上下文中。此外，为了防止Zuul使用RibbonRoutingFilter进行负载均衡和服务发现，我们将服务ID（serviceId）设置为null。这样，Zuul将使用SimpleHostRoutingFilter直接将请求转发到我们指定的URL（requestURI），而不会试图再次查找服务实例或应用负载均衡。

在上述示例过滤器中，如果groupInstances 为空，意味着没有找到任何匹配特定分组元数据的服务实例。在这种情况下，过滤器不会修改请求的路由路径，请求将继续通过Zuul的正常路由机制进行。返回 null 意味着告诉Zuul：“我的自定义过滤逻辑已经执行完毕，你可以继续执行后续的过滤器链”。这里返回 null 是Zuul过滤器的标准做法，它表示过滤器已成功执行，没有新的动作需要执行。

2.2 ZUUL路由补充

在Zuul中，filterType()的返回值决定了过滤器的类型，它可以是以下之一：

pre：这些过滤器在请求路由到目标服务之前执行。
route：在这个阶段的过滤器可以控制请求的实际路由。例如，它可以修改请求要路由到的地址，或者完全重写路由逻辑。
post：这些过滤器在请求已经被路由到目标服务，并且响应即将返回给客户端时执行。
error：当在其他阶段发生错误时，执行这些过滤器。

2.2 SpringGateWay实现服务分组

确保所有服务实例都注册到Eureka时带有所需的元数据，以便你的服务实例选择逻辑可以根据这些元数据正确识别逻辑分组。例如，你可以在application.yaml中为每个服务实例配置元数据

eureka:
  instance:
    metadata-map:
      logic-group: "group-a" # 根据实际情况设置逻辑分组的名称

import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.net.URI;
import java.util.List;
import java.util.Random;

@Component
public class HeaderMetadataGlobalFilter implements GlobalFilter, Ordered {

    private final DiscoveryClient discoveryClient;
    private final String HEADER_NAME = "X-Logic-Group"; // 请求头，用于传递逻辑分组信息

    public HeaderMetadataGlobalFilter(DiscoveryClient discoveryClient) {
        this.discoveryClient = discoveryClient;
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 从请求头中获取逻辑分组信息
        String logicGroup = exchange.getRequest().getHeaders().getFirst(HEADER_NAME);
        if (logicGroup != null && !logicGroup.isEmpty()) {
            // 假设服务名称是路径的一部分，比如 '/serviceA/...'
            String serviceName = getServiceNameFromRequest(exchange);
            List<ServiceInstance> instances = discoveryClient.getInstances(serviceName);

            // 筛选属于指定逻辑分组的服务实例
            ServiceInstance instance = instances.stream()
                    .filter(inst -> logicGroup.equals(inst.getMetadata().get(HEADER_NAME)))
                    // 这里需要改成一个负载均衡算法
                    .findAny()
                    .orElse(null);

            if (instance != null) {
                // 如果找到匹配的服务实例，构建新的URI
                URI newUri = buildNewUri(instance, exchange.getRequest().getURI());
                // 用新的URI更新请求，并继续过滤链
                exchange = exchange.mutate()
                        .request(exchange.getRequest().mutate().uri(newUri).build())
                        .build();
            }
        }
        return chain.filter(exchange);
    }

    // 从请求中提取服务名称的方法
    private String getServiceNameFromRequest(ServerWebExchange exchange) {
        String path = exchange.getRequest().getURI().getPath();
        if (path.startsWith("/")) {
            path = path.substring(1);
        }
        String[] segments = path.split("/");
        return segments.length > 0 ? segments[0] : null;
    }

    // 根据选中的服务实例构建新URI的方法
    private URI buildNewUri(ServiceInstance instance, URI originalUri) {
        // 获取服务实例的基本URI
        String instanceUriStr = instance.getUri().toString();
        // 获取原始URI的路径部分
        String path = originalUri.getRawPath();  // 使用getRawPath保留编码状态
        // 获取原始URI的查询字符串，如果存在的话
        String query = originalUri.getRawQuery();  // 使用getRawQuery以保留编码状态
        // 构建新的URI，将路径和查询字符串拼接到服务实例的URI后
        String newUriStr = instanceUriStr + path + (query != null ? "?" + query : "");
        return URI.create(newUriStr);
    }


    @Override
    public int getOrder() {
        // 将此过滤器的顺序设置为在LoadBalancerClientFilter之前，后者默认顺序为10150
        return 10100;
    }
}

当Spring Cloud Gateway接收到请求时，它遵循以下一般过程来处理该请求：

请求匹配：请求首先被检查是否匹配任何已配置的路由。每个路由定义了一系列的断言（谓词），这些断言可以基于HTTP请求的各个方面（例如路径、头部、方法等）进行评估。
过滤器链执行：一旦找到匹配的路由，请求将通过一系列已配置的过滤器。这些过滤器可以在发送下游请求之前（“pre”过滤器）和下游响应之后（“post”过滤器）修改请求和响应。
路由到下游服务：通过路由配置的URI将请求发送到下游服务。如果URI以lb://开头，它将使用Spring Cloud的负载均衡机制来选择服务实例。
返回响应：下游服务的响应通过过滤器链发送回客户端，过滤器可以对响应进行最终修改。

在上述例子中提到的自定义过滤器中，通过创建新的ServerWebExchange并修改请求的URI来直接指向选择的服务实例。理论上，这种方法确实可以绕过负载均衡，因为你已经明确指定了目标服务实例的地址。

然而，细节方面需要注意：

当你通过修改ServerWebExchange来改变URI时，确实可以绕过默认的负载均衡机制，因为你是直接指定了目标服务的URI。
重要的是确保新的URI是完整的，正确地指向了目标服务实例的地址。你需要包括协议（如http或https）、主机名和端口号，以及可能的路径。
如果URI以lb://开头，Spring Cloud Gateway会尝试对其进行负载均衡。因此，确保你的新URI不以lb://开头，而是直接使用http或https等。

3、服务间的实现

这里有两个工作需要做，一是实现类似网关的工作，也就是基于自定义头来路由请求到Eureka服务的特定逻辑分组实例，二是要实现头的传递，因为调用链很长，这个头需要一直传递下去。

3.1 RestTemplate传递头

1、创建带有@LoadBalanced注解的RestTemplate bean：

@Configuration
public class RestClientConfig {

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.getInterceptors().add(new HeaderPropagationInterceptor());
        return restTemplate;
    }
}

2、定义一个ClientHttpRequestInterceptor以传递头信息（也可以把所有头都传递下去）

public class HeaderPropagationInterceptor implements ClientHttpRequestInterceptor {

    private static final String LOGIC_GROUP_HEADER = "X-Logic-Group";

    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
        HttpServletRequest currentRequest = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String logicGroup = currentRequest.getHeader(LOGIC_GROUP_HEADER);
        if (logicGroup != null) {
            request.getHeaders().add(LOGIC_GROUP_HEADER, logicGroup);
        }
        return execution.execute(request, body);
    }
}

3.2 FeignClient传递头，拦截器实现。

@Configuration
public class GlobalFeignConfig {
    @Bean
    public RequestInterceptor headerForwardingInterceptor() {
        return template -> {
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            Enumeration<String> headerNames = request.getHeaderNames();
            if (headerNames != null) {
                while (headerNames.hasMoreElements()) {
                    String name = headerNames.nextElement();
                    String values = request.getHeader(name);
                    template.header(name, values);
                }
            }
        };
    }
}

它传递了所有的头。

3.3 自定义Ribbon路由规则

由于FeignClient和RestTemplte(带@LoadBalanced注解)底层都使用了Ribbon，自然通过这两种方式调用接口都会有这个路由效果。因此我们只需要自定义一个Bibbon路由规则就可以了。

public class CustomLoadBalancerRule extends AbstractLoadBalancerRule {
    private static final String LOGIC_GROUP_HEADER = "X-Logic-Group";

    @Override
    public Server choose(Object key) {
        ILoadBalancer lb = getLoadBalancer();
        List<Server> servers = lb.getReachableServers();
        HttpServletRequest request = RequestContext.getCurrentContext().getRequest();
        String logicGroup = request.getHeader(LOGIC_GROUP_HEADER);
        
        // 实现基于logicGroup的自定义逻辑来选择服务实例
        // ...
        
        return chooseAnyServer(servers);
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        // 初始化配置（如果需要）
    }

    private Server chooseAnyServer(List<Server> servers) {
        // 这里可以实现备选的选择逻辑，例如随机选择
        if (servers.isEmpty()) return null;
        return servers.get(ThreadLocalRandom.current().nextInt(servers.size()));
    }
}

创建一个RibbonClientConfiguration类

@Configuration
public class RibbonConfiguration {
    @Bean
    public IRule ribbonRule() {
        return new CustomLoadBalancerRule(); // 使用你的自定义规则
    }
}

然后，在你的应用主类或任何配置类上使用@RibbonClients注解来应用这个配置：（貌似不是必须的，需要验证）

@SpringBootApplication
@RibbonClients(defaultConfiguration = RibbonConfiguration.class)
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

对于大多数使用场景，如果你只是想全局应用一个统一的Ribbon配置，那么@Configuration类中定义的@Bean方法提供的配置就已经足够。只有在需要更细粒度控制或解决特定问题时，才考虑使用@RibbonClients。

3.4 SpringCloud LoadBalancer

ReactiveLoadBalancer与ServiceInstanceListSupplier的选择问题!

在Spring Cloud LoadBalancer中，ReactiveLoadBalancer的实现通常是用来选择服务实例，而不是用来过滤服务实例列表。过滤服务实例列表通常是通过实现ServiceInstanceListSupplier接口来完成的。

ReactiveLoadBalancer是一个更高层次的接口，其choose方法被用来从服务实例列表中按照某种策略选择一个实例。当你使用ReactiveLoadBalancer时，通常是在已经有一个服务实例列表的基础上，根据负载均衡策略（如轮询、随机等）选择一个实例。而ServiceInstanceListSupplier则是负责提供这个初始的服务实例列表，可以在这个阶段根据请求头信息对列表进行过滤。

如果你想在ReactiveLoadBalancer层面实现基于请求头的路由决策，你需要在调用choose方法时传递一些上下文信息。Spring Cloud LoadBalancer中的Request接口可以携带这些信息。然而，Request对象需要在调用choose之前构建，并且Spring Cloud LoadBalancer并没有提供一个内置的方式来根据传入的HTTP请求构建这个Request对象。这就是为什么在之前的解决方案中，我们使用ServiceInstanceListSupplier来实现基于请求头的路由决策的原因。

ServiceInstanceListSupplier 方式：

首先，你需要确保在请求进入Spring Cloud Gateway时能够捕获并存储当前的ServerWebExchange。Spring Cloud Gateway提供了一个方便的方式来进行这种操作，你可以定义一个全局过滤器：（在WebFlux环境中，使用ThreadLocal来存储ServerWebExchange是不合适的，正确的做法是使用Reactor的上下文（Context）来存储信息）

import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class ServerWebExchangeStoreFilter implements GlobalFilter, Ordered {
    public static final String EXCHANGE_ATTRIBUTE_NAME = "serverWebExchange";

    @Override
    public int getOrder() {
        // Ensure this filter has the highest precedence
        return Ordered.HIGHEST_PRECEDENCE;
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // Store ServerWebExchange in the Reactor Context
        return chain.filter(exchange)
                .contextWrite(ctx -> ctx.put(EXCHANGE_ATTRIBUTE_NAME, exchange));
    }
}

在这个实现中，get()方法利用了Flux.deferContextual来延迟对Reactor上下文的访问。我们试图从上下文中获取ServerWebExchange，然后从中读取请求头Custom-Header。根据这个头信息，我们过滤服务实例列表以匹配头信息。

然后创建一个全局的ServiceInstanceListSupplier：

import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;

import java.util.List;
import java.util.stream.Collectors;

public class HeaderBasedServiceInstanceListSupplier implements ServiceInstanceListSupplier {
    private final DiscoveryClient discoveryClient;
    private final String serviceId;

    public HeaderBasedServiceInstanceListSupplier(DiscoveryClient discoveryClient, String serviceId) {
        this.discoveryClient = discoveryClient;
        this.serviceId = serviceId;
    }

    @Override
    public Flux<List<ServiceInstance>> get() {
        return Flux.deferContextual(ctx -> {
            if (ctx.hasKey(ServerWebExchangeStoreFilter.EXCHANGE_CONTEXT_ATTRIBUTE)) {
                ServerWebExchange exchange = ctx.get(ServerWebExchangeStoreFilter.EXCHANGE_CONTEXT_ATTRIBUTE);
                String headerValue = exchange.getRequest().getHeaders().getFirst("Custom-Header");

                List<ServiceInstance> instances = discoveryClient.getInstances(serviceId);
                // 过滤服务实例，仅保留头信息匹配的实例
                List<ServiceInstance> filteredInstances = instances.stream()
                    .filter(instance -> instance.getMetadata().get("Custom-Metadata-Key").equals(headerValue))
                    .collect(Collectors.toList());

                return Flux.just(filteredInstances);
            } else {
                return Flux.error(new IllegalStateException("ServerWebExchange is not available in the context."));
            }
        });
    }

    @Override
    public String getServiceId() {
        return serviceId;
    }
}

现在，创建一个全局的自定义ReactorLoadBalancer工厂：

import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.loadbalancer.annotation.LoadBalancerClient;
import org.springframework.cloud.loadbalancer.annotation.LoadBalancerClients;
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
@LoadBalancerClients(defaultConfiguration = DefaultCustomLoadBalancerConfiguration.class)
public class GlobalLoadBalancerConfiguration {
}

@Configuration
class DefaultCustomLoadBalancerConfiguration {

    @Bean
    public ServiceInstanceListSupplier discoveryClientServiceInstanceListSupplier(
            DiscoveryClient discoveryClient,
            Environment environment,
            LoadBalancerClientFactory loadBalancerClientFactory) {
        return new HeaderBasedServiceInstanceListSupplier(discoveryClient, loadBalancerClientFactory.getName(environment));
    }
}

在这个配置中，使用@LoadBalancerClients注解来指定默认的负载均衡配置。DefaultCustomLoadBalancerConfiguration类中定义了一个Bean工厂方法，该方法会根据当前的服务创建一个HeaderBasedServiceInstanceListSupplier实例。

ReactiveLoadBalancer方式

保存ServerWebExchange同上

import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class ServerWebExchangeStoreFilter implements GlobalFilter, Ordered {
    public static final String EXCHANGE_CONTEXT_ATTRIBUTE = "serverWebExchange";

    @Override
    public int getOrder() {
        // Ensure this filter runs before other filters
        return Ordered.HIGHEST_PRECEDENCE;
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // Add ServerWebExchange to Reactor context
        return chain.filter(exchange)
                .subscriberContext(ctx -> ctx.put(EXCHANGE_CONTEXT_ATTRIBUTE, exchange));
    }
}

实现自定义的ReactiveLoadBalancer

自定义的负载均衡器将访问Reactor上下文来获取ServerWebExchange并提取请求头信息，基于该信息做出服务实例选择决策：

import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.Response;
import org.springframework.cloud.client.loadbalancer.reactive.ReactorServiceInstanceLoadBalancer;
import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
import reactor.core.publisher.Mono;

import java.util.List;

public class CustomHeaderBasedReactiveLoadBalancer implements ReactorServiceInstanceLoadBalancer {

    private final ServiceInstanceListSupplier serviceInstanceListSupplier;
    private final String serviceId;

    public CustomHeaderBasedReactiveLoadBalancer(ServiceInstanceListSupplier serviceInstanceListSupplier, String serviceId) {
        this.serviceInstanceListSupplier = serviceInstanceListSupplier;
        this.serviceId = serviceId;
    }

    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        return Mono.deferContextual(ctx -> {
            if (ctx.hasKey(ServerWebExchangeStoreFilter.EXCHANGE_CONTEXT_ATTRIBUTE)) {
                ServerWebExchange exchange = ctx.get(ServerWebExchangeStoreFilter.EXCHANGE_CONTEXT_ATTRIBUTE);
                String headerValue = exchange.getRequest().getHeaders().getFirst("Custom-Header");

                return serviceInstanceListSupplier.get(request)
                        .next()
                        .map(serviceInstances -> {
                            // 过滤服务实例列表，基于请求头信息
                            List<ServiceInstance> filteredInstances = serviceInstances.stream()
                                .filter(si -> headerValue.equals(si.getMetadata().get("Custom-Metadata-Key")))
                                .collect(Collectors.toList());

                            // 这里只是示例，实际上你可能需要一个更复杂的选择策略
                            return new DefaultResponse(filteredInstances.get(0));
                        });
            } else {
                return Mono.error(new IllegalStateException("ServerWebExchange is not available in the context."));
            }
        });
    }
}

注册自定义的ReactiveLoadBalancer

最后，在你的Spring Cloud Gateway配置类中，注册自定义的ReactiveLoadBalancer：

import org.springframework.cloud.loadbalancer.annotation.LoadBalancerClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@LoadBalancerClient(name = "default", configuration = DefaultLoadBalancerConfiguration.class)
public class CustomLoadBalancerConfiguration {

    @Bean
    public ReactorServiceInstanceLoadBalancer reactorServiceInstanceLoadBalancer(
            ServiceInstanceListSupplier serviceInstanceListSupplier) {
        return new CustomHeaderBasedReactiveLoadBalancer(serviceInstanceListSupplier);
    }

    // CustomHeaderBasedReactiveLoadBalancer definition here
    // ...
}

在上面的代码中，@LoadBalancerClient注解的name属性被设置为"default"，这意味着它将为所有没有特定负载均衡配置的服务提供负载均衡策略。

确保你的自定义ReactorServiceInstanceLoadBalancer实现和全局过滤器（用于存储ServerWebExchange）已经正确定义，如之前的回答中所示。

不过，需要注意的是，不同版本的Spring Cloud可能在实现和配置上有所差异。@LoadBalancerClient的默认行为和如何对待"default"这个名称可能会有所不同，因此建议查阅你正在使用的Spring Cloud版本的官方文档来获取确切的信息。

总之，你选择哪种方式来注册你的自定义负载均衡器取决于你的具体需求和你所使用的Spring Cloud版本。在某些场景下，重写LoadBalancerClientFactory可能更合适，而在其他场景下，使用@LoadBalancerClient注解可能更简单直观。

import org.springframework.cloud.client.loadbalancer.LoadBalancerClientFactory;
import org.springframework.cloud.gateway.config.LoadBalancerProperties;
import org.springframework.cloud.loadbalancer.annotation.LoadBalancerClientConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@Import(LoadBalancerClientConfiguration.class)
public class GlobalLoadBalancerConfiguration {

    @Bean
    public LoadBalancerClientFactory loadBalancerClientFactory() {
        return new CustomLoadBalancerClientFactory();
    }

    static class CustomLoadBalancerClientFactory extends LoadBalancerClientFactory {
        @Override
        public ReactorServiceInstanceLoadBalancer getInstance(String serviceId) {
            ServiceInstanceListSupplier supplier = getLazyProvider(serviceId, ServiceInstanceListSupplier.class).getIfAvailable();
            return new CustomHeaderBasedReactiveLoadBalancer(supplier, serviceId);
        }
    }

    // Your CustomHeaderBasedReactiveLoadBalancer definition here
    // ...
}

这个配置类使用了@Import注解来确保LoadBalancerClientConfiguration中的默认配置被加载。然后它提供了一个自定义LoadBalancerClientFactory的Bean，该Bean重写了getInstance方法来返回自定义的负载均衡器实例。

这样，在应用程序中就设置了一个全局有效的自定义负载均衡器，它将用于所有通过Spring Cloud Gateway的服务调用。

请注意，具体的配置可能依赖于您使用的Spring Cloud版本，并且Spring Cloud组件可能会有所不同。以上示例代码提供了一种可能的实现方式，但根据您的实际环境和需求，您可能需要调整配置。如果您在注册过程中遇到任何问题，建议查看Spring Cloud Gateway和Spring Cloud LoadBalancer的官方文档以获取最新的配置指导。

参考：

Spring Cloud灰度发布方案----自定义路由规则-CSDN博客

【云原生】Spring Cloud Gateway的底层原理与实践方法探究-阿里云开发者社区

微服务网关：SpringCloud Gateway保姆级入门教程 - 知乎

https://www.jianshu.com/p/5bc811483c36

SpringCloud 自定义ribbon路由实现灰度发布_springcloud ribbon 灰度发-CSDN博客

济南大飞哥

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
SpringCloud通过服务逻辑分组实现灰度功能

当有调用时，我们根据HTTP头信息（约定好头）来决定转发到那个分组，从而能实现灰度功能，当然这样只实现了接口的灰度，其他中间件像MQ、Redis需要根据情况来决定要不要灰度，还是和非灰度共用。这里有两个工作需要做，一是实现类似网关的工作，也就是基于自定义头来路由请求到Eureka服务的特定逻辑分组实例，二是要实现头的传递，因为调用链很长，这个头需要一直传递下去。确保所有服务实例都注册到Eureka时带有所需的元数据，以便你的服务实例选择逻辑可以根据这些元数据正确识别逻辑分组。方法提供的配置就已经足够。
复制链接

扫一扫