SpringMVC
SpringMVC简介
什么是MVC
MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分
M：Model，模型层，指工程中的JavaBean，作用是处理数据
JavaBean分为两类：
- 一类称为实体类：专门存储业务数据的，如Student、User等
- 一类称为业务处理Bean：指Service或Dao对象，专门用于处理业务逻辑和数据访问
V：View，视图层，指工程中的Html或jsp等页面，作用是与用户进行交互，展示数据
C:Controller，控制层，指工程中的Servlet，作用是接受请求和响应浏览器
MVC的工作流程：
用户通过视图层发送请求到服务器，在服务器中请求被Controller接收，Controller调用相应的Model层处理请求，处理完毕将结果返回到Controller，Controller再根据请求处理的结果找到相应的View视图，渲染数据后最终响应给浏览器
什么是SpringMVC
SpringMVC是Spring的一个后续产品，是Spring的一个子项目
SpringMVC是Spring为表述层开发提供的一套完备的解决方案
注：三层架构分为表述层（表示层）、业务逻辑层、数据访问层，表述层表示前台页面和后台servlet
SpringMVC的特点
- Spring家族原生产品，与IOC容器等基础设施无缝对接
- 基于原生Servlet，通过了功能强大的前端控制器DispatcherServlet，对请求和响应进行统一处理
- 表述层各细分领域需要解决的问题全方位覆盖，提供全面解决方案
- 代码清新简洁，大幅度提升开发效率
- 内部组件化程度高，可插拔式组件即插即用，想要什么功能配置想要组件即可
- 性能卓著，尤其适合现代大型、超大型互联网项目需求
创建Maven工程
HelloWorld
a>添加web模块
b>打包方式：war
c>引入依赖
<dependencies>
<!--SpringMVC-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.1</version>
</dependency>
<!--日志-->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.3</version>
</dependency>
<!--ServletAPI-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<!--Spring5和Thymeleaf整合包-->
<dependency>
<groupId>org.thymeleaf</groupId>
<artifactId>thymeleaf-spring5</artifactId>
<version>3.0.12.RELEASE</version>
</dependency>
</dependencies>
注：由于Maven的传递性，我们不必将所有需要的包全部配置依赖，而是配置最顶配的依赖，其他靠传递性注入
配置web.xml
注册SpringMVC的前端控制器DispatherServlet
a>默认配置方式
此配置作用下，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或.css或.css方式的请求路径
但是/不能匹配.jsp请求路径的请求
-->
<url-pattern>/</url-pattern>
</servlet-mapping>
b>扩展配置方式
可通过init-param标签设置SpringMVC配置文件的位置和名称，通过load-on-startup标签设置SpringMVC前端控制器DispatcherServlet的初始化时间
<!--配置SpringMVC的前端控制器，对浏览器发送的请求进行统一处理-->
<servlet>
<servlet-name>SpringMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--配置SpringMVC配置文件的位置和名称-->
<init-param>
<param-name>contextConfigLocation</param-name>
<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>
创建请求控制器
由于前端控制器对浏览器发送的请求进行了统一处理，但是具体的请求有不同的处理过程，因此需要创建处理器具体请求的类，即请求控制器
请求控制器中每一个处理请求的方法成为控制器方法
因为SpringMVC的控制器由一个POJO（普通的Java类）担任，因此需要通过@Controller注解将其标识为一个控制层组件，交给Spring的IoC容器管理，此时SpringMVC才能识别控制器的存在
@Controller
public class HelloController{
}
创建SpringMVC的配置文件
<!--扫描组件-->
<context:component-scan base-package="com.cedric.mvc.controller"></context:component-scan>
<!--配置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>
测试HelloWorld
a>实现对首页的访问
在请求控制器中创建处理请求对象的方法
// @RequesMapping注解:处理请求和控制器方法之间的映射关系
// @RequesMapping注解的value属性可以通过请求地址匹配请求，/表示当前工程的上下文路径
// “/” --> /WEB-INF/templates/index.html
@RequestMapping( "/")
public String index(){
// 返回视图名称
return "index";
}
b>访问指定页面
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>首页</h1>
<a th:href="@{/target}">访问目标文件target.html</a>
</body>
</html>
在请求控制器中创建处理请求的方法
@RequestMapping("/target")
public String toTarget(){
return "target";
}
总结
浏览器发送请求，若请求地址符合前端控制器的url-pattern，该请求就会被前端控制器DispatherServlet处理。 前端控制器会读取SpringMVC的核心配置文件，通过扫描组件找到控制器， 将请求地址和控制器中@RequestMapping注解的value 属性值进行匹配，若匹配成功，该注解所标识的控制器方法就是处理请求的方法。 处理请求的方法需要返回一个字符串类型的视图 名称，该视图名称会被视图解析器，加上前缀和后缀组成视图的路径，通过Thymeleaf对视图进行渲染， 最终转发到视图所对应页面
@RequestMapping注解
@RequestMapping注解给功能
从注解的名称上我们可以看到，@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来，建立映射的关系
SpringMVC接收到指定的请求，就会来找到在映射关系中对应的控制器方法来处理这个请求
@RequestMapping注解的位置
@RequestMapping标识一个类：设置映射请求的路径的初始信息
@RequestMapping标识一个方法：设置映射请求请求路径的具体信息
@Controller
@RequestMapping("hello")
public class RequestMappingController {
// 此时请求映射所映射的请求路径为：/hello/testRequestMapping
@RequestMapping(
value = {"testRequestMapping"}
)
public String success(){
return "success";
}
@RequestMapping注解的value属性
@RequestMapping注解的value属性通过请求的请求地址匹配请求映射
@RequestMapping注解的value属性是一个字符串类型的数组，表示该请求映射能够匹配多个请求地址所对应的请求
@RequestMapping注解的value属性必须设置，至少通过请求地址匹配请求映射
<a th:href="@{testRequestMapping}">测试@RequestMapping注解的value属性--》testRequestMapping</a><br>
<a th:href="@{test}">测试@RequestMapping注解的value属性--》test</a><br>
@RequestMapping(
value = {"testRequestMapping","test"}
)
public String testRequestMapping(){
return "success";
}
@RequestMapping注解的method属性
@RequestMapping注解的method属性通过请求的请求方式（get或post）匹配请求映射
@RequestMapping注解的method属性是一个RequestMethod类型的数组，表示该请求映射能够匹配多种请求方式
若当前的请求地址满足请求的映射的value属性，但是请求方式不满足method属性，则浏览器报错405
Request method ‘POST’ not supported
<a th:href="@{test}">测试@RequestMapping注解的value属性--》test</a><br>
<form th:action="test" method="post">
<input type="submit" value="测试@RequestMapping注解的method--》POST">
</form>
@RequestMapping(
value = {"testRequestMapping","test"},
method = {RequestMethod.GET,RequestMethod.POST}
)
public String testRequestMapping(){
return "success";
}
注：
1.对于处理指定请求方式的控制器方式,SpringMVC中提供了@RequestMapping的派生注解
处理get请求的映射-->@GetMapping
处理post请求的映射-->@PostMapping
处理put请求的映射-->@PutMapping
处理delete请求的映射-->@DeleteMapping
2.常用的请求方式有：get、post、delete、put
但是目前浏览器只支持get和post，若在form表单提交时，为method设置了其他请求方式的字符串（put或delete），则按照默认的请求方式get处理
若要发送put和delete请求，则需要通过Spring提供的过滤器HiddenHttpMethodFilter
@RequestMapping注解的param属性
@RequestMapping注解的params属性通过请求参数匹配请求映射
@RequestMapping注解的params属性是一个字符串类型的数组，可以通过四种表达方式设置请求参数和请求映射匹配关系
“param”：要求请求映射所匹配的请求必须携带params请求参数
“!param”:要求请求映射所匹配的请求必须不能携带param请求参数
"param=value":要求请求映射所匹配的请求必须携带param请求参数且param=value
"param!=value":要求请求映射所匹配的请求必须携带param请求参数，但是param！=value
<a th:href="@{/testParamsAndHeaders(username='admin',password=123456)}">测试@RequestMapping注解params属性-->/testParamsAndHeaders</a><br>
@RequestMapping(
value = {"testParamsAndHeaders","/test"},
method = {RequestMethod.GET,RequestMethod.POST}
params = {"username=admin","password=123456"}
)
public String testParamsAndHeaders(){
return "success";
}
@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错误（资源未找到）
SpringMVC支持ant风格的路径
?:表示任意单个字符
*：表示任意的0个或多个字符
：表示任意的一层或多层目录
注意：在使用时，只能使用/**/xxx的方式
SpringMVC支持路径中的占位符
原始方式：/deleteUser?id=1
rest方式：/deleteUser/1
SpringMVC路径中的占位符常用与restful风格中，当请求路径中将某些数据通过路径的方式传输到服务器中，就可以在相应的@RequestMapping注解的value属性中通过占位符{xxx}表示传输的数据，在通过@PathVariable注解，将占位符所表示的数据赋值给控制器方法的形参
<a th:href="@{/testRest/1/admin}">测试路径中的占位符--->/testRest</a><br>
@RequestMapping("testRest/{id}/{username}")
public String testRest(@PathVariable("id") Integer id,@PathVariable("username") String username){
System.out.println("id:" + id + "username:" + username);
return "success";
}
SpringMVC获取请求参数
通过ServletAPI获取
将HttpServletRequest作为控制器方法的形参，此时HttpServletRequest类型的参数表示封装了当前请求报文的对象
@RequestMapping("/testParam")
public String testParam(HttpServletRequest request){
String username = request.getParameter("username");
String password = requset.getParameter("password");
System.out.println("username:" + username + ",password" + password);
return "success";
}
通过控制器方法的形参获取请求参数
在控制器方法的形参位置，设置和请求参数同名的形参，当浏览器发送请求，匹配到请求映射时，在DispatcherServlet中就会将请求参数赋值给相应的形参
<a th:href="@{/testParam(username='admin',password=123456)}">测试使用控制器的形参获取请求参数</a>
@RequestMapping("/testParam")
public String testParam(String username,String password){
System.out.println("username:" + username + "password:" + password);
return "success";
}
注：
若请求所传输的请求参数中有多个同名的请求参数，此时可以在控制器方法的形参中设置字符串数组或字符串类型的形参接收此请求参数
若使用字符串数组类型的参数，此参数的数组中包含了每一个数据
若使用字符串类型的形参，此参数的值为每个数据中间使用逗号拼接的结果
@RequestParam
@RequestParam是将请求参数和控制器方法的形参创建映射关系
@RequestParam注解一共三个属性：
value：指定为形参赋值的请求参数的参数名
required：设置是否必须传输此请求参数，默认值为true
若设置为true时，则当前请求必须传输value所指定的请求参数，若没有传输该请求参数，且没有设置defaultValue属性，则页面报错404：Required String parameter ‘xxx’ is not present；若设置为false，则当前请求不是必须传输value所指定的请求参数，若没有传输，则注解所标识的形参值为null
defaultValue：不管required属性值为true或false，当value所指定的请求参数没有传输时，则使用默认值为形参赋值
@RequestHeader
@RequestHeader是将请求头信息和控制器方法的形参创建映射关系
@RequestHeader注解一共有三个属性：value、required、defaultValue，用法同@RequestParam
@CookieValue
@CookieValue是将cookie数据和控制器方法的形参创建映射关系
@CookieValue注解一共有三个属性，value、required、defaultValue，用法同@Requestparam
通过POJO获取请求参数
可以在控制器方法的形参位置设置一个实体类类型的形参，此时若浏览器传输的请求参数的参数名和实体类中的属性名一致，那么请求参数就会为此属性赋值
<form th:action="@{/testBean}" 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" value="使用实体类接受请求参数">
</form>
@RequestMapping("testBean")
public String testBean(User user){
System.out.println(user);
return "success";
}
解决获取请求参数的乱码问题
可以使用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>
域对象共享数据
使用sevletAPI向request域对象共享数据
@RequestMapping("/testRequestByServletAPI")
public String testRequestByServletAPI(HttpServletRequest request){
request.setAttribute("testRequestScope","hello,Servlet");
return "success";
}
使用ModelAndView向request域对象共享数据
@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView(){
/**
* ModelAndView有Model和View功能
* Model主要用于请求i对象域
* View主要用于设置视图，实现页面跳转
*/
ModelAndView mav = new ModelAndView();
// 处理模型数据，即向请求域request共享数据
mav.addObject("testRequestScope","hello,ModelAndView");
// 设置视图名称
mav.setViewName("success");
return mav;
}
使用Model向request域对象共享数据
@RequestMapping("/testModel")
public String testModel(Model model){
model.addAttribute("testRequestScope","hello,Model");
System.out.println("Model" + model.getClass().getName());
return "success";
}
使用Map向request域对象共享数据
@RequestMapping("/testMap")
public String testMap(Map<String,Object> map){
map.put("testRequestScope","hello,Map");
System.out.println("Map:" + map.getClass().getName());
return "success";
}
使用ModelMap向request域对象共享数据
@RequestMapping("/testModelMap")
public String testModelMap(ModelMap modelMap){
modelMap.addAttribute("testRequestScope","hello,modelMap");
System.out.println("ModelMap:" + modelMap.getClass().getName());
return "success";
}
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{}
向Session域共享数据
@RequestMapping("/testSession")
public String testSession(HttpSession session){
session.setAttribute("testSessionScope","hello,Session");
return "success";
}
向application域共享数据
@RequestMapping("/testApplication")
public String testApplication(HttpSession session){
session.setAttribute("testApplicationScope","hello,Application");
return "success";
}
SpringMVC的视图
SpringMVC中的视图时View接口吗，视图的作用渲染数据，将模型Model中的数据展示给用户
SpringMVC视图的种类有很多，默认有转发视图和重定向视图
当工程引入jstl的依赖，转发视图会自动转换为jstlView
若使用的视图技术是Thymeleaf，在SpringMVC的配置文件中配置了Thymeleaf的视图解析器，由此视图解析器解析之后所得到的是ThymeleafView
ThemeleafView
当控制器方法中所设置的视图名称没有任何前缀时，此时视图名称会被SpringMVC配置文件中所配置的视图解析器解析，视图名称拼接视图前缀和视图后缀所得到的最终路径，会通过转发的方式实现跳转
@RequestMapping("testThymeleafView")
public String testThymeleafView(){
return "success";
}
转发视图
SpringMVC中默认的转发视图是InternalResourceView
SpringMVC中创建转发视图的情况：
当控制器方法中所设置的的视图名称以"forward:"为前缀时，会创建InternalResourceView视图，此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀”forward：“去掉，剩余部分作为最终路径通过转发的方式实现跳转
@RequestMapping("/testForward")
public String testForward(){
return "forward:/testThymeleafView";
}
重定向视图
SpringMVC中默认的重定向视图RedirectView
当控制器方法中所设置的视图名称以"redirect:"为前缀时，创建RedirectView视图，此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀“redirect：”去掉，剩余部分作为最终路径通过重定向的方式实现跳转
@RequestMapping("testRedirect")
public String testRedirect(){
return "redirect:/testThymeleafView";
}
注：重定向视图在解析时，会先将redirect：前缀去掉，然后会判断剩余部分是否以/开头，若是则会将自动拼接上下文路径
视图控制器view-controller
当控制器方法中，仅仅用来实现页面跳转，即只需要设置视图名称时，可以将处理器方法使用view-controller标签进行表示
<!--
path:设置处理的请求地址
view-name：设置请求地址所对应的视图名称
-->
<mvc:view-controller path="/" view-name="index"></mvc:view-controller>
注：
当SpringMVC中设置任何一个view-controller时，其他控制器中的请求映射将会全部失效，此时需要在 SpringMVC的核心配置文件中设置开启mvc注解驱动的标签：
mvc:annotation-driven/
RESTFul
RESTFul简介
REST：Representational State Transfer，表现层资源状态转移
a>资源
资源是一种看待服务器的方式，即：将服务器看做是由很多离散的资源组成。每个资源是服务器上一个可命名的抽象概念。因为资源是一个抽象的概念。所以它不仅仅能代表服务器文件系统中的一个文件、数据库中的一张表等等具体的东西，可以将资源设计的要多抽象有多抽象，只要想象力允许而且客户端应用开发者能够理解。与面向对象设计类似，资源是以名词核心来组织的，首先关注的是名词。一个资源可以由一个或多个URI来标识。URI既是资源的名称，也是资源在WEB上的地址，对某个资源感兴趣的客户端应用，可以通过资源的URI与其进行交互
b>资源的表述
资源的表述是一段对于资源在某个特定时刻的状态的描述。可以在客户端-服务端之间转移（交换）。资源的表述可以有多种格式，例如HTML/XML/JSON/纯文本/图片等等，资源的表述格式可以通过协商机制来确定，请求-响应方向的表述通常使用不同的格式
c>状态转移
状态转移说的是：在客户端与服务端之间转移（transfer）代表资源状态的表述。通过转移和操作资源的表述来间接实现操作资源的目的
RESTFul的实现
具体说，就是HTTP协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE
他们分别对应四种基本操作：GET用来获取资源，POST用来新建资源，PUT用来更新资源，DELETE用来删除资源
REST风格提倡URI地址使用统一的风格设计，从前到后各个单词之间使用斜杆分开，不使用问号键值对方式携带请求参数，而是将要发送给服务器的数据作为URI地址的一部分，以保证风格的一致性
HiddenHttpMethod
由于浏览器只支持发送get和post方式的请求，那么该如何发送put和delete请求呢？
SpringMVC提供了HiddenHttpMethod帮助我们将POST请求转换为DELETE或PUT请求
HiddenHttpMethod处理put和delete请求的条件：
a>当前的请求方式方式必须为post
b>当前请求必须传输请求参数_method
<a th:href="@{/user}">查询所有用户信息</a><br>
<a th:href="@{/user/1}">根据id查询用户信息</a><br>
<form th:action="@{/user}" method="post">
用户名：<input type="text" name="username"/><br>
密码：<input type="password" name="password"/><br>
<input type="submit" value="添加"/><br>
</form>
<form th:action="@{/user}" method="post">
<input type="hidden" name="_method" value="put"/>
用户名：<input type="text" name="username"/><br>
密码：<input type="password" name="password"/><br>
<input type="submit" value="更新"/><br>
</form>
package com.cedric.mvc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
@Controller
public class UserController {
/**
* 使用RESTFul模拟用户资源的增删改查
* /user GET 查询所有用户信息
* /user/1 GET 根据用户id查询用户信息
* /user POST 添加用户信息
* /user/1 DELETE 删除用户信息
* /user PUT 修改用户信息
*/
@RequestMapping(value = "/user",method = RequestMethod.GET)
public String getAllUser(){
System.out.println("查询所有用户信息");
return "success";
}
@RequestMapping(value = "/user/{id}",method = RequestMethod.GET)
public String getUserById(){
System.out.println("根据id查询用户信息");
return "success";
}
@RequestMapping(value = "/user",method = RequestMethod.POST)
public String insertUser(String username,String password){
System.out.println("新增用户信息：" + username + "," + password);
return "success";
}
@RequestMapping(value = "/user",method = RequestMethod.PUT)
public String updateUser(String username,String password){
System.out.println("更改用户信息：" + username + "," + password);
return "success";
}
}
<!--配置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>
HttpMessageConverter
HttpMessageConverter，报文信息转换器，将请求报文转换成java对象，或将Java对象转换为响应报文
HttpMessageConverter提供了两个注解和两个类型：@RequestBody，@ResponseBody，RequestEntity，ResponseEntity
@RequestBody
@RequestBody可以获取请求体，需要在控制器方法设置一个形参，使用@RequestBody进行标识，当请求的请求体就会为当前注解所标识的形参赋值
<form th:action="@{/testRequestBody}" method="post">
<input type="text" name="username"/>
<input type="text" name="password"/>
<input type="submit" value="测试@RequestBody"/>
</form>
@RequestMapping("testRequestBody")
public String testRequestBody(@RequestBody String requestBody){
System.out.println("requestBody:" + requestBody);
return "success";
}
输出结果：requestBody：username=admin&password=123456
RequestEntity
RequestEntity封装请求报文的一种类型，需要在控制器方法的形参中设置该类型的形参，当前请求的请求报文就会赋值给该形参，可以通过getHeaders()获取请求头信息，通过getBody()获取请求体信息
@RequestMapping("testRequestEntity")
public String testRequestEntity(RequestEntity<String> requestEntity){
// 当前的requestEntity表示整个请求报文的信息
System.out.println("请求头：" + requestEntity.getHeaders());
System.out.println("请求体：" + requestEntity.getBody());
return "success";
}
输出结果：
请求头：[host:"localhost:8080", connection:"keep-alive", content-length:"27", cache-control:"max-age=0", sec-ch-ua:""Chromium";v="94", "Google Chrome";v="94", ";Not A Brand";v="99"", sec-ch-ua-mobile:"?0", sec-ch-ua-platform:""Windows"", upgrade-insecure-requests:"1", origin:"http://localhost:8080", user-agent:"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.71 Safari/537.36", accept:"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,/;q=0.8,application/signed-exchange;v=b3;q=0.9", sec-fetch-site:"same-origin", sec-fetch-mode:"navigate", sec-fetch-user:"?1", sec-fetch-dest:"document", referer:"http://localhost:8080/SpringMVC/", accept-encoding:"gzip, deflate, br", accept-language:"zh-CN,zh;q=0.9", cookie:"JSESSIONID=C33B058EF2A3ACF9B7D07268D3F87190; Idea-5449cec2=ea0e73c6-6e1a-4f49-8f3f-707a696a378a", Content-Type:"application/x-www-form-urlencoded;charset=UTF-8"]
请求体：username=admin&password=111
15:15:56.281 [http-nio-8080-exec-7] DEBUG org.springframework.web.servlet.DispatcherServlet - Completed 200 OK
@ResponseBody
@ResponseBody用于标识一个控制器方法，可以将该方法的返回值直接作为响应报文的响应体响应到浏览器
@RequestMapping("/testResponseBody")
@ResponseBody
public String testResponseBody(){
return "succcess";
}
ResponseBody处理json
@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中会自动装配一个消息转换器:MappingJacksonHttpMessageConverter,可以将响应到浏览器的Java对象转换为Json格式的字符串
<mvc:annotation-driven/>
c>在处理器方法上使用@ResponseBody注释进行标识
d>在Java对象直接作为控制器方法的返回值返回，就会自动转换为Json格式的字符串
@RequestMapping("/testResponseUser")
@ResponseBody
public User testResponseUser(){
return new User(1001,"admin","12345",3,"男");
}
浏览器的页面中展示的结果：
@RestController注解
@RestController注解是SpringMVC提供的一个复合注解，标识在控制器的类上，就相当于为类添加了一个@Controller注解，并且为其中的每个方法都添加了@ResponseBody注解
ResponseEntity
ResponseEntity用于控制器方法的返回值类型，该控制器方法的返回值就是响应到浏览器的响应报文
文件上传和下载
文件下载
使用ResponseEntity实现下载文件的功能
@Controller
public class FileUpAndDownController {
@RequestMapping("/testDown")
public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws IOException {
// 获取ServletContext对象
ServletContext servletContext = session.getServletContext();
// 获取服务器中文件的真实路径
String realPath = servletContext.getRealPath("/static/img/1.png");
// 创建输出流
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.png");
// 设置响应状态码
HttpStatus statusCode = HttpStatus.OK;
// 创建ResponseEntity对象
ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes,headers,statusCode);
is.close();
return responseEntity;
}
文件上传
@RequestMapping("testUp")
public String testUp(MultipartFile photo,HttpSession session) throws IOException {
String fileName = photo.getOriginalFilename();
// 获取上传的文件后缀名
String suffixName = fileName.substring(fileName.lastIndexOf("."));
// 将UUID作为文件名
String uuid = UUID.randomUUID().toString();
// 将uuid和后缀名拼接后的结果作为最终的文件名
fileName = uuid + suffixName;
// 通过ServletContext获取服务器中photo目录的路径
ServletContext servletContext = session.getServletContext();
String filePath = servletContext.getRealPath("file");
File file = new File(filePath);
// 判断filePath是否存在
if(!file.exists()){
// 若不存在，创建目录
file.mkdir();
}
String finalPath = filePath + File.separator + fileName;
// 实现上传功能
photo.transferTo(new File(finalPath));
return "success";
}
拦截器
拦截器的配置
SpringMVC中的拦截器用于拦截控制器的方法执行
SpringMVC中的拦截器需要实现HandlerInterceptor接口
SpringMVC中的拦截器必须在SpringMVC的配置文件中进行配置：
<bean class="com.cedric.mvc.interceptors.FirstInterceptor"></bean>
<ref bean="firstInterceptor"></ref>
<!-- 以上两种配置方式都是对DispatcherServlet所处理的所有请求进行拦截-->
<mvc:interceptor>
<mvc:mapping path="/**/"/>
<mvc:exclude-mapping path="/"/>
<ref bean="firstInterceptor"></ref>
</mvc:interceptor>
<!--
以上配置方式可以通过ref或者bean标签设置拦截器，通过mvc:mapping设置需要拦截的请求，通过mvc:exclude-mapping
设置需要排除的请求，即不需要拦截的请求
-->
拦截器的三个抽象方法
SpringMVC中的拦截器有三个抽象方法：
preHandle：控制器方法执行之前执行preHandle()，其boolean类型的返回值表示是否拦截或放行，返回true为放行，即调用控制器方法；返回false表示拦截，即不调用控制器方法
postHandle：控制器方法执行之后执行postHandle()
afterComplation：处理完视图和模型数据，渲染视图完毕之后执行afterComplation()
多个拦截器的执行顺序
a>若每个拦截器的preHandle()都返回true
自此多个拦截器的执行顺序和拦截器在SpringMVC的配置文件的配置顺序有关：
preHandle()会按照配置的执行顺序，而postHandle()和afterComplation()会按照配置的反序执行
b>若某个拦截器的preHandle()返回了false
preHandle()返回false和他之前的拦截器的preHandle()都会执行，postHandle()都不执行，返回false拦截器之前拦截的afterComplation()会执行
异常处理器
基于配置的异常处理
SpringMVC提供了一个处理控制器方法执行过程中所出现的异常接口：HandlerExceptionResolver
HandlerExceptionResolver接口的实现类有：DefaultHandlerExceptionResolver和SimpleMappingExceptionResolver
SpringMVC提供了自定义的异常处理器SimpleMappingExceptionResolver，使用方式：
<!--配置异常处理-->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
<property name="exceptionMappings">
<props>
<!-- properties的键表示处理器方法执行过程中出现的异常
properties的值表示若出现指定异常时，设置一个新的视图名称，跳转到指定页面-->
<prop key="java.lang.ArithmeticException">error</prop>
</props>
</property>
<!-- 设置将异常信息共享在请求域中的键
exceptionAttribute属性设置一个属性名，将出现的异常信息在请求域中进行共享-->
<property name="exceptionAttribute" value="ex"></property>
</bean>
基于注解的异常处理
// @ControllerAdvice将当前类标识为异常处理的组件
@ControllerAdvice
public class ExceptionController {
// @ExceptionHandler用于设置所标识方法处理的异常
@ExceptionHandler(value = {ArithmeticException.class,NullPointerException.class})
// ex表示当前请求处理中出现的异常对象
public String testException(Exception ex,Model model){
model.addAttribute("ex",ex);
return "error";
}
}
注解配置SpringMVC
使用配置类和注解代替web.xml和SpringMVC配置文件的功能
创建初始化类，代替web.xml
在Servlet3.0环境中，容器会在类路径中查找实现javax.servlet.ServletContainerlnitializer接口的类，如果找到的话就用它来配置Servlet容器。
Spring提供了这个接口的实现，名为SpringServletContainerInitializer，这个类反过来又会查找实现WebApplicationinitializer的类并将配置的任务交给它们来完成。Spring3.2引入了一个便利的
WebApplicationInitializer基础实现，名为AbstractAnnotationConfigDispatcherServletlnitializer，当我们的类扩展了AbstractAnnotationConfigDispatcherServletInitializer并将其部署到Servlet3.0容器的时候，容器会自动发现它，并用它来配置Servlet上下文。
package com.cedric.mvc.config;
import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.filter.HiddenHttpMethodFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
import javax.servlet.Filter;
/**
* web工程的初始化类，用来代替web.xml
*/
public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {
/**
* 指定Spring的配置类
* @return
*/
@Override
protected Class<?>[] getRootConfigClasses() {
return new Class[]{SpringConfig.class};
}
/**
* 指定SpringMVC的配置类
* @return
*/
@Override
protected Class<?>[] getServletConfigClasses() {
return new Class[]{WebConfig.class};
}
/**
* 指定DispatchServlet的映射规则，即url-pattern
* @return
*/
@Override
protected String[] getServletMappings() {
return new String[]{"/"};
}
/**
* 注册过滤器
* @return
*/
@Override
protected Filter[] getServletFilters() {
CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
characterEncodingFilter.setEncoding("UTF-8");
characterEncodingFilter.setForceResponseEncoding(true);
HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
return new Filter[]{characterEncodingFilter,hiddenHttpMethodFilter};
}
}
package com.cedric.mvc.config;
import com.cedric.mvc.interceptor.TestInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.multipart.MultipartResolver;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.*;
import org.springframework.web.servlet.handler.SimpleMappingExceptionResolver;
import org.thymeleaf.spring5.SpringTemplateEngine;
import org.thymeleaf.spring5.view.ThymeleafViewResolver;
import org.thymeleaf.templatemode.TemplateMode;
import org.thymeleaf.templateresolver.ITemplateResolver;
import org.thymeleaf.templateresolver.ServletContextTemplateResolver;
import java.util.List;
import java.util.Properties;
/**
* 代替SpringMVC的配置文件：
* 1.扫描组件 2.视图解析器 3.view-controller 4.default-servlet-handler
* 5.mvc注解驱动 6.文件上传解析器 7.异常处理 8.拦截器
*/
//将当前类标识为一个配置类
@Configuration
//1.扫描组件
@ComponentScan("com.cedric.mvc.controller")
//5.mvc注解驱动
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
// 4.default-servlet-handler
@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
configurer.enable();
}
// 8.拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
TestInterceptor testInterceptor = new TestInterceptor();
registry.addInterceptor(testInterceptor).addPathPatterns("/**");
}
// 3.view-controller
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/hello").setViewName("hello");
}
// 6.文件上传解析器
@Bean
public MultipartResolver multipartResolver(){
CommonsMultipartResolver commonsMultipartResolver = new CommonsMultipartResolver();
return commonsMultipartResolver;
}
// 7.异常处理
@Override
public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
Properties prop = new Properties();
prop.setProperty("java.lang.ArithmeticException","error");
exceptionResolver.setExceptionMappings(prop);
exceptionResolver.setExceptionAttribute("exception");
resolvers.add(exceptionResolver);
}
// 配置生成模板解析器
@Bean
public ITemplateResolver templateResolver(){
WebApplicationContext webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
// ServletContextTemplateResolver需要一个ServletContext作为构造参数，可通过WebApplicationContext的方法获得
ServletContextTemplateResolver templateResolver = new ServletContextTemplateResolver(webApplicationContext.getServletContext());
templateResolver.setPrefix("/WEB-INF/templates/");
templateResolver.setSuffix(".html");
templateResolver.setCharacterEncoding("UTF-8");
templateResolver.setTemplateMode(TemplateMode.HTML);
return templateResolver;
}
// 生成模板引擎并为模板引擎注入模板解析器
@Bean
public SpringTemplateEngine templateEngine(ITemplateResolver templateResolver){
SpringTemplateEngine templateEngine = new SpringTemplateEngine();
templateEngine.setTemplateResolver(templateResolver);
return templateEngine;
}
// 生成视图解析器并为视图解析器注入模板引擎
@Bean
public ViewResolver viewResolver(SpringTemplateEngine templateEngine){
ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
viewResolver.setCharacterEncoding("UTF-8");
viewResolver.setTemplateEngine(templateEngine);
return viewResolver;
}
}
SpringMVC的执行流程
SpringMVC常用组件
DispatcherServlet：前端控制器，不需要工程师开发，由框架提供
作用：统一处理请求和响应，整个流程控制的中心，由它调用其他组件处理用户的请求
HandlerMapping：处理映射器，不需要工程师开发，由框架提供
作用：根据请求的url，method等信息查找Handler,即控制器方法
Handler：处理器，需要工程师开发
作用：在DispatcherServlet的控制器下Handler对具体的用户请求进行处理
HandlerAdapter：处理器适配器，不需要工程师开发，由框架提供
作用：通过HandlerAdapter对处理器（控制器方法）进行执行
ViewResolver：视图解析器，不需要工程师开发，由框架提供
作用：进行视图解析，得到相应的视图，例如：ThymeleafView，InternalResourceView，RedirectView
View：视图，不需要工程师开发，由框架提供
作用：将模型数据通过页面展示给用户
DispatcherServlet初始化过程
DispatcherServlet本质上是一个Servlet，所以遵循天然的Servlet生命周期。宏观上是Servlet生命周期来进行调度
执行流程
1.用户向服务器发送请求，请求被SpringMVC前端控制器DispatcherServlet捕获
2.DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI），判断请求URI对应的映射：
a)不存在
2.1.再判断是否配置了mvc：default-servlet-handler
2.2.如果没有配置，则控制台报映射查找不到，客户端展示404错误
2.3.如果有配置，则访问目标资源（一般为静态资源，如：HTML、CSS、JS），找不到客户端也会展示404错误
b)存在则执行下面的流程
3.根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain执行链对象的形式返回
4.DispatcherServlet根据获得的Handler，选择一个合适的HanderAdapter
5.如果成功获取HanderAdapter，此时将开始执行拦截器的preHandler()方法（正向）
6.提前Request中的模型数据，填充Handler入参，开始执行Handler（Controller）方法，处理请求，再填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作：
a)HttpMessageConveter：将请求消息（如Json，xml等数据）转换成一个对象，将对象转换为指定的响应信息
b)数据转换：对请求消息进行数据转换，如String转换成Integer、Double等
c)数据格式化：对请求消息进行数据数据格式化。如将字符串转换成格式化数字或格式化日期等
d)数据验证：数据验证的有效性（长度、格式等），验证结果存储到BindingResult或Error中
7）Handler执行完成后，向DispatcherServlet返回一个ModelAndView对象
8）此时将开始执行拦截器的postHandler()方法【逆向】
9）根据返回的ModelAndView（此时会判断是否存在异常：如果存在异常，则执行HandlerExceptionResovler进行异常处理）选择一个适合的ViweResovler进行视图解析，根据Model和View来渲染视图
10）渲染视图完毕执行拦截器的afterCompletion（）方法【逆向】
11）将渲染结果返回给客户端
浙公网安备 33010602011771号