Use Response Compression Middleware

Introduction
ASP.NET Example
Spring Boot Example
Express.js Example
Next.js Example
Flask Example
Laravel Example
Conclusion

Introduction

Response Compression Middleware improves the performance of your web application by compressing HTTP responses. Compressed responses reduce bandwidth usage and speed up client load times, which is crucial for large responses such as JSON, HTML, or CSS files.

Ignoring response compression can lead to slower load times, increased server bandwidth usage, and worse user experience, especially on slower networks.

ASP.NET Example

ASP.NET Core makes it simple to enable response compression via built-in middleware. You can use Gzip or Brotli compression depending on your requirements.

Gzip Compression Code

using Microsoft.AspNetCore.ResponseCompression;

var builder = WebApplication.CreateBuilder(args);

// Add response compression
builder.Services.AddResponseCompression(options =>
{
    options.Providers.Add<GzipCompressionProvider>();
    options.EnableForHttps = true;
});

builder.Services.Configure<GzipCompressionProviderOptions>(options =>
{
    options.Level = System.IO.Compression.CompressionLevel.Fastest;
});

var app = builder.Build();
app.UseResponseCompression();

app.MapGet("/", () => "Hello, Gzip!");

app.Run();

Brotli Compression Code

using Microsoft.AspNetCore.ResponseCompression;

var builder = WebApplication.CreateBuilder(args);

// Add response compression
builder.Services.AddResponseCompression(options =>
{
    options.Providers.Add<BrotliCompressionProvider>();
    options.EnableForHttps = true;
});

builder.Services.Configure<BrotliCompressionProviderOptions>(options =>
{
    options.Level = System.IO.Compression.CompressionLevel.Optimal;
});

var app = builder.Build();
app.UseResponseCompression();

app.MapGet("/", () => "Hello, Brotli!");

app.Run();

Comparison:

Gzip: Faster, less CPU-intensive, widely supported.
Brotli: Better compression ratio, slightly slower, ideal for text-heavy responses.

You can choose the provider based on your performance vs compression needs. For modern browsers, Brotli is preferred; Gzip is safer for compatibility.

Spring Boot Example

// application.properties
server.compression.enabled=true
server.compression.mime-types=application/json,application/xml,text/html,text/xml,text/plain
server.compression.min-response-size=1024

Express.js Example

const express = require('express');
const compression = require('compression');

const app = express();

// Enable compression
app.use(compression());

app.get('/', (req, res) => {
  res.send('Hello, world!');
});

app.listen(3000, () => console.log('Server running on port 3000'));

Next.js Example

// next.config.js
const compression = require('compression');
const express = require('express');
const next = require('next');

const dev = process.env.NODE_ENV !== 'production';
const app = next({ dev });
const handle = app.getRequestHandler();

app.prepare().then(() => {
  const server = express();

  // Enable compression
  server.use(compression());

  server.all('*', (req, res) => handle(req, res));

  server.listen(3000, () => console.log('Next.js server running on port 3000'));
});

Flask Example

from flask import Flask
from flask_compress import Compress

app = Flask(__name__)
Compress(app)

@app.route('/')
def home():
    return 'Hello, world!'

if __name__ == '__main__':
    app.run()

Laravel Example

// In Laravel, you can use middleware for response compression
// Create a middleware
php artisan make:middleware CompressResponse

// In CompressResponse.php
public function handle($request, Closure $next)
{
    $response = $next($request);
    return $response->header('Content-Encoding', 'gzip');
}

// Register middleware in Kernel.php

Conclusion

Response compression is a vital optimization technique for modern web applications. ASP.NET Core and other frameworks provide easy-to-use middleware to compress HTTP responses, improving performance and user experience.

Choosing Gzip vs Brotli: Brotli offers better compression but is slightly slower, while Gzip is faster and widely supported. Modern browsers can handle Brotli efficiently, making it ideal for text-heavy content.

Ignoring compression entirely can lead to higher bandwidth usage, slower response times, and poor UX, especially for APIs and large content. Enabling response compression ensures faster, more efficient content delivery.

Isaac.