SpringMVC学习记录
注意：以下内容是学习 北京动力节点 的SpringMVC视频后所记录的笔记、源码以及个人的理解等，记录下来仅供学习
第4章 SpringMVC 核心技术
4.3 拦截器
SpringMVC 中的 Interceptor 拦截器是非常重要和相当有用的，它的主要作用是拦截指定的用户请求，并进行相应的预处理与后处理。其拦截的时间点在“处理器映射器根据用户提交的请求映射出了所要执行的处理器类，并且也找到了要执行该处理器类的处理器适配器，在处理器适配器执行处理器之前”。当然，在处理器映射器映射出所要执行的处理器类时，已经将拦截器与处理器组合为了一个处理器执行链，并返回给了中央调度器。
4.3.1 一个拦截器的执行
package com.bjpowernode.handler;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Date;
//拦截器类：拦截用户的请求。
public class MyInterceptor implements HandlerInterceptor {
private long btime = 0;
/*
* preHandle叫做预处理方法。
*/
@Override
public boolean preHandle(HttpServletRequest request,HttpServletResponse response,Object handler) throws Exception {
btime = System.currentTimeMillis();
System.out.println("拦截器的MyInterceptor的preHandle()");
//计算的业务逻辑，根据计算结果，返回true或者false
//给浏览器一个返回结果 //request.getRequestDispatcher("/tips.jsp").forward(request,response);
return true;
}
/*
postHandle:后处理方法。
*/
@Override
public void postHandle(HttpServletRequest request,Object handler,ModelAndView mv) throws Exception {
System.out.println("拦截器的MyInterceptor的postHandle()");
//对原来的doSome执行结果，需要调整。
if( mv != null){
//修改数据
mv.addObject("mydate",new Date());
//修改视图
mv.setViewName("other");
}
}
/*
afterCompletion:最后执行的方法
*/
@Override
public void afterCompletion(HttpServletRequest request,Exception ex) throws Exception {
System.out.println("拦截器的MyInterceptor的afterCompletion()");
long etime = System.currentTimeMillis();
System.out.println("计算从preHandle到请求处理完成的时间："+(etime - btime ));
}
}
自定义拦截器，需要实现Handlerinterceptor接口。而该接口中含有三个方法：
1、 preHandle(request,response,Object handler) 预处理方法：
该方法在处理器方法执行之前执行。其返回值为boolean，若为true，则紧接着会执行处理器方 法，且会将afterCompletion()方法放入到一个专门的方法栈中等待执行。
重要：
是整个项目的入口，门户。 当preHandle返回true 请求可以被处理。 preHandle返回false，请求到此方法就截止。
参数：
Object handler ： 被拦截的控制器对象
返回值boolean
true：请求是通过了拦截器的验证，可以执行处理器方法。
拦截器的MyInterceptor的preHandle()
=====执行MyController中的doSome方法=====
拦截器的MyInterceptor的postHandle()
拦截器的MyInterceptor的afterCompletion()
false：请求没有通过拦截器的验证，请求到达拦截器就截止了。 请求没有被处理
拦截器的MyInterceptor的preHandle()
特点：
a.方法在控制器方法（MyController的doSome）之前先执行的。 用户的请求首先到达此方法
b.在这个方法中可以获取请求的信息， 验证请求是否符合要求。可以验证用户是否登录， 验证用户是否有权限访问某个连接地址（url）。
如果验证失败，可以截断请求，请求不能被处理。
如果验证成功，可以放行请求，此时控制器方法才能执行。
2、postHandle(request/response/ Object handlei,modelAndView) 后处理方法：
该方法在处理器方法执行之后执行。处理器方法若最终未被执行，则该方法不会执行。 由于该方法是在处理器方法执行完后执行，且该方法参数中包含ModelAndView，所以该方法可以修 改处理器方法的处理结果数据，且可以修改跳转方向。
参数：
Object handler：被拦截的处理器对象MyController
ModelAndView mv:处理器方法的返回值
特点：
a.在处理器方法之后执行的（MyController.doSome()）
b.能够获取到处理器方法的返回值ModelAndView,可以修改ModelAndView中的
数据和视图，可以影响到最后的执行结果。
c.主要是对原来的执行结果做二次修正，
ModelAndView mv = MyController.doSome();
postHandle(request,handler,mv);
3、afterCompletion(request,Exception ex)最后执行的方法：
当preHandle()方法返回true时，会将该方法放到专门的方法栈中，等到对请求进行响应的所有 工作完成之后才执行该方法。即该方法是在中央调度器渲染(数据填充)了响应页面之后执行的，此 时对ModelAndView再操作也对响应无济于事。
afterCompletion**最后执行的方法，清除资源，例如在Controller方法中加入数据
参数
Object handler:被拦截器的处理器对象
Exception ex：程序中发生的异常
特点:
a.在请求处理完成后执行的。框架中规定是当你的视图处理完成后，对视图执行了forward。就认为请求处理完成。
b.一般做资源回收工作的， 程序请求过程中创建了一些对象，在这里可以删除，把占用的内存回收。
换一种表现方式，也可以这样理解:
(1) 注册拦截器
springmvc.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!--声明组件扫描器-->
<context:component-scan base-package="com.bjpowernode.controller" />
<!--声明 springmvc框架中的视图解析器， 帮助开发人员设置视图文件的路径-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--前缀：视图文件的路径-->
<property name="prefix" value="/WEB-INF/view/" />
<!--后缀：视图文件的扩展名-->
<property name="suffix" value=".jsp" />
</bean>
<!--声明拦截器： 拦截器可以有0或多个-->
<mvc:interceptors>
<!--声明第一个拦截器-->
<mvc:interceptor>
<!--指定拦截的请求uri地址
path：就是uri地址，可以使用通配符 **
** ： 表示任意的字符，文件或者多级目录和目录中的文件
http://localhost:8080/myweb/user/listUser.do
http://localhost:8080/myweb/student/addStudent.do
-->
<mvc:mapping path="/**"/>
<!--声明拦截器对象-->
<bean class="com.bjpowernode.handler.MyInterceptor" />
</mvc:interceptor>
</mvc:interceptors>
</beans>
mvc:mapping/用于指定当前所注册的拦截器可以拦截的请求路径，而 /**表示拦截所 有请求。
(2) 修改 index 页面
index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
String basePath = request.getScheme() + "://" +
request.getServerName() + ":" + request.getServerPort() +
request.getContextPath() + "/";
%>
<html>
<head>
<title>Title</title>
<base href="<%=basePath%>" />
</head>
<body>
<p>一个拦截器</p>
<form action="some.do" method="post">
姓名：<input type="text" name="name"> <br/>
年龄：<input type="text" name="age"> <br/>
<input type="submit" value="提交请求">
</form>
</body>
</html>
(3) 修改处理器
MyController.java
package com.bjpowernode.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
/**
* @RequestMapping:
* value ： 所有请求地址的公共部分，叫做模块名称
* 位置： 放在类的上面
*/
@Controller
public class MyController {
@RequestMapping(value = "/some.do")
public ModelAndView doSome(String name,Integer age) {
System.out.println("=====执行MyController中的doSome方法=====");
//处理some.do请求了。 相当于service调用处理完成了。
ModelAndView mv = new ModelAndView();
mv.addObject("myname",name);
mv.addObject("myage",age);
mv.setViewName("show");
return mv;
}
}
(4) 修改 show 页面
show.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h3>/WEB-INF/view/show.jsp从request作用域获取数据</h3><br/>
<h3>myname数据：${myname}</h3><br/>
<h3>myage数据：${myage}</h3>
</body>
</html>
4.3.2 多个拦截器的执行
项目在4.3.1的基础上
项目结构
(1) 再定义一个拦截器
MyInterceptor2 .java
package com.bjpowernode.handler;
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 {
@Override
public boolean preHandle(HttpServletRequest request,Object handler) throws Exception {
System.out.println("22222-拦截器的MyInterceptor的preHandle()");
return true;
}
@Override
public void postHandle(HttpServletRequest request,ModelAndView mv) throws Exception {
System.out.println("22222-拦截器的MyInterceptor的postHandle()");
}
@Override
public void afterCompletion(HttpServletRequest request,Exception ex) throws Exception {
System.out.println("22222-拦截器的MyInterceptor的afterCompletion()");
}
}
(2) 多个拦截器的注册与执行
springmvc.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!--声明组件扫描器-->
<context:component-scan base-package="com.bjpowernode.controller" />
<!--声明 springmvc框架中的视图解析器， 帮助开发人员设置视图文件的路径-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--前缀：视图文件的路径-->
<property name="prefix" value="/WEB-INF/view/" />
<!--后缀：视图文件的扩展名-->
<property name="suffix" value=".jsp" />
</bean>
<!--声明拦截器： 拦截器可以有0或多个
在框架中保存多个拦截器是ArrayList，
按照声明的先后顺序放入到ArrayList
-->
<mvc:interceptors>
<!--声明第一个拦截器-->
<mvc:interceptor>
<mvc:mapping path="/**"/>
<!--声明拦截器对象-->
<bean class="com.bjpowernode.handler.MyInterceptor" />
</mvc:interceptor>
<!--声明第二个拦截器-->
<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="com.bjpowernode.handler.MyInterceptor2" />
</mvc:interceptor>
</mvc:interceptors>
</beans>
当有多个拦截器时，形成拦截器链。拦截器链的执行顺序，与其注册顺序一致。需要再次强调一点的是，当某一个拦截器的peHandle()方法返回 true 并被执行到时，会向一个专门的方法栈中放入该拦截器的 afterCompletion()方法。
多个拦截器中方法与处理器方法的执行顺序如下图：
从图中可以看出，只要有一个preHandle()方法返回false，则上部的执行链将被断开， 其后续的处理器方法与postHandle()方法将无法执行。但，无论执行链执行情况怎样，只要 方法栈中有方法，即执行链中只要有preHandle()方法返回true,就会执行方法栈中的 afterCompletion()方法。最终都会给出响应。
换一种表现方式，也可以这样理解：
4.3.3 公共资源
(1) pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.bjpowernode</groupId>
<artifactId>ch11-interceptor2</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!--servlet依赖-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<!--jsp依赖-->
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.2.1-b03</version>
<scope>provided</scope>
</dependency>
<!--springmvc依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
</dependencies>
<build>
<plugins>
<!-- 编码和编译和JDK版本 -->
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
(2) web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<!--声明，注册springmvc的核心对象DispatcherServlet
需要在tomcat服务器启动后，创建DispatcherServlet对象的实例。
为什么要创建DispatcherServlet对象的实例呢？
因为DispatcherServlet在他的创建过程中， 会同时创建springmvc容器对象，
读取springmvc的配置文件，把这个配置文件中的对象都创建好， 当用户发起
请求时就可以直接使用对象了。
servlet的初始化会执行init（）方法。 DispatcherServlet在init（）中{
//创建容器，读取配置文件
WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
//把容器对象放入到ServletContext中
getServletContext().setAttribute(key,ctx);
}
启动tomcat报错，读取这个文件 /WEB-INF/springmvc-servlet.xml（/WEB-INF/myweb-servlet.xml）
springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/<servlet-name>-servlet.xml .
-->
<servlet>
<servlet-name>myweb</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--自定义springmvc读取的配置文件的位置-->
<init-param>
<!--springmvc的配置文件的位置的属性-->
<param-name>contextConfigLocation</param-name>
<!--指定自定义文件的位置-->
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!--在tomcat启动后，创建Servlet对象
load-on-startup:表示tomcat启动后创建对象的顺序。它的值是整数，数值越小，
tomcat创建对象的时间越早。 大于等于0的整数。
-->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>myweb</servlet-name>
<!--
使用框架的时候， url-pattern可以使用两种值
1. 使用扩展名方式， 语法 *.xxxx,xxxx是自定义的扩展名。 常用的方式 *.do,*.action,*.mvc等等
不能使用 *.jsp
http://localhost:8080/myweb/some.do
http://localhost:8080/myweb/other.do
2.使用斜杠 "/"
-->
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>
