SpringMVC一文详解
SpringMVC详解
- 一：SpringMVC概述
-
- 1）第一个springMVC项目
- 2）SpringMVC请求处理流程
- 3）spring执行过程源码分析
- 4）SpringMVC的执行流程
- 二：SpringMVC注解式开发
-
- 1）@RequestMapping 定义请求规则
- 2）method属性
- 3）处理器方法的参数
-
- 1）逐个参数接收
- 2）**校正请求参数名**@RequestParam
- 3）对象接收参数
- 4）过滤器解决post方式乱码
- 5）处理器方法的返回值
-
- 1）ModelAndView作为返回值：
- 2）String作为返回值：
- 3）返回void:
- 4）返回对象 Object
- 5）返回List集合
- 6）返回值是字符串
- 6）**解读**\
-
- 1）处理静态资源的方式：
- 2）一条配置处理所有的静态资源
- 3）相对路径和绝对路径
- 三：SSM整合开发
-
-
- **实现步骤：**
-
- 1）加入依赖：pom.xml
- 2）定义包，组织程序的结构
- 3）编写配置文件：
- 4）web.xml文件：
- 5）处理器定义（controller）
- 6）定义视图
-
- 四：Spring核心技术
-
- 1）请求转发和重定向
-
- 1）请求转发（forward）
- 2）重定向（redirect）
- 2）异常处理
-
- 1）@ExceptionHandler
- 2）@ControllerAdvice
- 3）异常处理步骤：
- 3）拦截器
-
- 1）一个拦截器的执行
-
- 1）拦截器概述
- 2）拦截器的使用步骤
- 3）拦截器的执行时间
- 4）拦截器的三个方法
- 5）拦截器的执行顺序
- 2）多个拦截器的请求
-
- 1）多个拦截器的使用步骤
- 2）多个拦截器的执行顺序
- 3）拦截器和过滤器的区别
一：SpringMVC概述
1.SpringMVC：是基于spring的一个框架，实际上就是spring的一个模块，专门做web开发的。
可以理解为是servlet的一个升级。web开发底层是servlet，框架是在servlet基础上加入一些功能，让你做web开发方便。
SpringMVC就是一个Spring，Spring是容器，通过ioc能够管理对象，使用，或者注解的方式，
@Repository，@Component，@Service，@Controller。SpringMVC能够创建对象，放到容器中（SpringMVC容器），SpringMVC容器中放的是控制器对象。
我们要做的是 使用@Controller创建控制器对象，把对象放入到SpringMVC容器中，把创建的对象作为控制器使用，这个控制器对象能够接收用户的请求，显示处理结果，就当做是一个servlet使用。
使用@Controller注解创建的是一个普通类的对象，不是Servlet。但是SpringMVC赋予了控制器对象一些额外的功能。能够像Servlet一样接收请求，处理结果。
web开发底层是servlet，springMVC中有一个对象是servlet：DispatcherServlet()：叫做中央调度器
DispatcherServlet：负责接收用户的所有请求，用户把请求给了DispatcherServlet，之后DispatcherServlet把请求转发给我们Controller对象，最后是Controller对象处理请求。
index.jsp---->DispatcherServlet---->转发，分配给—>Controller对象（@Controller注解创建的对象）
1）第一个springMVC项目
需求：用户在页面发起一个请求，请求交给springMVC的控制器对象，
并显示请求处理结果（在结果页面显示一个欢迎语句）。
实现步骤：
1.新建web maven工程
2.加入依赖
spring-webmvc依赖，间接的把spring的依赖都加入到项目。
jsp，servlet依赖。
pom.xml：
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webmvcartifactId>
<version>5.2.5.RELEASEversion>
dependency>
<dependency>
<groupId>javax.servletgroupId>
<artifactId>javax.servlet-apiartifactId>
<version>4.0.1version>
<scope>providedscope>
dependency>
<dependency>
<groupId>javax.servlet.jspgroupId>
<artifactId>jsp-apiartifactId>
<version>2.1version>
<scope>providedscope>
dependency>
3.重点：在web.xml文件中注册springmvc框架的核心对象DispatcherServlet。
1）DispatcherServlet叫做中央调度器，是一个servlet，它的父类是继承HttpServlet
2）DispatcherServlet也叫做前端控制器（front controller）
3）DispatcherServlet负责接收用户提交的请求，调用其他的控制器对象，并把请求的处理结果显示给用户。
web.xml文件：
<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">
<servlet>
<servlet-name>dispatcherservlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
<init-param>
<param-name>contextConfigLocationparam-name>
<param-value>classpath:springmvc.xmlparam-value>
init-param>
<load-on-startup>1load-on-startup>
servlet>
<servlet-mapping>
<servlet-name>dispatcherservlet-name>
<url-pattern>*.dourl-pattern>
servlet-mapping>
web-app>
4.创建一个发起请求的页面，index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
第一个SpringMVC项目
5.创建控制器类
1）在类的上面加入@Controller注解，创建对象，并放入到springmvc容器中
2）在类中的方法上面加入@RequestMapping注解。
/**
* @Controller 创建控制器对象，对象放在springmvc的容器中
* 位置：在类的上面
* 和spring中讲的@Service，@Component一样
*
* 能处理亲请求的都是控制器（处理器）：myController能处理请求，叫做后端控制器(back controller)
*/
@Controller
public class MyController {
/*
处理用户提交的请求，springMVC中使用方法来处理的。
方法是自定义的，可以有多种返回值，多种参数，方法名称自定义。
*/
/**
* 准备使用doSome方法处理some.do的请求
* @RequestMapping 请求映射，作用是把一个请求地址和一个方法绑定在一起。
* 一个请求指定一个方法处理
* 属性：1.value 是一个String，表示请求的uri地址的(some.do)。
* value的值必须是唯一的，不能重复。在使用时，推荐地址以"/"开头
* 位置：1.在方法的上面，常用的。
* 2.在类上面
*
* 说明：使用RequestMapping修饰的方法叫做处理器方法或者控制器方法。
* 使用@RequestMapping修饰的方法可以处理请求的，类似Servlet中的doGet，doPost
*
* 返回值：ModelAndView 表示本次请求的处理结果
* Model：数据，请求处理完成后，要显示给用户的数据
* View：视图，比如jsp等等。
* @return
*/
@RequestMapping(value = "/some.do")
public ModelAndView doSome(){
System.out.println("doSome方法执行了");
//在这里就可以处理some.do的请求了。
ModelAndView mv = new ModelAndView();
//添加数据，框架在请求的最后把数据放入到request作用域中。
//相当于request.setAttribute("msg","欢迎使用springmvc做web开发");
mv.addObject("msg","欢迎使用springmvc做web开发");
//指定视图
//框架对视图执行的forward操作，相当于是 request.getRequestDispather("/show.jsp").forward(..);
//当配置了视图解析器后，可以使用逻辑名称(文件名)，指定视图。
//框架会使用视图解析器的前缀 + 逻辑名称 + 后缀 组成完整的路径，这里就是字符串连接操作。
///WEB-INF/view/ + show + .jsp
mv.setViewName("show");
//返回mv
return mv;
}
}
6.创建一个作为结果的jsp，显示请求处理的结果。
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
msg数据：${msg}
7.创建spring的配置文件（spring配置文件一样）
1）声明组件扫描器，指定@Controller注解所在的包名
<context:component-scan base-package="com.sss.controller"/>
2）声明视图解析器：帮助处理视图的。防止恶意访问。
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/view/"/>
<property name="suffix" value=".jsp"/>
bean>
2）SpringMVC请求处理流程
1）用户发起请求some.do
2）tomcat(web.xml–url-pattern知道 *.do的请求是给DispatcherServlet(中央调度器))
3）DispatcherServlet根据springmvc.xml配置文件，知道dome.do—>doSome()方法
4）DispatcherServlet(中央调度器)把some.do转发给MyController.doSome()方法。
5）框架执行doSome()方法，把得到的ModelAndView进行处理，转发到show.jsp
3）spring执行过程源码分析
1.tomcat启动，创建容器的过程
通过load-on-start标签指定的1，创建DisaptcherServlet对象。
DisaptcherServlet它的父类是继承HttpServlet的，它是一个servlet，在被创建时，会执行init()方法。
在init()方法中会执行：
//创建容器，读取配置文件
WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
//把容器对象放入到ServletContext中
getServletContext().setAttribute(key,ctx);
上面创建容器的作用：创建@Controller注解所在的类的对象，也就是创建MyController对象。
这个对象放入到springmvc的容器中，容器是map，类似map.put(“myControll，er”,MyController对象)。
2.请求的处理过程
1）执行servlet的service()
protected void service(HttpServletRequest request, HttpServletResponse response)
protected void doService(HttpServletRequest request, HttpServletResponse response)
DispatcherServlet.doDispatch(request, response){
调用MyController的.doSome()方法
}
doDispatch：springmvc中DispatcherServlet的核心方法， 所有的请求都在这个方法中完成的。
4）SpringMVC的执行流程
流程图：
执行流程简单分析：
（1）浏览器提交请求到中央调度器
（2）中央调度器直接将请求转给处理器映射器。
（3）处理器映射器会根据请求，找到处理该请求的处理器，并将其封装为处理器执行链(HandlerExecutionChain)后返回给中央调度器。
HandlerExecutionChain：类中保存着：1.处理器对象(MyController) 2.项目中所有的拦截器List
（4）中央调度器根据处理器执行链中的处理器，找到能够执行该处理器的处理器适配器。
（5）处理器适配器调用执行处理器。
（6）处理器将处理结果及要跳转的视图封装到一个对象 ModelAndView 中，并将其返回给
处理器适配器。
（7）处理器适配器直接将结果返回给中央调度器。
（8）中央调度器调用视图解析器，将 ModelAndView 中的视图名称封装为视图对象。
（9）视图解析器将封装了的视图对象返回给中央调度器
（10）中央调度器调用视图对象，让其自己进行渲染，即进行数据填充，形成响应对象。
（11）中央调度器响应浏览器。
二：SpringMVC注解式开发
1）@RequestMapping 定义请求规则
指定模块名称
多个相关功能对应一个控制器类
/**
* @RequestMapping
* value：所有请求地址的公共部分，叫做模块名称
* 位置：放在类上面
*/
@RequestMapping(value = "/test")
@Controller
public class MyController {
@RequestMapping(value = "/some.do")
public ModelAndView doSome(){
ModelAndView mv = new ModelAndView();
//添加数据
mv.addObject("msg","欢迎使用springmvc做web开发");
//指定视图
mv.setViewName("show");
return mv;
}
@RequestMapping(value = "/other.do")
public ModelAndView doOther(){
ModelAndView mv = new ModelAndView();
mv.addObject("msg","欢迎使用springmvc做web开发!!!");
mv.setViewName("show");
return mv;
}
}
2）method属性
对于@RequestMapping，其有一个属性 method，用于对被注解方法所处理请求的提交
方式进行限制，即只有满足该 method 属性指定的提交方式的请求，才会执行该被注解方法。
Method 属性的取值为 RequestMethod 枚举常量。常用的为 RequestMethod.GET 与
RequestMethod.POST，分别表示提交方式的匹配规则为 GET 与 POST 提交。
@RequestMapping(value = "/test")
@Controller
public class MyController {
/**
* @RequestMapping 请求映射
* 属性：method，表示请求的方式，它的值是RequestMethod类枚举值
* 例如表示get请求方式，RequestMethod.GET，post方式，RequestMethod.POST
* 不指定请求方式，就没有限制。
*/
//指定some.do使用get请求方式
@RequestMapping(value = "/some.do",method = RequestMethod.GET)
public ModelAndView doSome(){
ModelAndView mv = new ModelAndView();
//添加数据
mv.addObject("msg","欢迎使用springmvc做web开发");
//指定视图
mv.setViewName("show");
return mv;
}
}
以上处理器方法只能处理 POST 方式提交的请求。客户端浏览器常用的请求方式，及其
提交方式有以下几种：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ag9ChO9w-1597502002544)(E:\桌面\总结知识点及案例及帮助文档\Snipaste_2020-08-01_12-54-20.png)]
3）处理器方法的参数
处理器方法可以包含以下四类参数，这些参数会在系统调用时由系统自动赋值，即程序
员可在方法内直接使用。
➢ HttpServletRequest
➢ HttpServletResponse
➢ HttpSession
➢ 请求中所携带的请求参数（用户提交的参数）
1）逐个参数接收
@RequestMapping(value = "/test")
@Controller
public class MyController {
/**
* 逐个接收请求参数：
* 要求：处理器方法的形参名和请求参数中参数名相同，同名的请求参数赋值给同名的形参
*
* 框架接收请求参数
* 1.使用request对象接收请求参数
* String strName = request.getParameter("myname");
* String strAge = request.getParameter("myage");
* 2.springmvc框架通过DispatcherServlet 调用 MyControlle的doSome()
* 调用方法时，按名称对应，把接收的参数赋值给形参
* doSome(strName,Integer.valueOf(strAge));
* 框架会提供类型转换的功能，能把String转为int,long,float,double类型。
*/
@RequestMapping(value = "/some.do",method = RequestMethod.POST)
public ModelAndView doSome(String name,Integer age){
ModelAndView mv = new ModelAndView();
//添加数据
mv.addObject("myname",name);
mv.addObject("myage",age);
System.out.println(name);
System.out.println(age);
//指定视图
mv.setViewName("show");
return mv;
}
}
2）校正请求参数名@RequestParam
/**
* 请求参数名和处理器方法的形参名不一样
* @RequestParm 解决请求中参数名和形参名不一样的问题。
* 属性：1.value 请求中的参数名称
* 2.required 是一个布尔类型，默认是true
* true：表示请求中必须包含此参数。如果没有参数，直接报错400
* false：表示请求中没有包含此参数，也不会报错。
* 位置：在处理方法的形参定义的前面
*/
@RequestMapping(value = "/other.do",method = RequestMethod.POST)
public ModelAndView doOther(@RequestParam(value = "rname")String name,
@RequestParam(value = "rage") Integer age){
ModelAndView mv = new ModelAndView();
//添加数据
mv.addObject("myname",name);
mv.addObject("myage",age);
//指定视图
mv.setViewName("show");
return mv;
}
3）对象接收参数
/**
* 处理器方法形参是java对象，要求这个对象的属性名和请求中参数名一样的。
* 框架会创建形参的java对象，给属性赋值，请求中的参数是name，框架会调用setName()
*/
@RequestMapping(value = "/three.do",method = RequestMethod.POST)
public ModelAndView doThree(Student myStudent){
ModelAndView mv = new ModelAndView();
//添加数据
mv.addObject("myname",myStudent.getName());
mv.addObject("myage",myStudent.getAge());
//指定视图
mv.setViewName("show");
return mv;
}
4）过滤器解决post方式乱码
过滤器可以自定义，也可以使用框架中提供的过滤器 CharacterEncodingFilter
使用框架提供的过滤器：
web.xml文件中：
<filter>
<filter-name>characterEncodingFilterfilter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
<init-param>
<param-name>encodingparam-name>
<param-value>utf-8param-value>
init-param>
<init-param>
<param-name>forceRequestEncodingparam-name>
<param-value>trueparam-value>
init-param>
<init-param>
<param-name>forceResponseEncodingparam-name>
<param-value>trueparam-value>
init-param>
filter>
<filter-mapping>
<filter-name>characterEncodingFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
5）处理器方法的返回值
使用@Controller 注解的处理器的处理器方法，其返回值常用的有四种类型：
➢ 第一种：ModelAndView
➢ 第二种：String
➢ 第三种：无返回值 void
➢ 第四种：返回自定义类型(Object)对象
1）ModelAndView作为返回值：
有数据和视图，对视图执行forward
…
2）String作为返回值：
表示视图，可以是逻辑名称，也可以是完整视图路径，需要配置视图解析器
注意：如果是完整视图路径，不可以配置视图解析器。
/**
* 处理方法返回String--表示逻辑视图名称，需要配置视图解析器
*/
@RequestMapping(value = "/returenString-view.do",method = RequestMethod.POST)
public String doSome(String name,Integer age){
System.out.println(name);
System.out.println(age);
//show ：逻辑视图名称，项目中配置了视图解析器。
//框架对视图执行的是forward转发操作。
return "show";
}
springMVC配置文件中：设置视图解析器
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/view/"/>
<property name="suffix" value=".jsp"/>
bean>
3）返回void:
不能表示数据，也不能表示视图。
在处理ajax的时候，可以使用void返回值。通过HttpServletResponse输出数据，响应ajax请求。
ajax请求服务器端返回的就是数据，和视图无关
控制器方法：
/**
* 处理方法返回void，处理ajax请求
*/
@RequestMapping(value = "/returenVoid-ajax.do")
public void doSome2(String name, Integer age, HttpServletResponse response) throws IOException {
//处理ajax，使用json做数据的格式
//就当service调用完后了，使用Student表示处理结果
Student student = new Student();
student.setName(name);
student.setAge(age);
String json = "{}";
//将java对象转为json格式的数据
if (student != null){
ObjectMapper om = new ObjectMapper();
json = om.writeValueAsString(student);
System.out.println("Student转换的json==》"+json);
}
//输出数据，响应ajax请求
response.setContentType("application/json;charset=utf-8");
PrintWriter pw = response.getWriter();
pw.print(json);
pw.flush();
pw.close();
}
ajax：
<script type="text/javascript">
/*入口*/
$(function () {
$("#bth").click(function () {
$.ajax({
url:"test/returenVoid-ajax.do",
data:{
name:"zhangsan",
age:"20"
},
dataType:"json",
success:function (resp) {
//resp从服务器返回的是json格式的字符串，{"name":"zhangsan","age":20}
//jquery会把字符串转为json对象，赋值给resp形参。
alert(resp.name + resp.age);
}
})
})
})
</script>
处理json数据需要用到jackson依赖：
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-coreartifactId>
<version>2.9.0version>
dependency>
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-databindartifactId>
<version>2.9.0version>
dependency>
4）返回对象 Object
处理器方法也可以返回 Object 对象。这个 Object 可以是 Integer，String，自定义对象，
Map，List 等。但返回的对象不是作为逻辑视图出现的，而是作为直接在页面显示的数据出
现的。
返回对象，需要使用@ResponseBody 注解，将转换后的 JSON 数据放入到响应体中
返回Object，例如String Integer Map List Student等都是对象
对象有属性，属性就是数据，所以返回Object表示数据，和视图无关。
可以使用对象表示的数据，响应ajax的请求。
现在做ajax，注意使用json的数据格式，实现步骤：
1.加入处理json的工具库的依赖，springMVC默认使用的是jackson。
2.在springMVC配置文件中加入 注解驱动。
3.在处理器方法的上面加入@ResponseBody注解
springMVC处理器方法返回Object，可以转换为json输出到浏览器，响应Ajax的内部原理
1. /**
* 处理器方法返回一个Student，通过框架转为json，响应ajax请求
* @ResponseBody
* 作用：把处理器方法返回的对象转为json后，通过HttpServletResponse输出给浏览器。
* 位置在方法的定义上面，和其他注解没有顺序的先后关系。
*
* 返回对象框架的处理流程：
* 1.框架会把返回的Stduen类型，调用框架中的ArrayList集合中每个类的canWrite()
* 来检查那个HttpMessageConverter(消息转换器)接口的实现类能处理Student类型的数据。
* 2.框架会调用实现类的write()，MappingJackson2HttpMessageConverter的write()方法，
* 把张三同学的Student对象转为json，调用jackson的ObjectMapper实现转为json。
* 3.框架会调用@ResponseBody把结果数据输出到浏览器，ajax请求处理完成。
*/
@RequestMapping(value = "/returenStudent-ajax.do")
@ResponseBody
public Student doStudentJsonObejce(String name, Integer age, HttpServletResponse response) {
System.out.println("returenStudent-ajax.do");
//调用service，获取请求结果数据，studen对象就表示处理结果数据
Student student = new Student();
student.setName(name);
student.setAge(age);
return student; //会被框架转为json
}
5）返回List集合
控制器：
/**
* 处理器方法返回List
* 处理流程和上面返回json数据是一样的
*/
@RequestMapping(value = "/returenStudentArray-ajax.do")
@ResponseBody
public List<Student> doStudentJsonObejceArray(String name, Integer age) {
List<Student> list = new ArrayList<>();
//调用service，获取请求结果数据，studen对象就表示处理结果数据
Student student = new Student();
student.setName("张三");
student.setAge(23);
list.add(student);
student = new Student();
student.setName("李四");
student.setAge(20);
list.add(student);
return list; //会被框架转为json对象数组
}
jsp：
<script type="text/javascript">
/*入口*/
$(function () {
$("#bth").click(function () {
$.ajax({
url:"test/returenStudentArray-ajax.do",
data:{
name:"张三",
age:"20"
},
dataType:"json",
success:function (resp) {
//[{"name":"张三","age":23},{"name":"李四","age":20}] resp现在是json对象数组
//循环输出
$.each(resp,function (i,n) {
alert(n.name+" "+n.age);
})
}
})
})
})
</script>
6）返回值是字符串
若要返回非中文字符串，将前面返回数值型数据的返回值直接修改为字符串即可。但若
返 回 的 字 符 串 中 带 有 中 文 字 符 ， 则 接 收 方 页 面 将 会 出 现 乱 码 。 此 时 需 要 使 用
@RequestMapping 的 produces 属性指定字符集。
produces，产品，结果，即该属性用于设置输出结果类型
/**
* 处理器方法返回的是String，String表示数据的，不是视图
* 区分返回值String是数据，还是视图，看有没有@ResponseBody注解
* 如果有@ResponseBody注解，返回的是数据，反之就是视图
*
* 默认使用"text/plain;charset=ISO-8859-1"作为ConType，导致中文有乱码
* 解决方案：
* 使用 @RequestMapping 的 produces 属性指定字符集。
* produces，产品，结果，即该属性用于设置输出结果类型。"text/plain;charset=utf-8"
*/
@RequestMapping(value = "/returenString-ajax.do",produces = "text/plain;charset=utf-8")
@ResponseBody
public String doString(String name, Integer age) {
return "Hello SpringMVC 李四"; //会被框架转为json
}
<script type="text/javascript">
/*入口*/
$(function () {
$("#bth").click(function () {
$.ajax({
url:"test/returenString-ajax.do",
data:{
name:"张三",
age:"20"
},
dataType:"text",
success:function (resp) {
alert("返回的是文本数据"+resp);
}
})
})
})
</script>
6）解读
保持的值为 *.do，扩展名方式，图片会正常显示。
将的值修改为 / ，则图片将无法显示。
1）处理静态资源的方式：
web.xml文件：
<servlet>
<servlet-name>dispatcherservlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
<init-param>
<param-name>contextConfigLocationparam-name>
<param-value>classpath:springmvc.xmlparam-value>
init-param>
<load-on-startup>1load-on-startup>
servlet>
<servlet-mapping>
<servlet-name>dispatcherservlet-name>
<url-pattern>/url-pattern>
servlet-mapping>
springMVC配置文件：第一种处理静态资源的方式
<mvc:default-servlet-handler/>
springMVC配置文件：第二种处理静态资源的方式：(常用)
<mvc:resources mapping="/img/**" location="/img/"/>
<mvc:resources mapping="/js/**" location="/js/"/>
2）一条配置处理所有的静态资源
新建一个static目录，把所有的静态资源放进去。
<mvc:resources mapping="/static/**" location="/static/"/>
3）相对路径和绝对路径
在jsp和html中使用的地址，都是在前端页面中的地址，都是相对地址
地址分类：
1.绝对地址，带有协议名称的是绝对地址，http://www.baidu.com，ftp://202.122.23.1
2.相对地址，没有协议开头的，例如：user/some.do，/user/some.do，相对地址不能独立使用，必须有一个参考地址，通过参考地址+相对地址本身才能指定资源。
3.参考地址
在你的页面中，访问地址不加"/"
访问的是：http://localhost:8080/ch06_path/index.jsp
路径：http://localhost:8080/ch06_path/
资源：index.jsp
在index.jsp发起 test/some.do请求，访问地址变为：http://localhost:8080/ch06_path/test/some.do
当你的地址没有斜杠开头，例如：test/some.do，当你点击这个连接时，访问地址是当前页面的地址，加上你连接的地址。http://localhost:8080/ch06_path/ + user/some.do
访问地址不加"/" 也会有一定的错误，解决方案：
1.加入${pageContext.request.contextPath}
2.在头部加入一个base标签，是html语言中的标签，表示当前页面中访问地址的基地址。
你的页面中所有，没有 ”/“ 开头的地址，都是以base标签中的地址为参考地址。
使用base中的地址 + test/some.do 组成访问地址
静态获取基地址：
Title
动态获取基地址：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
String basePath = request.getScheme() + "://" +
request.getServerName() + ":" + request.getServerPort() +
request.getContextPath() + "/";
%>
Title
在你的页面中，访问地址加"/"
访问的是：http://localhost:8080/ch06_path/index.jsp
路径：http://localhost:8080/ch06_path/
资源：index.jsp
在index.jsp发起 /test/some.do请求，访问地址变为：http://localhost:8080/test/some.do
此时你的参考地址就是你的服务器地址：http://localhost:8080
在使用 ”/“ 的时候，可以使用：EL表达式解决这个问题。
pageContext.request.contextPath：代表的是项目名称。
发起some.do请求
三：SSM整合开发
ssm：SpringMVC + Spring + MyBatis
SpringMVC：视图层，界面层，负责接收请求，显示处理结果的。
Spring：业务层，管理service，dao，工具类对象的。
MyBatis：持久层，用来访问数据库的。
用户发起请求–springMVC接收请求–Spring中的service对象处理业务–MyBatis处理数据
ssm整合也叫ssi（IBatis也就是myBatis的前身），整合中有容器。
1.第二个容器SpringMVC容器，管理Controller控制器对象的。
2.第二个容器Spring容器，管理service,dao工具类对象的。
我们要做的是把使用的对象交给合适的容器创建管理，把Controller还有web开发的相关对象，
交给springmvc容器，这些web用的对象写在springmvc配置文件中。
SpringMVC容器和Spring容器是有关系的，关系已经确定好了。
SpringMVC容器是Spring容器的子容器，类似于java中的继承。
子可以访问父的内容，在子容器中的Controller可以访问父容器中的service对象，
就可以实现Controller使用service对象。
实现步骤：
0.使用springdb库中的student表。
1.新建maven项目
2.加入依赖
springmvc，spring，mybatis三个框架的依赖，jackson依赖，MySQL驱动，druid连接池
jsp，servlet依赖
3.写web.xml文件
1）注册DispatcherServlet（中央调度器）目的，1.创建springmvc容器对象，才能创建Controller类的对象
2.创建的是Servlet，才能接收用户的请求。
2）注册spring的监听器：ContextLoaderListener，目的：创建spring容器，才能创建service，dao等对象。
3）注册字符集过滤器，解决post请求乱码的问题。
4.创建包，Controller包，service包，dao，实体类
5.写springmvc，spring，myBatis，数据库，配置文件
6.写代码，dao接口和mapper文件，service和实体类
7.写jsp文件。
实现步骤：
1）加入依赖：pom.xml
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.11version>
<scope>testscope>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webmvcartifactId>
<version>5.2.5.RELEASEversion>
dependency>
<dependency>
<groupId>javax.servletgroupId>
<artifactId>javax.servlet-apiartifactId>
<version>4.0.1version>
<scope>providedscope>
dependency>
<dependency>
<groupId>javax.servlet.jspgroupId>
<artifactId>jsp-apiartifactId>
<version>2.1version>
<scope>providedscope>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.5.5version>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatis-springartifactId>
<version>1.3.1version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>5.1.49version>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>5.2.5.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-txartifactId>
<version>5.2.5.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-jdbcartifactId>
<version>5.2.5.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webartifactId>
<version>5.2.5.RELEASEversion>
dependency>
<dependency>
<groupId>com.alibabagroupId>
<artifactId>druidartifactId>
<version>1.1.12version>
dependency>
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-coreartifactId>
<version>2.9.0version>
dependency>
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-databindartifactId>
<version>2.9.0version>
dependency>
2）定义包，组织程序的结构
entity，dao，controller，service
3）编写配置文件：
jdbc.properteis
jdbc.url=jdbc:mysql://localhost:3306/springdb
jdbc.user=root
jdbc.password=999
applicationContext配置文件：spring配置文件：
<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"
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">
<context:component-scan base-package="com.sss.service"/>
<context:property-placeholder location="classpath:jdbc.properties"/>
<bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
init-method="init" destroy-method="close">
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.user}"/>
<property name="password" value="${jdbc.password}"/>
<property name="maxActive" value="20"/>
bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="myDataSource"/>
<property name="configLocation" value="classpath:myBatis.xml"/>
bean>
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
<property name="basePackage" value="com.sss.dao"/>
bean>
beans>
springMVC配置文件:
<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.sss.controller"/>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/view/"/>
<property name="suffix" value=".jsp"/>
bean>
<mvc:annotation-driven/>
<mvc:resources mapping="/static/**" location="/static/"/>
beans>
MyBatis配置文件：
<configuration>
<mappers>
<package name="com.sss.dao"/>
mappers>
configuration>
4）web.xml文件：
<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">
<servlet>
<servlet-name>dispatcherservlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
<init-param>
<param-name>contextConfigLocationparam-name>
<param-value>classpath:springmvc.xmlparam-value>
init-param>
<load-on-startup>1load-on-startup>
servlet>
<servlet-mapping>
<servlet-name>dispatcherservlet-name>
<url-pattern>/url-pattern>
servlet-mapping>
<context-param>
<param-name>contextConfigLocationparam-name>
<param-value>classpath:applicationContext.xmlparam-value>
context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
listener-class>
listener>
<filter>
<filter-name>characterEncodingFilterfilter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
<init-param>
<param-name>encodingparam-name>
<param-value>utf-8param-value>
init-param>
<init-param>
<param-name>forceRequestEncodingparam-name>
<param-value>trueparam-value>
init-param>
<init-param>
<param-name>forceResponseEncodingparam-name>
<param-value>trueparam-value>
init-param>
filter>
<filter-mapping>
<filter-name>characterEncodingFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
web-app>
5）处理器定义（controller）
@Controller
public class StudentController {
@Autowired
private StudentService studentService;
/**注册学生信息*/
@RequestMapping(value = "/stuAdd")
public ModelAndView stuInsert(Student student){
ModelAndView am = new ModelAndView();
int count = studentService.stuInsert(student);
if (count > 0){
am.addObject("msg","注册成功！");
am.setViewName("sucsess");
}else {
am.addObject("msg","注册失败！");
am.setViewName("fail");
}
return am;
}
/**响应ajax，输出数据，查询方法*/
@RequestMapping(value = "/stuSelect")
@ResponseBody
public List<Student> stuSele(){
List<Student> students = studentService.stuList();
for (Student student: students){
System.out.println(student);
}
return students;
}
}
6）定义视图
首页：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
String basePath = request.getScheme() + "://" +
request.getServerName() + ":" + request.getServerPort() +
request.getContextPath() + "/";
%>
Title
SSM整合开发-实现Student表的操作
查询学生信息
查询学生信息2
注册学生信息
注册界面：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
四：Spring核心技术
1）请求转发和重定向
注意，对于请求转发的页面，可以是WEB-INF中页面；而重定向的页面，是不能为WEB-INF
中页的。因为重定向相当于用户再次发出一次请求，而用户是不能直接访问 WEB-INF 中资
源的。
1）请求转发（forward）
处理器方法返回 ModelAndView 时，需在 setViewName()指定的视图前添加 forward:，且
此时的视图不再与视图解析器一同工作，这样可以在配置了解析器时指定不同位置的视图。
**视图页面必须写出相对于项目根的路径。**forward 操作不需要视图解析器。
处理器方法返回 String,在视图路径前面加入 forward: 视图完整路径。
/**
* 处理器方法返回ModelAndView，实现转发forward
* 语法：setViewName("forward:视图文件完整路径");
* forward特点：不和视图解析器一同使用，就当项目中没有视图解析器。
*/
@RequestMapping(value = "/some.do")
public ModelAndView doSome(String name,Integer age){
ModelAndView mv = new ModelAndView();
//添加数据
mv.addObject("msg","欢迎使用springmvc做web开发");
//指定视图
//加forward，是显示转发
//mv.setViewName("forward:/WEB-INF/view/show.jsp");
mv.setViewName("forward:/hello.jsp");
return mv;
}
2）重定向（redirect）
/**
* 处理器方法返回ModelAndView，实现重定向redirect
* 语法：setViewName("redirect:视图完整路径");不能使用逻辑视图名称。
* redirect特点：不和视图解析器一同使用，就当项目中没有视图解析器。
*
* 框架对重定向的操作：
* 1.框架会把Model中的简单类型的数据，转为String使用，作为hello.jsp的get请求参数使用。
* 并显示在地址栏，目的是在other.do 和 hello.jsp 两次请求之间传递数据。
* 2.在目标hello.jsp页面可以使用参数集合对象${param}获取请求参数值
* ${param.myname}
*/
@RequestMapping(value = "/other.do")
public ModelAndView doOther(String name,Integer age){
ModelAndView mv = new ModelAndView();
mv.addObject("msg","欢迎使用springmvc做web开发!!!");
//重定向不能访问受保护的WEB-INF目录下的资源
//mv.setViewName("redirect:/WEB-INF/view/show.jsp");
//重定向
mv.setViewName("redirect:/hello.jsp");
return mv;
}
name数据：${param.myname}
age数据：${param.myage}
取参数数据：<%=request.getParameter("myage")%>
2）异常处理
springMVC框架采用的是统一，全局的异常处理。
把controller中所有的异常处理都集中到一个地方，采用的aop的思想。把业务逻辑和异常处理代码分开，解耦合。
使用两个注解：
1）@ExceptionHandler
使用注解@ExceptionHandler 可以将一个方法指定为异常处理方法。该注解只有一个可
选属性 value，为一个 Class数组，用于指定该注解的方法所要处理的异常类，即所要匹
配的异常。
而被注解的方法，其返回值可以是 ModelAndView、String，或 void，方法名随意，方法
参数可以是 Exception 及其子类对象、HttpServletRequest、HttpServletResponse 等。系统会
自动为这些方法参数赋值。
对于异常处理注解的用法，也可以直接将异常处理方法注解于 Controller 之中。
2）@ControllerAdvice
3）异常处理步骤：
新建maven项目，配置web.xml，pom.xml省略
1.新建一个自定义异常类，MyUserException，再定义它的子类NameException，AgeException
2.在controller中抛出NameExcepetion，AgeException
3.创建一个普通类，作为全局异常处理类。
1）在类的上面加入@ControllerAdvice
2）在类中定义方法，方法的上面加入@ExceptionHandler
4.创建处理异常的视图页面
5.创建springmvc的配置文件
1）组件扫描器，扫描@Controller注解
2）组件扫描器，扫描@ControllerAdvice所在的包
3）声明注解驱动
自定义异常类：
//父异常类
public class MyUserExcepetion extends Exception {
public MyUserExcepetion() {
super();
}
public MyUserExcepetion(String message) {
super(message);
}
}
controller中抛出异常：
@RequestMapping(value = "/test")
@Controller
public class MyController {
@RequestMapping(value = "/some.do")
public ModelAndView doSome(String name,Integer age) throws MyUserExcepetion {
ModelAndView mv = new ModelAndView();
//根据请求参数，抛出异常
if (!"zs".equals(name)){
throw new NameExcepetion("姓名不正确");
}
if (age == null || age > 80){
throw new AgeException("年龄比较大了");
}
//添加数据
mv.addObject("myName",name);
mv.addObject("myAge",age);
//指定视图
mv.setViewName("show");
return mv;
}
}
定义异常响应页面：
nameError.jsp
提示信息：${msg}
系统异常消息：${exception.message}
定义全局异常处理类：
/**
* @ControllerAdvice 控制器增强（也就是说给控制器类增加功能，增加的是异常处理功能）
* 位置：在类的上面
* 特点：必须让框架知道这个注解所在的包名，需要在springmvc配置文件中声明组件扫描器。
* 指定@ControllerAdvice所在的包名。
*/
@ControllerAdvice
public class GlobalExcepetionHandler {
//定义方法，处理发生的异常
/**
* 处理异常的方法和控制器方法的定义一样，可以有多个参数，可以有ModelAndView，String
* void，对象类型的返回值
*
* 形参：Exception 表示Controller中抛出的异常对象。
* 通过形参可以获取发生的异常信息。
*
* @ExceptionHandler (异常的class)：表示异常的类型，当发生此类型异常时，
* 由当前方法处理。
*
* 位置：方法的上面
*/
@ExceptionHandler(value = NameExcepetion.class)
public ModelAndView doNameExcepetion(Exception ex){
//处理NameException的异常
/*
异常发生处理逻辑：
1.需要把异常记录下来，记录到数据库，或者是日志文件。
记录异常发生的时间，那个方法发生的，还有异常的错误内容。
2.发送通知，把异常的信息通过邮件，短信，微信发送给相关人员。
3.给用户友好的提示
*/
ModelAndView mv = new ModelAndView();
mv.addObject("msg","姓名必须是张三！");
mv.addObject("exception",ex);
mv.setViewName("nameError");
return mv;
}
@ExceptionHandler(value = AgeException.class)
public ModelAndView doAgeExcepetion(Exception ex){
//处理NameException的异常
/*
异常发生处理逻辑：
1.需要把异常记录下来，记录到数据库，或者是日志文件。
记录异常发生的时间，那个方法发生的，还有异常的错误内容。
2.发送通知，把异常的信息通过邮件，短信，微信发送给相关人员。
3.给用户友好的提示
*/
ModelAndView mv = new ModelAndView();
mv.addObject("msg","您的年龄不能大于80！");
mv.addObject("exception",ex);
mv.setViewName("nameError");
return mv;
}
/**
* 处理其他异常，NameException，AgeException以外，不知类型的异常。
* @ExceptionHandler 后边不加value
*/
@ExceptionHandler
public ModelAndView doOtherExcepetion(Exception ex){
//处理其他异常
ModelAndView mv = new ModelAndView();
mv.addObject("msg","出现异常！");
mv.addObject("exception",ex);
mv.setViewName("defaultError");
return mv;
}
}
定义SpringMVC配置文件：
<context:component-scan base-package="com.sss.controller"/>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/view/"/>
<property name="suffix" value=".jsp"/>
bean>
<context:component-scan base-package="com.sss.handler"/>
<mvc:annotation-driven/>
3）拦截器
1）一个拦截器的执行
1）拦截器概述
SpringMVC 中的 Interceptor 拦截器是非常重要和相当有用的，它的主要作用是拦截指定Java 框架 SpringMVC
的用户请求，并进行相应的预处理与后处理。其拦截的时间点在“处理器映射器根据用户提交的请求映射出了所要
执行的处理器类，并且也找到了要执行该处理器类的处理器适配器，在处理器适配器执行处理器之前”。当然，在
处理器映射器映射出所要执行的处理器类时，已经将拦截器与处理器组合为了一个处理器执行链，并返回给了中央
调度器。
拦截器：
1）是SpringMVC中的一种，需要实现HandlerInterceptor接口。
2）拦截器和过滤器类似，功能方向侧重点不同。
过滤器是用来过滤请求参数，设置编码字符集等工作的。
拦截器是拦截用户的请求，对请求做判断处理的。
3）拦截器是全局的，可以多个Controller做拦截。
一个项目中可以有0个或者多个拦截器，他们在一起拦截用户的请求。
拦截器常用在：用户的登录处理，权限的检查，记录日志。
2）拦截器的使用步骤
1.定义类实现HandlerInterceptor接口，并重写接口中的三个方法。
public class MyInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//计算得业务逻辑，根据计算结果，返回true或者false。
System.out.println("拦截器的preHandle方法");
return true;
}
@Override
public void postHandle(HttpServletRequest request,HttpServletResponse response,
Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("拦截的postHandle方法");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) throws Exception {
System.out.println("拦截器的afterCompletion方法");
}
}
2.在springMVC配置文件中，声明拦截器，让框架知道拦截器的存在。
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/test/**"/>
<bean class="com.sss.Interceptor.MyInterceptor"/>
mvc:interceptor>
mvc:interceptors>
3）拦截器的执行时间
1）在请求处理之前，也就是Controller类中的方法执行之前先被拦截。
2）在控制器方法执行之后，也会执行拦截器。
3）在请求处理完成后，也会执行拦截器。
4）拦截器的三个方法
public class MyInterceptor implements HandlerInterceptor {
/**
* preHandle叫做预处理方法
* 重要：是整个项目的入口，门户。preHandle返回true，请求可以被处理。
* preHandle返回false，请求到此方法为止。
* 参数：
* Object handler : 被拦截的控制器对象。
* 返回值：boolean
* true：表示请求是通过了拦截器的验证，可以执行处理器方法。
* false：请求没有通过拦截器的验证，请求到达拦截器就截止了。请求失败
* 特点：
* 1.在控制器方法(MyController)之前先执行的。
* 用户的请求首先到达此方法
* 2.在这个方法中可以获取请求的信息，验证请求是否符合要求。
* 可以验证用户是否登录，验证用户是否有权限访问某个链接地址（url）。
* 如果验证失败，可以截断请求，请求不能被处理。
* 如果验证成功，可以放行请求，此时控制器方法才能执行。
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("拦截器的preHandle方法");
return true;
}
/**
* postHandle：后处理方法
* 参数：
* Object handler : 被拦截的控制器对象。
* ModelAndView modelAndView：处理器方法的返回值
* 特点：
* 1.在处理器方法之后执行的
* 2.能够获取到处理器方法的返回值ModelAndView，可以修改ModelAndView中的
* 数据和视图，可以影响到最后的执行结果。
* 3.主要是对原来的执行结果，做二次修正。
*/
@Override
public void postHandle(HttpServletRequest request,
HttpServletResponse response,
Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("拦截的postHandle方法");
}
/**
* afterCompletion：最后执行的方法
* 参数：
* Object handler：被拦截的对象
* Exception ex：程序中发生的异常
* 特点：
* 1.在请求处理完成后执行的。在框架中规定是当你的视图，处理完成后，对视图执行了forward。就认为请求处理完成。
* 2.一般做资源回收工作的，程序请求过程中创建了一些对象，在这里可以删除，把占有的内存回收。
*/
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) throws Exception {
System.out.println("拦截器的afterCompletion方法");
}
}
5）拦截器的执行顺序
2）多个拦截器的请求
1）多个拦截器的使用步骤
再定义一个拦截器：
public class MyInterceptor2 implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("拦截器的preHandle方法-22222");
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response,
Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("拦截的postHandle方法-22222");
//对原先的doSome执行结果，进行修改
if(modelAndView != null){
//修改数据
modelAndView.addObject("myDate",new Date());
//修改视图
modelAndView.setViewName("other");
}
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) throws Exception {
System.out.println("拦截器的afterCompletion方法-22222");
}
}
springMVC配置文件声明第二个拦截器：
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/test/**"/>
<bean class="com.sss.Interceptor.MyInterceptor"/>
mvc:interceptor>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="com.sss.Interceptor.MyInterceptor2"/>
mvc:interceptor>
mvc:interceptors>
2）多个拦截器的执行顺序
从图中可以看出，只要有一个 preHandle()方法返回 false，则上部的执行链将被断开，
其后续的处理器方法与 postHandle()方法将无法执行。但，无论执行链执行情况怎样，只要
方法栈中有方法，即执行链中只要有 preHandle()方法返回 true，就会执行方法栈中的
afterCompletion()方法。最终都会给出响应。
3）拦截器和过滤器的区别
1.过滤器是servlet规范中的对象，拦截器是框架中的对象
2.过滤器是实现Filter接口的对象，拦截器是实现HandlerInterceptor
3.过滤器是用来设置request，response的参数，属性的，侧重于数据过滤的。
拦截器是用来验证请求的，能截断请求。
4.过滤器是在拦截器之前先执行的。
5.过滤器是tomcat服务器创建的对象，拦截器是springMVC容器创建的对象
6.过滤器有一个执行时间点，拦截器有三个执行时间点。
7.过滤器可以处理jsp，js，html等等。
拦截器是侧重于对Controller的对象，如果你的请求不能被DispatcherServlet接收，这个请求不会执行拦截器的内容等。
8.拦截器拦截普通类方法执行，过滤器过滤servlet请求响应。