springmvc异常处理&拦截器

最新推荐文章于 2026-03-26 09:10:14 发布

原创最新推荐文章于 2026-03-26 09:10:14 发布 · 420 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

笔记

本文详细介绍了SpringMVC的异常处理和拦截器。在异常处理方面，包括自定义异常类、异常处理器的配置及异常界面的编写。在拦截器部分，解释了拦截器的作用、与过滤器的区别，以及如何编写和配置拦截器，详细阐述了拦截器的preHandle、postHandle和afterCompletion三个方法的执行流程。

sprintmvc

文章目录

sprintmvc
一、异常处理
二、拦截器

一、异常处理

流程：Controller调用service，service调用dao，异常都是向上抛出的，最终有DispatcherServlet找异常处理器进
行异常的处理。

模拟异常的控制器：

package com.fjut.controller;

import com.fjut.exception.SysException;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/exceptionController")
public class ExceptionController {

    @RequestMapping("/testException")
    public String testException()throws SysException{
        System.out.println("testException执行了");

        try {
            //模拟异常
            int a = 10/0;
        } catch (Exception e) {
            e.printStackTrace();
            throw new SysException("分母不能为零的异常...");
        }
        return "success";
    }
}

第一步：编写自定义异常类（做提示信息的）

package com.fjut.exception;

/**
 * 自定义异常类
 */
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;
    }
}

2.编写异常处理器

package com.fjut.exception;

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) {
        SysException sysException = null;
        if(e instanceof  SysException){
            sysException = (SysException) e;
        }else{
            sysException = new SysException("系统正在维护中...");
        }
        //创建ModelAndView对象
        ModelAndView mv = new ModelAndView();
        //设置错误信息，传到界面
        mv.addObject("errorMsg",sysException.getMessage());
        //指定跳转的界面名
        mv.setViewName("error");
        return mv;
    }
}

3.在springmvc.xml中配置异常处理器

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

4.编写异常界面

<%--
  Created by IntelliJ IDEA.
  User: lenovo
  Date: 2020/12/2
  Time: 21:28
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    ${errorMsg}
</body>
</html>

二、拦截器

1. 拦截器的概述

1.SpringMVC框架中的拦截器用于对处理器进行预处理和后处理的技术。
2.可以定义拦截器链，连接器链就是将拦截器按着一定的顺序结成一条链，在访问被拦截的方法时，拦截器链
中的拦截器会按着定义的顺序执行。
3.拦截器和过滤器的功能比较类似，有区别
      1.过滤器是Servlet规范的一部分，任何框架都可以使用过滤器技术。
      2. 拦截器是SpringMVC框架独有的。
      3. 过滤器配置了/*，可以拦截任何资源。
      4.拦截器只会对控制器中的方法进行拦截。
4.拦截器也是AOP思想的一种实现方式
5.想要自定义拦截器，需要实现HandlerInterceptor接口。

简述：拦截器和过滤器的区别：
1.过滤器是所有web工程都可以用，而拦截器只有在使用springmvc框架才能使用。
2.过滤器可以拦截任何资源。而拦截器只会拦截Controller的方法。

2.拦截器

1.编写拦截器类，必须实现HandlerInterceptor接口。

package com.fjut.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;

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

/**
 * 自定义拦截器
 */
public class MyInterceptor implements HandlerInterceptor{

    /**
     * 预处理，在Controller方法执行前执行
     * return true  表示放行，执行下一个拦截器。若没有拦截器了，就执行Controller中的方法
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor执行了。。。");
        return true;
    }
}

Controller类

package com.fjut.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/myController")
public class MyController {

    @RequestMapping("/testInterceptor")
    public String testInterceptor(){
        System.out.println("testInterceptor执行了。。。");
        return "success";
    }
}

2.在springmvc.xml中配置拦截器类

<!--配置拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--要拦截的具体的方法-->
            <mvc:mapping path="/myController/*"/>
            <!--不要拦截的方法
            <mvc:exclude-mapping path=""></mvc:exclude-mapping>
            -->
            <!--配置拦截器对象-->
            <bean class="com.fjut.interceptor.MyInterceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>

注意：

preHandle方法是controller方法执行前拦截的方法
1. 可以使用request或者response跳转到指定的页面

request.getRequestDispatcher("/WEB-INF/pages/xxx.jsp").forward(request,response);

      2. return true放行，执行下一个拦截器，如果没有拦截器，执行controller中的方法。
      3. return false不放行，不会执行controller中的方法。
2. postHandle是controller方法执行后执行的方法，在JSP视图执行前。
      1. 可以使用request或者response跳转到指定的页面
      2. 如果指定了跳转的页面，那么controller方法跳转的页面将不会显示。
3. afterCompletion方法是在JSP执行后执行
      1. request或者response不能再跳转页面了

结果：先执行拦截器，后执行Controller方法
在这里插入图片描述

2.拦截器执行流程

在这里插入图片描述
多个拦截器的配置：

<!-- 配置拦截器 --> 
<mvc:interceptors> 
	<mvc:interceptor> 
	<!-- 哪些方法进行拦截 --> 
	<mvc:mapping path="/user/*"/> 
	<!-- 哪些方法不进行拦截 <mvc:exclude-mapping path=""/> -->
	<!-- 注册拦截器对象 --> 
	<bean class="cn.itcast.demo1.MyInterceptor1"/> 
	
	</mvc:interceptor> <mvc:interceptor> 
	<!-- 哪些方法进行拦截 --> 
	<mvc:mapping path="/**"/> 
	<!-- 注册拦截器对象 --> 
	<bean class="cn.itcast.demo1.MyInterceptor2"/> 
	</mvc:interceptor> 
</mvc:interceptors>

标签

#springmvc