Reading HttpServletRequest Multiple Times in Spring

1. Introduction

In this tutorial, we’ll learn how to read the body from the HttpServletRequest multiple times using Spring.

HttpServletRequest is an interface which exposes getInputStream()  method to read the body. By default, the data from this InputStream can be read only once.

2. Maven Dependencies

The first thing we’ll need is the appropriate spring-webmvc and jakarta.servlet dependencies:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>6.0.13</version>
</dependency>

Also, since we’re using the application/json content-type, the jackson-databind dependency is required:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.17.2</version>
</dependency>

Spring uses this library to convert to and from JSON.

3. Spring’s ContentCachingRequestWrapper

Spring provides a ContentCachingRequestWrapper class. This class provides a method, getContentAsByteArray() to read the body multiple times.

This class has a limitation, though:  We can’t read the body multiple times using the getInputStream() and getReader() methods.

This class caches the request body by consuming the InputStream. If we read the InputStream in one of the filters, then other subsequent filters in the filter chain can’t read it anymore. Because of this limitation, this class is not suitable in all situations.

To overcome this limitation, let’s now take a look at a more general-purpose solution.

4. Extending HttpServletRequest

Let’s create a new class – CachedBodyHttpServletRequest – which extends HttpServletRequestWrapper. This way, we don’t need to override all the abstract methods of the HttpServletRequest interface.

HttpServletRequestWrapper class has two abstract methods getInputStream() and getReader(). We’ll override both of these methods and create a new constructor.

4.1. The Constructor

First, let’s create a constructor. Inside it, we’ll read the body from the actual InputStream and store it in a byte[] object:

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);
    }
}

As a result, we’ll be able to read the body multiple times.

4.2. getInputStream()

Next, let’s override the getInputStream() method. We’ll use this method to read the raw body and convert it into an object.

In this method, we’ll create and return a new object of CachedBodyServletInputStream class (an implementation of ServletInputStream):

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

4.3. getReader()

Then, we’ll override the getReader() method. This method returns a BufferedReader object:

@Override
public BufferedReader getReader() throws IOException {
    ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(this.cachedBody);
    return new BufferedReader(new InputStreamReader(byteArrayInputStream));
}

5. Implementation of ServletInputStream

Let’s create a class – CachedBodyServletInputStream – which will implement ServletInputStream. In this class, we’ll create a new constructor as well as override the isFinished(), isReady() and read() methods.

5.1. The Constructor

First, let’s create a new constructor that takes a byte array.

Inside it, we’ll create a new ByteArrayInputStream instance using that byte array. After that, we’ll assign it to the global variable cachedBodyInputStream:

public class CachedBodyServletInputStream extends ServletInputStream {

    private InputStream cachedBodyInputStream;

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

5.2. read()

Then, we’ll override the read() method. In this method, we’ll call ByteArrayInputStream#read:

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

5.3. isFinished()

Then, we’ll override the isFinished() method. This method indicates whether InputStream has more data to read or not. It returns true when zero bytes available to read:

@Override
public boolean isFinished() {
    return cachedBody.available() == 0;
}

5.4. isReady()

Similarly, we’ll override the isReady() method. This method indicates whether InputStream is ready for reading or not.

Since we’ve already copied InputStream in a byte array, we’ll return true to indicate that it’s always available:

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

6. The Filter

Finally, let’s create a new filter to make use of the CachedBodyHttpServletRequest class. Here we’ll extend Spring’s OncePerRequestFilter class. This class has an abstract method doFilterInternal().

In this method, we’ll create an object of the CachedBodyHttpServletRequest class from the actual request object:

CachedBodyHttpServletRequest cachedBodyHttpServletRequest =
  new CachedBodyHttpServletRequest(request);

Then we’ll pass this new request wrapper object to the filter chain. So, all the subsequent calls to the getInputStream() method will invoke the overridden method:

filterChain.doFilter(cachedContentHttpServletRequest, response);

7. Conclusion

In this tutorial, we quickly walked through the ContentCachingRequestWrapper class. We also saw its limitations.

Then, we created a new implementation of the HttpServletRequestWrapper class. We overrode the getInputStream() method to return an object of ServletInputStream class.

Finally, we created a new filter to pass the request wrapper object to the filter chain. So, we were able to read the request multiple times.