Spring Boot – Custom Interceptors (Clean Notes)

1. What is an Interceptor?

An Interceptor is a Spring component that allows you to intercept HTTP requests and responses before or after they reach the controller.

Think of it as a checkpoint between the client and your controller.

You can use it for:

• Authentication & Authorization
• Logging requests & responses
• Caching
• Rate limiting
• Performance tracking
• Header validation

2. Where Interceptor Fits in Request Flow

Client → Tomcat → DispatcherServlet
          ↓
      Interceptor (preHandle)
          ↓
      Controller
          ↓
      Interceptor (postHandle)
          ↓
      View / Response
          ↓
      Interceptor (afterCompletion)

3. Interceptor Life Cycle Methods

public class MyInterceptor implements HandlerInterceptor {

    boolean preHandle(...)   // Before controller
    void postHandle(...)     // After controller, before response
    void afterCompletion(...)// After response is sent
}

4. Creating a Custom Interceptor

@Component
public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response, Object handler) {
        System.out.println("Before Controller");
        return true; // false will block request
    }
}

5. Registering Interceptor

@Configuration
public class AppConfig implements WebMvcConfigurer {

    @Autowired
    private MyInterceptor interceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(interceptor)
                .addPathPatterns("/api/**")
                .excludePathPatterns("/login");
    }
}

6. Annotation Based Interceptor (Advanced)

Step 1: Create Annotation

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyCustomAnnotation {
    String value() default "";
}

Step 2: Use It

@MyCustomAnnotation("secure")
public void updateUser() { }

Step 3: Intercept It

@Aspect
@Component
public class MyAnnotationInterceptor {

    @Around("@annotation(myCustomAnnotation)")
    public Object handle(ProceedingJoinPoint jp,
                         MyCustomAnnotation myCustomAnnotation) throws Throwable {

        System.out.println("Before method");
        Object result = jp.proceed();
        System.out.println("After method");
        return result;
    }
}

7. Interceptor vs Filter vs AOP

8. Real-Time Example

Use Case:
Block request if token is missing.

if(request.getHeader("token") == null) {
    response.sendError(401, "Unauthorized");
    return false;
}

🎯 Interview Q&A

Q1. What is an interceptor?
A Spring mechanism to intercept requests before or after controller execution.

Q2. Difference between filter and interceptor?
Filter works at servlet level, interceptor works inside Spring MVC.

Q3. Can we stop request in interceptor?
Yes, return false from preHandle().

Q4. When to use annotation-based interceptor?
When only specific methods need interception.

Q5. Is interceptor thread safe?
Yes, if no shared mutable state is used.