当前位置： 首页 > news >正文

全局异常处理器为什么不能处理过滤器异常，有那些解决方案

news 来源：原创 2025/5/16 21:08:36

一、全局异常处理器无法处理过滤器异常的原因

1. 请求生命周期的不同阶段

  • 过滤器（Filter）：过滤器是Servlet规范的一部分，它在请求进入Servlet容器时首先被执行。过滤器可以修改请求或响应，甚至可以完全终止请求处理过程。
  • 拦截器（Interceptor）：拦截器是Spring MVC的一部分，它在请求进入控制器之前和之后执行。拦截器主要用于对请求进行预处理和后处理。
  • 控制器（Controller）：控制器是Spring MVC的核心组件，负责处理具体的业务逻辑，并返回视图或数据。

全局异常处理器（如@ControllerAdvice和@ExceptionHandler注解）主要作用于控制器层，即在请求到达控制器并触发异常时才会生效。而过滤器和拦截器的工作发生在请求到达控制器之前或之后，因此它们抛出的异常不会自动传递到全局异常处理器。

2. 异常传播路径不同

  • 过滤器异常：当过滤器抛出异常时，这个异常会直接中断请求处理链，并且不会继续传递给后续的过滤器或控制器。因此，全局异常处理器无法捕捉这些异常。
  • 拦截器异常：虽然拦截器也是在请求到达控制器之前执行，但它的异常处理机制与过滤器类似，同样不会自动传递到全局异常处理器。

二、具体解决方案及其详细实现步骤

方案一：在过滤器内部捕获并处理异常

这是最直接的方法，在过滤器中显式地捕获异常并进行处理。这样可以确保异常不会中断请求处理链，并且可以根据需要返回特定的错误信息。

实现步骤：
  1. 创建过滤器类：
    • 创建一个实现了javax.servlet.Filter接口的类。
    • 在doFilter方法中添加异常捕获逻辑。
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class MyFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化过滤器时执行的代码
        System.out.println("MyFilter initialized");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        try {
            // 过滤器逻辑
            chain.doFilter(request, response);
        } catch (BusinessException e) {
            handleException((HttpServletRequest) request, (HttpServletResponse) response, e);
        }
    }

    private void handleException(HttpServletRequest request, HttpServletResponse response, BusinessException e)
            throws IOException {
        response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
        response.setContentType("application/json");
        response.setCharacterEncoding("UTF-8");

        // 日志记录（可选）
        System.err.println("Caught BusinessException: " + e.getMessage());

        // 返回JSON格式的错误信息
        response.getWriter().write("{\"error\": \"" + e.getMessage() + "\"}");
    }

    @Override
    public void destroy() {
        // 销毁过滤器时执行的代码
        System.out.println("MyFilter destroyed");
    }
}
  1. 配置过滤器：
    • 在Spring Boot应用中，可以通过Java配置类注册过滤器。
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean<MyFilter> loggingFilter(){
        FilterRegistrationBean<MyFilter> registrationBean = new FilterRegistrationBean<>();

        registrationBean.setFilter(new MyFilter());
        registrationBean.addUrlPatterns("/api/*"); // 指定需要过滤的URL模式

        return registrationBean;
    }
}
注意事项：
  • 日志记录：在捕获异常后记录日志，便于后续排查问题。可以使用SLF4J或其他日志框架。
  • 状态码选择：根据异常类型选择合适的HTTP状态码（如400表示客户端错误，500表示服务器错误）。
  • 性能考虑：尽量减少过滤器中的复杂逻辑，避免影响整体性能。
  • 返回格式：确保返回的数据格式与API规范一致，例如JSON格式。
  • 维护性：如果多个过滤器需要处理异常，可以考虑将异常处理逻辑抽取到一个公共的方法或类中。

方案二：使用ErrorPageRegistrar接口

通过实现ErrorPageRegistrar接口，可以在应用启动时注册自定义的错误页面映射。这种方法适用于处理特定状态码或异常类型的错误。

实现步骤：
  1. 创建自定义ErrorPageRegistrar：
import org.springframework.boot.web.server.ErrorPage;
import org.springframework.boot.web.server.ErrorPageRegistrar;
import org.springframework.boot.web.server.ErrorPageRegistry;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;

@Component
public class CustomErrorPageRegistrar implements ErrorPageRegistrar {

    @Override
    public void registerErrorPages(ErrorPageRegistry registry) {
        // 注册针对特定HTTP状态码的错误页面
        registry.addErrorPages(new ErrorPage(HttpStatus.BAD_REQUEST, "/errors/400"));
        registry.addErrorPages(new ErrorPage(HttpStatus.INTERNAL_SERVER_ERROR, "/errors/500"));

        // 注册针对特定异常类型的错误页面
        registry.addErrorPages(new ErrorPage(BusinessException.class, "/errors/business-error"));
    }
}
  1. 创建错误页面控制器：
