Read Request Body Multiple Times in Spring Boot

1. Introduction

In this tutorial, we’ll explore how to read the request body multiple times in Spring Boot using ContentCachingRequestWrapper. This is useful for tasks such as logging, debugging, or when you need to access the request content more than once.

2. Understanding HttpServletRequest and Request Body

Spring Boot uses the Servlet API, with the Dispatcher Servlet acting as the main entry point. The HttpServletRequest interface provides two primary methods to read the request body: getInputStream and getReader. These methods rely on the same InputStream, so once the stream is read, it cannot be read again.

To solve this, we can cache the request content for multiple reads.

3. Using ContentCachingRequestWrapper

Spring Boot provides the ContentCachingRequestWrapper class, which wraps the original HttpServletRequest object and caches its content.

Example Using a Filter

First, create a filter to wrap the HttpServletRequest with ContentCachingRequestWrapper.

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.GenericFilterBean;
import org.springframework.web.util.ContentCachingRequestWrapper;

import java.io.IOException;

@Component
public class CachingRequestBodyFilter extends GenericFilterBean {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {

        HttpServletRequest httpRequest = (HttpServletRequest) request;
        ContentCachingRequestWrapper wrappedRequest = new ContentCachingRequestWrapper(httpRequest);

        chain.doFilter(wrappedRequest, response);
    }
}

This CachingRequestBodyFilter ensures that every request is wrapped before it reaches the controller.

Note: The request body content via ContentCachingRequestWrapper object will only be available after the doFilter method is called. This is because the content is cached only when the request is read during the filter chain processing.

FYI: We can also implement the same functionality using OncePerRequestFilter to ensure the filter is only applied once per request.

Next, create a controller to handle employee data in a POST request.

import jakarta.servlet.http.HttpServletRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.util.ContentCachingRequestWrapper;

@RestController
public class EmployeeController {

    private static final Logger log = LoggerFactory.getLogger(EmployeeController.class);

    @PostMapping("/employee")
    public String saveEmployee(HttpServletRequest request) {
        ContentCachingRequestWrapper requestWrapper = (ContentCachingRequestWrapper) request;
        String requestBody = requestWrapper.getContentAsString();
        
        log.info("Inside Controller. Request Body: {}", requestBody);
        return "Received employee data: " + requestBody;
    }
}

This demonstrates a Spring Boot REST controller that handles POST requests, where the request body is logged using ContentCachingRequestWrapper. This wrapper allows the request body to be read multiple times, enabling logging and further processing without losing the content.

Here, the Employee class will look like this:

public class Employee {

    private String firstName;
    private String lastName;
    private Integer pincode;
    private Double salary;
    
    // Getters and setters   
}

4. Methods for Accessing the Request Body

4.1 getContentAsString

This method returns the cached request content as a String.

String requestBody = requestWrapper.getContentAsString();

4.2 getContentAsByteArray

This method returns the cached request content as a byte array.

byte[] requestBody = requestWrapper.getContentAsByteArray();

Reading the request body multiple times isn’t supported by the getInputStream() and getReader() methods.

5. Constructing Java Objects from Request Body

To convert the request body into Java objects, you can use ObjectMapper from the Jackson library with each of these methods.

5.1 getContentAsString

import com.fasterxml.jackson.databind.ObjectMapper;

ObjectMapper objectMapper = new ObjectMapper();
Employee employee = objectMapper.readValue(requestWrapper.getContentAsString(), Employee.class);

5.2 getContentAsByteArray

import com.fasterxml.jackson.databind.ObjectMapper;

ObjectMapper objectMapper = new ObjectMapper();
Employee employee = objectMapper.readValue(requestWrapper.getContentAsByteArray(), Employee.class);

When using getInputStream() and getReader() methods, it’s important to note that there is a limitation – we can’t read the request body multiple times.

6. FAQs

7. Conclusion

In this tutorial, we explored how to read the request body multiple times in Spring Boot using the ContentCachingRequestWrapper class. This approach ensures that even after the request body has been read, it can still be accessed for tasks like logging or further processing.

8. Learn More