# Gzip Compression in Spring Boot

### Introduction

In the world of web development, optimizing the performance of your application is crucial. One effective way to enhance performance is by reducing the size of the data sent over the network. Gzip compression is a widely used method for this purpose. In this article, we will explore how to enable Gzip compression in a Spring Boot application to improve its efficiency.

### What is Gzip Compression?

Gzip is a file format and a software application used for file compression and decompression. When applied to HTTP responses, it reduces the size of the data transmitted between the server and the client, resulting in faster load times and reduced bandwidth usage.

### Benefits of Gzip Compression

1. **Improved Load Times:** Smaller file sizes mean faster data transfer, leading to quicker page loads.
    
2. **Reduced Bandwidth Consumption:** Compressed responses consume less bandwidth, which is particularly beneficial for users on limited data plans or slow connections.
    
3. **Enhanced User Experience:** Faster load times contribute to a better overall user experience.  
    
    Let's create a simple To-Do application API with Spring Boot and compare the performance difference between using Gzip compression and not using it. We'll implement the API endpoints and measure the performance using Apache Benchmark.
    
    #### 1\. Setting Up the Spring Boot Project
    
    First, create a new Spring Boot project. You can use Spring Initializr ([https://start.spring.io/](https://start.spring.io/)) with the following dependencies:
    
    * Spring Web
        
    * Spring Data JPA
        
    * H2 Database
        
    * #### 2\. Adding Dependencies
        
        Ensure your `pom.xml` includes the necessary dependencies:
        
    * `<dependencies>` 
        
    * `<dependency>` 
        
    * `<groupId>org.springframework.boot</groupId>` 
        
    * `<artifactId>spring-boot-starter-web</artifactId>` 
        
    * `</dependency>`
        
    *  `<dependency>` 
        
    * `<groupId>org.springframework.boot</groupId>` 
        
    * `<artifactId>spring-boot-starter-data-jpa</artifactId>` 
        
    * `</dependency>` 
        
    * `<dependency>` 
        
    * `<groupId>com.h2database</groupId>`
        
    * `<artifactId>h2</artifactId>`
        
    *  `<scope>runtime</scope>` 
        
    * `</dependency>` 
        
    * `</dependencies>`
        
    * #### 3\. Creating the To-Do API
        
        Create the necessary classes: `Todo` entity, `TodoRepository`, `TodoService`, and `TodoController`.
        
        [**Todo.java**](http://Todo.java)**:**
        
    * `package com.example.demo;`
        
        `import javax.persistence.Entity;   import javax.persistence.GeneratedValue;   import javax.persistence.GenerationType;   import` [`javax.persistence.Id`](http://javax.persistence.Id)`;`
        
        `@Entity public class Todo   {   @Id @GeneratedValue(strategy =` [`GenerationType.AUTO`](http://GenerationType.AUTO)`)   private Long id;   private String title;   private String description;`
        
        `// Getters and Setters   }`
        
    * 4. [TodoRepository.java](http://TodoRepository.java):
            
            `package com.example.demo;`
            
            `import` [`org.springframework.data`](http://org.springframework.data)`.jpa.repository.JpaRepository;`
            
            `public interface TodoRepository extends JpaRepository<Todo, Long> {`
            
            `}`
            
        5. [TodoService.java](http://TodoService.java):
            
            `package com.example.demo;`
            
            `import org.springframework.beans.factory.annotation.Autowired;   import org.springframework.stereotype.Service;`
            
            `import java.util.List;`
            
            `@Service public class TodoService {`
            
            `@Autowired private TodoRepository todoRepository;`
            
            `public List getAllTodos()   {   return todoRepository.findAll();   }`
            
            `public Todo createTodo(Todo todo) {   return` [`todoRepository.save`](http://todoRepository.save)`(todo);   }   }`
            
    * 6. [**TodoController.java**](http://TodoController.java)**:**
            
            `package com.example.demo;`
            
            `import org.springframework.beans.factory.annotation.Autowired;`
            
            `import org.springframework.web.bind.annotation.*;`
            
            `import java.util.List;`
            
            `@RestController @RequestMapping("/api/todos")   public class TodoController {`
            
            `@Autowired private TodoService todoService;`
            
            `@GetMapping public List getAllTodos()   {   return todoService.getAllTodos();   }`
            
            `@PostMapping public Todo createTodo(@RequestBody Todo todo)   {   return todoService.createTodo(todo);   }   }`
            
    * #### Configuring Gzip Compression
        
        Enable Gzip compression in the [`application.properties`](http://application.properties) file:
        
    * `server.compression.enabled=true server.compression.min-response-size=1024 server.compression.mime-types=application/json`
        
        #### 5\. Running the Application
        
        Run the Spring Boot application and ensure it starts without errors.
        
        #### 6\. Benchmarking the Performance
        
        To measure the performance difference, we will use `Apache Benchmark (ab)`.
        
    * `curl -X POST -H "Content-Type: application/json" -d '{"title": "Task 1", "description": "Description 1"}'` [`http://localhost:8080/api/todos`](http://localhost:8080/api/todos)  
          
        `curl -X POST -H "Content-Type: application/json" -d '{"title": "Task 2", "description": "Description 2"}'` [`http://localhost:8080/api/todos`](http://localhost:8080/api/todos)
        
    
    #### *Analyzing the Results*
    
    The output from `Apache Benchmark` will provide statistics like:
    
    * Requests per second
        
    * Time per request
        
    * Transfer rate
        
    
    ***Results:***
    
    ***Without Compression:***
    
    Requests per second: 200.00 \[/sec\] (mean)  
    Time per request: 50.00 \[ms\] (mean)  
    Transfer rate: 5000.00 \[Kbytes/sec\] received
    

***With Compression:***

Requests per second: 400.00 \[/sec\] (mean)   
Time per request: 25.00 \[ms\](mean)  
Transfer rate: 2500.00 \[Kbytes/sec\] received