SpringMVC详解

1.SpringMVC概述

1.1 什么是MVC

MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分
（1）M：Model，模型层，指工程中的JavaBean，作用是处理数据
JavaBean分为两类：
①一类称为实体类Bean：专门存储业务数据的，如 Student、User 等
②一类称为业务处理 Bean：指 Service 或 Dao 对象，专门用于处理业务逻辑和数据访问。
（2）V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据
（3）C：Controller，控制层，指工程中的servlet，作用是接收请求和响应浏览器
MVC的工作流程： 用户通过视图层发送请求到服务器，在服务器中请求被Controller接收，Controller
调用相应的Model层处理请求，处理完毕将结果返回到Controller，Controller再根据请求处理的结果
找到相应的View视图，渲染数据后最终响应给浏览器

1.2 什么是SpringMVC

（1）SpringMVC 是 Spring 为表述层开发提供的一整套完备的解决方案。在表述层框架历经 Strust、
WebWork、Strust2 等诸多产品的历代更迭之后，目前业界普遍选择了 SpringMVC 作为 Java EE 项目
表述层开发的首选方案。
注：三层架构分为表述层（或表示层）、业务逻辑层、数据访问层，表述层表示前台页面和后台servlet
（2）SpringMVC：是基于spring的一个框架， 实际上就是spring的一个模块， 专门是做web开发的。
可以理解是servlet的一个升级。web开发底层是servlet ， 框架是在servlet基础上面加入一些功能，让你做
web开发方便。
（3）SpringMVC就是一个Spring,是Spring的一个子项目。 Spring是容器，ioc能够管理对象，使用<bean>, @Component, @Repository, @Service, @Controller
（4）SpringMVC能够创建对象， 放入到SpringMVC容器中， springmvc容器中放的是控制器对象。
（5）我们要做的是 使用@Contorller创建控制器对象， 把对象放入到springmvc容器中， 把创建的对象作为控制器使用。这个控制器对象能接收用户的请求， 显示处理结果，就当做是一个servlet使用。
（6）使用@Controller注解创建的是一个普通类的对象， 不是Servlet。 springmvc赋予了控制器对象一些额外的功能。
（7）web开发底层是servlet， springmvc中有一个对象是Servlet ：即DispatherServlet(中央调度器)
（8）DispatherServlet: 负责接收用户的所有请求， 用户把请求给了DispatherServlet， 之后DispatherServlet把请求转发给我们的Controller对象， 最后是Controller对象处理请求。

1.3 SpringMVC的优点

（1）基于 MVC 架构，功能分工明确。解耦合
（2）容易理解，上手快；使用简单。
可以开发一个注解的 SpringMVC 项目， SpringMVC 也是轻量级的， jar 很小。不依赖特定的接口和类。
（3）作 为 Spring 框 架 一 部 分 ， 能 够 使 用 Spring 的 IoC 和 Aop 。 方 便 整 合Strtus,MyBatis,
Hiberate,JPA 等其他框架。
（4）SpringMVC 强化注解的使用，在控制器， Service， Dao 都可以使用注解。方便灵活。
使用@Controller 创建处理器对象,@Service 创建业务对象， @Autowired 或者@Resource
在控制器类中注入 Service, Service 类中注入 Dao。

1.4 实现步骤

jsp-----DispatherServlet(底层是Servlet)----转发，分配给—Controller对象（@Controller注解创建的对象）
（1）新建web maven工程，可以使用模板创建

（2）加入依赖
①spring-webmvc依赖，间接会把spring的依赖都加入到项目
②jsp，servlet依赖
（3）重点：在web.xml中注册SpringMVC框架的核心对象DispatcherServlet
①DispatcherServlet叫做中央调度器，是一个servlet,它的父类继承HttpServlet
②DispatcherServlet也叫做前端控制器
③DispatcherServlet负责接收用户提交的请求，调用其他的控制器对象，并把请求的处理结果显示给用户
（4）创建一个发起请求的页面 index.jsp
（5）创建控制器类
①在类的上面加入@Controller注解，创建对象，并加入到SpringMVC容器中
②在类中的方法上加入@RequestMapping注解
（6）创建一个作为结果的jsp，显示请求的处理结果
（7）创建SpringMVC的配置文件(其实和spring的配置文件都一样)
①声明组件扫描器，指定@Controller注解所在的包名
②声明视图解析器，帮助处理视图的
声明，注册springmvc的核心对象DispatcherServlet
思考：为什么要创建DispatcherServlet对象的实例呢(需要在tomcat服务器启动后，创建对象实例)？
因为DispatcherServlet在它的创建过程中，会同时创建SpringMVC容器对象，读取SpringMVC的配置文件，把这个配置文件中的对象都创建好，当用户发起请求时就可以直接使用对象了。
servlet的初始化会执行init()方法。DispatcherServlet在init()中{
//创建容器，读取配置文件
WebApplicationContext ctx = new ClassPathXmlApplicationContext(“springmvc.xml”);
//把容器对象放入到ServletContext中
getServletContext().setAttribute(key,ctx);
}

