Efficiently Read Request Body Multiple Times in Spring Boot

1. Introduction

Reading the request body multiple times in a Spring Boot application can be challenging. The default behavior of HttpServletRequest allows the request body to be read only once, posing difficulties in scenarios where the request needs to be processed by multiple filters or components.

2. Limitations of ContentCachingRequestWrapper

Spring’s ContentCachingRequestWrapper is a convenient class for caching and reading request bodies in Spring Boot applications. Despite its usefulness, this class has a significant limitation that developers should be aware of.

The primary limitation of ContentCachingRequestWrapper is its inability to support multiple reads of the request body using the standard getInputStream() and getReader() methods. This limitation arises because the class consumes the InputStream during the first read, caching the request body internally. As a result, subsequent attempts to read the body using the same methods do not work as expected.

One critical consequence of this limitation is the impact it has on the filter chain in Spring applications. When the request body is read and cached by ContentCachingRequestWrapper, subsequent filters in the chain cannot access the original InputStream to read the body again. This behavior can lead to unexpected issues and errors, especially in scenarios where multiple filters or components need access to the request body. In situations where multiple reads of the request body are essential, developers may find ContentCachingRequestWrapper to be less suitable due to this limitation.

For more details on using ContentCachingRequestWrapper, you can check out our previous post here.

To overcome these limitations, we’ll delve into creating custom classes and implementations tailored for efficient request body management.

3. A Robust Solution: Custom Caching Implementation

To overcome the limitations of ContentCachingRequestWrapper, we can implement a custom solution using which we can read request body multiple times in Spring Boot. This involves creating a wrapper around HttpServletRequest and custom implementations for ServletInputStream.

Step 1: Custom ServletInputStream Implementation

Our journey begins with crafting a custom ServletInputStream implementation named CachedBodyServletInputStream. This class is designed to handle the cached InputStream and facilitate reading binary data from the client request.

import jakarta.servlet.ReadListener;
import jakarta.servlet.ServletInputStream;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

public class CachedBodyServletInputStream extends ServletInputStream {

    private InputStream cachedBodyInputStream;

    public CachedBodyServletInputStream(byte[] cachedBody) {
        this.cachedBodyInputStream = new ByteArrayInputStream(cachedBody);
    }

    @Override
    public boolean isFinished() {
        try {
            return cachedBodyInputStream.available() == 0;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public boolean isReady() {
        return true;
    }

    @Override
    public void setReadListener(ReadListener readListener) {
        throw new UnsupportedOperationException();
    }

    @Override
    public int read() throws IOException {
        return cachedBodyInputStream.read();
    }
}

We initialize the class with a byte array cacheBody representing the cached input stream. The constructor CachedBodyServletInputStream(byte[] cachedBody) creates a new ByteArrayInputStream using the provided byte array, setting up the input stream for reading.

The isFinished() method checks if the input stream has more data to read by checking its availability, returning true if no bytes are available.

The isReady() method always returns true since the input stream is already copied into a byte array, making it ready for reading.

The setReadListener(ReadListener listener) method is not supported and throws an UnsupportedOperationException.

Finally, the read() method reads a byte of data from the input stream and returns it as an integer value, or -1 if the end of the stream is reached.

Step 2: Creating CachedBodyHttpServletRequest

This class extends HttpServletRequestWrapper and caches the request body in a byte array.

import jakarta.servlet.ServletInputStream;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletRequestWrapper;
import org.springframework.util.StreamUtils;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class CachedBodyHttpServletRequest extends HttpServletRequestWrapper {

    private byte[] cachedBody;

    public CachedBodyHttpServletRequest(HttpServletRequest request) throws IOException {
        super(request);
        InputStream requestInputStream = request.getInputStream();
        this.cachedBody = StreamUtils.copyToByteArray(requestInputStream);
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        return new CachedBodyServletInputStream(this.cachedBody);
    }

    @Override
    public BufferedReader getReader() throws IOException {
        // Create a reader from cachedContent and return it
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(this.cachedBody);
        return new BufferedReader(new InputStreamReader(byteArrayInputStream));
    }
}

This class is designed to cache the request body by reading it from the actual InputStream and storing it in a byte array (byte[]). The constructor CachedBodyHttpServletRequest(HttpServletRequest request) handles this process by using StreamUtils.copyToByteArray(requestInputStream) to copy the request’s input stream into the cachedBody byte array.

Additionally, this class overrides the getInputStream() method to return a CachedBodyServletInputStream, which allows reading the raw body efficiently. Moreover, it overrides the getReader() method to return a BufferedReader that reads from the cached byte array, providing access to the cached request body as a Reader.

Step 3: Creating CacheBodyHttpServletFilter

In our final step, we create a filter named CacheBodyHttpServletFilter to effectively manage the request body.

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import java.io.IOException;

@Component
@Order(value = Ordered.HIGHEST_PRECEDENCE)
public class CacheBodyHttpServletFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        CachedBodyHttpServletRequest cachedBodyHttpServletRequest = new CachedBodyHttpServletRequest(request);
        filterChain.doFilter(cachedBodyHttpServletRequest, response);
    }
}

This filter leverages our custom CachedBodyHttpServletRequest class to wrap the original request, ensuring efficient handling of the request body.

The filter extends OncePerRequestFilter, ensuring that its doFilterInternal method is executed only once per request. Inside this method, we instantiate a CachedBodyHttpServletRequest object by passing the original request as a parameter. This custom request wrapper encapsulates the logic for caching the request body. Finally, we pass this custom-wrapped request along with the response through the filter chain using filterChain.doFilter, allowing subsequent filters or the servlet to process the request with the cached body intact.

4. Source Code

The complete source code of the above examples can be found here.

5. FAQs

6. Conclusion

By implementing a custom HttpServletRequestWrapper and ServletInputStream, we can efficiently read the request body multiple times in a Spring Boot application. This approach overcomes the limitations of ContentCachingRequestWrapper, providing a robust solution for handling multiple reads of the request body.

7. Learn More