首页 > 软件编程 > java > SpringMVC异常处理和拦截器

SpringMVC的异常处理和拦截器处理思路解析

2025-09-05 14:42:29 作者：期待のcode

这篇文章介绍了SpringMVC的异常处理和拦截器功能,在异常处理部分,详细说明了如何通过DispatcherServlet捕获并处理异常,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧

SpringMVC的异常处理

异常处理思路：Controller 调用 service，service 调用 dao，异常都是向上抛出的，此时 DispatcherServlet 会暂停正常的请求处理流程，转而进入异常处理流程，并将异常交给异常解析器处理。

controller代码

package com.qcby.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
@RequestMapping("/exception")
public class ExController {
    /**
     * try-catch 处理异常
     */
    @RequestMapping("/findAll.do")
     public String findAll1(){
        try {
            System.out.println("执行了...");
            // 模拟异常
            int a = 10 / 0;
        } catch (Exception e) {
            e.printStackTrace();
            //跳转到友好提示页面
        }
        return "suc";
    }
    /**
     * 使用异常处理器方式
     */
    @RequestMapping("/findAl2.do")
    public String findAll2(){
        System.out.println("执行了...");
        // 模拟异常
        int a = 10/0;
        return "suc";
    }
}

自定义异常类（与业务相关的异常），需要遵循JDK异常规范，继承 Exception

package com.qcby.model;
public class SysException extends Exception {
    private String message;
    @Override
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
    public SysException(String message) {
        this.message = message;
    }
}

message 是一个用于存储异常信息的成员变量，作用是描述当前异常发生的具体原因或详细信息。当创建 SysException 实例时，会将具体的异常描述字符串传入并赋值给 message，之后可以通过 getMessage() 方法获取这个信息，用于调试或向用户展示错误原因。

自定义异常处理器，SpringMVC 提供了 HandlerExceptionResolver 异常处理的核心接口，定义了处理异常的规范

package com.qcby.util;
import com.qcby.model.SysException;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class SysExceptionResolver implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
        // 在控制台打印异常的信息
        e.printStackTrace();
        // 声明变量
        SysException exception = null;
        // 如果是自定义的SysException直接强转使用
        if(e instanceof SysException){
            exception = (SysException)e;
        }else {
            // 如果是其他异常，则包装成一个新的SysException，并设置默认提示信息
            exception = new SysException("系统正在维护，请联系管理员");
        }
        // 存入异常提示信息
        ModelAndView mv = new ModelAndView();
        //Throwable定义了getMessage()方法，用于返回异常/错误的详细描述信息
        mv.addObject("errorMsg",e.getMessage());
        // 设置跳转的页面
        mv.setViewName("error");
        return mv;
    }
}

如果捕获的异常 e 是 SysException 类型，直接强转使用；如果是其他异常，则包装成一个新的SysException，并设置默认提示信息 “系统正在维护，请联系管理员”，目的是将所有异常统一转为SysException类型，便于后续统一处理，避免对不同异常类型写重复代码。通过 e.getMessage() 获取异常的消息文本，将其存入模型中，指定异常发生时要跳转的视图名称为error，最终返回ModelAndView，Spring 会根据该对象渲染对应的错误页面并响应给客户端。

SpringMVC 基于组件式开发，在 springmvc.xml 配置文件中配置异常处理器

    <!--配置异常处理器-->
    <bean id="sysExceptionResolver" class="com.qcby.util.SysExceptionResolver" />

jsp页面代码

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
    <title>错误提示页面</title>
</head>
<body>

	<h3>错误的友好提示页面</h3>

	${errorMsg}

</body>
</html>

效果展示：

SpringMVC框架中的拦截器

在 SpringMVC 中，拦截器是一种基于 AOP 思想的组件，主要用于对处理器进行预处理和后处理技术

拦截器（Filter）和过滤器（Interceptor）的功能比较类似，但有区别

技术归属与依赖
过滤器属于Servlet 规范的一部分（定义在javax.servlet包中），不依赖任何框架，只要是 Servlet 容器（如Tomcat）就能运行，可以通过web.xml或@WebFilter注解配置过滤器；
拦截器是 Spring 框架提供的组件（定义在org.springframework.web.servlet包中），依赖于 Spring 容器，仅在 Spring 环境中生效，其运行需要 Spring 的 DispatcherServlet 调度，本质是 Spring 对请求处理流程的增强。
作用范围与处理对象
过滤器处理的是 ServletRequest 和 ServletResponse 对象，关注的是请求数据响应数据本身，作用于整个请求、响应周期，可以处理所有进入 Servlet 容器的请求，覆盖范围更广；
拦截器只拦截通过 DispatcherServlet 分发的请求，即处理的是 HandlerMethod（SpringMVC 的 Controller 方法），关注的是业务方法调用，范围更窄。
执行时机与生命周期
过滤器的生命周期由 Servlet 容器管理，随容器启动而初始化，随容器关闭而销毁；
拦截器的生命周期由 Spring 容器管理，随 Spring 上下文初始化而创建，随上下文销毁而销毁。

自定义拦截器步骤

首先需要定义一个controller层的方法用于测试

