How to Decompress Gzip Requests in Spring Boot

1. Introduction

In our previous articles, we covered gzip compression in Spring Boot and conditionally enabling gzip compression. This time, we will delve into decompressing gzip requests in a Spring Boot application. We’ll explore how to implement and test this functionality to ensure your Spring Boot application can handle compressed data efficiently.

2. Why Decompress Gzip Requests?

Gzip compression significantly reduces the size of data being transferred over the network, which enhances the speed and efficiency of web applications. While compressing responses is common, handling compressed requests is equally crucial, especially for services receiving large payloads from clients. Decompression ensures that the server can properly interpret and process the incoming compressed data.

3. Does Spring Boot Offer Built-In Gzip Decompression?

Spring Boot does not provide an out-of-the-box solution for decompressing gzip request bodies. You need to implement a custom filter to handle the decompression. This guide will walk you through creating a custom filter to decompress gzip requests and how to test it using tools like curl and Postman.

4. Setting Up Decompression in Spring Boot

To decompress gzip requests in Spring Boot, you need to create a filter that intercepts incoming requests, checks if they are compressed, and decompresses them. Here’s a detailed approach:

Steps:

1. Add Dependencies:

Ensure you have the necessary dependencies in your pom.xml (for Maven) or build.gradle (for Gradle).

For Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

For Gradle

implementation 'org.springframework.boot:spring-boot-starter-web'

2. Create a Gzip Decompression Filter:

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

import java.io.IOException;

@Component
public class GzipDecompressionFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        if (request.getHeader("Content-Encoding") != null && request.getHeader("Content-Encoding").contains("gzip")) {
            request = new GzipHttpServletRequestWrapper(request);
        }
        filterChain.doFilter(request, response);
    }
}

Explanation:

• GzipDecompressionFilter: This filter extends OncePerRequestFilter, ensuring it only runs once per request.
• doFilterInternal: This method is overridden to apply the filter logic.It checks if the Content-Encoding header is set to gzip. If so, it wraps the request in GzipHttpServletRequestWrapper to handle decompression and proceeds with the filter chain.

3. Create a Wrapper for HttpServletRequest:

import jakarta.servlet.ServletInputStream;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletRequestWrapper;

import java.io.IOException;
import java.util.zip.GZIPInputStream;

public class GzipHttpServletRequestWrapper extends HttpServletRequestWrapper {

    public GzipHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        return new GzipServletInputStreamWrapper(new GZIPInputStream(super.getInputStream()));
    }
}

Explanation:

• GzipHttpServletRequestWrapper: This class extends HttpServletRequestWrapper and overrides the getInputStream method to return a decompressed input stream.
• getInputStream: It wraps the original input stream with GZIPInputStream, enabling decompression of the incoming data.

4. Create a Wrapper for ServletInputStream:

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

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

class GzipServletInputStreamWrapper extends ServletInputStream {

    private final InputStream delegate;

    public GzipServletInputStreamWrapper(InputStream delegate) {
        this.delegate = delegate;
    }

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

    @Override
    public void close() throws IOException {
        delegate.close();
    }

    @Override
    public boolean isFinished() {
        return false;
    }

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

    @Override
    public void setReadListener(ReadListener listener) {

    }

}

Explanation:

• GzipServletInputStreamWrapper: This class wraps the InputStream to handle decompressed data. It overrides methods of ServletInputStream to delegate the read operations to the underlying InputStream.
• read: Reads decompressed data from the wrapped input stream.
• close: Closes the underlying input stream.
• isFinished and isReady: These methods indicate whether the stream is finished or ready.
• setReadListener: This method is a placeholder to comply with the ServletInputStream interface, even though it is not used in this context.

5. Create a Controller to Handle the Request:

import com.bootcamptoprod.dto.Employee;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GzipDecompressController {

    @PostMapping("/decompress")
    public ResponseEntity<Employee> decompress(@RequestBody Employee employee) {

        System.out.println("Employee Id: " + employee.getId());
        System.out.println("Employee Name: " + employee.getName());

        return ResponseEntity.ok(employee);
    }
}

Explanation:

• EmployeeController: This controller handles POST requests to /decompress using the decompress method. It prints the employee details to the console demonstrating successful decompression and deserialization. Also, it returns the same employee object in the response.

Employee DTO:

public class Employee {

    private int id;
    private String name;
    
    // No args constructor
    // Getters and setters

}

How It All Works Together?

When a request is made to the Spring Boot application, the GzipDecompressionFilter first checks if the “Content-Encoding” header indicates that the request body is gzip-compressed. If this condition is met, the filter wraps the HttpServletRequest in a GzipHttpServletRequestWrapper, which replaces the standard input stream with a GzipServletInputStreamWrapper. This wrapper utilizes a GZIPInputStream to decompress the incoming data, allowing the server to read the original uncompressed payload seamlessly.

Once the request is processed, the GzipDecompressController receives the decompressed JSON data as an Employee object, allowing for easy access to the id and name fields. The controller then logs the employee details and returns the object as a response, completing the flow of handling gzip-compressed requests effectively.

Output:

Spring Boot Gzip Request Decompression Output

5. Testing Decompression

5.1 Using curl:

To test the decompression, you can use the curl command to send a gzip-compressed request to your Spring Boot application.

1. Create a JSON payload file (data.json):

{
  "id": 1,
  "name": "John Doe"
}

2. Compress the JSON payload:

gzip -c data.json > data.json.gz

3. Send the compressed request using curl:

curl -X POST http://localhost:8080/decompress \
     -H "Content-Encoding: gzip" \
     -H "Content-Type: application/json" \
     --data-binary "@data.json.gz"

5.2 Using Postman:

Postman is a user-friendly tool that can be used to test API requests, including those with gzip compression.

1. Open Postman and create a new POST request:

• URL: http://localhost:8080/decompress
• Method: POST

2. Set the Headers:

• Content-Encoding: gzip
• Content-Type: application/json

3. Compress your JSON payload using a tool like gzip or an online compressor:

Example using gzip – terminal

gzip -c data.json > data.json.gz

4. Send the Request:

Upload the compressed file as the body of your request in Postman. Use the ‘binary’ option in the request body and select the ‘data.json.gz’ file that was created on your local system inside step-3.

Postman will send the compressed data, and your Spring Boot application should handle the decompression.

6. Source Code

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

7. Things to Consider

Here are some important considerations to keep in mind when working with gzip decompression:

• Performance Impact: While decompression adds some overhead, the overall performance gain from reduced bandwidth usage and faster data transmission generally outweighs the cost. Always monitor and test your application’s performance to ensure it meets your requirements.
• Error Handling: Ensure proper error handling is implemented for cases where decompression might fail, such as corrupted gzip data, invalid data or unsupported encoding types.
• Content-Type Validation: Validate the “Content-Type” header of the incoming request to ensure it matches the expected type (e.g., “application/json”) before processing the decompressed data.
• Logging and Monitoring: Implement logging and monitoring to track the occurrence of compressed requests and any issues that arise during decompression. This helps in identifying and resolving potential problems quickly.
• Client Compatibility: Inform your clients about the gzip compression requirements for request bodies, and ensure they can send gzip-compressed data appropriately.

8. FAQs

9. Conclusion

In summary, by implementing gzip decompression in your Spring Boot application using a custom filter, you can effectively handle gzip-compressed request bodies. This approach, though not natively supported by Spring Boot, ensures efficient data processing and integration.

10. Learn More