import org.springframework.boot.web.servlet.error.ErrorController;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.RequestDispatcher;
import javax.servlet.http.HttpServletRequest;

@Controller
public class CustomErrorController implements ErrorController {

    @RequestMapping("/errors/400")
    public String handleError400(HttpServletRequest request, Model model) {
        Object status = request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE);
        if (status != null && status.toString().equals(Integer.toString(HttpStatus.BAD_REQUEST.value()))) {
            model.addAttribute("message", "Bad Request");
            return "error-400";
        }
        return "error";
    }

    @RequestMapping("/errors/500")
    public String handleError500(HttpServletRequest request, Model model) {
        Object status = request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE);
        if (status != null && status.toString().equals(Integer.toString(HttpStatus.INTERNAL_SERVER_ERROR.value()))) {
            model.addAttribute("message", "Internal Server Error");
            return "error-500";
        }
        return "error";
    }

    @RequestMapping("/errors/business-error")
    public String handleBusinessError(HttpServletRequest request, Model model) {
        model.addAttribute("message", "Business Error");
        return "business-error";
    }

    @Override
    public String getErrorPath() {
        return "/error";
    }
}
  1. 创建视图模板：
    • 在src/main/resources/templates目录下创建相应的HTML文件，例如error-400.html、error-500.html和business-error.html。
<!-- error-400.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Error 400</title>
</head>
<body>
    <h1>Bad Request</h1>
    <p>${message}</p>
</body>
</html>
注意事项：
  • 兼容性检查：确保使用的框架版本支持ErrorPageRegistrar接口。
  • 优先级设置：如果有多个错误处理机制，注意它们之间的优先级关系。
  • 路径正确性：确保错误页面的路径正确，并且能够被访问到。
  • 国际化支持：如果应用支持多语言，考虑为不同的语言提供相应的错误页面。
  • 视图解析器：确保Spring MVC的视图解析器配置正确，以便找到对应的视图模板。
  • 缓存策略：考虑为错误页面设置适当的缓存策略，以提高性能。

方案三：结合HandlerInterceptor和自定义异常处理器

可以通过拦截器捕获异常，并将异常包装成一个特定的格式，再交给全局异常处理器处理。这种方法需要一些额外的配置和逻辑来确保异常能够正确传递。

实现步骤：
  1. 创建拦截器类：
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

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

@Component
public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        try {
            // 拦截器逻辑
            return true;
        } catch (BusinessException e) {
            throw new CustomGlobalException(e.getMessage());
        }
    }
}
  1. 注册拦截器：
import org.springframework.beans.factory.annotation.Autowired;
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 {

    @Autowired
    private MyInterceptor myInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myInterceptor).addPathPatterns("/api/**");
    }
}
  1. 全局异常处理器：
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(CustomGlobalException.class)
    public ResponseEntity<String> handleCustomGlobalException(CustomGlobalException ex) {
        return new ResponseEntity<>(ex.getMessage(), HttpStatus.BAD_REQUEST);
    }
}
为什么这种方法有效

尽管HandlerInterceptor中的preHandle方法抛出的异常不会自动传递给Spring MVC的全局异常处理器，但通过以下设计，我们可以实现这一目标：

  1. 捕获并重新抛出异常：在拦截器中捕获特定类型的业务异常，并将其包装成一个新的自定义异常类型（如CustomGlobalException）。这使得异常能够在请求链中继续传播。

  2. 全局异常处理器：通过@RestControllerAdvice和@ExceptionHandler注解，定义一个全局异常处理器来捕获并处理特定类型的异常（如CustomGlobalException）。

  3. 异常传播机制：通过显式地重新抛出新的异常类型，确保异常能够在请求链中继续传播，并最终被全局异常处理器捕获。

注意事项：
  • 功能区分：明确哪些逻辑适合放在过滤器中，哪些适合放在拦截器中。通常，过滤器用于处理请求前后的通用操作（如认证、日志），而拦截器用于处理MVC层的操作。
  • 性能优化：尽量减少拦截器中的复杂逻辑，避免影响请求处理速度。
  • 异常传播：拦截器抛出的异常可以被Spring的全局异常处理器捕捉并处理。
  • 顺序控制：确保拦截器的执行顺序符合预期，特别是在有多个拦截器的情况下。
  • 依赖注入：通过Spring的依赖注入机制，可以在拦截器中使用其他服务或组件。

方案四：使用FilterRegistrationBean和自定义异常处理器

你可以通过FilterRegistrationBean注册过滤器，并在过滤器中捕获异常，然后将其转发到一个专门的异常处理端点。

