SpringMVC系列--异常处理和拦截器

最新推荐文章于 2023-06-03 08:51:34 发布

冬瓜闯世界

最新推荐文章于 2023-06-03 08:51:34 发布

阅读量540

点赞数 3

分类专栏： SpringMVC

本文链接：https://blog.csdn.net/qq_43404873/article/details/109901825

版权

SpringMVC 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

SpringMVC中的异常处理

系统中异常包括两类：预期异常和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试通过手段减少运行时异常的发生。

系统的dao、service、controller出现都通过throws Exception向上抛出，最后由springmvc前端控制器交由异常处理器进行异常处理，如下图所示：
在这里插入图片描述

实现步骤

编写异常类和错误页面

CustomException .java

package com.ssm.po;

public class CustomException extends  Exception {
    private  String message;

    public CustomException(String message) {
        this.message = message;
    }

    @Override
    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

error.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>执行失败</title>
</head>
<body>
 执行失败!
${message}
</body>
</html>

自定义异常处理器

package com.ssm.error;

import com.ssm.po.CustomException;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;

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

public class CustomExceptionResolver  implements HandlerExceptionResolver{
    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        ex.printStackTrace();
        CustomException customException = null;

        //如果抛出的是系统自定义异常则直接转换
        if(ex instanceof  CustomException){
            customException = (CustomException) ex;
        }else{
            //如果抛出的不是系统自定义异常则重新构造一个系统错误异常
            customException = new CustomException("系统错误，请与系统管理员联系!");
        }
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("message",customException.getMessage());
        modelAndView.setViewName("error");
        return modelAndView;
    }
}

配置异常处理器

在Springmvc-config.xml中配置我们自定义的异常处理器

 <!--配置自定义异常处理器-->
    <bean id="handlerExceptionResolver" class="com.ssm.error.CustomExceptionResolver"/>

CustomerController

在控制类编写一个请求，用来模拟我们查询用户的时候出错了，方便我们测试异常处理器，代码如下:

 @RequestMapping("/testException")
    public  String testException() throws  Exception{
        System.out.println("testException执行了....");
        try{
            //模拟异常
            int a = 10/0;
        }catch (Exception e){
            e.printStackTrace();
            throw  new CustomException("查询所有用户出现错误了...");
        }

        return  "success";
    }

当我们请求http://localhost:8081/testException，由于我们在代码中模拟异常，会抛出一个异常，SpringMVC最终会交给我们自定义的异常处理器处理，会执行resolveException()方法，最终会跳转到error页面，并且显示我们的错误信息。
在这里插入图片描述
其实在实际开发中，我们可以把错误页面写的更美观一些，当我们网站出现问题的时候，可以友好地提示用户。

拦截器

拦截器概述

SpringMVC中的拦截器(Intercepter)类似于Servlet中的过滤器(Filter),它主要用于拦截用户请求并做相应的处理。例如通过拦截器可以进行权限验证、判断用户是否登录等。

拦截器的定义

拦截器可以通过以下两种方式进行定义:

一种是通过实现 HandlerInterceptor接口或者继承HandlerIntercepter接口的实现类(如HandlerInterceptorAdapter)来定义
另一种是通过实现WebRequestInterceptor接口或继承WebRequestInterceptor接口的实现类来定义

以实现HandlerInterceptor接口的定义方式为例，自定义拦截器的代码如下所示:

public class UserInterceptor implements HandlerInterceptor{
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return false;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

关于接口中的3个方法具体描述如下:

preHandler()方法: 该方法会在控制器方法前执行，其返回值表示是否中断后续操作。当其返回值为true时，表示继续向下执行；当其返回值为false时，会中断后续的所有操作(包括调用下一个拦截器和控制器类中的方法执行等)
postHandler()方法：该方法会在控制器方法调用之后，且解析视图之前执行。可以通过此方法对请求域中的模型和视图做出进一步的修改。
afterCompletion()方法：该方法在整个请求完成，即视图渲染结束之后执行。可以通过此方法实现一些资源清理、记录日志信息等工作。

拦截器的配置

要使自定义的拦截器生效，需要在springmvc-config.xml中进行配置。代码如下:

 <!--配置拦截器-->
    <mvc:interceptors>
        <!--使用bean直接定义在<mvc:interceptors>下面的Intercepteor 将拦截所有请求-->
        <bean class="com.ssm.interceptor.UserInterceptor"/>

        <!--拦截器1-->
        <mvc:interceptor>
            <!--配置拦截器作用的路径-->
            <mvc:mapping path="/**"/>
            <!--配置不需要拦截器作用的路径-->
            <mvc:exclude-mapping path=""/>
            <!--定义在<mvc:interceptor>下面，表示对匹配路径的请求才进行拦截-->
            <bean class="com.ssm.interceptor.Interceptor1"/>
        </mvc:interceptor>

