SpringMVC-08-拦截器

1、拦截器概述

SpringMVC的处理器拦截器类似于Servlet开发中的过滤器 Filter ，用于对 Handler 进行预处理和后处理。开发者可以自己定义一些拦截器来实现特定的功能。

过滤器与拦截器的区别：

过滤器
- servlet规范中的一部分，任何JavaWeb工程都可以使用
- 在url-pattern中配置了/*之后，可以对所有要访问的资源进行过滤
拦截器
- 拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用
- 拦截器只会拦截进入Spring体系中的请求，即进入DispatcherServlet中的请求
- 像.jsp这种的资源请求，拦截器不会执行，因为它并没用进入DispatcherServlet，而是进到Tomcat内置的 JspServlet中

拦截器是AOP思想的具体应用！

2、拦截器使用

自定义拦截器

那如何实现拦截器呢？

想要自定义拦截器，必须实现 HandlerInterceptor 接口

public interface HandlerInterceptor {

	default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		return true;
	}

	default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable ModelAndView modelAndView) throws Exception {
	}

	default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,@Nullable Exception ex) throws Exception {
	}

}

preHandle
- 在 Handler执行之前执行
- 返回true: 放行，执行下一个拦截器
- 返回false: 拦截，终止此次请求后面的处理链，接下来需要自己处理request和response来控制网页
postHandle
- 在 Handler执行之后，ViewResolver解析逻辑视图之前执行
- 可以修改ModelAndView 来控制模型数据和接下来将要跳转的视图(仅限于返回逻辑视图名的Handler)
afterCompletion
- 一次请求在Spring体系处理工作完成之后的回调(即，ViewResolver渲染出物理视图之后)
- 不管Handler是否正常执行(可能抛异常)，此方法都会执行
- 类似于try-catch语法中的finally，常用来做资源清理和根据异常的处理

自定义拦截器 MyInterceptor

public class MyInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object handler) throws Exception {
        System.out.println("------------preHandle------------");

        return !"false".equals(httpServletRequest.getParameter("status"));
    }

    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
        System.out.println("------------postHandle------------");
    }

    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
        System.out.println("------------afterCompletion------------");
        System.out.println(e);
        if (e != null)
            httpServletRequest.getRequestDispatcher("/").forward(httpServletRequest, httpServletResponse);
    }
}

配置拦截器

在Spring的配置文件中定义

<!--关于拦截器的配置-->
<mvc:interceptors>
    <mvc:interceptor>
        <!-- /** 包括路径及其子路径 -->
        <!-- /admin/* 拦截的是/admin/add等等这种 , /admin/add/user不会被拦截 -->
        <!-- /admin/** 拦截的是/admin/下的所有路径 -->
        <mvc:mapping path="/**"/>
        <mvc:exclude-mapping path="/login"/>
        <!--bean配置的就是拦截器-->
        <bean class="com.moondream.interceptor.MyInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

mvc:mapping
- 拦截器映射拦截的路径
mvc:exclude-mapping
- 在映射拦截路径中排除的路径
bean
- 要配置的拦截器类

测试

添加Controller

@RestController
public class TestController {

    @RequestMapping("test1")
    public String test1() {
        System.out.println("Handler执行");
//        int i = 1 / 0;
        return "hello";
    }

}

拦截器拦截：后面的处理链不会执行
拦截器放行：请求正常处理
Handler 出现异常：postHandle不会执行，异常被afterCompletion捕获，并由afterCompletion处理请求

3、拦截器执行顺序

添加 MyInterceptor2

public class MyInterceptor2 implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object handler) throws Exception {
        System.out.println("------------preHandle-2------------");
        return true;
    }

    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
        System.out.println("------------postHandle-2------------");
    }

    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
        System.out.println("------------afterCompletion-2------------");
    }
}

<!--关于拦截器的配置-->
<mvc:interceptors>
    <mvc:interceptor>
        <!-- /** 包括路径及其子路径 -->
        <!-- /admin/* 拦截的是/admin/add等等这种 , /admin/add/user不会被拦截 -->
        <!-- /admin/** 拦截的是/admin/下的所有路径 -->
        <mvc:mapping path="/**"/>
        <mvc:exclude-mapping path="/login"/>
        <!--bean配置的就是拦截器-->
        <bean class="com.moondream.interceptor.MyInterceptor"/>
    </mvc:interceptor>
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <bean class="com.moondream.interceptor.MyInterceptor2"/>
    </mvc:interceptor>
</mvc:interceptors>

执行测试，观察控制台输出

由图可知，

在 preHandle阶段，拦截器按注册顺序执行
在 postHandle阶段和 afterCompletion阶段，拦截器逆序执行

这好比进入一个有多重门的院子，进去要先开外门，再开内门，出去要先开内门，再开外门。

4、验证用户是否登录 (项目案例)

实现思路

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

编写一个登陆页面 login.jsp

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

编写一个Controller处理请求

@Controller
@RequestMapping("/user")
public class UserController {
    //跳转到登陆页面
    @RequestMapping("/jumplogin")
    public String jumpLogin() throws Exception {
        return "login";
    }
    //跳转到成功页面
    @RequestMapping("/jumpSuccess")
    public String jumpSuccess() throws Exception {
        return "success";
    }
    //登陆提交
    @RequestMapping("/login")
    public String login(HttpSession session, String username, String pwd) throws Exception {
        // 向session记录用户身份信息
        System.out.println("接收前端==="+username);
        session.setAttribute("user", username);
        return "success";
    }
    //退出登陆
    @RequestMapping("logout")
    public String logout(HttpSession session) throws Exception {
        // session 过期
        session.invalidate();
        return "login";
    }
}

编写一个登陆成功的页面 success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    
<h1>登录成功页面</h1>
<hr>
    
${user}
<a href="${pageContext.request.contextPath}/user/logout">注销</a>
</body>
</html>

在 index 页面上测试跳转！启动Tomcat 测试，未登录也可以进入主页！

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
  <h1>首页</h1>
  <hr>
  <%--登录--%>
  <a href="${pageContext.request.contextPath}/user/jumplogin">登录</a>
  <a href="${pageContext.request.contextPath}/user/jumpSuccess">成功页面</a>
  </body>
</html>

编写用户登录拦截器

public class LoginInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
        // 如果是登陆页面则放行
        System.out.println("uri: " + request.getRequestURI());
        if (request.getRequestURI().contains("login")) {
            return true;
        }
        HttpSession session = request.getSession();
        // 如果用户已登陆也放行
        if(session.getAttribute("user") != null) {
            return true;
        }
        // 用户没有登陆跳转到登陆页面
        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);
        return false;
    }
    
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
    }
    
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
    }
    
}

在Spring的配置文件中注册拦截器

<!--关于拦截器的配置-->
<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <bean id="loginInterceptor" class="com.moondream.interceptor.LoginInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

再次重启Tomcat测试！

OK，测试登录拦截功能无误.

posted @ 2024-12-08 21:15 MoonDreamV 阅读(40) 评论(0) 编辑收藏举报

刷新页面返回顶部

blog-moondream