一、Spring MVC 简介
1.MVC模式
MVC是软件工程中的一种软件架构模式，它是一种分离业务逻辑与显示界面的开发思想。
* M（model）模型：处理业务逻辑，封装实体
* V（view） 视图：展示内容
* C（controller）控制器：负责调度分发（1.接收请求、2.调用模型、3.转发到视图）
2.Spring MVC概述
SpringMVC 是一种基于 Java 的实现 MVC 设计模式的轻量级 Web 框架，属于SpringFrameWork 的后续产品，已经融合在 Spring Web Flow 中。
SpringMVC 已经成为目前最主流的MVC框架之一，并且随着Spring3.0 的发布，全面超越 Struts2，成为最优秀的 MVC 框架。它通过一套注解，让一个简单的 Java 类成为处理请求的控制器，而无须实现任何接口。同时它还支持 RESTful 编程风格的请求。
总结： SpringMVC的框架就是封装了原来Servlet中的共有行为；例如：参数封装，视图转发等。
3.Spring MVC快速入门
需求： 客户端发起请求，服务器接收请求，执行逻辑并进行视图跳转。
①：创建web项目，导入依赖坐标
<?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>cn.xuguowen</groupId>
<artifactId>springmvc_quickstart</artifactId>
<version>1.0-SNAPSHOT</version>
<!--因为是web项目，所以要打成war包-->
<packaging>war</packaging>
<!--导入mvc得依赖坐标-->
<dependencies>
<!--springMVC坐标-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.1.5.RELEASE</version>
</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</version>
<scope>provided</scope>
</dependency>
</dependencies>
</project>
②：在web.xml中配置Spring MVC前端控制器DispathcerServlet
<?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">
<!--配置mvc的前端控制器 DispathcerServlet，通过名称我猜测他就是一个servlet-->
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--
现在启动项目，是访问不到/quick的，因为没有加载mvc的核心配置文件，
也就没有生成bean对象，也就访问不到bean对象中的方法
所以：我们要在前端控制器初始化时，就加载mvc的配置文件
-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mvc.xml</param-value>
</init-param>
<!--
那么你还得知道前端控制器（servlet）的生命周期：当第一次请求的时候，就会通过构造方法创建servlet实例,
然后紧接着执行init()方法，进行初始化得操作（加载mvc得配置文件）
但是我现在要求项目启动（web应用）时，就完成前端控制器（servlet）得初始化，并加载mvc得配置文件
-->
<load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<!--
面试题: / 和 /*的区别
1./ 表示匹配所有的访问（请求）路径（/update），但是不匹配带有后缀名的访问路径（a.jsp ……）
2./* 表示匹配所有的访问路径（/login、a.jsp）
-->
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
③：编写Controller类和视图界面
/**
* @author 徐国文
* @create 2021-10-18 15:09
* 把这个普通的类变为一个servlet类，然后还要指定类中方法的访问路径
*/
public class UserController {
public String quick() {
System.out.println("Spring MVC 从入门到入土！");
// 完成请求转发
return "/WEB-INF/pages/success.jsp";
}
}
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h1>Spring MVC 从入门到入土！</h1>
</body>
</html>
④：使用注解配置Controller类中业务方法的映射地址
@Controller // 将创建的UserController对象存储到Spring MVC创建的ioc容器中（子容器）
public class UserController {
@RequestMapping("/quick")
public String quick() {
System.out.println("quick running.....");
return "/WEB-INF/pages/success.jsp";
}
}
⑤：配置SpringMVC核心文件spring-mvc.xml
<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="cn.xuguowen"/>
</beans>
4.Web工作执行流程
二、Spring MVC 组件概述
1.Spring MVC执行流程
1. 用户发送请求至前端控制器DispatcherServlet。
2. DispatcherServlet收到请求调用HandlerMapping处理器映射器。
3. 处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
4. DispatcherServlet调用HandlerAdapter处理器适配器。
5. HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。
6. Controller执行完成返回ModelAndView。
7. HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。
8. DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
9. ViewReslover解析后返回具体View。
10. DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。
11. DispatcherServlet将渲染后的视图响应响应用户。
2.Spring MVC组件解析
1. 前端控制器：DispatcherServlet
用户请求到达前端控制器，它就相当于 MVC 模式中的 C，DispatcherServlet 是整个流程控制的
中心，由它调用其它组件处理用户的请求，DispatcherServlet 的存在降低了组件之间的耦合性。
2. 处理器映射器：HandlerMapping
HandlerMapping 负责根据用户请求找到 Handler 即处理器，SpringMVC 提供了不同的映射器
实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。
3. 处理器适配器：HandlerAdapter
通过 HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型
的处理器进行执行。
4. 处理器：Handler【**开发者编写**】
它就是我们开发中要编写的具体业务控制器。由 DispatcherServlet 把用户请求转发到
Handler。由Handler 对具体的用户请求进行处理。
5. 视图解析器：ViewResolver
View Resolver 负责将处理结果生成 View 视图，View Resolver 首先根据逻辑视图名解析成物
理视图名，即具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给
用户。
6. 视图：View 【**开发者编写**】
SpringMVC 框架提供了很多的 View 视图类型的支持，包括：jstlView、freemarkerView、
pdfView等。最常用的视图就是 jsp。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展
示给用户，需要由程序员根据业务需求开发具体的页面。
笔试题：
- 1.Spring MVC中的三大组件/四大组件是什么？
处理器映射器、处理器适配器、视图解析器
处理器映射器、处理器适配器、视图解析器、前端控制器
注意： 处理器映射器、处理器适配器、视图解析器也是可以显示配置的。
<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="cn.xuguowen"/>
<!--显示配置处理器映射器和处理器适配器-->
<!--
在开发中经常使用这个标签显示的配置处理器映射器和处理器适配器，
配置了这个标签之后，还增强了功能，支持json字符串的读写（不需要使用json的API了）
-->
<mvc:annotation-driven/>
<!--显示的配置视图解析器-->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--
在处理器handler中返回的是逻辑视图名，需要拼接上真实的物理地址
/WEB-INF/pages/逻辑视图名称.jsp
-->
<!--配置前缀-->
<property name="prefix" value="/WEB-INF/pages/"></property>
<!--配置后缀-->
<property name="suffix" value=".jsp"></property>
</bean>
</beans>
3.Spring MVC注解解析
①：@Controller
SpringMVC基于Spring容器，所以在进行SpringMVC操作时，需要将Controller存储到SpringIOC容器中，如果使用@Controller注解标注的话，就需要使用：
<!--
开启注解扫描：此时注解扫描只扫描controller包下的注解，
其他的注解扫描在spring的核心配置文件中配置，没必要进行重复的扫描
-->
<context:component-scan base-package="cn.xuguowen.controller"/>
②：@RequestMapping
* 作用：
用于建立请求 URL 和处理请求方法之间的对应关系
* 位置：
1.类上：请求URL的第一级访问目录。此处不写的话，就相当于应用的根目录。写的话 需要以/开头。
它出现的目的是为了使我们的URL可以按照模块化管理:
用户模块
/user/add
/user/update
/user/delete
...
账户模块
/account/add
/account/update
/account/delete
2.方法上：请求URL的第二级访问目录，和一级目录组成一个完整的 URL 路径。
* 属性：
1.value：用于指定请求的URL。它和path属性的作用是一样的
2.method：用来限定请求的方式
3.params：用来限定请求参数的条件
例如：params={"accountName"} 表示请求参数中必须有accountName
pramss={"money!100"} 表示请求参数中money不能是100
三、Spring MVC 的请求
1.请求参数类型介绍
客户端请求参数的格式是：name=value&name=value……
服务器需要获取请求参数，而且还需要对请求参数进行类型转换、数据的封装
Spring MVC可以接收以下类型的请求参数
- 基本类型参数
- 对象类型参数
- 数组类型参数
- 集合类型参数
2.获取基本类型参数
Controller中的业务方法的参数名称要与请求参数的name一致，参数值会自动映射匹配。并且能自动做类型转换；自动的类型转换是指从String向其他类型的转换。
<a href="${pageContext.request.contextPath}/user/simpleParam?id=1&username=马双">
传递基本类型参数
</a>
@RequestMapping("/simpleParam")
public String simpleParam(Integer id,String username) {
System.out.println(id);
System.out.println(username);
return "success";
}
3.获取对象类型参数
Controller中的业务方法参数的POJO属性名与请求参数的name一致，参数值会自动映射匹配，并自动完成数据封装。
<form action="${pageContext.request.contextPath}/user/pojoParams" method="post">
<%--需要注意的是：name的值要和实体类中的属性名一致，因为要经过setXxx()方法进行封装
将表单中的参数赋值给实体类中的属性上
--%>
学号：<input type="text" name="id"><br>
姓名：<input type="text" name="name"><br>
<%--post请求方式下，传递中文数据到达后台会出现乱码，因为编码和解码的方式不同，
配置过滤器使得编码和解码方式一致--%>
<input type="submit" value="对象类型参数">
</form>
public class User {
private Integer id;
private String name;
// setXxx()
}
/**
* 将页面表单传递的参数封装到user实体中（按照一定的要求编写代码，mvc底层将我们完成）
* 需要注意的就是：前端页面中文本框中的name属性值要和实体类中的属性名成一致，这样框架才会帮我们完成数据的封装
* @param user
* @return
*/
@RequestMapping("/pojoParams")
public String pojoParams(User user) {
System.out.println(user);
return "success";
}
4.中文乱码过滤器
在Tomcat8.5+环境下，get请求方式下的中文乱码问题tomcat服务器内部进行了解决。但是当post请求时，中文数据会出现乱码，我们可以设置一个过滤器来进行编码的过滤。
<!--解决所有请求的乱码问题-->
<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<!--使用utf-8编码进行编码和解码-->
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
5.获取数组类型参数
<form action="${pageContext.request.contextPath}/user/arrayParams" method="post">
<%--说明：
1.复选框value属性的值是传送到后台控制器的数据
2.复选框中文本内容的值是标签后面的内容，标签后面的内容是什么，页面中显示什么内容
--%>
编号：<input type="checkbox" name="ids" value="1">1
<input type="checkbox" name="ids" value="2">2
<input type="checkbox" name="ids" value="3">3
<input type="checkbox" name="ids" value="4">4
<input type="submit" value="传递数组类型参数">
</form>
/**
* 将复选框中value属性的值传递到ids参数上，
* 注意的是：复选框中name属性的值要和形参中的数组名相同
* @param ids
* @return
*/
@RequestMapping("/arrayParams")
public String arrayParams(Integer[] ids) {
System.out.println(Arrays.toString(ids));
return "success";
}
6.获取集合类型参数
获得集合参数时，要将集合参数包装到一个POJO(QueryVo)中才可以。
<form action="${pageContext.request.contextPath}/user/listParams" method="post">
关键字：<input type="text" name="keyWords"><br>
user对象: <br>
<input type="text" name="user.id" placeholder="学号"><br>
<input type="text" name="user.name" placeholder="姓名"><br>
list对象： <br>
第一个元素
<input type="text" name="userList[0].id" placeholder="学号">
<input type="text" name="userList[0].name" placeholder="姓名"> <br>
第二个元素
<input type="text" name="userList[1].id" placeholder="学号">
<input type="text" name="userList[1].name" placeholder="姓名"> <br>
map对象: <br>
第一个元素
<input type="text" name="userMap['u1'].id" placeholder="学号">
<input type="text" name="userMap['u1'].name" placeholder="姓名"> <br>
第二个元素
<input type="text" name="userMap['u2'].id" placeholder="学号">
<input type="text" name="userMap['u2'].name" placeholder="姓名"> <br>
<input type="submit" value="传递复杂类型的参数">
</form>
public class QueryVo {
private String keyWords;
private User user;
private List<User> userList;
private Map<String,User> userMap;
}
// setXxx()
/**
* 接收页面传递的复杂参数类型（集合，实体对象）
* @param vo
* @return
*/
@RequestMapping("/listParams")
public String listParams(QueryVo vo) {
System.out.println(vo);
return "success";
}
7.自定义类型转换器
SpringMVC 默认已经提供了一些常用的类型转换器；例如：客户端提交的字符串转换成int类型进行参数设置，日期格式类型要求为：yyyy/MM/dd ，不然的话会报错，对于特有的行为，SpringMVC提供了自定义类型转换器方便开发者自定义处理。
<%--传递日期参数，传递的日期参数格式必须是2020/12/12这样式的，否则框架不会转换的--%>
<form action="${pageContext.request.contextPath}/user/converterParam">
日期： <input type="text" name="birthday"> <br>
<input type="submit" value="传递日期类型的参数">
</form>
/**
* 页面传递的日期参数是 2022/12/12这样类型的日期参数，
* 框架是可以自动进行转换的（将日期字符串自动转换为日期类型对象）
* 但是如果前端页面就要传递2020-12-11这样格式的日期字符串，框架是不会将日期字符串解析成日期对象的，会出现400错误，Bad Request
* 自定义类型转换器
* @param birthday
* @return
*/
@RequestMapping("/converterParam")
public String converterParam(Date birthday) {
System.out.println(birthday);
return "success";
}
自定义类型转换器
/**
* @author 徐国文
* @create 2021-10-19 22:06
* 自定义类型转换器的步骤：
* 1.实现Converter接口，重写接口中的方法
* 2.在spring mvc的核心配置文件中配置自定义类型转换器
* 3.在显示配置处理器映射器和处理器是配器中配置 conversion-service="conversionService"
* <mvc:annotation-driven conversion-service="conversionService"/>
*/
public class DateConverter implements Converter<String, Date> { // 将日期字符串转换成日期对象
public Date convert(String str) {
// 页面传递的日期字符串是 2020-12-12
try {
// 根据指定参数格式，将日期字符串解析成日期对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf.parse(str);
return date;
} catch (ParseException e) {
e.printStackTrace();
}
return null;
}
}
8.相关注解
①：@RequestParam
当请求的参数name名称与Controller的业务方法参数名称不一致时，就需要通过@RequestParam注解显示的绑定
<%--演示@RequestParam注解--%>
<a href="${pageContext.request.contextPath}/user/findByPage?pageNo=2">
分页查询
</a>
/**
* 演示@RequestParam注解：当页面传递的请求参数name和后台控制器中业务方法的形参名称不一致时，可以使用这个注解完成自动匹配
* 页面传递的参数name是 pageNo，而方法中形参的名称是 pageNum,是无法完成自动匹配的
* 此时需要借助@RequestParam注解来解决这个问题
* 说明该注解中的属性
* 1.name属性：表示页面传递参数的name
* 2.defaultValue 如果页面中没有传递该name的值，那么默认值是 1
* 3.required 设置前端页面是否必须传递该参数，默认值是true，表示必须携带该参数进行请求
* 但是当你设置了defaultValue属性后，它的值会自动改为false，表示传递该参数不是必须的
* @param pageNum 当前页数
* @param pageSize 每页显示的条数
* @return
*/
@RequestMapping("/findByPage")
public String findByPage(@RequestParam(name = "pageNo",defaultValue = "1",required = false) Integer pageNum, @RequestParam(defaultValue = "5") Integer pageSize) {
System.out.println("当前页数:" + pageNum); // 2
System.out.println("每页显示的条数:" + pageSize); // 5
return "success";
}
②：@RequestHeader
获取请求头的数据。
/**
* 通过@RequestHeader注解获取请求头中的所有值
* @param cookie
* @return
*/
@RequestMapping("/requestHeader")
public String requestHeader(@RequestHeader String cookie) {
System.out.println(cookie);
return "success";
}
③：@CookieValue
获取cookie中的数据，根据键获取值。
/**
* 根据@CookieValue注解获取cookie中某一项的值
* ctrl shift y IDEA快捷键，转换大小写
* @param jsessionid
* @return
*/
@RequestMapping("/cookieValue")
public String cookieValue(@CookieValue("JSESSIONID") String jsessionid) {
System.out.println(jsessionid);
return "success";
}
9.获取Servlet相关API
SpringMVC支持使用原始ServletAPI对象作为控制器方法的参数进行注入，常用的对象如下：
/**
* 获取servlet原生的api，直接在方法形参上标识就ok，框架会帮我们自动注入
* @param request
* @param response
* @param session
* @return
*/
@RequestMapping("/servletApi")
public String servletApi(HttpServletRequest request, HttpServletResponse response, HttpSession session) {
System.out.println(request);
System.out.println(response);
System.out.println(session);
return "success";
}
四、Spring MVC 的响应
1.SpringMVC响应方式介绍
页面跳转
- 1.返回字符串逻辑视图（本质：请求转发）
- 2.void原始ServletAPI
- 3.ModelAndView
返回数据
- 1.直接返回字符串数据
- 2.将对象或集合转为json返回（Spring MVC进阶）
2. 返回字符串逻辑视图
直接返回字符串：此种方式会将返回的字符串与视图解析器的前后缀拼接后跳转到指定页面。
<!--显示的配置视图解析器-->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--
在处理器handler中返回的是逻辑视图名，需要拼接上真实的物理地址
/WEB-INF/pages/逻辑视图名称.jsp
-->
<!--配置前缀-->
<property name="prefix" value="/WEB-INF/pages/"></property>
<!--配置后缀-->
<property name="suffix" value=".jsp"></property>
</bean>
3. 原始ServletAPI实现转发和重定向
我们可以通过request、response对象实现响应
/**
* 在业务方法中使用原生的servletAPI完成页面的转发以及重定向
* 注意：该方法没有返回值
* @param request
* @param response
*/
@RequestMapping("returnServlet")
public void returnServlet(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
// 1.请求转发到success.jsp页面
// request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request,response);
// 2.重定向到success.jsp页面上：发起两次请求
// 所以重定向不能访问WEB-INF安全目录下的资源文件，如果想要访问该目录下的文件，就得是服务器内部转发访问
// 是不允许客户端访问安全目录下得资源文件得
// response.sendRedirect(request.getContextPath() + "/WEB-INF/pages/success.jsp");
response.sendRedirect(request.getContextPath() + "/index.jsp");
}
4. 转发(forward)和重定向(redirect)
企业开发我们一般使用返回字符串逻辑视图实现页面的跳转，这种方式其实就是请求转发。
我们也可以写成：forward转发
如果用了forward：则路径必须写成实际视图url，不能写逻辑视图。它相当于：request.getRequestDispatcher("url").forward(request,response)
使用请求转发，既可以转发到jsp，也可以转发到其他的控制器方法。
/**
* 在实际开发中，我们不会使用原生得servletAPI完成转发以及重定向
* 最常用的还是返回字符串逻辑视图实现转发和重定向
* return "forward:实际视图的url" == request.getRequestDispatcher("url").forward(request,response)
* @param model
* @return
*/
@RequestMapping("/forward")
public String forward(Model model) {
// 借助模型对象存储数据（底层就是request.setAttribute("username":"zhangsan") ）
model.addAttribute("username","MyikJ");
// 1.转发到success.jsp页面上
return "forward:/WEB-INF/pages/success.jsp";
// 2.也可以转发到controller中的其他业务方法上
// return "forward:/user/findAll";
}
我们也可以写成：redirect重定向
我们可以不写虚拟目录，springMVC框架会自动拼接，并且将Model中的数据拼接到url地址上。
/**
* 使用字符串逻辑视图的方式实现重定向，其中项目路径（虚拟路径是可以省略的）
* response.sendRedirect(request.getContextPath() + "/index.jsp");
* return "redirect:[虚拟路径/项目路径]/index.jsp"
* @param model
* @return
*/
@RequestMapping("/redirect")
public String redirect(Model model) {
// 注意：向模型中添加属性，它的底层代码就是request.setAttribute("username","徐国文");
// 数据存储的域范围是request
// 如果重定向之后，模型中的数据会被拼接到url后面作为参数
// http://localhost:8080/springmvc_quickstart/index.jsp?username=%E5%BE%90%E5%9B%BD%E6%96%87
model.addAttribute("username","徐国文");
// 项目路径可以省略不写，框架会帮助我们拼接的
return "redirect:/index.jsp";
}
注意： 使用关键字进行转发和重定向，视图解析器是不会进行拼接前缀和后缀的，他底层就是使用request和response对象来操作的。
5.ModelAndView
①：在Controller中方法创建并返回ModelAndView对象，并且设置视图名称
/**
* 使用ModelAndView对象存储数据，并进行转发方式一(服务器内部转发)
* model:模型 来封装数据的
* view:视图 展示数据的
* @return
*/
@RequestMapping("/returnModelAndView1")
public ModelAndView returnModelAndView1() {
ModelAndView modelAndView = new ModelAndView();
modelAndView.addObject("username","returnModelAndView1");
// handler（controller）执行完毕之后返回modelAndView对象，然后处理器适配器将modelAndView
// 对象返回给前端控制器，前端控制器调用视图解析器解析返回view对象
// 所以它这里要经过视图解析器，也就会拼接上mvc配置文件中配置的前缀和后缀
modelAndView.setViewName("success");
return modelAndView;
}
②：在Controller中方法形参上直接声明ModelAndView，无需在方法中自己创建，在方法中直接使用该对象设置视图，同样可以跳转页面
/**
* 使用ModelAndView对象存储数据，并进行转发方式二(服务器内部转发)
* @param modelAndView
* @return
*/
@RequestMapping("/returnModelAndView2")
public ModelAndView returnModelAndView2(ModelAndView modelAndView) {
modelAndView.addObject("username","returnModelAndView2");
modelAndView.setViewName("success");
return modelAndView;
}
6.@SessionAttributes
如果在多个请求之间共用数据，则可以在控制器类上标注一个@SessionAttributes,配置需要在session中存放的数据范围，Spring MVC将存放在model中对应的数据暂存到 HttpSession 中。
注意：@SessionAttributes只能定义在类上
@Controller // 将创建的UserController对象存储到Spring MVC创建的ioc容器中（子容器）
@RequestMapping("/user") // 一级访问目录
@SessionAttributes("username") // model(request)域中存储的数据，会同步到session域中
public class UserController {
/**
* 在实际开发中，我们不会使用原生得servletAPI完成转发以及重定向，但是底层采用的就是原生的API方式完成的
* 所以是不会走视图解析器的，也就不会进行前缀和后缀的拼接
* 最常用的还是返回字符串逻辑视图实现转发和重定向
* return "forward:实际视图的url" == request.getRequestDispatcher("url").forward(request,response)
* @param model
* @return
*/
@RequestMapping("/forward")
public String forward(Model model) {
// 借助模型对象存储数据（底层就是request.setAttribute("username":"zhangsan") ）
model.addAttribute("username","MyikJ");
// 1.转发到success.jsp页面上
return "forward:/WEB-INF/pages/success.jsp";
// 2.也可以转发到controller中的其他业务方法上
// return "forward:/user/findAll";
}
/**
* 如果没有在类上加上 @SessionAttributes，是无法获取到/forward请求下存储的数据 username
* 如果在类上加上 @SessionAttributes ,就是将ruquest域中存储的数据存同步到session域中，
* 那么在其他的请求中就可以获取到request域中的数据了（model中存储的数据）
* @return
*/
@RequestMapping("/returnString")
public String returnString() {
return "success";
}
}
五 静态资源访问的开启
当有静态资源需要加载时，比如jquery文件，通过谷歌开发者工具抓包发现，没有加载到jquery文件，原因是SpringMVC的前端控制器DispatcherServlet的url-pattern配置的是 /（缺省）,代表对所有带有后缀名的
静态资源都进行拦截操作，这样就不会执行Tomcat内置的DefaultServlet处理，我们可以通过以下两种方式指定放行静态资源：
<!--在springmvc配置文件中指定放行资源-->
<!--
解决前端控制器url-pattern在 / 的配置下，带有后缀名的静态资源会被拦截，
不会交给其他组件去执行，出现404的错误
mapping:表示/js下的文件以及子目录都不会被前端控制器拦截，都会被放行
location:静态资源所在的目录。找到所在的目录，然后加载静态资源文件，这样就不会出现404的错误
-->
<!--开启静态资源可以访问的方式一：放行指定的url，可以去加载到静态资源-->
<mvc:resources mapping="/js/**" location="/js/"/>
<mvc:resources mapping="/css/**" location="/css/"/>
<mvc:resources mapping="/img/**" location="/img/"/>
<!--开启静态资源可以访问的方式二:放行全部的url，也就是可以加载所有的静态资源-->
<!--开启DefaultServlet处理静态资源-->
<mvc:default-servlet-handler/>