        <!--拦截器2-->
        <mvc:interceptor>
            <mvc:mapping path="/hello"/>
            <bean class="com.ssm.interceptor.Interceptor2"/>
        </mvc:interceptor>
    </mvc:interceptors>

在上述代码中，< mvc:interceptors >元素用于配置一组拦截器，其子元素< bean>中定义的是全局拦截器，它会拦截所有的请求。而< mvc:interceptor>元素中定义的是指定路径的拦截器，它会对指定路径下的请求生效。

< mvc:interceptor>元素的子元素< mvc:mapping>用于配置拦截器作用的路径，该路径在其属性path中定义。如上述代码中path的属性值"/**"表示拦截所有路径， "/hello"表示拦截所有以"hello"结尾的路径。如果在请求路径中包含不需要拦截的内容，可以通过 < mvc:exclude-mapping />元素进行配置。

注意:
< mvc:interceptor>中的子元素必须按照 < mvc:mapping…>⇒ < mvc:exclude-mapping…> ⇒ < bean …/>的顺序编写。

拦截器的执行流程

单个拦截器的执行流程

程序首先会执行拦截器类中的preHandle()方法，如果该方法的返回值为true，则程序就会继续向下执行处理器中的方法，否则将不再向下执行；在业务处理器(即控制器Controller类)处理完请求后，会执行postHandle()方法，然后通过DispatcherServlet向客户端返回响应；在DispatcherServlet处理完请求后，才会执行afterCompletion()方法。

代码实现

1.HelloController.java 代码如下:

package com.ssm.controller;

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

@Controller
public class HelloController {

    @RequestMapping("/hello")
    private  String hello(){
        System.out.println("Hello");
        return "success";
    }
}

2.UserInterceptor.java
该类需要实现HandlerInterceptor接口,代码如下

package com.ssm.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 UserInterceptor implements HandlerInterceptor{
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        System.out.println("UserInterceptor...preHandle");

        //对拦截的请求进行放行处理
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("UserInterceptor...postHandle");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("postHandle...afterCompletion");
    }
}

3.springmvc-config.xml配置拦截器

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">


    <!--定义扫描器-->
    <context:component-scan base-package="com.ssm.controller"/>

    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

    <!--配置注解驱动-->
    <mvc:annotation-driven/>

    <!--配置拦截器-->
    <mvc:interceptors>
        <!--使用bean直接定义在<mvc:interceptors>下面的Intercepteor 将拦截所有请求-->
        <bean class="com.ssm.interceptor.UserInterceptor"/>
</beans>

4.启动项目，访问地址http://localhost:8081/hello，控制台的输出结果如下所示:
在这里插入图片描述
发现单个拦截器的执行顺序和我们前面所说的顺序是一致的。

多个拦截器的执行流程

假设有两个拦截器Interceptor1和Interceptor2,并且在配置文件中，Interceptor1拦截器配置在前。
在这里插入图片描述从上图可以看成，当有多个拦截器同时工作时，它们的preHandler()方法会按照配置文件中拦截器的配置顺序执行，而它们的postHandler()方法和afterCompletion()方法则会按照配置顺序的反序进行。

代码实现

1.创建两个拦截器类Interceptor1和Interceptor2

Interceptor1.java

package com.ssm.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 Interceptor1 implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        System.out.println("Interceptor1...preHandle");

        //对拦截的请求进行放行处理
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("Interceptor1...postHandle");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("Interceptor1...afterCompletion");
    }
}

Interceptor2.java

package com.ssm.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 Interceptor2  implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        System.out.println("Interceptor2...preHandle");

        //对拦截的请求进行放行处理
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("Interceptor2...postHandle");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("Interceptor2...afterCompletion");
    }
}

2.配置拦截器

<!--配置拦截器-->
    <mvc:interceptors>
        <!--拦截器1-->
        <mvc:interceptor>
            <!--配置拦截器作用的路径-->
            <mvc:mapping path="/**"/>
            <!--定义在<mvc:interceptor>下面，表示对匹配路径的请求才进行拦截-->
            <bean class="com.ssm.interceptor.Interceptor1"/>
        </mvc:interceptor>

        <!--拦截器1-->
        <mvc:interceptor>
            <mvc:mapping path="/hello"/>
            <bean class="com.ssm.interceptor.Interceptor2"/>
        </mvc:interceptor>
    </mvc:interceptors>

第一个拦截器会作用于所有路径下的请求，而第二个拦截器会作用于以"/hello"结尾的请求。

启动程序，访问http://localhost:8081/hello，控制台输出如下信息:
在这里插入图片描述

应用案例——用户登录权限验证

案例的整个执行流程图如下:
在这里插入图片描述
实现思路如下:

