JHipster网关未生成AuthorizedFeignClient相关代码的原因及通信方案

Hey there! Let's break down your questions step by step—this is a common pain point when working with Spring Cloud setups, so I’ve got some solid insights for you.

First, let’s tackle why the gateway isn’t generating code tied to this annotation. Chances are it’s one of these scenarios:

• Missing annotation scanning: If @AuthorizedFeignClient is a custom annotation, your gateway project might not be scanning the package where it’s defined. Double-check that you’ve added @ComponentScan with the correct package path, or that any custom annotation processors are registered properly.
• Invalid annotation definition: If you built @AuthorizedFeignClient yourself, it might not be properly derived from Spring’s official @FeignClient annotation. Make sure you’ve included @FeignClient as a meta-annotation on your custom one, and that required attributes like name or url are being passed through.
• Missing dependencies: Your gateway might be missing critical dependencies. For Feign support, you need spring-cloud-starter-openfeign (and if you’re using WebFlux in the gateway, spring-cloud-starter-openfeign-webflux). If @AuthorizedFeignClient comes from an internal library, ensure that jar is included in your pom.xml or build.gradle.
• WebFlux/Feign incompatibility: Spring Cloud Gateway uses WebFlux (reactive stack), while standard Feign is built for Servlet environments. If you haven’t configured reactive Feign, the code generator might fail to pick up the annotation.
• Code generator misconfiguration: If you’re using a tool like OpenAPI Generator to auto-generate Feign clients, it might not be configured to recognize @AuthorizedFeignClient. Check your generator config to ensure it’s set to process custom Feign annotations.

If you can’t use that annotation, there are several reliable ways to handle communication:

• Gateway Route Forwarding (Simplest Approach)
  Just configure Spring Cloud Gateway to act as a reverse proxy, routing requests directly to your microservices via service discovery. Add this to your gateway’s application.yml:

  spring:
    cloud:
      gateway:
        routes:
          - id: user-service-route
            uri: lb://user-service
            predicates:
              - Path=/user/**
            filters:
              - AddRequestHeader=Authorization, {token-from-gateway-context}
  

  The lb:// prefix tells the gateway to use load balancing via service discovery (like Eureka or Consul). You can add filters to inject auth headers or modify requests as needed.

• Reactive WebClient Calls
  Since the gateway uses WebFlux, WebClient is the recommended reactive client for direct service calls. Create a client bean:

  @Service
  public class UserServiceClient {
      private final WebClient webClient;
  
      public UserServiceClient(WebClient.Builder webClientBuilder) {
          this.webClient = webClientBuilder.baseUrl("lb://user-service").build();
      }
  
      public Mono<User> getUserById(Long id, String authToken) {
          return webClient.get()
                  .uri("/user/{id}", id)
                  .header("Authorization", authToken)
                  .retrieve()
                  .bodyToMono(User.class);
      }
  }
  

  This lets you make async, non-blocking calls while handling auth headers directly.

• Standard @FeignClient with Auth Interceptors
  Ditch the custom annotation and use Spring’s official @FeignClient, then add an interceptor to handle authorization automatically:

  1. Define the Feign client:

     @FeignClient(name = "user-service")
     public interface UserServiceFeignClient {
         @GetMapping("/user/{id}")
         User getUserById(@PathVariable("id") Long id);
     }
     

  2. Create a request interceptor to inject auth headers:

     @Component
     public class FeignAuthInterceptor implements RequestInterceptor {
         @Override
         public void apply(RequestTemplate template) {
             // Fetch the auth token from the gateway's request context (e.g., ServerWebExchange)
             String authToken = // Your logic to get the token
             template.header("Authorization", authToken);
         }
     }
     

  This keeps your client clean while handling auth consistently.

• RestTemplate (Not Recommended for Gateway)
  While possible, RestTemplate is blocking and not ideal for the reactive Gateway stack. But if you need it, configure a load-balanced RestTemplate:

  @Bean
  @LoadBalanced
  public RestTemplate restTemplate() {
      return new RestTemplate();
  }
  
  // Usage in a service class
  @Autowired
  private RestTemplate restTemplate;
  
  public User getUserById(Long id, String authToken) {
      HttpHeaders headers = new HttpHeaders();
      headers.set("Authorization", authToken);
      HttpEntity<Void> entity = new HttpEntity<>(headers);
      return restTemplate.exchange(
              "http://user-service/user/{id}",
              HttpMethod.GET,
              entity,
              User.class,
              id
      ).getBody();
  }
  

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