【3万字详解】一篇文章搞定SpringMVC框架
文章目录
- 前言
- 第1章 SpringMVC 概述
-
- 1.1 SpringMVC 简介
- 1.2 SpringMVC 优点
- 1.3 SpringMVC 快速入门
-
- 1.3.1 导入Maven依赖
- 1.3.2 配置前端控制器
- 1.3.3 创建 SpringMVC 配置文件
- 1.3.4 创建控制器
- 1.3.5 注册组件扫描器
- 1.3.6 创建show.jsp
- 1.3.7 注册视图解析器
- 1.3.8 使用 SpringMVC 框架 web 请求处理顺序
- 1.4 SpringMVC 的 MVC 组件
- 1.5 SpringMVC 执行流程
- 第2章 SpringMVC 注解开发
-
- 2.1 @RequestMapping 定义请求规则
-
- 2.1.1 指定模块名称
- 2.1.2 请求提交方式
- 2.2 控制器方法的参数
-
- 2.2.1 逐个参数接收
- 2.2.2 请求参数中文乱码问题
-
- （1）解决方案
- （2）源码分析
- 2.2.3 校正请求参数名@RequestParam
- 2.2.4 对象参数接收
- 2.3 处理器方法的返回值
-
- 2.3.1 返回 ModelAndView
- 2.3.2 返回 String
- 2.3.3 返回 Object
-
- （1）环境搭建
- （2）返回自定义类型对象
- （3）返回 List 集合
- （4）返回 String 对象
- 2.4 解读< url-pattern />
-
- 2.4.1 配置详解
-
- （1）*.do
- （2）/
- 2.4.2 静态资源访问
-
- （1）使用< mvc:default-servlet-handler />
- （2）使用< mvc:resources />
- （3）声明注解驱动
- 第3章 SpringMVC 核心技术
-
- 3.1 转发与重定向
-
- 3.1.1 请求转发
- 3.1.2 请求重定向
- 3.2 拦截器
-
- 3.2.1 一个拦截器的执行
-
- （1）注册拦截器
- （2）修改 index 页面
- （3）创建处理器
- （4）创建 show 页面
- （5）控制台输出结果
- 3.2.2 多个拦截器的执行
-
- （1）再定义一个拦截器
- （2）多个拦截器注册与执行
- （3）控制台输出结果
- 3.2.3 权限拦截器举例
-
- （1）修改 index 页面
- （2）创建处理器
- （3）定义 welcome 页面
- （4）定义权限拦截器
- （5）定义 fail 页面
- （6）注册权限拦截器
- （7）定义 login 页面
- （8）定义logout页面
前言
该技术博客是关于动力节点SpringMVC教程的笔记总结，方便自己学习的同时希望能为大家带来帮助！
相关文章推荐 ：
- 【3万字详解】一篇文章搞定Mybatis框架
- 【5万字详解】一篇文章搞定Spring框架
- 【步骤详细】手把手整合Spring + Mybatis
- SSM整合（流程详细）
- 史上最强SpringMVC请求处理流程解析（通俗易懂）
第1章 SpringMVC 概述
1.1 SpringMVC 简介
SpringMVC 也叫 Spring web mvc。是 Spring 框架的一部分，是在 Spring3.0 后发布的。
1.2 SpringMVC 优点
- 基于 MVC 架构：功能分工明确，解耦合
- 使用简单：就可以开发一个注解的 SpringMVC 项目，SpringMVC 也是轻量级的，jar 很小。不依赖的特定的接口和类。
- 作为Spring框架一部分，能 够 使 用 Spring 的 IoC 和 Aop，方便整合 Strtus，MyBatis，Hiberate，JPA 等其他框架。
- SpringMVC 强化注解的使用，在控制器，Service，Dao 都可以使用注解。方便灵活。使用@Controller 创建处理器对象,@Service 创建业务对象，@Autowired 或者@Resource
在控制器类中注入 Service, Service 类中注入 Dao。
1.3 SpringMVC 快速入门
所谓 SpringMVC 的注解式开发是指，在代码中通过对类与方法的注解，便可完成处理器在 springmvc 容器的注册。注解式开发是重点。
完成功能：用户提交一个请求，服务端处理器在接收到这个请求后，给出一条欢迎信息，在响应页面中显示该信息。
1.3.1 导入Maven依赖
在创建好 web 项目后，加入 Servlet 依赖，SpringMVC 依赖
<dependency>
<groupId>javax.servletgroupId>
<artifactId>javax.servlet-apiartifactId>
<version>3.1.0version>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webmvcartifactId>
<version>5.2.5.RELEASEversion>
dependency>
1.3.2 配置前端控制器
<servlet>
<servlet-name>springmvcservlet-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>springmvcservlet-name>
<url-pattern>*.dourl-pattern>
servlet-mapping>
1.3.3 创建 SpringMVC 配置文件
在工程的类路径即 src 目录下创建 SpringMVC 的配置文件 springmvc.xml。该文件名可以任意命名。
1.3.4 创建控制器
在类上与方法上添加相应注解即可
@Controller：表示当前类为处理器
@RequestMapping：表示当前方法为处理器方法。该方法要对 value 属性所指定的 URI 进行处理与响应。被注解的方法的方法名可以随意
//@Controller：创建控制器对象，对象放在springmvc容器中
@Controller
public class MyController {
/**
* 处理用户提交的请求，SpringMVC中使用方法处理
* 方法是自定义的，有多种返回值，多种参数，方法名称自定义
*
* @RequestMapping：请求映射，作用是把请求地址与方法绑定在一起
* 一个请求绑定一个方法
* 属性：1.value：String类型，表示请求的uri地址(some.do)
* value值必须唯一，不能重复
* 在使用时，推荐地址以"/"开头
*
* 使用@RequestMapping修饰的方法叫做：控制器方法
* 使用@RequestMapping修饰的方法可以处理请求，类似于Servlet中的doGet,doPost
*
* 返回值：ModelAndView 表示本次请求的处理结果
* Model：数据，请求处理完成后，要显示给用户的数据
* View：视图，比如jsp等
*/
@RequestMapping(value = "some.do")
public ModelAndView doSome(){
//处理some.do请求。service层调用完成
ModelAndView mv = new ModelAndView();
//添加数据，框架在请求的最后把数据放入到request作用域
//request.setAttribute("msg","欢迎使用SpringMVC做web开发");
mv.addObject("msg","欢迎使用SpringMVC做web开发");
mv.addObject("fun","执行的是doSome方法");
//指定视图，指定视图的完整路径
//框架对视图执行转发操作：request.getRequestDispatcher("/show.jsp").forward(req,resp);
//mv.setViewName("/WEB-INF/jsp/show.jsp");
//配置了视图解析器后，可以使用文件名称指定视图
mv.setViewName("show");
return mv;
}
}
若有多个请求路径均可匹配该处理器方法的执行，则@RequestMapping 的 value 属性中可以写上一个数组。
ModelAndView 类中的 addObject()方法用于向其 Model 中添加数据。Model 的底层为一个 HashMap。
Model 中的数据存储在 request 作用域中，SringMVC 默认采用转发的方式跳转到视图，本次请求结束，模型中的数据被销毁。
1.3.5 注册组件扫描器
在 springmvc.xml 中注册组件扫描器
<context:component-scan base-package="com.xu.controller"/>
1.3.6 创建show.jsp
在 webapp 目录下新建一个子目录 jsp，在其中新建一个 jsp 页面：show.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Titletitle>
head>
<body>
<h3>从request作用域获取数据h3>
<br>
<h3>msg数据：${msg}h3>
<br>
<h3>fun数据：${fun}h3>
body>
html>
1.3.7 注册视图解析器
SpringMVC 框架为了避免对于请求资源路径与扩展名上的冗余，在视图解析器 InternalResouceViewResolver 中引入了请求的前辍与后辍。而 ModelAndView 中只需给出要跳转页面的文件名即可，对于具体的文件路径与文件扩展名，视图解析器会自动完成拼接。
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/"/>
<property name="suffix" value=".jsp"/>
bean>
1.3.8 使用 SpringMVC 框架 web 请求处理顺序
1.4 SpringMVC 的 MVC 组件
1.5 SpringMVC 执行流程
- 浏览器提交请求到中央调度器
- 中央调度器直接将请求转给处理器映射器。
- 处理器映射器会根据请求，找到处理该请求的处理器，并将其封装为处理器执行链后返回给中央调度器。
- 中央调度器根据处理器执行链中的处理器，找到能够执行该处理器的处理器适配器。
- 处理器适配器调用执行处理器。
- 处理器将处理结果及要跳转的视图封装到一个对象 ModelAndView 中，并将其返回给处理器适配器。
- 处理器适配器直接将结果返回给中央调度器。
- 中央调度器调用视图解析器，将 ModelAndView 中的视图名称封装为视图对象。
- 视图解析器将封装了的视图对象返回给中央调度器
- 中央调度器调用视图对象，让其自己进行渲染，即进行数据填充，形成响应对象。
- 中央调度器响应浏览器。
第2章 SpringMVC 注解开发
2.1 @RequestMapping 定义请求规则
2.1.1 指定模块名称
通过@RequestMapping 注解可以定义处理器对于请求的映射规则。该注解可以注解在方法上，也可以注解在类上，但意义是不同的。value 属性值常以“/”开始。
@RequestMapping 的 value 属性用于定义所匹配请求的 URI。但对于注解在方法上与类上，其 value 属性所指定的 URI，意义是不同的。
一个@Controller 所注解的类中，可以定义多个处理器方法。当然，不同的处理器方法所匹配的 URI 是不同的。这些不同的 URI 被指定在注解于方法之上的@RequestMapping 的 value 属性中。但若这些请求具有相同的 URI 部分，则这些相同的 URI，可以被抽取到注解在类之上的@RequestMapping 的 value 属性中。此时的这个 URI 表示模块的名称。URI 的请求是相对于 Web 的根目录。
换个角度说，要访问处理器的指定方法，必须要在方法指定 URI 之前加上处理器类前定义的模块名称
/**
* @RequestMapping:
* value:所有请求地址的公共部分，叫做模块名称
*/
@Controller
@RequestMapping("/test")
public class MyController {
@RequestMapping({"/some.do","/first.do"})
public ModelAndView doSome(){
ModelAndView mv = new ModelAndView();
mv.addObject("msg","欢迎使用SpringMVC进行web开发");
mv.addObject("fun","执行的是doSome方法");
mv.setViewName("show");
return mv;
}
}
2.1.2 请求提交方式
对于@RequestMapping，其有一个属性 method，用于对被注解方法所处理请求的提交方式进行限制，即只有满足该 method 属性指定的提交方式的请求，才会执行该被注解方法。
Method 属性的取值为 RequestMethod 枚举常量。常用的为 RequestMethod.GET 与 RequestMethod.POST，分别表示提交方式的匹配规则为 GET 与 POST 提交。
/**
* @RequestMapping:请求映射
* 属性：method，表示请求的方式，它的值是RequestMethod类的枚举值
* 例如：表示get请求，RequestMethod.GET
* 表示post请求，RequestMethod.POST
*/
//指定some.do使用get请求方式
@RequestMapping(value = "/some.do",method = RequestMethod.GET)
以上处理器方法只能处理 POST 方式提交的请求。客户端浏览器常用的请求方式，及其提交方式有以下几种：
也就是说，只要指定了处理器方法匹配的请求提交方式为 POST，则相当于指定了请求发送的方式：要么使用表单请求，要么使用 AJAX 请求。其它请求方式被禁用。
当然，若不指定 method 属性，则无论是 GET 还是 POST 提交方式，均可匹配。即对于请求的提交方式无要求。
修改控制器MyController：
@Controller
@RequestMapping("/test")
public class MyController {
@RequestMapping(value = "some.do",method = RequestMethod.GET)
public ModelAndView doSome(){
ModelAndView mv = new ModelAndView();
mv.addObject("msg","欢迎使用SpringMVC做web开发");
mv.addObject("fun","执行的是doSome方法");
mv.setViewName("show");
return mv;
}
@RequestMapping(value = "other.do",method = RequestMethod.POST)
public ModelAndView doOther(){
ModelAndView mv = new ModelAndView();
mv.addObject("msg","欢迎使用SpringMVC做web开发");
mv.addObject("fun","执行的是doOther方法");
mv.setViewName("other");
return mv;
}
}
2.2 控制器方法的参数
处理器方法可以包含以下四类参数，这些参数会在系统调用时由系统自动赋值，即程序员可在方法内直接使用。
- HttpServletRequest
- HttpServletResponse
- HttpSession
- 请求中所携带的请求参数
前三个参数声明在方法中后，框架自动进行赋值，直接进行使用就可以了。使用方式与 Servlet 中使用方式相同！
2.2.1 逐个参数接收
只要保证请求参数名与该请求处理方法的参数名相同即可。
Step1：修改 index 页面
<form action="receive.do" method="get">
姓名：<input type="text" name="name"> <br>
年龄：<input type="text" name="age"> <br>
<input type="submit" value="提交参数">
form>
Step2：修改控制器 MyController
@Controller
public class MyController {
/**
* 逐个接收请求参数
* 要求：控制器方法的形参名和请求中参数名必须一致
* 同名的请求参数赋值给同名形参
*
* 框架接收请求参数
* 1.使用request对象接收请求参数
* String strName = request.getParameter("name");
* String strAge = request.getParameter("age");
* 2.SpringMVC框架通过 DispatcherServlet 调用MyController的doSome()
* 调用方法时，按名称对应，把接收的参数赋值给形参
* doSome(strName,Integer.valueOf(strAge))
* 框架会提供类型转换的功能，把 String 转为 int,long,float,double等类型
*
* 400状态码是客户端错误，表示提交请求参数的过程中，发生了问题
*/
@RequestMapping("/receive.do")
public ModelAndView doSome(String name,Integer age){
ModelAndView mv = new ModelAndView();
mv.addObject("myname",name);
mv.addObject("myage",age);
mv.setViewName("show");
return mv;
}
}
Step3：在/WEB-INF/jsp 下添加 show.jsp 页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Titletitle>
head>
<body>
<h3>从request作用域获取数据h3>
<br>
<h3>myname数据：${myname}h3>
<br>
<h3>myage数据：${myage}h3>
body>
html>
2.2.2 请求参数中文乱码问题
对于前面所接收的请求参数，若含有中文，则会出现中文乱码问题。Spring 对于请求参数中的中文乱码问题，给出了专门的字符集过滤器：spring-web-5.2.5.RELEASE.jar 的org.springframework.web.filter 包下的 CharacterEncodingFilter 类。
（1）解决方案
在 web.xml 中注册字符集过滤器，即可解决 Spring 的请求参数的中文乱码问题。不过，最好将该过滤器注册在其它过滤器之前。因为过滤器的执行是按照其注册顺序进行的。
<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>
（2）源码分析
字符集设置核心方法：
2.2.3 校正请求参数名@RequestParam
所谓校正请求参数名，是指若请求 URL 所携带的参数名称与处理方法中指定的参数名不相同时，则需在处理方法参数前，添加一个注解 @RequestParam(“请求参数名”)，指定请求 URL 所携带参数的名称。该注解是对处理器方法参数进行修饰的。value 属性指定请求参数的名称。
Step1：修改 index 页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>$Title$title>
head>
<body>
<p>请求参数名和处理器方法的参数名不一样p>
<form action="receiveparam.do" method="post">
姓名：<input type="text" name="rname"> <br>
年龄：<input type="text" name="rage"> <br>
<input type="submit" value="提交参数">
form>
body>
html>
Step2：修改控制器 MyController
/**
* 请求中参数名和控制器方法的参数名不一样
* @RequestParam:逐个接收请求参数，解决请求中参数名和方法形参名不同问题
*/
@RequestMapping("/receiveparam.do")
public ModelAndView receiveParam(@RequestParam("rname") String name,
@RequestParam("rage") Integer age) {
ModelAndView mv = new ModelAndView();
mv.addObject("myName", name);
mv.addObject("myAge", age);
mv.setViewName("show");
return mv;
}
required 属性：
/**
* 请求中参数名和控制器方法的参数名不一样
* @RequestParam:逐个接收请求参数，解决请求中参数名和方法形参名不同问题
* 属性:require 是一个boolean，默认是true
* true:表示请求中必须包含此参数
* false:表示请求中可以不包含此参数
*/
@RequestMapping("/receiveparam.do")
public ModelAndView receiveParam(@RequestParam(value = "rname",required = false) String name,
@RequestParam(value = "rage",required = false) Integer age) {
ModelAndView mv = new ModelAndView();
mv.addObject("myName", name);
mv.addObject("myAge", age);
mv.setViewName("show");
return mv;
}
2.2.4 对象参数接收
将处理器方法的参数定义为一个对象，只要保证请求参数名与这个对象的属性同名即可。
Step1：定义类 Student
//保存请求参数值的普通类
public class Student {
//属性名和请求中参数名要一致
private String name;
private Integer age;
//get、set、toString方法已省略
}
Step2：修改控制器 MyController
/**
* 处理器方法形参是java对象，该对象的属性名和请求中参数名一样
* 框架会创建形参java对象，给属性赋值。请求中的参数是name，框架会调用setName()
*/
@RequestMapping("/receiveobject.do")
public ModelAndView receiveObject(Student student) {
ModelAndView mv = new ModelAndView();
mv.addObject("myName",student.getName());
mv.addObject("myAge",student.getAge());
mv.addObject("myStudent",student);
mv.setViewName("show");
return mv;
}
Step3：修改 show 页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Titletitle>
head>
<body>
<h3>从request作用域获取数据h3>
<br>
<h3>myName数据：${myName}h3>
<br>
<h3>myAge数据：${myAge}h3>
<br>
<h3>myStudent数据：${myStudent}h3>
body>
html>
2.3 处理器方法的返回值
使用@Controller 注解的处理器的处理器方法，其返回值常用的有四种类型：
➢ 第一种：ModelAndView
➢ 第二种：String
➢ 第三种：无返回值 void
➢ 第四种：返回自定义类型对象
根据不同的情况，使用不同的返回值。
2.3.1 返回 ModelAndView
若处理器方法处理完后，需要跳转到其它资源，且又要在跳转的资源间传递数据，此时处理器方法返回 ModelAndView 比较好。当然，若要返回 ModelAndView，则处理器方法中需要定义 ModelAndView 对象。
在使用时，若该处理器方法只是进行跳转而不传递数据，或只是传递数据而并不向任何资源跳转（如对页面的 Ajax 异步响应），此时若返回 ModelAndView，则将总是有一部分多余：要么 Model 多余，要么 View 多余。即此时返回 ModelAndView 将不合适。
2.3.2 返回 String
处理器方法返回的字符串可以指定逻辑视图名，通过视图解析器解析可以将其转换为物理视图地址
返回内部资源逻辑视图名
若要跳转的资源为内部资源，则视图解析器可以使用 InternalResourceViewResolver 内部
资源视图解析器。此时处理器方法返回的字符串就是要跳转页面的文件名去掉文件扩展名后的部分。这个字符串与视图解析器中的 prefix、suffix 相结合，即可形成要访问的 URI。
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/"/>
<property name="suffix" value=".jsp"/>
bean>
修改处理器 MyController
/**
* 处理器方法返回String，表示逻辑视图名称，需要配置视图解析器
*/
@RequestMapping("/returnstring.do")
public String doReturnView(HttpServletRequest req, String name, Integer age) {
//我们可以手动添加数据到request作用域
req.setAttribute("myName",name);
req.setAttribute("myAge",age);
//show:逻辑视图名称，框架对视图执行forward转发操作
return "show";
}
当然，也可以直接返回资源的物理视图名。不过，此时就不需要再在视图解析器中再配置前辍与后辍了。
@RequestMapping("/returnstring2.do")
public String doReturnView2(HttpServletRequest req,String name,Integer age){
//我们可以手动添加数据到request作用域
req.setAttribute("myName",name);
req.setAttribute("myAge",age);
//返回完整视图路径，项目中不能配置视图解析器
return "/WEB-INF/jsp/show.jsp";
}
2.3.3 返回 Object
处理器方法也可以返回 Object 对象。这个 Object 可以是 Integer，String，自定义对象，Map，List 等。但返回的对象不是作为逻辑视图出现的，而是作为直接在页面显示的数据出现的。
返回对象，需要使用@ResponseBody 注解，将转换后的 JSON 数据放入到响应体中。
（1）环境搭建
导入依赖
由于返回 Object 数据，一般都是将数据转化为了 JSON 对象后传递给浏览器页面的。而这个由 Object 转换为 JSON，是由 Jackson 工具完成的。所以需要导入 Jackson 的相关 Jar 包。
<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>
声明注解驱动
将 Object 数据转化为 JSON 数据，需要由消息转换器 HttpMessageConverter 完成。而转换器的开启，需要由 mvc:annotation-driven 来完成。
SpringMVC 使用消息转换器实现请求数据和对象，处理器方法返回对象和响应输出之间的自动转换
当 Spring 容器进行初始化过程中，在 mvc:annotation-driven 处创建注解驱动时，默认创建了七个 HttpMessageConverter 对象。也就是说，我们注册 mvc:annotation-driven ，就是为了让容器为我们创建 HttpMessageConverter 对象。
<mvc:annotation-driven/>
HttpMessageConverter 接口 : HttpMessageConverter< T >是 Spring3.0 新添加的一个接口，负责将请求信息转换为一个对象（类型为 T），将对象（类型为 T）输出为响应信息
HttpMessageConverter 接口定义的方法：
//指定转换器可以读取的对象类型，即转换器是否可将请求信息转换为clazz类型的对象，
//同时指定支持 MIME 类型 (text/html,applaiction/json 等)
boolean canRead(Class<?> clazz,MediaType mediaType)
//指定转换器是否可将 clazz 类型的对象写到响应流中，响应流支持的媒体类型在 MediaType 中定义
boolean canWrite(Class<?> clazz,MediaType mediaType):
//该转换器支持的媒体类型
LIst<MediaType> getSupportMediaTypes()
//将请求信息流转换为 T 类型的对象。
T read(Class<? extends T> clazz,HttpInputMessage inputMessage)
//将 T 类型的对象写到响应流中，同时指定相应的媒体类型为 contentType
void write(T t,MediaType contnetType,HttpOutputMessgae outputMessage)
加入注解驱动 mvc:annotation-driven 后适配器类的 messageConverters 属性值
（2）返回自定义类型对象
返回自定义类型对象时，不能以对象的形式直接返回给客户端浏览器，而是将对象转换
为 JSON 格式的数据发送给浏览器的。
由于转换器底层使用了Jackson转换方式将对象转换为JSON数据，所以需要导入Jackson
的相关 Jar 包。
Step1：定义数据类
public class Student {
private String name;
private Integer age;
//get、set、toString
}
Step2：修改处理器 MyController
/**
* 处理器方法返回一个Student，通过框架转为json，相应ajax请求
*
* @ResponseBody
* 作用：把处理器方法返回对象转为json后，通过HttpServletResponse输出给浏览器
*
* 返回对象框架的处理流程:
* 1.框架会把返回Student类型，调用框架中ArrayList中每个类的 canWrite()
* 检查哪个HttpMessageConverter接口的实现类能处理Student类型的数据————MappingJackson2HttpMessageConverter
* 2.框架会调用MappingJackson2HttpMessageConverter的write()
* 把李四同学的Student对象转为json，调用Jackson的ObjectMapper转为json
* contentType:application/json;charset=utf-8
* 3.框架会调用@ResponseBody把2的结果数据输出到浏览器，ajax请求处理完成
*/
@RequestMapping("/returnStudentJson.do")
@ResponseBody
public Student doStudentJsonObject(){
//调用service获取请求结果数据，Student对象表示结果数据
//创建java对象转为json
Student student = new Student();
student.setAge(20);
student.setName("李四同学");
return student;
}
Step3：修改 index 页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>$Title$title>
<script src="http://libs.baidu.com/jquery/2.0.0/jquery.js">script>
<script type="text/javascript">
$(function () {
$("button").click(function () {
$.ajax({
url: "returnStudentJson.do",
success: function (data) {
//data从服务器端返回的是json格式的字符串: {"name":"李四","age":20}
//jquery会把字符串转为json对象，赋值给data形参
alert(data.name + " " + data.age);
}
});
});
});
script>
head>
<body>
<button>提交Ajax请求button>
body>
html>
（3）返回 List 集合
Step1：修改处理器 MyController
/**
* 处理器方法返回List
*/
@RequestMapping("/returnStudentJsonArray.do")
@ResponseBody
public List<Student> dsfs(String name,Integer age){
ArrayList<Student> list = new ArrayList<>();
Student student = new Student();
student.setName("李四同学");
student.setAge(20);
list.add(student);
student = new Student();
student.setName("张三同学");
student.setAge(28);
list.add(student);
return list;
}
Step2：修改 index 页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>$Title$title>
<script src="http://libs.baidu.com/jquery/2.0.0/jquery.js">script>
<script type="text/javascript">
$(function () {
$("button").click(function () {
$.ajax({
url: "returnStudentJsonArray.do",
success: function (data) {
//data从服务器端返回的是json格式的字符串:
//[{"name":"李四同学","age":20},{"name":"张三同学","age":28}]
//jquery会把字符串转为json对象，赋值给data形参
$.each(data,function (i,n){
alert(n.name + " " + n.age)
})
}
});
});
});
script>
head>
<body>
<button>提交Ajax请求button>
body>
html>
（4）返回 String 对象
若要返回非中文字符串，将前面返回数值型数据的返回值直接修改为字符串即可。但若返回的字符串中带有中文字符，则接收方页面将会出现乱码。此时需要使用 @RequestMapping 的 produces 属性指定字符集。
produces，产品，结果，即该属性用于设置输出结果类型。
Step1：修改处理器 MyController
/**
* 处理器方法返回的是String，String表示数据，不是视图
* 区分返回值String是数据还是视图，只看是否有@ResponseBody注解
* 如果有@ResponseBody注解，返回String就是数据，反之就是视图
*
* 默认使用"text/plain;charset=ISO-8859-1"作为contentType，导致中文有乱码
* 解决方案：给@RequestMapping添加 produces 属性，指定新的contentType
*/
@RequestMapping(value = "/returnStringData.do",produces = "text/plain;charset=utf-8")
@ResponseBody
public String doStringData(String name,Integer age){
return "Hello SpringMVC 返回对象，表示数据";
}
Step2：修改 index 页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>$Title$title>
<script src="http://libs.baidu.com/jquery/2.0.0/jquery.js">script>
<script type="text/javascript">
$(function () {
$("button").click(function () {
$.ajax({
url: "returnStringData.do",
success: function (data) {
alert("返回的文本数据：" + data)
}
});
});
});
script>
head>
<body>
<button>提交Ajax请求button>
body>
html>
2.4 解读< url-pattern />
2.4.1 配置详解
（1）*.do
在没有特殊要求的情况下，SpringMVC 的中央调度器 DispatcherServlet 的 url-pattern 常使用后辍匹配方式，如写为*.do 或者 *.action, *.mvc 等。
（2）/
可以写为/，因为 DispatcherServlet 会将向静态资源的获取请求，例如.css、.js、.jpg、.png 等资源的获取请求，当作是一个普通的 Controller 请求。中央调度器会调用处理器映射器为其查找相应的处理器。当然也是找不到的，所以在这种情况下，所有的静态资源获取请求也均会报 404 错误。
需求：在 index.jsp 页面中存在一个访问图片的链接。该项目用于演示将写为*.do
可以访问到该图片，而写为 / ，则无法访问。
A、在项目中添加图片：
在项目的 web 下添加一个目录 images，并在其中添加一张图片资源。
B、修改 index 页面：
<img src="images/1.jpg">
C、修改< url-pattern />的值：
保持< url-pattern />的值为 *.do，扩展名方式，图片会正常显示。
将< url-pattern />的值修改为 / ，则图片将无法显示。
2.4.2 静态资源访问
< url-pattern />的值并不是说写为/后，静态资源就无法访问了。经过一些配置后，该问题也是可以解决的。
（1）使用< mvc:default-servlet-handler />
声 明 了 < mvc:default-servlet-handler /> 后 ， springmvc 框 架 会 在 容 器 中 创 建 DefaultServletHttpRequestHandler 处理器对象。它会像一个检查员，对进入 DispatcherServlet 的 URL 进行筛查，如果发现是静态资源的请求，就将该请求转由 Web 应用服务器默认的 Servlet 处理。一般的服务器都有默认的 Servlet。
在 Tomcat 中，有一个专门用于处理静态资源访问的 Servlet 名叫 DefaultServlet。其< servlet-name />为 default。可以处理各种静态资源访问请求。该 Servlet 注册在 Tomcat 服务器的 web.xml 中。在 Tomcat 安装目录/conf/web.xml。
只需要在 springmvc.xml 中添加< mvc:default-servlet-handler />标签即可。
<mvc:default-servlet-handler/>
< mvc:default-servlet-handler />表示使用 DefaultServletHttpRequestHandler 处理器对象。而该处理器调用了 Tomcat 的 DefaultServlet 来处理静态资源的访问请求。
（2）使用< mvc:resources />
在 Spring3.0 版本后，Spring 定义了专门用于处理静态资源访问请求的处理器 ResourceHttpRequestHandler。并且添加了< mvc:resources />标签，专门用于解决静态资源无法访问问题。需要在 springmvc 配置文件中添加如下形式的配置：
<mvc:resources mapping="/images/**" location="/images/"/>
location 表示静态资源所在目录。当然，目录不要使用/WEB-INF/及其子目录。
mapping 表 示 对 该 资 源 的 请 求 （ 以 /images/ 开 始 的 请 求 ， 如 /image/beauty.jpg , /images/car.png 等）。注意，后面是两个星号。
（3）声明注解驱动
解决动态资源和静态资源冲突的问题，在 springmvc 配置文件加入：
<mvc:annotation-driven/>
第3章 SpringMVC 核心技术
3.1 转发与重定向
当处理器对请求处理完毕后，向其它资源进行跳转时，有两种跳转方式：请求转发与重定向。而根据所要跳转的资源类型，又可分为两类：跳转到页面与跳转到其它处理器。
注意，对于请求转发的页面，可以是WEB-INF中页面；而重定向的页面，是不能为WEB-INF中页面的。 因为重定向相当于用户再次发出一次请求，而用户是不能直接访问 WEB-INF 中资源的。
SpringMVC 框架把原来 Servlet 中的请求转发和重定向操作进行了封装。现在可以使用简单的方式实现转发和重定向。
//forward:表示转发
request.getRequestDispatcher("xx.jsp").forward()
//redirect:表示重定向
response.sendRedirect("xxx.jsp")
3.1.1 请求转发
处理器方法返回 ModelAndView 时，需在 setViewName()指定的视图前添加 forward:，且此时的视图不再与视图解析器一同工作，这样可以在配置了解析器时指定不同位置的视图。视图页面必须写出相对于项目根的路径。forward 操作不需要视图解析器。
处理器方法返回 String,在视图路径前面加入 forward: 视图完整路径。
@Controller
public class MyController {
/**
* 处理器方法返回ModelAndView，实现转发forward
* 语法：setViewName("forward:视图文件完整路径")
* forward特点：不和视图解析器一起使用
* 我们可以使用forward操作转发到任何路径，这就是forward存在的意义
*/
@RequestMapping("/doForward.do")
public ModelAndView doSome(){
ModelAndView mv = new ModelAndView();
mv.addObject("msg","欢迎使用SpringMVC做web开发");
mv.addObject("fun","执行doSome()");
mv.setViewName("forward:/WEB-INF/jsp/show.jsp");
return mv;
}
}
3.1.2 请求重定向
在处理器方法返回的视图字符串的前面添加 redirect:，则可实现重定向跳转。
处理器方法定义：
@Controller
public class MyController {
/**
* 处理器方法返回ModelAndView，实现重定向redirect
* 语法：setViewName("redirect:视图文件完整路径")
* redirect特点：不和视图解析器一起使用
*
* 框架对重定向操作：
* 1.框架会把Model中的简单类型数据转为String使用，作为hello.jsp的get请求参数使用
* 目的是：doRedirect.do 和 hello.jsp 两次请求之间传递数据
*
* 2.在目标hello.jsp页面可以使用参数集合对象${param}获取请求参数值
* ${param.myname}
*
* 3.重定向不能访问/WEB-INF资源
*/
@RequestMapping("/doRedirect.do")
public ModelAndView doRedirect(){
ModelAndView mv = new ModelAndView();
mv.addObject("msg","欢迎使用SpringMVC做web开发");
mv.addObject("fun","执行doSome()");
mv.setViewName("redirect:/hello.jsp");
return mv;
}
}
3.2 拦截器
SpringMVC 中的 Interceptor 拦截器是非常重要和相当有用的，它的主要作用是拦截指定的用户请求，并进行相应的预处理与后处理。其拦截的时间点在“处理器映射器根据用户提交的请求映射出了所要执行的处理器类，并且也找到了要执行该处理器类的处理器适配器，在处理器适配器执行处理器之前”。当然，在处理器映射器映射出所要执行的处理器类时，已经将拦截器与处理器组合为了一个处理器执行链，并返回给了中央调度器。
3.2.1 一个拦截器的执行
自定义拦截器：
//拦截器类：拦截用户的请求
public class MyInterceptor implements HandlerInterceptor {
/**
* preHandle:预处理方法
* 重要:是整个项目的入口、门户。
* 当preHandle返回true，请求可以被处理
* 当preHandle返回false，请求到此方法就截止
*
* Object handler:被拦截的控制器对象
* 返回值 boolean
* true:请求通过了拦截器的验证，可以执行处理器方法
* false:请求没有通过拦截器的验证，请求到达拦截器就截止
* 请求没有被处理
*
* 特点：
* 1.方法在控制器之前先执行
* 用户请求首先到达此方法
* 2.在此方法中可以获取请求的信息，验证请求是否符合要求
* 可以验证用户是否登录，验证用户是否有权限访问某个链接地址
* 如果验证失败，可以截断请求，请求不能被处理
* 如果验证成功，可以放行请求，此时控制器方法才能执行
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//计算的业务逻辑，根据结果返回boolean
System.out.println("执行preHandle()");
return true;
}
/**
* postHandle:后处理方法
* Object handler:被拦截的处理器对象
* ModelAndView:处理器方法的返回值
*
* 特点：
* 1.处理器方法之后执行
* 2.能够获取处理器方法的返回值ModelAndView，可以修改数据和视图
* 可以影响到最后的执行结果
* 3.主要对原来的执行结果做二次修正
*/
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView mv) 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("执行afterHandle()");
}
}
拦截器中方法与处理器方法的执行顺序如下图：
换一种表现方式，也可以这样理解：
（1）注册拦截器
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="com.xu.handler.MyInterceptor"/>
mvc:interceptor>
mvc:interceptors>
（2）修改 index 页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>$Title$title>
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）创建处理器
@Controller
public class MyController {
@RequestMapping("/some.do")
public ModelAndView doSome(String name, Integer age) {
System.out.println("执行处理器方法");
ModelAndView mv = new ModelAndView();
mv.addObject("myname", name);
mv.addObject("myage", age);
mv.setViewName("show");
return mv;
}
}
（4）创建 show 页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Titletitle>
head>
<body>
<h3>从request作用域获取数据h3>
<br>
<h3>msg数据：${myname}h3>
<br>
<h3>fun数据：${myage}h3>
body>
html>
（5）控制台输出结果
3.2.2 多个拦截器的执行
（1）再定义一个拦截器
public class MyInterceptor1 implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//计算的业务逻辑，根据结果返回boolean
System.out.println("执行preHandle1()");
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView mv) throws Exception {
System.out.println("执行postHandle1()");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("执行afterHandle1()");
}
}
（2）多个拦截器注册与执行
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="com.xu.handler.MyInterceptor"/>
mvc:interceptor>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="com.xu.handler.MyInterceptor1"/>
mvc:interceptor>
mvc:interceptors>
（3）控制台输出结果
当有多个拦截器时，形成拦截器链。拦截器链的执行顺序，与其注册顺序一致。需要再次强调一点的是，当某一个拦截器的 preHandle()方法返回 true 并被执行到时，会向一个专门的方法栈中放入该拦截器的 afterCompletion()方法。
多个拦截器中方法与处理器方法的执行顺序如下图：
从图中可以看出，只要有一个 preHandle()方法返回 false，则上部的执行链将被断开，其后续的处理器方法与 postHandle()方法将无法执行。但，无论执行链执行情况怎样，只要方法栈中有方法，即执行链中只要有 preHandle()方法返回 true，就会执行方法栈中的 afterCompletion()方法。最终都会给出响应。
换一种表现方式，也可以这样理解：
3.2.3 权限拦截器举例
只有经过登录的用户方可访问处理器，否则，将返回“对不起，登录失败”提示。
本例的登录，由一个 JSP 页面完成。即在该页面里将用户信息放入 session 中。也就是说，只要访问过该页面，就说明登录了。没访问过，则为未登录用户。
（1）修改 index 页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>$Title$title>
head>
<body>
<p>拦截器案例p>
<form action="system.do" method="post">
姓名：<input type="text" name="name"> <br>
<input type="submit" value="提交">
form>
body>
html>
（2）创建处理器
@Controller
public class MyController {
@RequestMapping("/system.do")
public ModelAndView doSome(String name) {
ModelAndView mv = new ModelAndView();
mv.addObject("name",name);
mv.setViewName("/welcome.jsp");
return mv;
}
}
（3）定义 welcome 页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Titletitle>
head>
<body>
<h1>登陆成功！h1>
body>
html>
（4）定义权限拦截器
//拦截器类：拦截用户的请求
public class MyInterceptor implements HandlerInterceptor {
//验证登陆的用户信息，正确return true，错误return false
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
String loginName = "";
//从session中获取name值
Object attr = request.getSession().getAttribute("name");
if (attr != null) {
loginName = (String)attr;
}
//判断登陆的账号是否符合要求
if (!"张三".equals(loginName)){
//不能访问系统，给用户提示
request.getRequestDispatcher("/fail.jsp").forward(request,response);
return false;
}
//张三登录
return true;
}
}
（5）定义 fail 页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Titletitle>
head>
<body>
<h1>对不起，登陆失败！h1>
body>
html>
（6）注册权限拦截器
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="com.xu.handler.MyInterceptor"/>
mvc:interceptor>
mvc:interceptors>
（7）定义 login 页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Titletitle>
head>
<body>
<h1>模拟登录，张三登录系统h1>
<%
session.setAttribute("name","张三");
%>
body>
html>
（8）定义logout页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Titletitle>
head>
<body>
<h1>退出系统，从session中删除数据h1>
<%
session.removeAttribute("name");
%>
body>
html>