Spring Cloud多RestTemplate配置异常：负载均衡结果不符合预期

Hey there, let's break down why your first RestTemplate is routing to unexpected servers despite using @LoadBalanced, shared UriTemplateHandler, and @RibbonClient configuration.

Possible Root Causes #

• Shared UriTemplateHandler causing context leakage: When you reuse the same UriTemplateHandler instance across multiple @LoadBalanced RestTemplates, the Ribbon load balancer context (which tracks service instances, load balancing rules, etc.) might get shared or overwritten. The LoadBalancerUriTemplateHandler (the default implementation for load-balanced templates) ties into the Ribbon client's metadata, so sharing it can mix up routing logic between your two templates.
• Misconfigured @RibbonClient scope: If your @RibbonClient is defined at the application level without proper qualification, it might be applying its configuration to both RestTemplates in an unintended way. For example, if you've customized a load balancing rule in the @RibbonClient's configuration class, it might not be scoped correctly to the intended template.
• Eureka instance metadata mismatch: Double-check that the service instances registered in Eureka have the correct metadata (like service name, zone, etc.) that aligns with your request expectations. Sometimes instances might be registered with typos or incorrect tags, leading Ribbon to pick unexpected nodes.

Step-by-Step Fixes #

1. Use separate UriTemplateHandler instances for each RestTemplate
   Instead of injecting a shared instance, create a dedicated UriTemplateHandler for each RestTemplate bean to isolate their load balancing contexts:

   @Configuration
   public class RestTemplateConfig {
       @Bean
       @LoadBalanced
       public RestTemplate firstRestTemplate(RestTemplateBuilder builder) {
           return builder
                   .uriTemplateHandler(new LoadBalancerUriTemplateHandler())
                   .build();
       }
   
       @Bean
       @LoadBalanced
       public RestTemplate secondRestTemplate(RestTemplateBuilder builder) {
           return builder
                   .uriTemplateHandler(new LoadBalancerUriTemplateHandler())
                   .build();
       }
   }
   

2. Qualify RestTemplates and align @RibbonClient scope
   If you need distinct Ribbon configurations for each template, use @Qualifier to distinguish them and pair each with a targeted @RibbonClient (or @RibbonClients for multiple setups):

   @SpringBootApplication
   @RibbonClients({
       @RibbonClient(name = "${service.name}", configuration = FirstRibbonConfig.class),
       @RibbonClient(name = "second-target-service", configuration = SecondRibbonConfig.class)
   })
   public class YourApplication {
       // ...
   }
   
   // Inject with qualifiers to ensure correct pairing
   @Autowired
   @Qualifier("firstRestTemplate")
   private RestTemplate firstRestTemplate;
   
   @Autowired
   @Qualifier("secondRestTemplate")
   private RestTemplate secondRestTemplate;
   

   Ensure each RestTemplate uses the service name matching its paired @RibbonClient's name attribute in requests.

3. Debug the load balancing decision
   Enable debug logs to trace how Ribbon selects instances. Add these lines to your application.properties:

   logging.level.org.springframework.cloud.netflix.ribbon=DEBUG
   logging.level.com.netflix.loadbalancer=DEBUG
   

   This will show you exactly which instances Ribbon is evaluating, which rule it's using to pick a server, and why it's choosing the unexpected one.

4. Verify Eureka instance registration
   Check the Eureka dashboard (typically at http://<eureka-host>:<port>/eureka) to confirm all target service instances are registered with the correct serviceId and marked as UP. Instances in a DOWN state or with mismatched service names can cause Ribbon to fall back to unexpected nodes.

内容的提问来源于stack exchange，提问作者Edna