实现步骤：
  1. 创建过滤器类：
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class MyFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        try {
            // 过滤器逻辑
            chain.doFilter(request, response);
        } catch (BusinessException e) {
            HttpServletRequest httpRequest = (HttpServletRequest) request;
            HttpServletResponse httpResponse = (HttpServletResponse) response;

            // 转发到异常处理端点
            httpResponse.sendRedirect(httpRequest.getContextPath() + "/handleException?msg=" + e.getMessage());
        }
    }
}
  1. 配置过滤器：
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean<MyFilter> loggingFilter(){
        FilterRegistrationBean<MyFilter> registrationBean = new FilterRegistrationBean<>();

        registrationBean.setFilter(new MyFilter());
        registrationBean.addUrlPatterns("/api/*"); // 指定需要过滤的URL模式

        return registrationBean;
    }
}
  1. 创建控制器来处理转发过来的异常：
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ExceptionController {

    @GetMapping("/handleException")
    public String handleException(@RequestParam String msg) {
        return "{\"error\": \"" + msg + "\"}";
    }
}
注意事项：
  • 路径正确性：确保转发的目标路径正确，并且能够被访问到。
  • 参数传递：确保异常信息能够正确传递到目标控制器。
  • 安全性：注意防止潜在的安全漏洞，如XSS攻击等。

三、总结与优化建议

通过上述几种方法，你可以有效地管理和处理过滤器中抛出的异常。每种方法都有其适用场景和注意事项：

  • 在过滤器内部捕获并处理异常：直接控制异常响应，适用于需要快速响应的场景。需要注意日志记录、状态码选择和返回格式。
  • 使用ErrorPageRegistrar接口：提供更灵活的错误页面处理器注册，适用于复杂的错误处理需求。需要注意路径正确性和国际化支持。
  • 结合HandlerInterceptor和自定义异常处理器：利用Spring MVC的拦截器机制，简化异常处理逻辑。需要注意功能区分和异常传播。
  • 使用FilterRegistrationBean和自定义异常处理器：通过过滤器捕获异常并转发到专门的异常处理端点，适用于需要统一处理异常的场景。

优化建议

  1. 统一的日志记录机制：

    • 使用统一的日志框架（如SLF4J）记录所有异常，便于后续分析和调试。
    • 记录异常发生的时间、上下文信息（如用户ID、请求参数等）。

  2. 集中化的异常处理：

    • 尽量将异常处理逻辑集中在一处，避免分散在各个地方。
    • 可以创建一个通用的异常处理器类，供过滤器、拦截器和控制器共同使用。

  3. 异步处理：

    • 对于一些耗时的操作（如发送邮件通知、记录日志等），可以考虑使用异步处理机制，避免阻塞主线程。

  4. 监控和报警：

    • 配置监控系统（如Prometheus、Grafana）来监控应用的健康状况，及时发现和处理异常。
    • 设置报警机制，在出现严重异常时发送通知（如邮件、短信等）。

通过这些详细的步骤和优化建议，你可以构建一个健壮且易于维护的异常处理机制，确保应用在面对各种异常情况时都能稳定运行。每个方案都有其优缺点，结合实际情况进行选择和组合是最佳实践。

相关文章：

  • vxe-table开启表尾和el-collapse-transition不兼容，动画卡顿
  • 【Qt QML】Loader动态加载组件（续）
  • 《安富莱嵌入式周报》第351期：DIY半导体制造，工业设备抗干扰提升方法，NASA软件开发规范，小型LCD在线UI编辑器，开源USB PD电源，开源锂电池管理
  • Web后端开发-总结
  • 多线程-JUC源码
  • 利用opencv_python(pdf2image、poppler）将pdf每页转为图片
  • 2025年夸克网盘自动签到程序,验证通过!
  • android App主题颜色动态更换
  • IO进程线程3
  • 【AD】5-3 PCB板框的内缩与外扩
  • OpenBMC：BmcWeb app获取socket
  • 嵌入式 ARM Linux 系统构成(1)：Bootloader层
  • oracle通过dmp导入数据
  • PHP之运算符
  • python-串口助手（OV7670图传）
  • 文献分享: ConstBERT固定数目向量编码文档
  • java 查找连个 集合的交集部分数据
  • 生命周期总结（uni-app、vue2、vue3生命周期讲解）
  • Linux总结
  • 进程间通信
  • 泽连斯基与埃尔多安会面，称已决定派遣代表团前往伊斯坦布尔
  • 证监会发布《上市公司募集资金监管规则》，6月15日起施行
  • 中办、国办关于持续推进城市更新行动的意见
  • 湃书单｜澎湃新闻编辑们在读的14本书：后工作时代
  • 腾讯一季度营收增长13%，马化腾：战略性的AI投入将带来长期回报
  • 反犹、资金与抗议：特朗普的施压如何撕裂美国大学？｜907编辑部