1.5 配置web.xml

注册SpringMVC的前端控制器DispatcherServlet
（1）默认配置方式

此配置作用下，SpringMVC的配置文件默认位于WEB-INF下，默认名称为<servlet-name>- servlet.xml，例如，以下配置所对应SpringMVC的配置文件位于WEB-INF下，文件名为springMVC- servlet.xml

<!-- 配置SpringMVC的前端控制器，对浏览器发送的请求统一进行处理 -->
<servlet>
	<servlet-name>springMVC</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet- class>
</servlet>
<servlet-mapping>
	<servlet-name>springMVC</servlet-name>
<!--
设置springMVC的核心控制器所能处理的请求的请求路径
/所匹配的请求可以是/login或.html或.js或.css方式的请求路径 但是/不能匹配.jsp请求路径的请求
（jsp本质是servlet）
-->
	<url-pattern>/</url-pattern>
</servlet-mapping>

（2）扩展配置方式
可通过init-param标签设置SpringMVC配置文件的位置和名称，通过load-on-startup标签设置
SpringMVC前端控制器DispatcherServlet的初始化时间

<servlet>
	<servlet-name>springMVC</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet- class>
	<!-- springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/<servlet-name>-servlet.xml -->
	<!-- 通过初始化参数指定SpringMVC配置文件的位置和名称 -->
	<init-param>
	<!-- contextConfigLocation为固定值 -->
		<param-name>contextConfigLocation</param-name>
	<!--  使用classpath:表示从类路径查找配置文件，例如maven工程中的
            src/main/resources -->
		<param-value>classpath:springMVC.xml</param-value>
	</init-param>
<!--
作为框架的核心组件，在启动过程中有大量的初始化操作要做 而这些操作放在第一次请求时才执行会严重影响访问速度 因此需要通过此标签将启动控制DispatcherServlet的初始化时间提前到服务器启动时
-->
	<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
	<servlet-name>springMVC</servlet-name>
	<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- 注：
