如何在Spring Boot中正确转发POST请求至另一个Web应用

Hey there! Let's walk through how to properly forward POST requests from App A to App B in Spring Boot. Since we're dealing with two separate web applications, server-side forward: won't work (that's only for internal routing within the same app). Instead, we need to use an HTTP client to send the request from App A to App B directly. Here are two reliable approaches:

Approach 1: Use RestTemplate (Traditional Synchronous) #

RestTemplate is the classic Spring HTTP client for synchronous requests. First, we need to register it as a bean, then use it in our controller to forward the request.

Step 1: Configure RestTemplate Bean #

Add this configuration class to App A to create a reusable RestTemplate instance:

@Configuration
public class RestClientConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

Step 2: Implement Forwarding in App A's Controller #

Inject the RestTemplate and handle the POST request, forwarding it to App B's /testB endpoint:

@RestController
public class RestControllerA {
    private final RestTemplate restTemplate;
    // Use constructor injection (recommended for Spring)
    public RestControllerA(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @PostMapping("/testA") // Shorthand for @RequestMapping(method = RequestMethod.POST)
    public void forwardPostRequest(@RequestBody Object inputData, HttpServletRequest request) {
        // Define App B's target URL (better to store this in application.properties)
        String targetUrl = "http://localhost:8081/testB";

        // Copy incoming request headers (like Content-Type, Authorization) to forward to App B
        HttpHeaders headers = new HttpHeaders();
        Enumeration<String> headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
            String headerName = headerNames.nextElement();
            headers.add(headerName, request.getHeader(headerName));
        }

        // Wrap the input data and headers into an HttpEntity
        HttpEntity<Object> requestEntity = new HttpEntity<>(inputData, headers);

        // Send the POST request to App B
        // Use postForObject if you don't need the response; use exchange for more control
        try {
            restTemplate.postForObject(targetUrl, requestEntity, Void.class);
        } catch (RestClientException e) {
            // Add error handling here (e.g., log the issue, throw a custom exception)
            throw new RuntimeException("Failed to forward request to App B", e);
        }
    }
}

Approach 2: Use WebClient (Reactive, Spring 5+) #

WebClient is Spring's modern, reactive HTTP client (recommended for new projects over RestTemplate, which is now in maintenance mode).

Step 1: Configure WebClient Bean #

Add this configuration to App A:

@Configuration
public class WebClientConfig {
    @Bean
    public WebClient webClient() {
        return WebClient.builder().build();
    }
}

Step 2: Implement Reactive Forwarding in App A's Controller #

Use WebClient to send the request reactively:

@RestController
public class RestControllerA {
    private final WebClient webClient;

    public RestControllerA(WebClient webClient) {
        this.webClient = webClient;
    }

    @PostMapping("/testA")
    public Mono<Void> forwardPostRequest(@RequestBody Object inputData, ServerHttpRequest request) {
        String targetUrl = "http://localhost:8081/testB";

        // Copy request headers
        HttpHeaders headers = new HttpHeaders();
        request.getHeaders().forEach((key, value) -> headers.addAll(key, value));

        return webClient.post()
                .uri(targetUrl)
                .headers(httpHeaders -> httpHeaders.addAll(headers))
                .bodyValue(inputData)
                .retrieve()
                .bodyToMono(Void.class)
                // Handle errors (e.g., App B is unreachable, returns 4xx/5xx status)
                .onErrorResume(error -> {
                    // Log the error and return a meaningful exception
                    return Mono.error(new RuntimeException("Failed to forward request to App B", error));
                });
    }
}

Key Notes for Production #

• Externalize Configuration: Store App B's URL in application.properties (e.g., app.b.base-url=http://app-b:8080) and inject it with @Value("${app.b.base-url}/testB") instead of hardcoding. This makes it easier to switch environments.
• Request Body Compatibility: Ensure the inputData DTO (or type) matches between App A and App B. If you're unsure, you can accept the request as a String (raw JSON) and forward it directly to avoid serialization issues.
• Query Parameters: If your /testA endpoint has query parameters, don't forget to append them to the target URL using request.getQueryString().
• Error Handling: Always add proper error handling for cases where App B is down, returns an error status, or times out.

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