有一个登录界面，需要些一个controller访问页面
登录页面有一提交表单的动作。需要在controller中处理
- 判断用户名密码是否正确
- 如果正确向session中写入用户信息，不正确，回到登录页面，提示错误信息。
- 跳转到主页面
拦截用户请求，判断用户是否登录
- 如果用户已经登录。放行
- 如果用户未登录，跳转到登录页面，并提示用户请登录。

User.java

package com.ssm.po;

public class User {
    private  Integer id;
    private  String username;
    private  String password;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

UserController.java

在该类中定义向主页跳转、向登录页面跳转、执行用户登录等操作的方法，代码如下

package com.ssm.controller;

import com.ssm.po.User;
import com.ssm.po.UserVo;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import javax.servlet.http.HttpSession;
import java.util.List;

@Controller
public class UserController {

    //跳转到登录界面
    @RequestMapping("/toLogin")
    public  String toLogin(){
        return  "login";
    }

    //登录验证
    @RequestMapping("/login")
    public  String login(User user, Model model,HttpSession session){
        String username = user.getUsername();
        String password = user.getPassword();

        if(username!=null && username.equals("xiaoxin")){
            if(password!=null && password.equals("726599")){
                //登录成功，保存session
                //跳转到主页
                session.setAttribute("user_session",user);
                return "redirect:main";
            }
        }

        //用户不存在，将错误信息添加到model中,并跳转到登录界面
        model.addAttribute("msg","用户名或密码错误，请重新输入");
        return  "login";

    }

    //向管理主页跳转
    @RequestMapping(value = "/main")
    public  String toMain(){
        return  "main";
    }

    //退出登录
    @RequestMapping("/loginout")
    public  String loginout(HttpSession session){
        //清除session
        session.invalidate();
        //重定向到登录界面
        return  "redirect:toLogin";
    }
}

UserInterceptor.java

package com.ssm.interceptor;

import com.ssm.po.User;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

public class UserInterceptor implements HandlerInterceptor{
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        //获取请求的URL
        String url = request.getRequestURI();

        //允许直接访问的"/toLogin"
        if(url.indexOf("/toLogin")>=0){
            return  true;
        }
        //允许直接访问的"/login"
        if(url.indexOf("/login")>=0){
            return  true;
        }

        //获取Session
        HttpSession session = request.getSession();
        //获取Session保存的用户数据
        User user = (User) session.getAttribute("user_session");

        //如果user不为空，则登录了放行，否则转发到登录界面
        if(user!=null){
            return  true;
        }
        request.setAttribute("msg","请先登录!");
        request.getRequestDispatcher("WEB-INF/jsp/login.jsp").forward(request,response);
        return false;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("UserInterceptor...postHandle");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("postHandle...afterCompletion");
    }
}

在preHandle()方法中，先获取了请求的URL，然后通过indexOf()方法判断URL中是否有“/toLogin”或“/login”字符串，如果有，就直接返回true，即直接放行。
如果是其他的请求，我们就需要获取Session中用户信息，如果Session中包含用户信息，即表示用户已登录，就直接放行；否则转发到登录界面，不再执行后续程序。

springmvc-config.xml

在配置文件中配置自定义的登录拦截信息，代码如下:

 <!--配置拦截器-->
    <mvc:interceptors>
        <!--拦截器1-->
        <mvc:interceptor>
            <!--配置拦截器作用的路径-->
            <mvc:mapping path="/**"/>
            <bean class="com.ssm.interceptor.UserInterceptor"/>
        </mvc:interceptor>

    </mvc:interceptors>

main.jsp

管理页面main.jsp,

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>管理界面</title>
</head>
<body>
    当前用户信息:${user_session.username}
    <a href="${pageContext.request.contextPath}/loginout">退出</a>
</body>
</html>

login.jsp

登录页面login.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录页面</title>
</head>
<body>
${msg}
<form action="${pageContext.request.contextPath}/login" method="post">
    用户名: <input type="text" name="username"> <br/>
    密码: <input type="text" name="password"> <br/>
    <input type="submit" value="登录">
</form>
</body>
</html>

启动程序，访问地址http://localhost:8081/main,这时候我们还没有进行登录就去访问主页时，访问请求会被登录拦截器拦截，从而跳转到登录界面
在这里插入图片描述
如果我们输入错误的用户名和密码，则会给出提示信息，效果如下:

输入正确的用户名"xiaoxin"和密码"726599",则会跳转到主页，效果如下:

点击"退出"连接,用户即可退出当前管理页面，复位到登录界面。

冬瓜闯世界

关注

3
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC系列--异常处理和拦截器

SpringMVC中的异常处理系统中异常包括两类：预期异常和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试通过手段减少运行时异常的发生。系统的dao、service、controller出现都通过throws Exception向上抛出，最后由springmvc前端控制器交由异常处理器进行异常处理，如下图所示：实现步骤编写异常类和错误页面CustomException .javapackage com.ssm.po;public
复制链接

扫一扫