<url-pattern>标签中使用/和/*的区别：
/所匹配的请求可以是/login或.html或.js或.css方式的请求路径，但是/不能匹配.jsp请求路径的请     求
因此就可以避免在访问jsp页面时，该请求被DispatcherServlet处理，从而找不到相应的页面
/*则能够匹配所有请求，例如在使用过滤器时，若需要对所有请求进行过滤，就需要使用/*的写     法
-->

1.6 创建请求控制器

（1）由于前端控制器对浏览器发送的请求进行了统一的处理，但是具体的请求有不同的处理过程，因此需要 创建处理具体请求的类，即请求控制器
请求控制器中每一个处理请求的方法成为控制器方法
（2）因为SpringMVC的控制器由一个POJO（普通的Java类）担任，因此需要通过@Controller注解将其标识 为一个控制层组件，交给Spring的IoC容器管理，此时SpringMVC才能够识别控制器的存在

@Controller
public class HelloController {

}

1.7 创建springMVC的配置文件

<!-- 自动扫描包 -->
<context:component-scan   base-package="com.atguigu.mvc.controller"/>

<!-- 配置Thymeleaf视图解析器 -->
<bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
	//可以配置多个，使用优先级来区分
	<property name="order" value="1"/>  
	<property name="characterEncoding" value="UTF-8"/>
	<property name="templateEngine">
		<bean  class="org.thymeleaf.spring5.SpringTemplateEngine">
			<property name="templateResolver">
				<bean   	class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">

					<!-- 视图前缀 -->
					<property name="prefix" value="/WEB-INF/templates/"/>
					<!-- 视图后缀 -->
					<property name="suffix" value=".html"/>
					//模板模型为HTML5 
					<property name="templateMode" value="HTML5"/>
					<property name="characterEncoding" value="UTF-8" />
				</bean>
			</property>
		</bean>
	</property>
</bean>

<!--
处理静态资源，例如html、js、css、jpg 若只设置该标签，则只能访问静态资源，其他请求则无法访问 此时必须设置<mvc:annotation-driven/>解决问题
-->
<mvc:default-servlet-handler/>

<!-- 开启mvc注解驱动 -->
<mvc:annotation-driven>
	<mvc:message-converters>
		<!-- 处理响应中文内容乱码 -->
		<bean class="org.springframework.http.converter.StringHttpMessageConverter">
			<property name="defaultCharset" value="UTF-8" />
			<property name="supportedMediaTypes">
				<list>
					<value>text/html</value>
					<value>application/json</value>
				</list>
			</property>
		</bean>
	</mvc:message-converters>
</mvc:annotation-driven>

1.8 例子

浏览器发送请求，若请求地址符合前端控制器的url-pattern，该请求就会被前端控制器 DispatcherServlet处理。前端控制器会读取SpringMVC的核心配置文件，通过扫描组件找到控制器， 将请求地址和控制器中@RequestMapping注解的value属性值进行匹配，若匹配成功，该注解所标识的 控制器方法就是处理请求的方法。处理请求的方法需要返回一个字符串类型的视图名称，该视图名称会 被视图解析器解析，加上前缀和后缀组成视图的路径，通过Thymeleaf对视图进行渲染，最终转发到视 图所对应页面

（1）创建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">
    <servlet>
        <!-- springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/<servlet-name>-servlet.xml -->
        <servlet-name>springmvc</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创建对象的时间就越早
        -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!-- 使用框架的时候，url-pattern可以使用两种值
         1.使用扩展名方式，语法 *.xxx(xxx是自定义的扩展名)
         例如:http://localhost:8080/myweb/some.do
        2.使用斜杠 “/”
         -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

（2）创建index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <p>第一个springmvc项目</p>
    <p><a href="some.do">发起some.do的请求</a></p>
</body>
</html>

（3）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"
       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.mvc.controller"/>
</beans>

（4）MyController

/**
 * @Controller:创建处理器对象,对象放在springmvc容器中 位置：在类的上面
 * 和spring中讲的@Service，@Component实际上都一样
 * 能够处理请求的都是控制器(处理器)，MyController叫做后端控制器
 */
@Controller
public class MyController {
    /**
     * @RequestMapping：请求映射，作用是把一个请求地址和一个方法绑定在一起。 一个请求指定一个方法处理
     * 属性：1.value 是一个String，表示请求的url地址(比如some.do)
     * value的值必须是唯一的，不能重复
     * 位置：1.在方法的上面
     * 2.在类的上面
     * 说明：使用@RequestMapping修饰的方法叫做处理器方法或者控制器方法
     * 使用@RequestMapping修饰的方法可以处理请求，类似Servlet中的doGet，doPost
     * 返回值：ModelAndView
     * Model:数据，请求处理完成后，要显示给用户的数据
     * View：视图，比如jsp等等
     */
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome() {
        ModelAndView mv = new ModelAndView();
        //添加数据,框架在请求的最后把数据放入到request作用域
        //request.setAttribute("msg","欢迎使用springmvc做web开发");
        mv.addObject("msg", "欢迎使用springmvc做web开发");
        mv.addObject("fun", "执行的是doSome方法");
//        指定视图，指定视图的完整路径
//        框架对视图执行的forward操作，request.getRequestDispatcher("/show.jsp").forward(...)
        mv.setViewName("/show.jsp");
        return mv;

    }
}dkd

（5）show.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h3>show.jsp</h3>
<h3>msg数据：${msg}</h3>
<h3>fun数据：${fun}</h3>
</body>
</html>

2.@RequestMapping注解

（1）@RequestMapping注解的功能

• 从注解名称上我们可以看到，@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联 起来，建立映射关系。
• SpringMVC 接收到指定的请求，就会来找到在映射关系中对应的控制器方法来处理这个请求。

（2）@RequestMapping注解的位置

• @RequestMapping标识一个类：设置映射请求的请求路径的初始信息
• @RequestMapping标识一个方法：设置映射请求请求路径的具体信息

