在Spring Boot中如何忽略POST请求体并复用同应用GET接口返回结果

Alright, let's break down these two Spring Boot scenarios you're dealing with— I've run into both before, so here's what I've found works:

1. How to Ignore the Request Body in a Spring Boot POST Request #

Depending on your use case, there are a few solid approaches here:

• Option 1: Skip declaring a request body parameter entirely
  If you don't need any content from the POST body, just leave out the @RequestBody annotation in your controller method. Spring won't try to parse the body unless you explicitly ask for it. Here's a quick example:

  @PostMapping("/submit-form")
  public ResponseEntity<Void> handleFormSubmission() {
      // Your business logic goes here
      return ResponseEntity.ok().build();
  }
  

  Heads up: If the client sends a body with a content type Spring expects to parse (like application/json), you might hit a parsing error. For those cases, use the next option.

• Option 2: Explicitly read and discard the body
  To avoid connection issues or parsing errors when the client does send a body, inject HttpServletRequest and skip the entire content stream:

  @PostMapping("/submit-form")
  public ResponseEntity<Void> handleFormSubmission(HttpServletRequest request) throws IOException {
      // Read and discard the entire request body
      request.getInputStream().skip(request.getContentLengthLong());
      // Your logic here
      return ResponseEntity.ok().build();
  }
  

• Option 3: Global filter for multiple endpoints
  If you need this behavior across several POST endpoints, create a filter that targets specific URLs and discards their bodies:

  @Component
  public class IgnoreBodyFilter extends OncePerRequestFilter {
      @Override
      protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
          // Target specific POST endpoints
          if ("/submit-form".equals(request.getRequestURI()) && HttpMethod.POST.matches(request.getMethod())) {
              request.getInputStream().skip(request.getContentLengthLong());
          }
          filterChain.doFilter(request, response);
      }
  }
  

2. Call a GET Endpoint Inside a POST Endpoint and Use Its Result as the POST Body #

First off—if the GET endpoint's logic lives in a service layer, call the service method directly instead of making an HTTP call. It's way more efficient and skips unnecessary network overhead. But if you need to go through the full controller stack (including interceptors, filters, or request validation), here's how to do it:

• Synchronous call with RestTemplate
  Inject RestTemplate into your controller and call the internal GET endpoint. Then replace the original POST body with the GET response:

  @RestController
  public class PostHandlerController {
      private final RestTemplate restTemplate;
  
      // Constructor injection is preferred over @Autowired
      public PostHandlerController(RestTemplate restTemplate) {
          this.restTemplate = restTemplate;
      }
  
      @PostMapping("/process-data")
      public ResponseEntity<String> handlePostRequest(@RequestBody(required = false) String originalBody) {
          // Call the internal GET endpoint
          String getResponse = restTemplate.getForObject("http://localhost:8080/fetch-data", String.class);
          
          // Use the GET response instead of the original POST body
          System.out.println("Using GET data instead of POST body: " + getResponse);
          
          return ResponseEntity.ok("Processed using GET data: " + getResponse);
      }
  }
  

  Note: Don't forget to define RestTemplate as a bean in your config class (e.g., with @Bean public RestTemplate restTemplate() { return new RestTemplate(); }).

• Reactive call with WebClient
  If you're using Spring WebFlux or prefer reactive programming, WebClient is the way to go:

  @RestController
  public class PostHandlerController {
      private final WebClient webClient;
  
      public PostHandlerController(WebClient.Builder webClientBuilder) {
          this.webClient = webClientBuilder.baseUrl("http://localhost:8080").build();
      }
  
      @PostMapping("/process-data")
      public Mono<ResponseEntity<String>> handlePostRequest(@RequestBody(required = false) String originalBody) {
          return webClient.get()
                  .uri("/fetch-data")
                  .retrieve()
                  .bodyToMono(String.class)
                  .map(getResponse -> ResponseEntity.ok("Processed using GET data: " + getResponse));
      }
  }
  

• Direct service method call (best practice)
  This is the cleanest approach if you can avoid HTTP calls. Just inject the service that powers your GET endpoint and reuse its logic:

  @RestController
  public class PostHandlerController {
      private final DataFetchService dataFetchService;
  
      public PostHandlerController(DataFetchService dataFetchService) {
          this.dataFetchService = dataFetchService;
      }
  
      @PostMapping("/process-data")
      public ResponseEntity<String> handlePostRequest(@RequestBody(required = false) String originalBody) {
          // Reuse the service method from the GET endpoint
          String fetchedData = dataFetchService.getSampleData();
          
          return ResponseEntity.ok("Processed using service data: " + fetchedData);
      }
  }
  
  // Example service that powers the GET endpoint
  @Service
  public class DataFetchService {
      public String getSampleData() {
          // Logic that your GET endpoint uses
          return "Sample data from internal service";
      }
  }
  

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