Scalable Human Blog

If you’re diving deep into Spring Boot and building web applications, you might have come across the term Interceptor. At first glance, it might seem like just another piece in the vast Spring ecosystem, but interceptors are powerful tools that can significantly enhance your application’s functionality. In this post, we’ll explore what Spring Boot interceptors are, why they’re useful, and how you can implement them to make your web applications more robust and flexible.

What Exactly is a Spring Boot Interceptor?

Imagine you’re hosting a grand event. Before guests enter the main hall, you might have a reception area where certain checks are performed—like verifying invitations, guiding guests, or providing them with information. Similarly, in a web application, an interceptor acts as that reception area for HTTP requests and responses.

An interceptor in Spring Boot allows you to intercept incoming HTTP requests and outgoing responses before they reach the controller or the client, respectively. This means you can add custom logic before a request is processed and after a response is generated, without cluttering your controller code.

Why Use Interceptors?

Interceptors are perfect for handling cross-cutting concerns—aspects that affect multiple parts of your application. Here are some common use cases:

• Authentication and Authorization: Validate user credentials before they access secured endpoints.

• Logging and Monitoring: Keep track of requests, responses, and execution times for debugging and analytics.

• Input Validation: Check request parameters or headers for required values.

• Response Modification: Add or alter headers, or modify response bodies before they reach the client.

Using interceptors helps keep your controller code clean and focused on business logic, promoting better separation of concerns.

How Do Interceptors Work?

Interceptors in Spring Boot implement the HandlerInterceptor interface, which provides three main methods:

1. preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)

• When it runs: Before the request reaches the controller.

• What it does: Allows you to perform operations like authentication checks or logging request data.

• Return value: true to continue processing; false to abort.

2. postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)

• When it runs: After the controller processes the request but before the view is rendered.

• What it does: Modify the ModelAndView or add attributes to the model.

3. afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)

• When it runs: After the complete request has finished and the view has been rendered.

• What it does: Perform cleanup activities or log the outcome of the request.

Let’s Build an Interceptor!

Enough theory—let’s get our hands dirty. We’ll create a simple interceptor that logs the execution time of each request.

Step 1: Create the Interceptor Class

import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

public class ExecutionTimeInterceptor implements HandlerInterceptor {

private static final String START_TIME = “startTime”;

@Override

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {

request.setAttribute(START_TIME, System.currentTimeMillis());

return true; // Continue processing

}

@Override

public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {

long startTime = (Long) request.getAttribute(START_TIME);

long endTime = System.currentTimeMillis();

long executeTime = endTime – startTime;

// Log the execution time

System.out.println(“Handle : ” + handler + ” , execution time : ” + executeTime + “ms”);

}

@Override

public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {

// You can add cleanup code here if needed

}

}

Step 2: Register the Interceptor

Next, we’ll tell Spring Boot to use our interceptor.

import org.springframework.context.annotation.Configuration;

import org.springframework.web.servlet.config.annotation.InterceptorRegistry;

import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration

public class WebConfig implements WebMvcConfigurer {

@Override

public void addInterceptors(InterceptorRegistry registry) {

registry.addInterceptor(new ExecutionTimeInterceptor())

.addPathPatterns(“/**”); // Apply to all routes

}

}

And that’s it! Now, every request to your application will be intercepted, and you’ll see execution times logged in your console.

Interceptors vs. Filters: What’s the Difference?

You might be thinking, “Wait, doesn’t a filter do something similar?” Great question!

• Filters operate at the servlet level and can modify both requests and responses before they reach any servlet or after they leave the servlet. They’re part of the Java Servlet specification.

• Interceptors work at the Spring MVC level and interact with the HandlerMapping and HandlerAdapter mechanisms. They have access to Spring-specific features and are aware of the controller lifecycle.

In essence, use filters for generic, application-wide concerns that are not tied to Spring, and use interceptors when you need access to Spring-specific features or the MVC workflow.

Best Practices When Using Interceptors

• Keep Them Lightweight: Avoid heavy processing in interceptors to prevent slowing down request handling.

• Be Mindful of Return Values: In preHandle, returning false stops the request from proceeding. Use this carefully, especially in authentication scenarios.

• Order Matters: If you have multiple interceptors, they execute in the order you add them. Plan accordingly.

• Exception Handling: Be cautious with exceptions in interceptors. Unhandled exceptions can prevent afterCompletion from running.

Wrapping Up

Spring Boot interceptors are like the unsung heroes of web application development. They provide a flexible way to handle cross-cutting concerns without polluting your business logic. Whether you’re building a small API or a large-scale web application, interceptors can help you write cleaner, more maintainable code.

So next time you’re thinking about adding logging, authentication checks, or any cross-cutting functionality, consider harnessing the power of interceptors!

Happy Coding!

Feel free to share your experiences or ask questions in the comments below. Let’s learn and grow together in this exciting journey of Spring Boot development.

📚 Further Reading & Related Topics

If you’re exploring Spring Boot interceptors and request processing enhancements, these related articles will provide deeper insights:

• Spring Boot Filters: Enhancing Request and Response Processing – Learn how filters complement interceptors to modify requests and responses efficiently.

• Advanced Mocking Techniques with Spring Boot: Mastering SpyBean and MockBean – Discover how to test Spring Boot interceptors effectively using mocking techniques.