What is the difference between Filters, Interceptors…

The differences lie in the purpose and stage of request processing:

Filters:

Part of the Servlet API specification.
Operate at the servlet container level (e.g., Tomcat).
Intercept requests before they reach the Spring DispatcherServlet and responses after it processes them.
Used for common tasks such as authentication, authorization, logging, encoding conversion, data compression.
Have access to HttpServletRequest and HttpServletResponse objects.
Can modify or halt request processing.
Configured in web.xml or via @WebFilter annotations.

// Example of a simple filter
import javax.servlet.*;
import java.io.IOException;

public class MyFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // Initialization
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // Logic before controller
        System.out.println("Request passed through filter");
        chain.doFilter(request, response); // Pass request further down the chain
        // Logic after controller
        System.out.println("Response passed through filter");
    }

    @Override
    public void destroy() {
        // Cleanup
    }
}

Interceptors:

Part of Spring Web MVC.
Operate at the DispatcherServlet level.
Intercept requests after a controller has been assigned but before the controller method is called, as well as after the method call.
Used for more specific web request handling tasks such as session validation, exception handling, adding data to the model before view rendering.
Have access to HttpServletRequest, HttpServletResponse, and Handler (controller method).
Can modify ModelAndView or stop request processing.
Configured via WebMvcConfigurer or XML configuration.

// Example of a simple interceptor
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // Logic before controller invocation
        System.out.println("Request passed through interceptor (preHandle)");
        return true; // continue processing, false to stop
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // Logic after controller invocation, before view rendering
        System.out.println("Request passed through interceptor (postHandle)");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // Logic after request processing is complete, including view rendering
        System.out.println("Request passed through interceptor (afterCompletion)");
    }
}

Listeners:

Part of the Servlet API specification.
Respond to lifecycle events of the web application, session, or servlet context.
Do not directly intercept requests.
Examples of events: application start/stop, session creation/destruction, attribute addition/removal in context or session.
Used for resource initialization/cleanup, session management, logging.
Configured in web.xml or via @WebListener annotations.

// Example of a session event listener
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class MySessionListener implements HttpSessionListener {
    @Override
    public void sessionCreated(HttpSessionEvent se) {
        // Session creation event
        System.out.println("Session with ID " + se.getSession().getId() + " created.");
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        // Session destruction event
        System.out.println("Session with ID " + se.getSession().getId() + " destroyed.");
    }
}

Summary table:

Characteristic	Filter	Interceptor	Listener
Specification	Servlet API	Spring Web MVC	Servlet API
Level of operation	Servlet container (before DispatcherServlet)	DispatcherServlet (after controller assignment)	Application/session/context lifecycle
What it intercepts	Requests and responses (before/after DS)	Requests (before/after controller)	Lifecycle events
Available objects	`HttpServletRequest`, `HttpServletResponse`	`HttpServletRequest`, `HttpServletResponse`, Handler (`Object`)	Depends on listener type (e.g., `HttpSessionEvent`)
Purpose	Common tasks (authentication, logging, encoding)	Web-specific tasks (session, controller exceptions)	Lifecycle/resource management
Configuration method	`web.xml`, `@WebFilter`	`WebMvcConfigurer`, XML	`web.xml`, `@WebListener`
Stop method	`chain.doFilter()` not called	`preHandle()` returns `false`	Not applicable to request interception

What is the difference between Filters, Interceptors, and Listeners in Spring?