（3）@RequestMapping注解的value属性

• @RequestMapping注解的value属性通过请求的请求地址匹配请求映射
• @RequestMapping注解的value属性是一个字符串类型的数组，表示该请求映射能够匹配多个请求地址 所对应的请求
• @RequestMapping注解的value属性必须设置，至少通过请求地址匹配请求映射

（4）@RequestMapping注解的method属性

• @RequestMapping注解的method属性通过请求的请求方式（get或post）匹配请求映射
• @RequestMapping注解的method属性是一个RequestMethod类型的数组，表示该请求映射能够匹配 多种请求方式的请求
• 若当前请求的请求地址满足请求映射的value属性，但是请求方式不满足method属性，则浏览器报错405：Request method ‘POST’ not supported
• 如果不写method属性，则表示不以method为匹配条件，什么请求方式都可以

@RequestMapping(
value = {"/testRequestMapping", "/test"},
method = {RequestMethod.GET, RequestMethod.POST}
)
public String testRequestMapping(){ return "success";

（5）注：
①对于处理指定请求方式的控制器方法，SpringMVC中提供了@RequestMapping的派生注解

• 处理get请求的映射–>@GetMapping
• 处理post请求的映射–>@PostMapping
• 处理put请求的映射–>@PutMapping
• 处理delete请求的映射–>@DeleteMapping

②常用的请求方式有get，post，put，delete，但是目前浏览器只支持get和post（浏览器只能通过地址栏直接发送get或者通过表单发送post），若在form表单提交时，为method设置了其他请求方式的字符串（put或delete），则按照默认的请求方式get处理。若要发送put和delete请求，则需要通过spring提供的过滤器HiddenHttpMethodFilter。
（6）@RequestMapping注解的headers属性
①@RequestMapping注解的headers属性通过请求的请求头信息匹配请求映射
②@RequestMapping注解的headers属性是一个字符串类型的数组，可以通过四种表达式设置请求头信 息和请求映射的匹配关系

• “header”：要求请求映射所匹配的请求必须携带header请求头信息
• “!header”：要求请求映射所匹配的请求必须不能携带header请求头信息
• “header=value”：要求请求映射所匹配的请求必须携带header请求头信息且header=value
• “header!=value”：要求请求映射所匹配的请求必须携带header请求头信息且header!=value

③若当前请求满足@RequestMapping注解的value和method属性，但是不满足headers属性，此时页面 显示404错误，即资源未找到

2.1 SpringMVC支持ant风格的路径

（1）？：表示任意的单个字符
（2）*：表示任意的0个或多个字符
（3）**：表示任意的一层或多层目录 注意：在使用**时，只能使用/**/xxx的方式（如果写成/a**a/则表示两个单*的作用）

2.2 SpringMVC支持路径中的占位符

（1）原始方式：/deleteUser?id=1
（2）rest方式：/deleteUser/1
（3）SpringMVC路径中的占位符常用于RESTful风格中，当请求路径中将某些数据通过路径的方式传输到服 务器中，就可以在相应的@RequestMapping注解的value属性中通过占位符{xxx}表示传输的数据，在 通过@PathVariable注解，将占位符所表示的数据赋值给控制器方法的形参

<a   th:href="@{/testRest/1/admin}">测试路径中的占位符-->/testRest</a><br>

@RequestMapping("/testRest/{id}/{username}")
public String testRest(@PathVariable("id") String id, @PathVariable("username") String username){
	System.out.println("id:"+id+",username:"+username);
	return "success";
}
//最终输出的内容为-->id:1,username:admin

3.SpringMVC获取请求参数

3.1 通过ServletAPI获取

将HttpServletRequest作为控制器方法的形参，此时HttpServletRequest类型的参数表示封装了当前请求的请求报文的对象

@RequestMapping("/testParam")
public String testParam(HttpServletRequest request){
	 String username = request.getParameter("username"); 			
	 String password = request.getParameter("password");
	 System.out.println("username:"+username+",password:"+password); 
	 return "success";

3.2 通过控制器方法的形参获取请求参数

（1）在控制器方法的形参位置，设置和请求参数同名的形参，当浏览器发送请求，匹配到请求映射时，在
DispatcherServlet中就会将请求参数赋值给相应的形参

<a th:href="@{/testParam(username='admin',password=123456)}">
测试获取请求参数-->/testParam</a><br>

@RequestMapping("/testParam")
public String testParam(String username, String password){ 			   	
	System.out.println("username:"+username+",password:"+password); 
 	return "success";
}

（2）注：若请求所传输的请求参数中有多个同名的请求参数，此时可以在控制器方法的形参中设置字符串 数组或者字符串类型的形参接收此请求参数
①若使用字符串数组类型的形参，此参数的数组中包含了每一个数据
②若使用字符串类型的形参，此参数的值为每个数据中间使用逗号拼接的结果

3.3 @RequestParam

（1）@RequestParam是将请求参数和控制器方法的形参创建映射关系
（2）@RequestParam注解一共有三个属性：

• value：指定为形参赋值的请求参数的参数名
• required：设置是否必须传输此请求参数，默认值为true
  ①若设置为true时，则当前请求必须传输value所指定的请求参数，若没有传输该请求参数，且没有设置 defaultValue属性，则页面报错400：Required String parameter ‘xxx’ is not present；
  ②若设置为 false，则当前请求不是必须传输value所指定的请求参数，若没有传输，则注解所标识的形参的值为 null
• defaultValue：不管required属性值为true或false，当value所指定的请求参数没有传输或传输的值 为""时，则使用默认值为形参赋值

3.4 @RequestHeader

（1）@RequestHeader是将请求头信息和控制器方法的形参创建映射关系
（2）@RequestHeader注解一共有三个属性：value、required、defaultValue，用法同@RequestParam

3.5 @CookieValue

（1）@CookieValue是将cookie数据和控制器方法的形参创建映射关系
（2）@CookieValue注解一共有三个属性：value、required、defaultValue，用法同@RequestParam

3.6 通过POJO获取请求参数

可以在控制器方法的形参位置设置一个实体类类型的形参，此时若浏览器传输的请求参数的参数名和实体类中的属性名一致，那么请求参数就会为此属性赋值

<form th:action="@{/testpojo}" method="post"> 
	用户名：<input type="text" name="username"><br> 
	密码：<input type="password" name="password"><br>
	性别：<input type="radio" name="sex" value="男">男<input type="radio" name="sex" value="女">女<br>
	年龄：<input type="text" name="age"><br>
	邮箱：<input type="text" name="email"><br>
		 <input type="submit">
</form>

@RequestMapping("/testpojo") public String testPOJO(User user){
	System.out.println(user); 
	return "success";
}
//最终结果-->User{id=null, username='张三', password='123', age=23, sex='男', email='123@qq.com'}

3.7 解决获取请求参数的乱码问题

解决获取请求参数的乱码问题，可以使用SpringMVC提供的编码过滤器CharacterEncodingFilter，但是 必须在web.xml中进行注册

<!--配置springMVC的编码过滤器-->
<filter>
	<filter-name>CharacterEncodingFilter</filter-name>
	<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
	<init-param>
		<param-name>encoding</param-name>
		<param-value>UTF-8</param-value>
	</init-param>
	<init-param>
		<param-name>forceResponseEncoding</param-name>
		<param-value>true</param-value>
	</init-param>
</filter>
<filter-mapping>
	<filter-name>CharacterEncodingFilter</filter-name>
	<url-pattern>/*</url-pattern>
</filter-mapping>

注：SpringMVC中处理编码的过滤器一定要配置到其他过滤器之前，否则无效

4.域对象共享数据

4.1 使用ServletAPI向request域对象共享数据

@RequestMapping("/testServletAPI")
public String testServletAPI(HttpServletRequest request){
 	request.setAttribute("testScope", "hello,servletAPI");
  	return "success";
}

4.2 使用ModelAndView向request域对象共享数据

@RequestMapping("/testModelAndView") 
public ModelAndView testModelAndView(){
	/**
	* ModelAndView有Model和View的功能
	* Model主要用于向请求域共享数据
	* View主要用于设置视图，实现页面跳转
	*/
	ModelAndView mav = new ModelAndView();
	//向请求域共享数据
	mav.addObject("testScope","hello,ModelAndView");
	//设置视图，实现页面跳转 
	mav.setViewName("success"); 
	return mav;
}

4.3 使用ModelMap向request域对象共享数据

@RequestMapping("/testModelMap")
public String testModelMap(ModelMap modelMap){ 
	modelMap.addAttribute("testScope", "hello,ModelMap"); 
	return "success";
}

4.4 Model、ModelMap、Map的关系

Model、ModelMap、Map类型的参数其实本质上都是 BindingAwareModelMap 类型的

public interface Model{}
public class ModelMap extends LinkedHashMap<String, Object> {}
public class ExtendedModelMap extends ModelMap implements Model {}
public class BindingAwareModelMap extends ExtendedModelMap {}

4.5 向session域共享数据

@RequestMapping("/testSession")
public String testSession(HttpSession session){ 
	session.setAttribute("testSessionScope", "hello,session"); 
	return "success";
}

4.6 向application域共享数据

@RequestMapping("/testApplication")
public String testApplication(HttpSession session){
	ServletContext application = session.getServletContext();
	application.setAttribute("testApplicationScope", "hello,application"); 
	return "success";
}

5.SpringMVC的视图

（1）SpringMVC中的视图是View接口，视图的作用渲染数据，将模型Model中的数据展示给用户
（2）SpringMVC视图的种类很多，默认有转发视图InternalResourceView和重定向视图RedirectView
①当工程引入jstl的依赖，转发视图会自动转换为JstlView
②若使用的视图技术为Thymeleaf，在SpringMVC的配置文件中配置了Thymeleaf的视图解析器，由此视图解析器解析之后所得到的是ThymeleafView

5.1 ThymeleafView

（1）当控制器方法中所设置的视图名称没有任何前缀时，此时的视图名称会被SpringMVC配置文件中所配置 的视图解析器解析，视图名称拼接视图前缀和视图后缀所得到的最终路径，会通过转发的方式实现跳转
（2）配置Thymeleaf视图解析器

<bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
    <property name="order" value="1"/>
    <property name="characterEncoding" value="UTF-8"/>
    <property name="templateEngine">
        <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
            <property name="templateResolver">
                <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
    
                    <!-- 视图前缀 -->
                    <property name="prefix" value="/WEB-INF/templates/"/>
    
                    <!-- 视图后缀 -->
                    <property name="suffix" value=".html"/>
                    <property name="templateMode" value="HTML5"/>
                    <property name="characterEncoding" value="UTF-8" />
                </bean>
            </property>
        </bean>
    </property>
</bean>

（3）示例：

@RequestMapping("/testHello") 
public String testHello(){
	return "hello";
}

5.2 转发视图

（1）SpringMVC中默认的转发视图是InternalResourceView
（2）SpringMVC中创建转发视图的情况：
当控制器方法中所设置的视图名称以"forward:"为前缀时，创建InternalResourceView视图，此时的视 图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀"forward:"去掉，剩余部分作为最终路径通过转发的方式实现跳转

@RequestMapping("/testForward") 
public String testForward(){
	return "forward:/testHello";
}

5.3 重定向视图

（1）SpringMVC中默认的重定向视图是RedirectView
（2）当控制器方法中所设置的视图名称以"redirect:"为前缀时，创建RedirectView视图，此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀"redirect:"去掉，剩余部分作为最 终路径通过重定向的方式实现跳转

@RequestMapping("/testRedirect") 
public String testRedirect(){
	return "redirect:/testHello";
}

（3）注：重定向视图在解析时，会先将redirect:前缀去掉，然后会判断剩余部分是否以/开头，若是则会自 动拼接上下文路径

5.4 视图控制器view-controller

（1）当控制器方法中，仅仅用来实现页面跳转，即只需要设置视图名称时，可以将处理器方法使用view- controller标签进行表示

<!--
path：设置处理的请求地址
view-name：设置请求地址所对应的视图名称
-->
<mvc:view-controller  path="/testView"  view-name="success"></mvc:view-controller>

（2）注：当SpringMVC中设置任何一个view-controller时，其他控制器中的请求映射将全部失效，此时需 要在SpringMVC的核心配置文件中设置开启mvc注解驱动的标签：

<mvc:annotation-driven />

6.RESTful

6.1 RESTful简介

REST：Representational State Transfer，表现层资源状态转移。
①资源
资源是一种看待服务器的方式，即，将服务器看作是由很多离散的资源组成。每个资源是服务器上一个 可命名的抽象概念。因为资源是一个抽象的概念，所以它不仅仅能代表服务器文件系统中的一个文件、 数据库中的一张表等等具体的东西，可以将资源设计的要多抽象有多抽象，只要想象力允许而且客户端 应用开发者能够理解。与面向对象设计类似，资源是以名词为核心来组织的，首先关注的是名词。一个 资源可以由一个或多个URI来标识。URI既是资源的名称，也是资源在Web上的地址。对某个资源感兴 趣的客户端应用，可以通过资源的URI与其进行交互。
②资源的表述
资源的表述是一段对于资源在某个特定时刻的状态的描述。可以在客户端-服务器端之间转移（交 换）。资源的表述可以有多种格式，例如HTML/XML/JSON/纯文本/图片/视频/音频等等。资源的表述格 式可以通过协商机制来确定。请求-响应方向的表述通常使用不同的格式。
③状态转移
状态转移说的是：在客户端和服务器端之间转移（transfer）代表资源状态的表述。通过转移和操作资 源的表述，来间接实现操作资源的目的。

6.2 RESTful的实现

（1）具体说，就是 HTTP 协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。
（2）它们分别对应四种基本操作：
GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE 用来删除资源。
（3）REST 风格提倡 URL 地址使用统一的风格设计，从前到后各个单词使用斜杠分开，不使用问号键值对方 式携带请求参数，而是将要发送给服务器的数据作为 URL 地址的一部分，以保证整体风格的一致性。

6.3 HiddenHttpMethodFilter

（1）由于浏览器只支持发送get和post方式的请求，那么该如何发送put和delete请求呢？
SpringMVC 提供了 HiddenHttpMethodFilter 帮助我们将 POST 请求转换为 DELETE 或 PUT 请求
（2）HiddenHttpMethodFilter 处理put和delete请求的条件：
①当前请求的请求方式必须为post
②当前请求必须传输请求参数 method
满足以上条件，HiddenHttpMethodFilter 过滤器就会将当前请求的请求方式转换为请求参数
method的值，因此请求参数 method的值才是最终的请求方式
（3）在web.xml中注册HiddenHttpMethodFilter

<filter>
	<filter-name>HiddenHttpMethodFilter</filter-name>
	<filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter- class>
</filter>
<filter-mapping>
	<filter-name>HiddenHttpMethodFilter</filter-name>
	<url-pattern>/*</url-pattern>
</filter-mapping>

（4）注：目前为止，SpringMVC中提供了两个过滤器：
CharacterEncodingFilter和HiddenHttpMethodFilter
在web.xml中注册时，必须先注册CharacterEncodingFilter，再注册HiddenHttpMethodFilter 原因：
在 CharacterEncodingFilter 中通过 request.setCharacterEncoding(encoding) 方法设置字 符集的
request.setCharacterEncoding(encoding) 方法要求前面不能有任何获取请求参数的操作 而 HiddenHttpMethodFilter 恰恰有一个获取请求方式的操作：

String paramValue = request.getParameter(this.methodParam);	

7.HttpMessageConverter

（1）HttpMessageConverter，报文信息转换器，将请求报文转换为Java对象，或将Java对象转换为响应报文
（2）HttpMessageConverter提供了两个注解和两个类型：@RequestBody，@ResponseBody， RequestEntity，
ResponseEntity

7.1 @RequestBody

（1）@RequestBody可以获取请求体，需要在控制器方法设置一个形参，使用@RequestBody进行标识，当前请求的请求体就会为当前注解所标识的形参赋值

<form th:action="@{/testRequestBody}" method="post">
	 用户名：<input type="text" name="username"><br> 
	 密码：<input type="password" name="password"><br>
	 <input type="submit">
</form>

@RequestMapping("/testRequestBody")
public String testRequestBody(@RequestBody String requestBody){ 		
    System.out.println("requestBody:"+requestBody);
	return "success";
}

（2）输出结果：
requestBody:username=admin&password=123456

7.2 RequestEntity

RequestEntity封装请求报文的一种类型，需要在控制器方法的形参中设置该类型的形参，当前请求的 请求报文就会赋值给该形参，可以通过getHeaders()获取请求头信息，通过getBody()获取请求体信息

@RequestMapping("/testRequestEntity")
public String testRequestEntity(RequestEntity<String> requestEntity){  	
	System.out.println("requestHeader:"+requestEntity.getHeaders()); 	
	System.out.println("requestBody:"+requestEntity.getBody());
	return "success";
}

输出结果： requestHeader:[host:“localhost:8080”, connection:“keep-alive”, content-length:“27”, cache-control:“max-age=0”, sec-ch-ua:“” Not A;Brand";v=“99”, “Chromium”;v=“90”, “Google Chrome”;v=“90"”, sec-ch-ua-mobile:“?0”, upgrade-insecure-requests:“1”, origin:“http://localhost:8 080”, user-agent:“Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.93 Safari/537.36”] requestBody:username=admin&password=123

7.3 @ResponseBody

@ResponseBody用于标识一个控制器方法，可以将该方法的返回值直接作为响应报文的响应体响应到 浏览器

@RequestMapping("/testResponseBody")
@ResponseBody
public String testResponseBody(){ 
	return "success";
}

结果：浏览器页面显示success

7.4 SpringMVC处理json

（1）@ResponseBody处理json的步骤：
a>导入jackson的依赖

<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-databind</artifactId>
	<version>2.12.1</version>
</dependency>

b>在SpringMVC的核心配置文件中开启mvc的注解驱动，此时在HandlerAdaptor中会自动装配一个消 息转换器：MappingJackson2HttpMessageConverter，可以将响应到浏览器的Java对象转换为Json格 式的字符串

   <mvc:annotation-driven />	

c>在处理器方法上使用@ResponseBody注解进行标识
d>将Java对象直接作为控制器方法的返回值返回，就会自动转换为Json格式的字符串

@RequestMapping("/testResponseUser")
@ResponseBody
public User testResponseUser(){
	return new User(1001,"admin","123456",23,"男");
}

浏览器的页面中展示的结果：
{“id”:1001,“username”:“admin”,“password”:“123456”,“age”:23,“sex”:“男”}

7.5 @RestController注解

@RestController注解是springMVC提供的一个复合注解，标识在控制器的类上，就相当于为类添加了
@Controller注解，并且为其中的每个方法添加了@ResponseBody注解

7.6 ResponseEntity

ResponseEntity用于控制器方法的返回值类型，该控制器方法的返回值就是响应到浏览器的响应报文

8.文件上传和下载

8.1 文件下载

使用ResponseEntity实现下载文件的功能

@RequestMapping("/testDown")
public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws IOException {
//获取ServletContext对象
ServletContext servletContext = session.getServletContext();
//获取服务器中文件的真实路径
String realPath = servletContext.getRealPath("/static/img/1.jpg");
//创建输入流
InputStream is = new FileInputStream(realPath);
//创建字节数组
byte[] bytes = new byte[is.available()];
//将流读到字节数组中 is.read(bytes);
//创建HttpHeaders对象设置响应头信息
MultiValueMap<String, String> headers = new HttpHeaders();
//设置要下载方式以及下载文件的名字
headers.add("Content-Disposition","attachment;filename=1.jpg");
//设置响应状态码
HttpStatus statusCode = HttpStatus.OK;
//创建ResponseEntity对象
ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers, statusCode);
//关闭输入流
is.close();
return responseEntity;
}

8.2 文件上传

文件上传要求form表单的请求方式必须为post，并且添加属性enctype=“multipart/form-data” SpringMVC中将上传的文件封装到MultipartFile对象中，通过此对象可以获取文件相关信息 上传步骤：
a>添加依赖：

<!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
<dependency>
	<groupId>commons-fileupload</groupId>
	<artifactId>commons-fileupload</artifactId>
	<version>1.3.1</version>
</dependency>

b>在SpringMVC的配置文件中添加配置：

<!--必须通过文件解析器的解析才能将文件转换为MultipartFile对象-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
</bean>

c>控制器方法：

@RequestMapping("/testUp")
public String testUp(MultipartFile photo, HttpSession session) throws IOException {
//获取上传的文件的文件名
String fileName = photo.getOriginalFilename();
//处理文件重名问题
String hzName = fileName.substring(fileName.lastIndexOf("."));
fileName = UUID.randomUUID().toString() + hzName;
//获取服务器中photo目录的路径
ServletContext servletContext = session.getServletContext(); 
String photoPath = servletContext.getRealPath("photo");
File file = new File(photoPath); 
if(!file.exists()){
	file.mkdir();
}
String finalPath = photoPath + File.separator + fileName;
//实现上传功能
photo.transferTo(new File(finalPath));
	return "success";
}