记录自己的Spring MVC学习的笔记，学习课程是通过B站尚硅谷的视频学习。
@Description SpringMVC学习
@Author Van
①SpringMVC简介
1.什么是MVC
1.是一种软件架构，将软件按照模型、视图、控制器来划分
M：Model，模型层、指工程中的JavaBean，作用是处理数据
JavaBean分为两类：
1.实体类Bean：专门存储业务数据，如Student、User登
2.业务处理类Bean：指Service或Dao对象，专门用于处理业务逻辑
V：View，视图层。工程中的前端页面，作用是展示和交互
C：Controller，控制层、指工程中的Servlet，作用是接受请求和相应浏览器
MVC的工作流程:
用户通过视图层发送请求到服务器，在服务器中请求被Controller接收，Controller调用相应的Model层处理请求，处理完毕将结果返回到Controller，Controller再根据请求处理的结果找到相应的View视图，渲染数据后最终响应给浏览器
2、什么是SpringMvc
1.SpringMVC是Spring的一个后续产品，是Spring的一个子项目
2.SpringMVC是Spring 为表述层开发提供的一整套完备的解决方案。在表述层框架历经Strust、WebWork、Strust2等诸多产品的历代更迭之后，目前业界普遍选择了SpringMVC 作为JavaEE项目表述层开发的首选方案。
springmvc就是一个Spring。Spring是容器，ioc能够管理对象，使用
SpringMvc能够创建对象，放入到容器中(SpringMavc容器），springmvc容器中放的是控制器对象，
我们要做的是使用econtorller创建控制器对象，_把对象放入到springnvc容器中，把创建的对象作为控制器使用这个控制器对象能接收用户的请求，显示处理结果，就当做是一个servlet使用。
使用econtroller注解创建的是一个普通类的对象，不是servlet。springavc赋予了控制器对象一些额外的功能。
3.SpringMVC的特点
1.Spring家族原生产品，与IOC容器等基础设施无缝对接
2.基于原生的Servlet，通过了功能强大的前端控制器DispatcherServlet，对请求和响应进行统─处理·表述层各细分领域需要解决的问题全方位覆盖，提供全面解决方案
3.代码清新简洁，大幅度提升开发效率
4.内部组件化程度高，可插拔式组件即插即用，想要什么功能配置相应组件即可。性能卓著，尤其适合现代大型、超大型互联网项目要求
4.请求过程
web开发底层是servlet，springmvc中有一个对象是servlet : DispatherServlet(中央调度器)
DispatherServlet:负责接收用户的所有请求，用户把请求给了pispatherServlet，之后Dispatherservlet把请求转发给
我们的controller对象，最后是controller对象处理请求.
index.jsp-----DispatcherServlet(Servlet) -----转发，分配给----Controller对象(@Controller注解创建的对象)
②Maven创建Web工程并配置
1.pom配置
spring-webmvc
logback-classic
javax.servlet-api
thymeleaf-spring5
junit
2.添加web模块
1.注册DispatcherServlet前端控制器
1.默认配置方式
此配置作用下，SpringMVC的配置文件默认位于WEB-INF下，默认名称为
例如，以下配置所对应SpringMVC的配置文件位于WEB-INF下，文件名为springMVCservlet.xml
2.扩展配置方式
可通过init-param标签设置SpringMVC配置文件的位置和名称，通过load-on-startup标签设置
SpringMVC前端控制器DispatcherServlet的初始化时间
3.创建控制器类
由于前端控制器对浏览器发送的请求进行了统一的处理，但是具体的请求有不同的处理过程，因此需要创建处理具体请求的类，即请求控制器
请求控制器中每一个处理请求的方法成为控制器方法
因为SpringMVC的控制器由一个POJO（普通的Java类）担任，因此需要通过@Controller注解将其标识
为一个控制层组件，交给Spring的IoC容器管理，此时SpringMVC才能够识别控制器的存在
1.在SpringMVC中不需要继承httpServlet就可以创建出控制器类
在controller包下创建一个类HelloController
@Controller
public class HelloController {
}
2.在SpringMVC.xml中开启组件扫描
3.配置thymeleaf试图解析器
4.创建一个首页，在Controller对象中设置跳转到index.html
// "/"--->/WEN-INF/templates/index.html
@RequestMapping(value = "/")
public String index(){
return "index";
}
5.转发向到下一个页面,可以通过thymeleaf和普通的跳转方式，同时在controller里面去实现映射
访问目标页面price
访问目标页面price
@RequestMapping(value = "/price")
public String price(){
return "price";
}
3.总结
1.浏览器访问，映射到前端控制器（DispatcherServlet），读取Spring配置文件，组建扫找到控制器，根据mapping转发
2.浏览器发送请求，若请求地址符合前端控制器的url-pattern，该请求就会被前端控制器
DispatcherServlet处理。前端控制器会读取SpringMVC的核心配置文件，通过扫描组件找到控制器，
将请求地址和控制器中@RequestMapping注解的value属性值进行匹配，若匹配成功，该注解所标识的
控制器方法就是处理请求的方法。处理请求的方法需要返回一个字符串类型的视图名称，该视图名称会
被视图解析器解析，加上前缀和后缀组成视图的路径，通过Thymeleaf对视图进行渲染，最终转发到视
图所对应页面
③RequestMapping注解
1.@RequestMapping注解的功能
1.从注解名称上我们可以看到，@RequestMapping注解的作用就是将清求和处理清求的控制器方法关跌起来，建立映射关系。
SpringMVC接收到指定的请求，就会来找到在映射关系中对应的控制器方法来处理这个请求。
2.不能同时有2个controller同时解析出一个地址
访问路径相同，请求的资源不同，但是浏览器端访问上下文路径，被前端控制器解析之后，不知道分发到哪个控制器方法进行处理
2.@RequestMapping注解的位置
1.@RequestMapping标识一个类：设置映射请求的请求路径的初始信息
1.在方法访问的路径前在加一个路径
2.先访问初始信息，再访问具体信息
3.常用于区分不同模块的同一个控制方法
2.@RequestMapping标识一个方法：设置映射请求的请求路径的具体信息
@Controller
@RequestMapping("/test")
public class TestRequestMappingController {
@RequestMapping("/price")
public String price(){
return "price";
}
}
3.@RequestMapping注解的常用属性
1.value属性：
1.@RequestMapping注解的value属性通过请求的请求地址匹配请求映射
2.@RequestMapping注解的value属性是一个字符串类型的数组，表示该请求映射能够匹配多个请求地址所对应的请求
3.@RequestMapping注解的value属性必须设置，至少通过请求地址匹配请求映射
4.所有属性里面value的属性匹配优先级最高
2.method属性：
1.@RequestMapping注解的method属性通过请求的请求方式（get或post）匹配请求映射
2.@RequestMapping注解的method属性是一个RequestMethod类型的数组，表示该请求映射能够匹配多种请求方式的请求
3.若当前请求的请求地址满足请求映射的value属性，但是请求方式不满足method属性，则浏览器报错405：Request method 'POST' not supported
-------》
get和post有什么区别？
1.get请求会把请求参数拼接到请求地址里面，以“？”进行拼接，请求参数名=请求参数值and···，不安全，速度快，数据量有限，文件上传不能使用get
2.post请求会把请求参数放到请求体中，格式请求参数名=请求参数值and···，安全，速度慢，数据量无限，文件上传只能用post
4.如果不设置method属性表示get、post等所有访问方式都可以访问
注意：
1、对于处理指定请求方式的控制器方法，SpringMVC中提供了@RequestMapping的派生注解
处理get请求的映射-->@GetMapping注解
处理post请求的映射-->@PostMapping
处理put请求的映射-->@PutMapping
处理delete请求的映射-->@DeleteMapping
2、常用的请求方式有get，post，put，delete
3.但是目前浏览器只支持get和post，若在form表单提交时，为method设置了其他请求方式的字符串（put或delete），则按照默认的请求方式get处理
若要发送put和delete请求，则需要通过spring提供的过滤器HiddenHttpMethodFilter，在RESTful部分会讲到
4.浏览器只能发送get、post请求，其他的请求不能发送，且就算设置成其他默认也是GET
3.params属性：
1.@RequestMapping注解的params属性通过请求的请求参数匹配请求映射
2.@RequestMapping注解的params属性是一个字符串类型的数组，可以通过四种表达式设置请求参数和请求映射的匹配关系
"param"：要求请求映射所匹配的请求必须携带param请求参数
"!param"：要求请求映射所匹配的请求必须不能携带param请求参数
"param=value"：要求请求映射所匹配的请求必须携带param请求参数且param=value
"param!=value"：要求请求映射所匹配的请求必须携带param请求参数但是param!=value
如果没有会报400错误，提示params的参数没有
3.例：
@RequestMapping(
value = {"/price","/test"},//多个代表其中一个有就可以
method = {RequestMethod.GET,RequestMethod.POST},//多个代表其中一个有就可以
params = {"username","fxm"} //多个代表必须多个参数都有
)
若当前请求满足@RequestMapping注解的value和method属性，但是不满足params属性，此时页面回报错400：Parameter conditions "username, password!=123456"
not met for actual request parameters: username={admin}, password={123456}
4.headers属性：用的比较少
1.@RequestMapping注解的headers属性通过请求的请求头信息匹配请求映射
2.@RequestMapping注解的headers属性是一个字符串类型的数组，可以通过四种表达式设置请求头信息和请求映射的匹配关系
"header"：要求请求映射所匹配的请求必须携带header请求头信息
"!header"：要求请求映射所匹配的请求必须不能携带header请求头信息
"header=value"：要求请求映射所匹配的请求必须携带header请求头信息且header=value
"header!=value"：要求请求映射所匹配的请求必须携带header请求头信息且header!=value
若当前请求满足@RequestMapping注解的value和method属性，但是不满足headers属性，此时页面显示404错误，即资源未找到
4.SpringMVC支持ant风格的路径
？：表示任意的单个字符
*：表示任意的0个或多个字符
**：表示任意的一层或多层目录
注意：在使用**时，只能使用xxx的方式
5.SpringMVC支持路径中的占位符-----重点
1.原始方式：/deleteUser?id=1
rest方式：/deleteUser/1
SpringMVC路径中的占位符常用于RESTful风格中，当请求路径中将某些数据通过路径的方式传输到服务器中，
就可以在相应的@RequestMapping注解的value属性中通过占位符{xxx}表示传输的数据，
再通过@PathVariable注解，将占位符所表示的数据赋值给控制器方法的形参
2.使用占位符，就必须把占位符对应的要传的值填入，不然会报404
④SpringMVC获取请求参数
1.通过ServletAPI获取
1.将HttpServletRequest作为控制器方法的形参，此时HttpServletRequest类型的参数表示封装了当前请求的请求报文的对象
测试用ServletAPI获取请求参数
@RequestMapping("/test_param")
public String param(HttpServletRequest request){
System.out.println(request.getParameter("username"));
System.out.println(request.getParameter("password"));
return "test_param";
}
2.使用占位符去传参不能使用request.getParameter()
2.通过控制器方法的形参获取请求参数
1.在控制器方法的形参位置，设置和请求参数同名的形参，当浏览器发送请求，匹配到请求映射时，在DispatcherServlet中就会将请求参数赋值给相应的形参
测试控制器方法的形参获取请求参数
@RequestMapping("/testParam")
public String testParam(String username,String password){
System.out.println(username);
System.out.println(password);
return "price";
}
2.如果用复选框会出现一个参数多个值会自动用数组或者字符串直接接收，直接用String name会自动把所有的值用“，”拼接起来。也可以用String[] name
public String testParam(String username,String password,String hobby1/String[] hobby2){
System.out.println(username);
System.out.println(password);
System.out.println(hobby1);
System.out.println(Arrays.toString(hobby2));
return "price";
}
3.注意都是get方式请求，因为只有get会把请求参数放到url中 ----》不太确定这个是不是正确的
4.若请求所传输的请求参数中有多个同名的请求参数，此时可以在控制器方法的形参中设置字符串数组或者字符串类型的形参接收此请求参数
若使用字符串数组类型的形参，此参数的数组中包含了每一个数据
若使用字符串类型的形参，此参数的值为每个数据中间使用逗号拼接的结果
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.例：
@RequestMapping("/testParam")
public String testRequestParam(
@RequestParam(value = "user_name",required = false，defaultValue = "hehe") String username,
String password
){
System.out.println(username);
System.out.println(password);
return "price";
}
4.@RequestHeader
1.@RequestHeader是将请求头信息和控制器方法的形参创建映射关系
2.@RequestHeader注解一共有三个属性：value、required、defaultValue，用法同@RequestParam
@RequestHeader(value = "host"，required = true，defaultValue = "hehe") String host
打印host=host:hehe,如果host存在则打印host的值
5.@cookievalue
1.服务器在第一次接收请求的时候会检查有没有session，如果没有就会创建一个session，所以session在第一次创建时在响应报文中，在响应回页面之后就一直存在于请求报文之中
6.通过POJO获取请求参数
1.可以在控制器方法的形参位置设置一个实体类类型的形参，此时若浏览器传输的请求参数的参数名和实体类中的属性名一致，那么请求参数就会为此属性赋值
7.解决获取请求参数的乱码问题
1.字符编码不一致需要在获取请求参数之前就把编码设置好，javaweb一共有3个组件----监听器、拦截器、servlet
2.执行顺序：监听器>拦截器->servlet，又因为监听器只负责监听，所以字符编码设置放在拦截器Filter里面
3.解决获取请求参数的乱码问题，可以使用SpringMVC提供的编码过滤器CharacterEncodingFilter，但是必须在web.xml中进行注册
ModelAndView mav = new ModelAndView();
//向请求域共享数据
mav.addObject("testScope", "hello,ModelAndView");
//设置视图，实现页面跳转
mav.setViewName("success");
return mav;
}
3.不管使用什么方法向request中共享数据，SpringMVC的底层实际都是封装成了ModelAndView
4.使用Model向request域对象共享数据
@RequestMapping("/price")
public String testRequestServletAPI(HttpServletRequest request){
request.setAttribute("testRequestScope","ServletAPI");
return "price";
}
5.使用map向request域对象共享数据
@RequestMapping("/testMap")
public String testMap(Map
map.put("testRequestScope","map");
return "price";
}
6.使用ModelMap向request域对象共享数据
@RequestMapping("/testModelMap")
public String testModelMap(ModelMap modelmap){
modelmap.addAttribute("testRequestScope","model");
return "price";
}
7.Model、Map、ModelMap之间的关系
1.Model、ModelMap、Map类型的参数其实本质上都是 BindingAwareModelMap 类型的
public interface Model{}
public class ModelMap extends linkedHashMap
public class ExtendedModelMap extends ModelMap implements Model {}
public class BindingAwareModelMap extends ExtendedModelMap {}
8.底层分析，控制器方法在底层调用后都会统一返回ModelAndView对象
不管用什么方法执行控制器底层都执行了一个handle()，这个方法就是实际控制器调用的方法，返回了一个ModelAndView的类型
这个分析就是咱们都知道请求分发和处理都是DispatcherServlet进行的，所以最后肯定是这个类中的方法接受的返回内容，
反过来就可以从这个类中最后调用的那个方法那里查看返回的类型是什么，这几个都试一下，就知道结果，其实也可以在前面输出一些ModelAndVIew会发现其实就是Model和View的组合
9.向session域共享数据
1.使用ServlerAPI来共享session数据
@RequestMapping("/testSession")
public String testSession(HttpSession session){
session.setAttribute("testSessionScope", "hello,session");
return "success";
}
2.有一个@SessionAttribute注解，可以设置当前数据共享到请求域时可以把数据共享到session域中，但是太麻烦，一般不使用
3.有一个@SessionAttributes注解，是将model放入session域中
10.向application域共享数据
@RequestMapping("/testApplication")
public String testApplication(HttpSession session){
ServletContext application = session.getServletContext();
application.setAttribute("testApplicationScope", "hello,application");
return "success";
}
⑥SpringMVC的视图
1.概念
1.SpringMVC中的视图是View接口，视图的作用渲染数据，将模型Model中的数据展示给用户
2.SpringMVC视图的种类很多，默认有转发视图和重定向视图
3.当工程引入jstl的依赖，转发视图会自动转换为JstlView
4.若使用的视图技术为Thymeleaf，在SpringMVC的配置文件中配置了Thymeleaf的视图解析器，由此视图解析器解析之后所得到的是ThymeleafView
2.ThymeleafView
1.当控制器方法中所设置的视图名称没有任何前缀时，此时的视图名称会被SpringMVC配置文件中所配置的视图解析器解析，视图名称拼接视图前缀和视图后缀所得到的最终路径，会通过转发的方式实现跳转
2.底层在DispatcherServlet中有一个resolveViewName()方法中如果视图名称加了前缀就会是对应的前缀，如果没有加就是ThymeleafView，底层可能是根据不同的视图前缀创建不同的View对象
tips：ThyrmeleafViewResolver内部有个createView方法，通过判断ViewName来进行View的创建
3.转发视图
1.SpringMVC中默认的转发视图是InternalResourceView
2.SpringMVC中创建转发视图的情况：
1.当控制器方法中所设置的视图名称以"forward:"为前缀时，创建InternalResourceView视图，
此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀"forward:"去掉，剩余部分作为最终路径通过转发的方式实现跳转
例如"forward:/"，"forward:/employee"
@RequestMapping("/testForward")
public String testForward(){
return "forward:/testHello";
}
这里的return实际是转发到了thymeleaf的控制器方法中，通过thymeleaf去渲染页面得到的页面。
所以在这个转发视图里面会产生两个View一个是InternalResourceView一个ThymeleafView
4.重定向视图
1.SpringMVC中默认的重定向视图是RedirectView
2.当控制器方法中所设置的视图名称以"redirect:"为前缀时，创建RedirectView视图，此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，
而是会将前缀"redirect:"去掉，剩余部分作为最终路径通过重定向的方式实现跳转
例如"redirect:/"，"redirect:/employee
@RequestMapping("/testRedirect")
public String testRedirect(){
return "redirect:/testThymeleaf";
}
3.重定向不能再获取request等域数据，因为重定向已经不是同一个请求了。
5.视图控制器：view-controller
1.当控制器方法中，仅仅用来实现页面跳转,不需要进行任何请求时，即只需要设置视图名称时，可以将处理器方法使用view-controller标签进行表示
注：
当SpringMVC中设置任何一个view-controller时，其他控制器中的请求映射将全部失效，此时需要在SpringMVC的核心配置文件中设置开启mvc注解驱动的标签：
6.默认的InternalResourceView
1.不使用thymeleaf的时候MVC提供了一个默认的视图
2.设置视图解析器
success.jsp
@RequestMapping("/success")
public String testSuccess(){
return "success";
}
3.此时return不加前缀和forward前缀就是InternalResourceView，redirect前缀是RedirectView
⑦RESTFul
1.简介
1.REST：Representational State Transfer，表现层资源状态转移。
a>资源：
>资源是一种看待服务器的方式，即，将服务器看作是由很多离散的资源组成。每个资源是服务器上一个可命名的抽象概念。因为资源是一个抽象的概念，
所以它不仅仅能代表服务器文件系统中的一个文件、数据库中的一张表等等具体的东西，可以将资源设计的要多抽象有多抽象，只要想象力允许而且客户端应用开发者能够理解。
与面向对象设计类似，资源是以名词为核心来组织的，首先关注的是名词。一个资源可以由一个或多个URI来标识。URI既是资源的名称，也是资源在Web上的地址。
对某个资源感兴趣的客户端应用，可以通过资源的URI与其进行交互。
b>资源的表述：
>资源的表述是一段对于资源在某个特定时刻的状态的描述。可以在客户端-服务器端之间转移（交换）。资源的表述可以有多种格式，例如HTML/XML/JSON/纯文本/图片/视频/音频等等。
资源的表述格式可以通过协商机制来确定。请求-响应方向的表述通常使用不同的格式。
c>状态转移:
状态转移说的是：在客户端和服务器端之间转移（transfer）代表资源状态的表述。通过转移和操作资源的表述，来间接实现操作资源的目的。
----->个人理解
>就是说对同一种资源的访问路径加上描述是一样的，比如对User的各种操作，原来通过请求地址不同来表示，现在请求地址一样通过Get POst来区分
比如 localhost:8080/springMVC/user/10. 如果是get就是得到这个用户信息返回，如果是delete就是删除这个用户
注意：其实restful实现起来很简单，咱们之前的@RequestMapping里面同样的地址，方法不同可以区分，其实就可以这么搞了
同一个地址，请求方式不同，我可以匹配到不同的控制器方法，来进行不同的操作，当然了，service和dao还是要写的
2.RESTful的实现
1.具体说，就是 HTTP 协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。
2.它们分别对应四种基本操作：GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE用来删除资源。
3.REST 风格提倡 URL 地址使用统一的风格设计，从前到后各个单词使用斜杠分开，不使用问号键值对方式携带请求参数，而是将要发送给服务器的数据作为 URL 地址的一部分，以保证整体风格的一致性。
3.HiddenHttpMethodFilter
1.由于浏览器只支持发送get和post方式的请求，那么该如何发送put和delete请求呢？
SpringMVC 提供了 HiddenHttpMethodFilter 帮助我们将 POST 请求转换为 DELETE 或 PUT 请求
2.HiddenHttpMethodFilter 处理put和delete请求的条件：
a>当前请求的请求方式必须为post
b>当前请求必须传输请求参数_method
满足以上条件，HiddenHttpMethodFilter 过滤器就会将当前请求的请求方式转换为请求参数_method的值，因此请求参数_method的值才是最终的请求方式
3.在web.xml中注册HiddenHttpMethodFilter
@Override
protected Class[] getRootConfigClasses() {
return new Class[]{SpringConfig.class};
}
@Override
protected Class[] getServletConfigClasses() {
return new Class[]{Configuration.class};
}
@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的配置文件
@Configuration
@ComponentScan("com.van.mvc.controller")
//5.MVC注解驱动,在设置了view-controller之后必须开启这个，不然其他controller会失效
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
//7.异常处理
@Override
public void configureHandlerExceptionResolvers(List
SimpleMappingExceptionResolver simpleMappingExceptionResolver = new SimpleMappingExceptionResolver();
Properties prop = new Properties();
prop.setProperty("java.lang.ArithmeticException","error");
simpleMappingExceptionResolver.setExceptionMappings(prop);
simpleMappingExceptionResolver.setExceptionAttribute("exception");
resolvers.add(simpleMappingExceptionResolver);
}
//在配置文件中也是一个bean 6.文件上传解析器
@Bean
public MultipartResolver multipartResolver(){
CommonsMultipartResolver commonsMultipartResolver = new CommonsMultipartResolver();
return commonsMultipartResolver;
}
//3.view-controller
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/hello").setViewName("hello");
}
//8.拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
TestInterceptor testInterceptor = new TestInterceptor();
registry.addInterceptor(testInterceptor).addPathPatterns("
@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
configurer.enable();
}
}
①③SpringMVC执行流程
1.SpringMVC常用组件
>>>DispatcherServlet：前端控制器，不需要工程师开发，由框架提供
作用：统一处理请求和响应，整个流程控制的中心，由它调用其它组件处理用户的请求
>>>HandlerMapping：处理器映射器，不需要工程师开发，由框架提供
作用：根据请求的url、method等信息查找Handler，即控制器方法
>>>Handler：处理器，需要工程师开发
作用：在DispatcherServlet的控制下Handler对具体的用户请求进行处理
>>>HandlerAdapter：处理器适配器，不需要工程师开发，由框架提供
作用：通过HandlerAdapter对处理器（控制器方法）进行执行
>>>ViewResolver：视图解析器，不需要工程师开发，由框架提供
作用：进行视图解析，得到相应的视图，例如：ThymeleafView、InternalResourceView、RedirectView
>>>View：视图
作用：将模型数据通过页面展示给用户
2.DispatcherServlet初始化过程
》DispatcherServlet 本质上是一个 Servlet，所以天然的遵循 Servlet 的生命周期。所以宏观上是 Servlet生命周期来进行调度。
a>初始化WebApplicationContext
所在类：org.springframework.web.servlet.frameworkServlet
initWebApplicationContext()里面进行了几个方法
1.创建WebApplicationContext对象执行createWebApplicationContext()
2.刷新WebApplicationContext 执行了 onRefresh()
3.将IOC容器在应用域共享
b>创建WebApplicationContext
createWebApplicationContext()里面执行了两个方法：
1.通过反射创建IOC容器对象
2.设置父容器：
1.SpringMVC和Spring整合就是各管各，不整合就是用一个配置文件
2.将Spring设置成SpringMVC的父容器---->同时WebApplicationContext是继承于ApplicationContext
c>DispatcherServlet初始化策略
1.frameworkServlet创建WebApplicationContext后，刷新容器，调用onRefresh(wac)，此方法在DispatcherServlet中进行了重写，调用了initStrategies(context)方法，
初始化策略，即初始化DispatcherServlet的各个组件
2.初始化策略里面初始化了许多常用组件，所以在配置时，一般会设置一个
3.DispatcherServlet调用组件处理请求的过程
--->DispatcherServlet本质是一个servlet，servlet调用就是用的service()方法，在FramworkServlet中最后都调用了processRequest()
--->frameworkServlet重写HttpServlet中的service()和doXxx()，这些方法中调用了processRequest(request, response)
a>processRequest()
1.在里面执行了一个doService(request, response)
2.执行服务，doService()是一个抽象方法，在DispatcherServlet中进行了重写
b>doService()
1.执行了doDispatch(request, response)
2.用于处理请求和响应
c>doDispatch()
---->这个方法就是常看的方法，里面有ha.handle()等等方法
1.创建了调用链 mappedHandler，里面有三个值，包含handler、interceptorList、interceptorIndex
1.handler：浏览器发送的请求所匹配的控制器方法
2.interceptorList：处理控制器方法的所有拦截器集合
3.interceptorIndex：拦截器索引，控制拦截器afterCompletion()的执行
2.通过控制器方法创建相应的处理器适配器，调用所对应的控制器方法
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
3.调用拦截器的preHandle()
4.由处理器适配器调用具体的控制器方法，最终获得ModelAndView对象，执行了handle()
mv = ha.handle(processedRequest, response,mappedHandler.getHandler());
5.调用拦截器的postHandle()
6. 后续处理：处理模型数据和渲染视图，调用了processDispatchResult()
d>processDispatchResult()
1.调用了render() 处理模型数据和渲染视图
2.调用拦截器的afterCompletion()
---------------------------------------------
tips：这abcd的顺序也是程序实际运行的流程
4.SpringMVC的执行流程
1) 用户向服务器发送请求，请求被SpringMVC 前端控制器 DispatcherServlet捕获。
2) DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI），判断请求URI对应的映射：
判断请求映射是在doDispatcher()中有一个HandlerMappings，里面包含了所有映射和对应的控制器方法。会在请求的映射里面去匹配，如果匹配到就返回到HandlerExecutionChain中，
先以URL找请求，再根据请求方式来分辨具体是哪个方法，如果有一样的就会给你报一个错出来，说有两个都可以处理
a) 不存在
i. 再判断是否配置了mvc:default-servlet-handler
ii. 如果没配置，则控制台报映射查找不到，客户端展示404错误 ----错误是no mapping for GET
iii. 如果有配置，则访问目标资源（一般为静态资源，如：JS,CSS,HTML），找不到客户端也会展示404错误---错误是DefaultServletHttpRequestHandler的错误
b) 存在则执行下面的流程
3) 根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain执行链对象的形式返回。
4) DispatcherServlet 根据获得的Handler，选择一个合适的HandlerAdapter。
5) 如果成功获得HandlerAdapter，此时将开始执行拦截器的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) 此时将开始执行拦截器的postHandle(...)方法【逆向】。
9) 根据返回的ModelAndView（此时会判断是否存在异常：如果存在异常，则执行HandlerExceptionResolver进行异常处理）选择一个适合的ViewResolver进行视图解析，根据Model和View，来渲染视图。
10) 渲染视图完毕执行拦截器的afterCompletion(…)方法【逆向】。
11) 将渲染结果返回给客户端。
--------------------------------------------------------------------------------------------------------------------------------
SpingMVC完结！
VAN
