Issue Description: Currently, Spring Boot’s global exception handling mechanism, provided by @ControllerAdvice, handles exceptions at the controller level but does not capture exceptions thrown by filters. This limitation poses challenges for applications that need consistent error handling across all layers, including filters, for scenarios such as security checks, logging, and request pre-processing.

Problem Statement: When an exception is thrown in a filter, it typically does not reach the controller layer, which prevents @ControllerAdvice from handling it. Consequently, developers need to implement custom error handling in each filter, which is repetitive and can lead to inconsistencies in error responses across the application.

To handle filter exceptions globally, developers currently have to:

  1. Wrap each filter with try-catch blocks and send an error response directly.
  2. Create a custom filter to forward exceptions to Spring Boot’s /error endpoint, requiring custom configuration and code that can be difficult to standardize across projects.

This limitation creates a fragmented approach to error handling and makes it challenging to maintain a unified error response structure in applications.

Proposed Solution: We propose adding a global exception handling mechanism for filters in Spring Boot, enabling consistent error handling across both filters and controllers. Here are some potential approaches for implementing this feature:

  • Exception Forwarding to /error Endpoint:
  • Introduce an optional configuration property, such as spring.web.filter.exception-forwarding, to automatically forward exceptions from filters to the /error endpoint. This would allow ErrorController and ErrorAttributes to handle filter exceptions consistently with other application errors.

  • Developers could enable this property to forward any filter exception to the /error endpoint, where it would be managed by the ErrorAttributes and handled as a unified part of the application's error response strategy.

  • Enhanced ErrorAttributes for Filter Exceptions:

  • Expand ErrorAttributes to support filter exceptions by allowing it to capture exception details at a lower level in the request lifecycle. This enhancement would enable more control over the error response format and attributes, even for errors thrown in filters.

  • By extending ErrorAttributes, filter-based exceptions could include metadata such as the exception type, message, and stack trace, facilitating consistent error responses.

  • @ControllerAdvice Extension for Filters:

  • Introduce a mechanism that allows @ControllerAdvice to optionally catch filter exceptions, providing the same flexibility and centralization for filter exceptions as it currently does for controller exceptions.

Benefits of the Proposed Solution:

  1. Consistent Error Responses: A unified error handling strategy across all application layers, reducing custom error-handling code in filters.
  2. Reduced Boilerplate: Eliminates the need for repetitive try-catch blocks in filters and manual forwarding to /error, simplifying filter implementation.
  3. Better Maintainability: Centralizes error handling, making applications easier to maintain and ensuring consistency in error reporting and logging.

Potential Use Cases:

  1. Security Filters: Centralized handling for exceptions raised by authentication and authorization filters, such as AccessDeniedException.
  2. Logging Filters: Centralized handling for exceptions from logging filters, ensuring logs and error responses align.
  3. Request Validation Filters: Uniform error handling for request validation exceptions in custom filters, such as required headers or parameters.

Comment From: ririnto

Extending @ControllerAdvice to be usable in Filter scope would mean giving up functionality that Spring already supports.

For example, war deployments.

Comment From: bclozel

Thanks for the proposal, but implementing the suggested change would break a lot of expectations and the hierarchy of web support. If you're looking for error handling at a filter level in Spring Boot applications, this already exists for WAR applications with the ErrorPageFilter.