目录
5、@RequestMapping注解的params属性（了解）
6、@RequestMapping注解的headers属性（了解）
2、使用ModelAndView向request域对象共享数据
5.SpringMVC的视图解析器:InternalResourceViewResolver
2、创建SpringConfig配置类，代替spring的配置文件
3、创建WebConfig配置类，代替SpringMVC的配置文件
1.SpringMVC简介
1.什么是MVC
MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分
M: Model，模型层，指工程中的JavaBean，作用是处理数据JavaBean分为两类:
—类称为实体类Bean:专门存储业务数据的，如Student~ User等
一类称为业务处理Bean:指Service或Dao对象，专门用于处理业务逻辑和数据访问。
V: View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互,展示数据
C: Controller，控制层，指工程中的servlet，作用是接收请求和响应浏览器
MVC的工作流程:
用户通过视图层发送请求到服务器，在服务器中请求被Controller接收，Controller调用相应的Model层处理请求，处理完毕将结果返回到Controller，Controller再根据请求处理的结果找到相应的View视图，渲染数据后最终响应给浏览器
2.什么是springmvc
SpringMVC是Spring的一个后续产品，是Spring的一个子项目
SpringMVC是Spring为表述层开发提供的一整套完备的解决方案。在表述层框架历经Strust、WebWork、Strust2等诸多产品的历代更迭之后，目前业界普遍选择了SpringMVC作为JavaEE项目表述层开发的首选方案。
注:三层架构分为表述层(或表示层)、业务逻辑层、数据访问层，表述层表示前台页面和后台servlet
3.SpringMVC的特点
Spring 家族原生产品，与IOC容器等基础设施无缝对接
● 基于原生的Servlet，通过了功能强大的前端控制器DispatcherServlet对请求和响应进行统—处理
● 表述层各细分领域需要解决的问题全方位覆盖，提供全面解决方案
● 代码清新简洁，大幅度提升开发效率
● 内部组件化程度高，可插拔式组件即插即用，想要什么功能配置相应组件即可
● 性能卓著，尤其适合现代大型、超大型互联网项目要求
2.SpringMVC—helloworld项目
1.导入的依赖
<dependencies>
<!-- springmvc-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.22</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.10.RELEASE</version>
</dependency>
</dependencies>2.配置web.xml
1.默认方式配置
<?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">
<!-- 配置SpringMVC前端控制器,对浏览器发送的请求统一处理-->
<servlet>
<servlet-name>SpringMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<url-pattern>/</url-pattern>
<!-- 设置springMvC的核心控制器所能处理的请求的请求路径
/所匹配的请求可以是/1ogin或.html或.js或.css方式的请求路径
但是/不能匹配.jsp请求路径的请求-->
</servlet-mapping>
</web-app>2.扩展配置方式 ——-常用
<?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">
<!-- 配置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>
<!-- 设置springMvC的核心控制器所能处理的请求的请求路径
/所匹配的请求可以是/1ogin或.html或.js或.css方式的请求路径
但是/不能匹配.jsp请求路径的请求-->
</servlet-mapping>
</web-app>3.创建控制器
@Controller
public class HelloController {
}
4.配置srpingMVC的配置文件
<?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.javastudy.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>
</beans>5.访问首页和指定页面的测试
@RequestMapping("/")
public String index(){
//返回视图名称
return "index";
}
@RequestMapping("/target")
public String toTarget(){
return "index";
}
当url为http://localhost:8080/SpringMVC/时,自动跳转到templates/index.html,显示页面内容
6.总结
浏览器发送请求，若请求地址符合前端控制器的url-pattern，该请求就会被前端控制器DispatcherServlet处理。前端控制器会读取SpringMVC的核心配置文件，通过扫描组件找到控制器，将请求地址和控制器中@RequestMapping注解的value属性值进行匹配，若匹配成功，该注解所标识的控制器方法就是处理请求的方法。处理请求的方法需要返回一个字符串类型的视图名称，该视图名称会被视图解析器解析，加上前缀和后缀组成视图的路径，通过Thymeleaf对视图进行渲染，最终转发到视图所对应页面
3.@RequestMapping注解
1.RequestMapping注解的功能
从注解名称上我们可以看到，@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来，建立映射关系。
SpringMVC接收到指定的请求，就会来找到在映射关系中对应的控制器方法来处理这个请求。
2.@RequestMapping注解的位置
@RequestMapping标识一个类：设置映射请求的请求路径的初始信息
@RequestMapping标识一个方法：设置映射请求请求路径的具体信息
此时跳转路径就应该是:http://localhost:8080/SpringMVC/hello/testRequestMapping
@Controller
@RequestMapping("/hello")
public class RequestMappingController {
@RequestMapping("/testRequestMapping")
public String success(){
return "success";
}
}
3、@RequestMapping注解的value属性
value属性是一个字符串类型的数组 ，表示该请求映射能够匹配多个请求地址所对应的请求
value属性必须设置!!!
@RequestMapping(value = {"/test","/testRequestMapping"})
public String success(){
return "success";
}4.@RequestMapping注解的method属性
@RequestMapping注解的method属性通过请求的请求方式（get或post）匹配请求映射
@RequestMapping注解的method属性是一个RequestMethod类型的数组，表示该请求映射能够匹配多种请求方式的请求
若当前请求的请求地址满足请求映射的value属性，但是请求方式不满足method属性，则浏览器报错405：Request method ‘POST’ not supported
@Controller
//@RequestMapping("/hello")
public class RequestMappingController {
@RequestMapping(value = {"/test","/testRequestMapping"},
method = {RequestMethod.GET,RequestMethod.POST})
public String success(){
return "success";
}
}
默认为GET和POST请求都支持,大括号里面的只要有一个满足,就可以匹配
处理get请求的映射–>@GetMapping
@GetMapping("/testGetMapping")
public String testGetMapping(){
return "success";
}处理post请求的映射–>@PostMapping ————–类似
5、@RequestMapping注解的params属性（了解）
@RequestMapping(
value = {"/testRequestMapping", "/test"}
,method = {RequestMethod.GET, RequestMethod.POST}
,params = {"username=admin","password=123456"}
)
public String testRequestMapping(){
return "success";
}
请求地址应为:http://localhost:8080/SpringMVC/testParamAndHeaders?username=admin&password=123456
注意:大括号里的条件必须同时满足
6、@RequestMapping注解的headers属性（了解）
因此不符合Host:localhost:8080
7、SpringMVC支持ant风格的路径
？：表示任意的单个字符
可以为任意地址:如/a1a或/a2a等等
*：表示任意的0个或多个字符
可以为任意地址:如/aa或/a1a或/a11a等等
**：表示任意的一层或多层目录
可以为任意地址:如/aa/testAnt或/testAnt或/a/a/a/testAnt等等
注意：在使用**时，只能使用/**/xxx的方式
8、SpringMVC支持路径中的占位符（重点）
原始方式：/deleteUser?id=1
rest方式：/deleteUser/1
SpringMVC路径中的占位符常用于RESTful风格中，当请求路径中将某些数据通过路径的方式传输到服务器中，就可以在相应的@RequestMapping注解的value属性中通过占位符{xxx}表示传输的数据，在通过@PathVariable注解，将占位符所表示的数据赋值给控制器方法的形最终的URL:
4.SpringMVC获取请求参数
1、通过ServletAPI获取 —不推荐
将HttpServletRequest作为控制器方法的形参，此时HttpServletRequest类型的参数表示封装了当前请求的请求报文的对象
@RequestMapping("/testServletAPI")
public String testServletAPI(HttpServletRequest request){
String username = request.getParameter("username");
String password = request.getParameter("password");
System.out.println("username = "+username+" password = "+password);
return "test_Param";
}<body>
<h1>测试请求参数</h1>
<a th:href="@{/testServletAPI(username='admin',password=123456)}">测试ServletAPI获取参数--------->/testServletAPI</a>
</body>2、通过控制器方法的形参获取请求参数
@RequestMapping("/testParam")
public String testParam(String username,String password,String hobby){
//多请求参数中出现多个同名的请求参数，可以在控制器方法的形参位置
// 设置字符串类型或字符串数组接收参数
System.out.println("username = "+username+" password = "+password+" hobby:"+hobby);
return "success";
}<form th:action="@{/testParam}" method="get">
用户名:<input type="text" name="username"><br/>
密码:<input type="password" name="password"><br/>
爱好:<input type="checkbox" name="hobby" value="a">a
<input type="checkbox" name="hobby" value="b">b
<input type="checkbox" name="hobby" value="c">c<br/>
<input type="submit" value="测试testParam获取参数">
</form>跳转地址:http://localhost:8080/SpringMVC/testParam?username=admin&password=123456&hobby=a&hobby=b&hobby=c
结果
3、@RequestParam
@RequestParam注解一共有三个属性：
value：指定为形参赋值的请求参数的参数名
required：设置是否必须传输此请求参数，默认值为true
若设置为true时，则当前请求必须传输value所指定的请求参数，若没有传输该请求参数，且没有设置defaultValue属性，则页面报错400：Required String parameter ‘xxx’ is not present；若设置为false，则当前请求不是必须传输value所指定的请求参数，若没有传输，则注解所标识的形参的值为null
defaultValue：不管required属性值为true或false，当value所指定的请求参数没有传输或传输的值为””(空)时，则使用默认值为形参赋值
@RequestMapping("/testParam")
public String testParam(@RequestParam("user_name") String username, String password, String hobby) {
//多请求参数中出现多个同名的请求参数，可以在控制器方法的形参位置
// 设置字符串类型或字符串数组接收参数
System.out.println("username = " + username + " password = " + password + " hobby:" + hobby);
return "success";
}此时URL:http://localhost:8080/SpringMVC/testParam?user_name=zxn&password=123456&hobby=a&hobby=b&hobby=c
当使用请求参数与形参值不一致时,@RequestParam使user_name装配到username中
4、@RequestHeader
@RequestHeader("Host") String host结果
Host:localhost:8080
5、@CookieValue
@CookieValue("JSESSIONID") String jsessionId请求头
结果
jsessionId :41F310C11DD39E2C19E379C37E70A0F1
6、通过POJO获取请求参数
public class User {
private Integer id;
private String username;
private String password;
private String sex;
private String email;
}<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" value="使用实体类接受请求参数">
</form> @RequestMapping("/testPojo")
public String testPojo(User user){
System.out.println(user);
return "success";
}最终结果
User{id=null, username=’zxn’, password=’123456′, sex=’??·’, email=’15454@qq.com’}
7、解决获取请求参数的乱码问题
get请求发生乱码,可以在Tomcat的config文件中找到server文件,修改数据:
加上URIEncoding=”UTF-8″
<Connector port=”8080″ URIEncoding=”UTF-8″ protocol=”HTTP/1.1″
connectionTimeout=”20000″
redirectPort=”8443″ />
便可以解决get请求乱码问题
post请求发生乱码,配置过滤器
<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>5.域对象共享数据
1、使用ServletAPI向request域对象共享数据
@Controller
public class ScopeController {
//使用ServletAPI向request域中共享数据
@RequestMapping("/testRequestByServletAPI")
public String testRequestByServletAPI(HttpServletRequest request){
request.setAttribute("testRequestScope","hello");
return "success";
}
}
<body>
<h1>首页</h1><br/>
<a th:href="@{/testRequestByServletAPI}">通过ServletAPI向Request域中共享数据------->/testRequestByServletAPI</a>
</body><body>
<h1>SUCCESS</h1>
<p th:text="${testRequestScope}"></p>
</body>最终结果
2、使用ModelAndView向request域对象共享数据
@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView(){
ModelAndView mav = new ModelAndView();
//处理模型数据,即向request域中共享数据
mav.addObject("testRequestScope","helloModelAndView");
//设置视图名称
mav.setViewName("success");
return mav;
}3、使用Model向request域对象共享数据
@RequestMapping("/testModel")
public String testModel(Model model){
model.addAttribute("testRequestScope","helloModel");
return "success";
}4、使用map向request域对象共享数据
@RequestMapping("/testMap")
public String testMap(Map<String,Object> map){
map.put("testRequestScope","helloMap");
return "success";
}5、使用ModelMap向request域对象共享数据
@RequestMapping("/testModelMap")
public String testModelMap(ModelMap map){
map.put("testRequestScope","helloModelMap");
return "success";
}6、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 {}
7、向session域共享数据
@RequestMapping("/testSession")
public String testSession(HttpSession session){
session.setAttribute("testSessionScope","helloSession");
return "success";
}<p th:text="${session.testSessionScope}"></p>8、向application域共享数据
@RequestMapping("/testApplication")
public String testApplication(HttpServletRequest request){
ServletContext context = request.getServletContext();
context.setAttribute("testApplicationScope","helloApplication");
return "success";
}6.SpringMVC的视图
SpringMVC中的视图是View接口，视图的作用渲染数据，将模型Model中的数据展示给用户
SpringMVC视图的种类很多，默认有转发视图和重定向视图
当工程引入jstl的依赖，转发视图会自动转换为JstlView
若使用的视图技术为Thymeleaf，在SpringMVC的配置文件中配置了Thymeleaf的视图解析器，由此视图解析器解析之后所得到的是ThymeleafView
1、ThymeleafView
当控制器方法中所设置的视图名称没有任何前缀时，此时的视图名称会被SpringMVC配置文件中所配置的视图解析器解析，视图名称拼接视图前缀和视图后缀所得到的最终路径，会通过转发的方式实现跳转
@RequestMapping("/testThymeLeafView")
public String testThymeLeafView(){
return "success";
}2、转发视图
SpringMVC中默认的转发视图是InternalResourceView
SpringMVC中创建转发视图的情况：
当控制器方法中所设置的视图名称以”forward:”为前缀时，创建InternalResourceView视图，此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀”forward:”去掉，剩余部分作为最终路径通过转发的方式实现跳转
@RequestMapping("/testForward")
public String testForward(){
return "forward:/testThymeLeafView";
}3、重定向视图
SpringMVC中默认的重定向视图是RedirectView
当控制器方法中所设置的视图名称以”redirect:”为前缀时，创建RedirectView视图，此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀”redirect:”去掉，剩余部分作为最终路径通过重定向的方式实现跳转
@RequestMapping("/testRedirect")
public String testRedirect(){
return "redirect:/testThymeLeafView";
}4、视图控制器view-controller
当控制器方法中，仅仅用来实现页面跳转，即只需要设置视图名称时，可以将处理器方法使用view-controller标签进行表示
<mvc:view-controller path="/" view-name="index"></mvc:view-controller>此时,进行页面跳转时,会报错误
这时应该开启MVC的注解驱动
<mvc:annotation-driven/>5.SpringMVC的视图解析器:InternalResourceViewResolver
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"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 扫描组件-->
<context:component-scan base-package="com.javastudy.controller"></context:component-scan>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/templates/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
</beans>@Controller
public class JSPController {
@RequestMapping("/success")
public String success(){
return "success";
}
}
<body>
<h1>首页</h1>
<a href="${pageContext.request.contextPath}/success">访问success.jsp------->/success</a>
</body>以上为使用 InternalResourceViewResolver视图解析器的效果
7.RESTful
1.RESTful简介
REST：Representational State Transfer，表现层资源状态转移。
a>资源
资源是一种看待服务器的方式，即，将服务器看作是由很多离散的资源组成。每个资源是服务器上一个可命名的抽象概念。因为资源是一个抽象的概念，所以它不仅仅能代表服务器文件系统中的一个文件、数据库中的一张表等等具体的东西，可以将资源设计的要多抽象有多抽象，只要想象力允许而且客户端应用开发者能够理解。与面向对象设计类似，资源是以名词为核心来组织的，首先关注的是名词。一个资源可以由一个或多个URI来标识。URI既是资源的名称，也是资源在Web上的地址。对某个资源感兴趣的客户端应用，可以通过资源的URI与其进行交互。
b>资源的表述
资源的表述是一段对于资源在某个特定时刻的状态的描述。可以在客户端-服务器端之间转移（交换）。资源的表述可以有多种格式，例如HTML/XML/JSON/纯文本/图片/视频/音频等等。资源的表述格式可以通过协商机制来确定。请求-响应方向的表述通常使用不同的格式。
c>状态转移
状态转移说的是：在客户端和服务器端之间转移（transfer）代表资源状态的表述。通过转移和操作资源的表述，来间接实现操作资源的目的。
2.RESTful的实现
具体说，就是 HTTP 协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。
它们分别对应四种基本操作：GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE 用来删除资源。
| C | create | insert into | POST | 增 |
| R | retrieve | select from | GET | 查 |
| U | update | update set | PUT | 改 |
| D | delete | delete from | DELETE | 删 |
REST 风格提倡 URL 地址使用统一的风格设计，从前到后各个单词使用斜杠分开，不使用问号键值对方式携带请求参数，而是将要发送给服务器的数据作为 URL 地址的一部分，以保证整体风格的一致性。
| 操作 | 传统方式 | REST风格 |
|---|---|---|
| 查询操作 | getUserById?id=1 | user/1–>get请求方式 |
| 保存操作 | saveUser | user–>post请求方式 |
| 删除操作 | deleteUser?id=1 | user/1–>delete请求方式 |
| 更新操作 | updateUser | user–>put请求方式 |
3.HiddenHttpMethodFilter
由于浏览器只支持发送get和post方式的请求，那么该如何发送put和delete请求呢？
SpringMVC 提供了 HiddenHttpMethodFilter 帮助我们将 POST 请求转换为 DELETE 或 PUT 请求
HiddenHttpMethodFilter 处理put和delete请求的条件：
a>当前请求的请求方式必须为post
b>当前请求必须传输请求参数_method
满足以上条件，HiddenHttpMethodFilter 过滤器就会将当前请求的请求方式转换为请求参数_method的值，因此请求参数_method的值才是最终的请求方式
在web.xml中注册HiddenHttpMethodFilter
<!--配置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>put案例:
<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="添加用户">
</form><br/>
@RequestMapping(value = "/user",method = RequestMethod.PUT)
public String updateUser(String username, String password, HttpServletRequest request){
System.out.println(request.getMethod());
System.out.println("修改用户信息-----username:"+username+" password:"+password);
return "success";
}
HiddenHttpMethodFilter通过获取_method的参数,将浏览器的get请求换为put请求,这样就可以匹配到上面这个方法
注意!!!!
过滤器的CharacterEncodingFilter一定要配置在HiddenHttpMethodFilter之前,因为HiddenHttpMethodFilter方法里已经获取了参数,所有如果配置在后面CharacterEncodingFilter会失效
8.RESTful案例
1.搭建环境
实体类(省略toString,get set方法)
public class Employee {
private Integer id;
private String lastName;
private String email;
//1 male, 0 female
private Integer gender;
}dao类
@Repository
public class EmployeeDao {
private static Map<Integer, Employee> employees = null;
static{
employees = new HashMap<Integer, Employee>();
employees.put(1001, new Employee(1001, "E-AA", "aa@163.com", 1));
employees.put(1002, new Employee(1002, "E-BB", "bb@163.com", 1));
employees.put(1003, new Employee(1003, "E-CC", "cc@163.com", 0));
employees.put(1004, new Employee(1004, "E-DD", "dd@163.com", 0));
employees.put(1005, new Employee(1005, "E-EE", "ee@163.com", 1));
}
private static Integer initId = 1006;
//实现添加和修改功能
public void save(Employee employee){
if(employee.getId() == null){
employee.setId(initId++);
}
employees.put(employee.getId(), employee);
}
public Collection<Employee> getAll(){
return employees.values();
}
public Employee get(Integer id){
return employees.get(id);
}
public void delete(Integer id){
employees.remove(id);
}
}
2.功能清单
| 功能 | URL 地址 | 请求方式 |
|---|---|---|
| 访问首页 | / | GET |
| 查询全部数据 | /employee | GET |
| 删除 | /employee/2 | DELETE |
| 跳转到添加数据页面 | /toAdd | GET |
| 执行保存 | /employee | POST |
| 跳转到更新数据页面 | /employee/2 | GET |
| 执行更新 | /employee | PUT |
3.访问首页
在springMVC.xml文件配置
<!-- 配置视图控制器 -->
<mvc:view-controller path="/" view-name="index"></mvc:view-controller>
<!-- 开启MVC注解驱动-->
<mvc:annotation-driven/>3.查询所有数据
controller层
@Controller
public class EmployeeController {
@Autowired
EmployeeDao dao;
@GetMapping("/employee")
public String getAllEmployee(Model model){
Collection<Employee> all = dao.getAll();
model.addAttribute("all",all);
return "employee";
}html页面
<table id="dataTable" border="1" cellspacing="0" cellpadding="0" style="text-align: center">
<tr>
<th colspan="5">Employee_information</th>
</tr>
<tr>
<th>id</th>
<th>last_name</th>
<th>email</th>
<th>gender</th>
<th>options</th>
</tr>
<tr th:each="employee:${all}">
<td th:text="${employee.id}"></td>
<td th:text="${employee.lastName}"></td>
<td th:text="${employee.email}"></td>
<td th:text="${employee.gender}"></td>
<td>
</td>
</tr>
</table>5.删除指定id的员工信息
controller层
@RequestMapping(value = "/employee/{id}",method = RequestMethod.DELETE)
public String deleteEmployee(@PathVariable("id") Integer id){
dao.delete(id);
return "redirect:/employee";
}HTML页面
<table id="dataTable" border="1" cellspacing="0" cellpadding="0" style="text-align: center">
<tr>
<th colspan="5">Employee_information</th>
</tr>
<tr>
<th>id</th>
<th>last_name</th>
<th>email</th>
<th>gender</th>
<th>options<a th:href="@{/toAdd}">add</a> </th>
</tr>
<tr th:each="employee:${all}">
<td th:text="${employee.id}"></td>
<td th:text="${employee.lastName}"></td>
<td th:text="${employee.email}"></td>
<td th:text="${employee.gender}"></td>
<td>
<a th:href="@{/employee/}+${employee.id}" @click="deleteEmployee">delete</a>
</td>
</tr>
</table>
<form id="deleteForm" method="post">
<input type="hidden" name="_method" value="delete">
</form>
<script type="text/javascript" th:src="@{/static/js/vue.js}"></script>
<script type="text/javascript">
var app=new Vue({
el:'#dataTable',
methods:{
deleteEmployee:function (event){
//根据id获取表单元素
var deleteForm=document.getElementById("deleteForm");
//将触发点击事件的超链接的href赋给表单的action
deleteForm.action=event.target.href;
//提交表单
deleteForm.submit();
//取消超链接的默认行为
event.preventDefault();
}
}
})
</script>当点击超链接删除时,执行vue中的方法,先获取deleteForm表单,将删除超链接的href赋给deleteForm表单的action属性,将表单提交,并且取消超链接的默认行为,这样就是进入到控制器,执行dao中的删除方法,删除成功,之后重定向回到/employee页面,删除成功.
注意:由于
导入的vue.js是静态资源,而springMVC的控制器DispatcherServlet无法处理静态资源,因此回报错误,这个时候需要在springMVC.xml文件中写入
<!-- 开放对静态资源的访问-->
<mvc:default-servlet-handler/>这个的意思是:当DispatcherServlet无法处理资源的时候,交给TOMCAT的默认Servlet来处理资源,这样就可以处理vue.js文件了.
6、跳转到添加数据页面
<th>options<a th:href="@{/toAdd}">add</a> </th> <mvc:view-controller path="/toAdd" view-name="employee_add"></mvc:view-controller>由于没有任何功能的实现,这个时候可以直接配置视图控制器,跳转到toAdd页面
7、执行保存
html页面
<body>
<form th:action="@{/employee}" method="post">
last_name:<input type="text" name="lastName"><br/>
email: <input type="text" name="email"><br/>
gender:<input type="radio" name="gender" value="1">男
<input type="radio" name="gender" value="0">女<br/>
<input type="submit" value="add">
</form>
</body>controller层
@RequestMapping(value = "/employee",method = RequestMethod.POST)
public String addEmployee(Employee employee){
dao.save(employee);
return "redirect:/employee";
}在html页面输入信息提交之后,通过dao的save页面,添加数据,之后重定向跳转到/employee页面
8、跳转到更新数据页面
<a th:href="@{/employee/}+${employee.id}">update</a>由于更新要回显当前用户的信息,因此不能直接配置视图控制器,在controller层
@RequestMapping(value = "/employee/{id}",method = RequestMethod.GET)
public String getEmployeeById(@PathVariable("id")Integer id,Model model){
Employee employee = dao.get(id);
model.addAttribute("employee",employee);
return "employee_update";
}查询到用户的信息后,保存到model中,最后转发到employee_update页面
<body>
<form th:action="@{/employee}" method="post">
<input type="hidden" th:value="${employee.id}" name="id">
<input type="hidden" name="_method" method="put">
last_name:<input type="text" name="lastName" th:value="${employee.lastName}"><br/>
email: <input type="text" name="email" th:value="${employee.email}"><br/>
gender:<input type="radio" name="gender" value="1" th:field="${employee.gender}">男
<input type="radio" name="gender" value="0" th:field="${employee.gender}">女<br/>
<input type="submit" value="update">
</form>
</body>9、执行更新
回显数据后,输入你要修改的信息,点击提交,到controller层
@RequestMapping(value = "/employee",method = RequestMethod.PUT)
public String updateEmployee(Employee employee){
dao.save(employee);
return "redirect:/employee";
}执行dao保存之后,重定向到/employee页面,这样功能完成
9.HttpMessageConverter
HttpMessageConverter，报文信息转换器，将请求报文转换为Java对象，或将Java对象转换为响应报文
HttpMessageConverter提供了两个注解和两个类型：@RequestBody，@ResponseBody，RequestEntity，ResponseEntity
1、@RequestBody
@Controller
public class HttpController {
@PostMapping("/testRequsetBody")
public String testRequsetBody(@RequestBody String requestBody) {
System.out.println(requestBody);
return "success";
}
}
<body>
<h1>首页</h1>
<form th:action="@{/testRequsetBody}" method="post">
username:<input type="text" name="username"><br/>
password:<input type="password" name="password"><br/>
<input type="submit" value="提交/testRequestBody">
</form>
</body>输入
输出
2、RequestEntity
@PostMapping("/testRequsetEntity")
public String testRequsetEntity(RequestEntity<String> entity) {
//当前RequestEntity表示整个请求报文的的信息
System.out.println("请求头:"+entity.getHeaders());
System.out.println("请求体:"+entity.getBody());
return "success";
}
3、@ResponseBody
@RequestMapping("/testResponseBody")
@ResponseBody
public String testResponseBody(){
return "success";
}加@ResponseBody的页面 此时将success作为数据响应到浏览器
不 加@ResponseBody的页面 success作为视图名称,视图解析器到
4、SpringMVC处理json
第一步:导入依赖
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.0</version>
</dependency>第二步:在SpringMVC.xml中开启注解驱动
<!-- 开启MVC注解驱动-->
<mvc:annotation-driven/>第三步:在处理器方法上加上@ResponseBody注解进行标识
@ResponseBody第四步:将Java对象直接作为控制器方法的返回值返回，就会自动转换为Json格式的字符串
@RequestMapping("/testResponseUser")
@ResponseBody
public User testResponseUser(){
return new User(1,"zxn","123456",15,"男");
}5、SpringMVC处理ajax
html:
<body>
<h1>首页</h1>
<form th:action="@{/testRequsetBody}" method="post">
username:<input type="text" name="username"><br/>
password:<input type="password" name="password"><br/>
<input type="submit" value="提交/testRequestBody">
</form><br/>
<form th:action="@{/testRequsetEntity}" method="post">
username:<input type="text" name="username"><br/>
password:<input type="password" name="password"><br/>
<input type="submit" value="提交/testRequsetEntity">
</form><br/>
<a th:href="@{/testResponse}">通过ServletApi的response响应浏览器</a><br/>
<a th:href="@{/testResponseBody}">testResponseBody</a><br/>
<a th:href="@{/testResponseUser}">testResponseUser</a><br/>
<div id="app">
<a th:href="@{/testAjax}" @click="testAjax">SpringMVC处理AJAX</a>
<span id="info"></span><br/>
</div><br/>
<script type="text/javascript" th:src="@{/static/js/vue.js}"></script>
<script type="text/javascript" th:src="@{/static/js/axios.min.js}"></script>
<script type="text/javascript">
var vue = new Vue({
el:"#app",
methods:{
testAjax:function (event){
axios({
method:"post",
url:event.target.href,
params:{
username:"zxn",
password:"123456"
}
}).then(function (response){
alert(response.data)
});
event.preventDefault();
}
}
});
</script>
</body>controller
@RequestMapping("/testAjax")
@ResponseBody
public String testAjax(String username,String password){
System.out.println("username:"+username+" password:"+password);
return "hello,AJAX";
}6、@RestController注解
@RestController注解是springMVC提供的一个复合注解，标识在控制器的类上，就相当于为类添加了@Controller注解，并且为其中的每个方法添加了@ResponseBody注解
7、ResponseEntity
ResponseEntity用于控制器方法的返回值类型，该控制器方法的返回值就是响应到浏览器的响应报文
10.文件上传和下载
1、文件下载
使用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/ani2.jpg");
//创建输入流
InputStream is = new FileInputStream(realPath);
//创建字节数组 is.available()为文件的字节数
byte[] bytes = new byte[is.available()];
//将流读到字节数组中
is.read(bytes);
//创建HttpHeaders对象设置响应头信息
MultiValueMap<String, String> headers = new HttpHeaders();
//设置要下载方式以及下载文件的名字
headers.add("Content-Disposition", "attachment;filename=ani2.jpg");
//设置响应状态码
HttpStatus statusCode = HttpStatus.OK;
//创建ResponseEntity对象
ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers, statusCode);
//关闭输入流
is.close();
return responseEntity;
}
}
2、文件上传
导入依赖
<!-- fileup-->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.3</version>
</dependency>
配置文件上传解析器
<!-- 配置文件上传解析器,将上传的文件封装为MultipartFile-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>
html
<form th:action="@{/testUp}" method="post" enctype="multipart/form-data">
头像:<input type="file" name="photo"><br/>
<input type="submit" name="上传">
</form>controller
@RequestMapping("/testUp")
public String testUp(MultipartFile photo,HttpSession session) throws IOException {
String filename = photo.getOriginalFilename();
ServletContext context = session.getServletContext();
String photoPath = context.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";
}解决文件的重名问题:
@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().replaceAll("-","");
//将UUID和后缀名拼接的结果作为文件名
filename=uuid+suffixName;
//通过ServletContext获取服务器中photo的目录
ServletContext context = session.getServletContext();
String photoPath = context.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";
}11.拦截器
1、拦截器的配置
SpringMVC中的拦截器用于拦截控制器方法的执行
SpringMVC中的拦截器需要实现HandlerInterceptor
SpringMVC的拦截器必须在SpringMVC的配置文件中进行配置：
1.此拦截器配置拦截所有的控制器方法:
<!-- 配置拦截器-->
<mvc:interceptors>
<bean class="com.javastudy.interceptor.FirstInterceptor"></bean>
</mvc:interceptors> <mvc:interceptors>
<ref bean="firstInterceptor"></ref>
</mvc:interceptors>2.一下表示拦截所有路径,但是不拦截 “/”
以下配置方式可以通过ref或bean标签设置拦截器，通过mvc:mapping设置需要拦截的请求，通过mvc:exclude-mapping设置需要排除的请求，即不需要拦截的请求
<!-- 配置拦截器-->
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<mvc:exclude-mapping path="/"/>
<ref bean="firstInterceptor"></ref>
</mvc:interceptor>
</mvc:interceptors>注意:必须为”/**”才为所有路径,”/*”表示的是所有一层路径
2、拦截器的三个抽象方法
SpringMVC中的拦截器有三个抽象方法：
preHandle：控制器方法执行之前执行preHandle()，其boolean类型的返回值表示是否拦截或放行，返回true为放行，即调用控制器方法；返回false表示拦截，即不调用控制器方法
postHandle：控制器方法执行之后执行postHandle()
afterComplation：处理完视图和模型数据，渲染视图完毕之后执行afterComplation()
3、多个拦截器的执行顺序
1.若每个拦截器的preHandle()都返回true
此时多个拦截器的执行顺序和拦截器在SpringMVC的配置文件的配置顺序有关：
preHandle()会按照配置的顺序执行，而postHandle()和afterComplation()会按照配置的反序执行
2.若某个拦截器的preHandle()返回了false
preHandle()返回false和它之前的拦截器的preHandle()都会执行，postHandle()都不执行，返回false的拦截器之前的拦截器的afterComplation()会执行
(当第二个拦截器返回false)
12.异常处理器
1、基于配置的异常处理
SpringMVC提供了一个处理控制器方法执行过程中所出现的异常的接口:
HandlerExceptionResolver
HandlerExceptionResolver接口的实现类有：DefaultHandlerExceptionResolver和SimpleMappingExceptionResolver
SpringMVC提供了自定义的异常处理器SimpleMappingExceptionResolver，使用方式：
<!-- 配置异常处理-->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
<!--
properties的键表示处理器方法执行过程中出现的异常
properties的值表示若出现指定异常时，设置一个新的视图名称，跳转到指定页面
-->
<property name="exceptionMappings">
<props>
<prop key="java.lang.ArithmeticException">error</prop>
</props>
</property>
<!-- exceptionAttribute属性设置一个属性名，将出现的异常信息在请求域中进行共享-->
<property name="exceptionAttribute" value="ex">
</property>
</bean>2、基于注解的异常处理
@ControllerAdvice
public class ExceptionController {
@ExceptionHandler(value = {ArithmeticException.class, NullPointerException.class})
public String testException(Exception exception, Model model){
model.addAttribute("ex",exception);
return "error";
}
}
13.注解配置SpringMVC
使用配置类和注解代替web.xml和SpringMVC配置文件的功能
1、创建初始化类，代替web.xml
//web工程的初始化类，用来代替web.xml
public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {
//指定spring的配置类
@Override
protected Class<?>[] getRootConfigClasses() {
return new Class[]{SpringConfig.class};
}
//指定SpringMVC的配置类
@Override
protected Class<?>[] getServletConfigClasses() {
return new Class[]{WebConfig.class};
}
//指定DispatcherServlet的映射规则，即url-pattern
@Override
protected String[] getServletMappings() {
return new String[]{"/"};
}
//注册过滤器
@Override
protected Filter[] getServletFilters() {
CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
characterEncodingFilter.setEncoding("UTF-8");
characterEncodingFilter.setForceResponseEncoding(true);
HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
return new Filter[]{characterEncodingFilter,hiddenHttpMethodFilter};
}
}2、创建SpringConfig配置类，代替spring的配置文件
@Configuration
public class SpringConfig {
//ssm整合之后，spring的配置信息写在此类中
}
3、创建WebConfig配置类，代替SpringMVC的配置文件
需要完成的功能:
1.扫描组件 2.视图解析器 3.view-controller 4.default-servlet-handler
5.MVC注解驱动 6.文件上传解析器 7.异常处理 8.拦截器
1.扫描组件
@ComponentScan("com.javastudy")5.MVC注解驱动
@EnableWebMvc2.视图解析器
//配置生成模板解析器
@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;
}4.default-servlet-handler
需要先实现WebMvcConfigurer接口
public class WebConfig implements WebMvcConfigurer{
// 4.default-servlet-handler
@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
configurer.enable();
}
}8.拦截器
public class WebConfig implements WebMvcConfigurer{
//8.拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
TestInterceptor testInterceptor = new TestInterceptor();
registry.addInterceptor(testInterceptor).addPathPatterns("/**").excludePathPatterns("/");
}
}3.view-controller
public class WebConfig implements WebMvcConfigurer{
// 3.view-controller
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/hello").setViewName("hello");
}
}6.文件上传解析器
// 6.文件上传解析器
@Bean
public MultipartResolver multipartResolver(){
CommonsMultipartResolver commonsMultipartResolver = new CommonsMultipartResolver();
return commonsMultipartResolver;
}7.异常处理
public class WebConfig implements WebMvcConfigurer{
//7.异常处理
@Override
public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
SimpleMappingExceptionResolver simpleMappingExceptionResolver = new SimpleMappingExceptionResolver();
Properties properties = new Properties();
properties.setProperty("java.lang.ArithmeticException","error");
simpleMappingExceptionResolver.setExceptionMappings(properties);
//exceptionAttribute属性设置一个属性名，将出现的异常信息在请求域中进行共享
simpleMappingExceptionResolver.setExceptionAttribute("ex");
resolvers.add(simpleMappingExceptionResolver);
}
}合并!!
//将当前类标志成一个配置类
@Configuration
//1.扫描组件
@ComponentScan("com.javastudy")
//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("/**").excludePathPatterns("/");
}
// 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 simpleMappingExceptionResolver = new SimpleMappingExceptionResolver();
Properties properties = new Properties();
properties.setProperty("java.lang.ArithmeticException","error");
simpleMappingExceptionResolver.setExceptionMappings(properties);
//exceptionAttribute属性设置一个属性名，将出现的异常信息在请求域中进行共享
simpleMappingExceptionResolver.setExceptionAttribute("ex");
resolvers.add(simpleMappingExceptionResolver);
}
//2.视图解析器
//配置生成模板解析器
@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;
}
}
14.SpringMVC执行流程
1、SpringMVC常用组件
-
DispatcherServlet：前端控制器，不需要工程师开发，由框架提供
作用：统一处理请求和响应，整个流程控制的中心，由它调用其它组件处理用户的请求
-
HandlerMapping：处理器映射器，不需要工程师开发，由框架提供
作用：根据请求的url、method等信息查找Handler，即控制器方法
-
Handler：处理器，需要工程师开发
作用：在DispatcherServlet的控制下Handler对具体的用户请求进行处理
-
HandlerAdapter：处理器适配器，不需要工程师开发，由框架提供
作用：通过HandlerAdapter对处理器（控制器方法）进行执行
-
ViewResolver：视图解析器，不需要工程师开发，由框架提供
作用：进行视图解析，得到相应的视图，例如：ThymeleafView、InternalResourceView、RedirectView
-
View：视图
作用：将模型数据通过页面展示给用户
2、SpringMVC的执行流程
-
用户向服务器发送请求，请求被SpringMVC 前端控制器 DispatcherServlet捕获。
-
DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI），判断请求URI对应的映射：
a) 不存在
i. 再判断是否配置了mvc:default-servlet-handler
ii. 如果没配置，则控制台报映射查找不到，客户端展示404错误
iii. 如果有配置，则访问目标资源（一般为静态资源，如：JS,CSS,HTML），找不到客户端也会展示404错误
b) 存在则执行下面的流程
-
根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain执行链对象的形式返回。
-
DispatcherServlet 根据获得的Handler，选择一个合适的HandlerAdapter。
-
如果成功获得HandlerAdapter，此时将开始执行拦截器的preHandler(…)方法【正向】
-
提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)方法，处理请求。在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作：
a) HttpMessageConveter： 将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息
b) 数据转换：对请求消息进行数据转换。如String转换成Integer、Double等
c) 数据格式化：对请求消息进行数据格式化。 如将字符串转换成格式化数字或格式化日期等
d) 数据验证： 验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中
-
Handler执行完成后，向DispatcherServlet 返回一个ModelAndView对象。
-
此时将开始执行拦截器的postHandle(…)方法【逆向】。
-
根据返回的ModelAndView（此时会判断是否存在异常：如果存在异常，则执行HandlerExceptionResolver进行异常处理）选择一个适合的ViewResolver进行视图解析，根据Model和View，来渲染视图。
-
渲染视图完毕执行拦截器的afterCompletion(…)方法【逆向】。
-
将渲染结果返回给客户端。
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/101087.html