@Controller
@RequestMapping("/dept")
public class DeptController {
    /**
     * 测试方法
     * @return
     */
    @RequestMapping("/findAll.do")
    public String findAll() {
        System.out.println("controller方法执行了...");
        return "suc";
    }
}

创建一个自定义拦截器类，需要实现HandlerInterceptor接口，重写接口内需要的方法

package com.qcby.util;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MyInterceptor implements HandlerInterceptor {
    /**
     * 拦截controller中方法
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor的preHandle方法执行了...");
        // 手动跳转页面
        // request.getRequestDispatcher("/WEB-INF/pages/suc.jsp").forward(request,response);
        // 拦截，不放行
        //return false;
        // 放行,执行controller中方法
        return true;
    }
}

需要在 springmvc.xml 配置文件中配置拦截器，并指定拦截 / 排除的路径

    <!--配置拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--该拦截器拦截哪些资源-->
            <mvc:mapping path="/dept/**"/>
            <!--哪些资源不拦截
            <mvc:exclude-mapping path="" />
            -->
            <!--拦截器对象-->
            <bean class="com.qcby.util.MyInterceptor1" />
        </mvc:interceptor>
    </mvc:interceptors>

请求路径：http://localhost:8080/dept/findAll.do
打印结果如图：

即 MyInterceptor 拦截器生效了

请求处理的大致流程为：客户端请求 → 过滤器 → Servlet容器 → DispatcherServlet → 拦截器 → Controller → 拦截器 → DispatcherServlet → 过滤器 → 客户端响应

拦截器围绕 Controller 方法的调用，在 HandlerInterceptor 接口中的有三个核心方法：

preHandle：是在 Controller 方法执行前拦截的方法，可以使用request或者response跳转到指定的页面；
return true 放行，执行下一个拦截器，如果没有拦截器，则执行controller中的方法；return false 不放行，会终止后续流程，包括controller中的方法与后续拦截器；
postHandle：是在 Controller 方法执行之后、视图渲染之前拦截的方法，可以使用request、response的方式或者通过 return "xxx"指定了要跳转的视图，若指定了跳转的页面那么跳转操作会覆盖 Controller 原本指定的页面，Controller 方法所要跳转的页面将不会显示；
afterCompletion：是在整个请求处理完成（视图渲染后）拦截的方法，request或者response不能再跳转页面了。

package com.qcby.util;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MyInterceptor1 implements HandlerInterceptor {
    /**
     * 拦截controller中的方法
     */
    //controller方法执行前拦截的方法
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,Object handler)throws Exception{
        System.out.println("MyInterceptor1的preHandler方法执行了");
        // 手动跳转页面
        // request.getRequestDispatcher("/WEB-INF/pages/suc.jsp").forward(request,response);
        // 拦截，不放行
        //return false;
        // 放行,执行方法
        return true;
    }
    //controller方法执行后拦截的方法
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)throws Exception{
        System.out.println("MyInterceptor1的postHandle方法执行了...");
        // 也是可以进行页面的跳转
        request.getRequestDispatcher("/WEB-INF/pages/suc.jsp").forward(request,response);
        return;
    }
    //controller跳转的jsp页面都执行完成了，最后执行该方法
    @Override
    public void afterCompletion(HttpServletRequest request,HttpServletResponse response,Object handler,Exception ex)throws Exception{
        System.out.println("MyInterceptor1的afterCompletion方法执行了...");
    }
}

配置多个拦截器

可以定义拦截器链，拦截器链就是将拦截器按着一定的顺序结成一条链，在访问被拦截的方法时，拦截器链中的拦截器会按着定义的顺序执行

我们再定义一个拦截器

package com.qcby.util;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MyInterceptor2 implements HandlerInterceptor {
    /**
     * 拦截controller中方法
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor2的preHandle方法执行了...");
        // 放行,执行controller中方法
        return true;
    }
    /**
     * controller方法执行后，要拦截的方法
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor2的postHandle方法执行了...");
    }
    /**
     * controller跳转的jsp页面都执行完成了，最后执行该方法
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor2的afterCompletion方法执行了...");
    }
}

配置两个拦截器

    <mvc:interceptors>
        <!--配置拦截器-->
        <mvc:interceptor>
            <!--该拦截器拦截哪些资源-->
            <mvc:mapping path="/dept/**"/>
            <!--哪些资源不想拦截
            <mvc:exclude-mapping path="" />
            -->
            <!--拦截器对象-->
            <bean class="com.qcby.util.MyInterceptor1" />
        </mvc:interceptor>
        <!--配置拦截器-->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.qcby.util.MyInterceptor2" />
        </mvc:interceptor>
    </mvc:interceptors>

总结执行顺序：

请求前阶段（preHandle）：按拦截器注册顺序执行（MyInterceptor1→MyInterceptor2）；
目标业务（Controller）：仅在所有拦截器的 preHandle 都返回 true 后才执行；
响应后阶段（postHandle、afterCompletion）：按注册逆序执行（MyInterceptor2→MyInterceptor1）。

到此这篇关于SpringMVC的异常处理和拦截器的文章就介绍到这了,更多相关SpringMVC异常处理和拦截器内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

SpringMVC的异常处理和拦截器处理思路解析