SpringMVC知识概括

SpringMVC介绍

简介：

• Spring 为展现层提供的基于 MVC 设计理念的优秀的 Web 框架，是目前最主流的 MVC 框架之一
• Spring3.0 后全面超越 Struts2，成为最优秀的 MVC 框架
• Spring MVC 通过一套 MVC 注解，让 POJO 成为处理请求的控制器，而无须实现任何接口。
• 支持 REST 风格的 URL 请求
• 采用了松散耦合可插拔组件结构，比其他 MVC 框架更具 扩展性和灵活性

环境搭建流程

步骤：

• 加入 jar 包
• 在 web.xml 中配置 DispatcherServlet
• 加入 Spring MVC 的配置文件
• 编写处理请求的处理器，并标识为处理器
• 编写视图

Spring MVC 的配置文件细节：

<!-- 配置自动扫描的包 -->
	<context:component-scan base-package="com.atguigu.springmvc"></context:component-scan>

DispatcherServlet配置细节：

• 配置 DispatcherServlet ：DispatcherServlet 默认加载/WEB-INF/<servletName-servlet/>.xml 的 Spring 配置文件, 启动 WEB 层 的Spring 容器。
• 也可以通过 contextConfigLocation 初始化参数自定义配置文件的位置和名称。

<!-- 配置 DispatcherServlet -->
	<servlet>
		<servlet-name>dispatcherServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<!-- 配置 DispatcherServlet 的一个初始化参数: 配置 SpringMVC 配置文件的位置和名称 -->
		<!-- 
			实际上也可以不通过 contextConfigLocation 来配置 SpringMVC 的配置文件, 而使用默认的.
			默认的配置文件为: /WEB-INF/<servlet-name>-servlet.xml
		-->
		<!--  
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:springmvc.xml</param-value>
		</init-param>
		-->
		<load-on-startup>1</load-on-startup>
	</servlet>

	<servlet-mapping>
		<servlet-name>dispatcherServlet</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>

@RequestMapping 映射请求

简介：

• Spring MVC 使用 @RequestMapping 注解为控制器指定可以处理哪些 URL 请求
• 在控制器的类定义及方法定义处都可标注@RequestMapping
  ①在类定义处：提供初步的请求映射信息。相对于 WEB 应用的根目录（访问时在根目录后面加多类上的路径）
  ②在方法处：提供进一步的细分映射信息。相对于类定义处的 URL。若类定义处未标注@RequestMapping，则方法处标记的 URL相对于WEB 应用的根目录
• DispatcherServlet 截获请求后，就通过控制器上@RequestMapping 提供的映射信息确定请求所对应的处理方法。

关于@RequestMapping的斜杆：

• 如果路径没有以/开头，则Spring(DefaultAnnotationHandlerMapping)将添加它。
• 请参阅类DefaultAnnotationHandlerMapping第122行(Spring 3.1.2)的方法String[]determineUrlsForHandler(String beanName)(即类级别)

String[] methodLevelPatterns = determineUrlsForHandlerMethods(handlerType, true);
for (String typeLevelPattern : typeLevelPatterns) {
    if (!typeLevelPattern.startsWith("/")) {
            typeLevelPattern = "/" + typeLevelPattern;
    }

• 请参阅类DefaultAnnotationHandlerMapping第182行(Spring 3.1.2)的方法String[]determineUrlsForHandler(Class<?> handlerType, final boolean hasTypeLevelMapping))(即方法级别)

String[] mappedPatterns = mapping.value();
if (mappedPatterns.length > 0) {
for (String mappedPattern : mappedPatterns) {
    if (!hasTypeLevelMapping && !mappedPattern.startsWith("/")) {
        mappedPattern = "/" + mappedPattern;
    }   

映射请求参数、请求方法或请求头：

• @RequestMapping 除了可以使用请求 URL 映射请求外，还可以使用请求方法、请求参数及请求头映射请求
• @RequestMapping 的 value、method、params 及 heads 分别表示请求URL、请求方法、请求参数及请求头的映射条件，他们之间是与的关系，联合使用多个条件可让请求映射更加精确化。
• @RequestMapping 还支持Ant 风格资源地址支持 3 种匹配符：
  ①?：匹配文件名中的一个字符
  ②*：匹配文件名中的任意字符
  ③** ：匹配多层路径

@RequestMapping属性中consumes、produces：

• 介绍下请求报文头里的几个属性：
  ①Accept代表发送端（客户端）希望接受的数据类型。
  <1>比如：Accept：text/xml;
  <2>代表客户端希望接受的数据类型是xml类型
  ②Content-Type代表发送端（客户端|服务器）发送的实体数据的数据类型。
  <1>比如：Content-Type：text/html;
  <2>代表发送端发送的数据格式是html。
• @RequestMapping属性中consumes、produces的作用：
  ①consumes： 指定处理请求的提交内容类型（Content-Type），例如application/json, text/html;
  ②produces: 指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回；
• 为什么使用consumes、produces者两个属性？
  ①答：可以针对请求方数据类型来进行访问的控制和过滤。

@PathVariable 映射 URL 绑定的占位符

@PathVariable 简介：

• PathVariable是路径变量。顾名思义，就是要获取一个url 地址中的一部分值。
• 带占位符的 URL 是 Spring3.0 新增的功能，该功能在SpringMVC 向 REST 目标挺进发展过程中具有里程碑的意义
• 通过 @PathVariable 可以将 URL 中占位符参数绑定到控制器处理方法的入参中：URL 中的 {xxx} 占位符可以通过@PathVariable(“xxx”) 绑定到操作方法的入参中。

REST风格URL简介：

• REST：即 Representational StateTransfer。（资源）表现层状态转化。是目前最流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多网站的采用.
• 资源（Resources）：网络上的一个实体，或者说是网络上的一个具体信息。它可以是一段文本、一张图片、一首歌曲、一种服务，总之就是一个具体的存在。可以用一个URI（统一资源定位符）指向它，每种资源对应一个特定的URI 。要 获取这个资源，访问它的URI就可以，因此 URI 即为每一个资源的独一无二的识别符.
• 表现层（Representation）：把资源具体呈现出来的形式，叫做它的表现层（Representation）。比如，文本可以用 txt 格式表现，也可以用 HTML 格 式、XML 格式、JSON 格式表现，甚至可以采用二进制格式。
• 状态转化（StateTransfer）：每发出一个请求，就代表了客户端和服务器的一次交互过程。HTTP协议，是一个无状态协议，即所有的状态都保存在服务器端。因此，如果客户端想要操作服务器，必须通过某种手段，让服务器端发生“状态转化”（State Transfer）。而这种转化是建立在表现层之上的，所以就是 “ 表现层状态转化”。具体说，就是 HTTP协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。它们分别对应四种基本操作：GET 用来获取资源，POST用来新建资源，PUT 用来更新资源，DELETE用来删除资源。
• 幂等性：
  ①幂等性概念：幂等通俗来说是指不管进行多少次重复操作，都是实现相同的结果。
  ②GET，PUT，DELETE都是幂等操作，而POST不是。
  ③首先GET请求很好理解，对资源做查询多次，此实现的结果都是一样的。PUT请求的幂等性可以这样理解，将A修改为B，它第一次请求值变为了B，再进行多次此操作，最终的结果还是B，与一次执行的结果是一样的，所以PUT是幂等操作。同理可以理解DELETE操作，第一次将资源删除后，后面多次进行此删除请求，最终结果是一样的，将资源删除掉了。POST不是幂等操作，因为一次请求添加一份新资源，二次请求则添加了两份新资源，多次请求会产生不同的结果，因此POST不是幂等操作。

REST风格URL示例：

• – /order/1 HTTP GET ：得到 id = 1 的 order
• – /order/1 HTTP DELETE：删除 id = 1的 order
• – /order/1 HTTP PUT：更新id = 1的 order
• – /order HTTP POST：新增 order

发送PUT和DELETE的解决方案：

• 添加HiddenHttpMethodFilter过滤器：
  ①浏览器form 表单只支持 GET 与 POST 请求，而DELETE、PUT 等method 并不支持，Spring3.0 添加了一个过滤器，
  ②发送请求到tomcat时仍然是post请求，但到了spring后可以将这些请求转换为标准的 http 方法，使得支持GET、POST、PUT 与DELETE 请求。
  ③除了配置过滤器外还需要添加多一个字段：
  <1> __method:“DELETE”,或者 _method:“PUT” 参数
• HttpPutFormContentFilter过滤器：(现最新版本已改为FormContentFilter)
  ①可以直接通过ajax发送PUT或DELETE请求。
  ②作用：
  <1>将请求体中的数据解析包装成一个map。
  <2>request被重新包装，request.getParameter()被重写，就会从自己封装的map中取数据
  ③org.springframework 5.1之后使用 FormContentFilter 代替 HttpPutFormContentFilter，官方文档介绍使用这个新的过滤器，并且支持DELETE方法

AJAX发送DELETE或PUT请求的问题：

• 如果直接发送ajax=PUT或DELETE形式的请求，请求体中有数据，但是对象封装不上。
• 原因：
  ①Tomcat：
  <1>将请求体中的数据，封装一个map。
  <2>request.getParameter(“参数名”)就会从这个map中取值。
  <3>SpringMVC封装POJO对象的时候会把POJO中每个属性的值，request.getParamter(“参数名”);
  ②AJAX发送PUT请求引发的血案：
  <1>PUT请求，请求体中的数据，request.getParameter(“参数名”)拿不到
  <2>Tomcat一看是PUT不会封装请求体中的数据为map，只有POST形式的请求才封装请求体为map
• 因此需要加上FormContentFilter过滤器

org.apache.catalina.connector.Request--parseParameters() (3111);

protected String parseBodyMethods = "POST";
if( !getConnector().isParseBodyMethod(getMethod()) ) {
     success = true;
     return;
}

映射请求参数 & 请求参数

简介：

• Spring MVC 通过分析处理方法的签名，将 HTTP 请求信息绑定到处理方法的相应人参中。
• Spring MVC 对控制器处理方法签名的限制是很宽松的， 几乎可以按喜欢的任何方式对方法进行签名。
• 必要时可以对方法及方法入参标注相应的注解(@PathVariable、@RequestParam、@RequestHeader 等)、Spring MVC 框架会将 HTTP 请求的信息绑定到相应的方法入参中，并根据方法的返回值类型做出相应的后续处理。

详解：

• 使用 @RequestParam 绑定请求参数值，顾名思义就是获取参数的。
  ①在处理方法入参处使用 @RequestParam 可以把请求参数传递给请求方法
  <1>value：参数名
  <2>required：是否必须。默认为 true, 表示请求参数中必须包含对应的参数，若不存在，将抛出异常
• 使用 @RequestHeader 绑定请求报头的属性值
  ①请求头包含了若干个属性，服务器可据此获知客户端的信 息，通过 @RequestHeader 即可将请求头中的属性值绑定到处理方法的入参中
• 使用 @CookieValue 绑定请求中的 Cookie 值
  ①@CookieValue 可让处理方法入参绑定某个 Cookie 值
• 使用 POJO 对象绑定请求参数值
  ①Spring MVC 会按请求参数名和 POJO 属性名进行自动匹配，自动为该对象填充属性值。支持级联属性。如：dept.deptId、dept.address.tel 等
• 使用 Servlet API 作为入参
  ①MVC 的 Handler 方法可以接受以下这些 ServletAPI 类型的参数：
  <1>HttpServletRequest
  <2>HttpServletResponse
  <3>HttpSession
  <4>java.security.Principal
  <5>Locale
  <6>InputStream
  <7>OutputStream
  <8>Reader
  <9>Writer

处理模型数据

Spring MVC 提供了以下几种途径输出模型数据：

• ModelAndView：处理方法返回值类型为 ModelAndView时, 方法体即可通过该对象添加模型数据
• Map、Model 及 ModelMap：入参为org.springframework.ui.Model、org.springframework.ui.ModelMap 或 java.uti.Map 时，处理方法返回时，Map、Model 及 ModelMap 中的数据会自动添加到模型中。
• @SessionAttributes:：将模型中的某个属性暂存到 HttpSession 中，以便多个请求之间可以共享这个属性
• @ModelAttribute:：方法入参标注该注解后, 入参的对象就会放到数据模型中
• 详细链接：
  ①SpringMVC处理模型数据
  ②SpringMvc中模型数据存储的理解

ModelAndView:

• 控制器处理方法的返回值如果为 ModelAndView, 则其既包含视图信息，也包含模型数据信息。
• ModelAndView则需要我们手动进行new。
• 添加模型数据:
  ①MoelAndView addObject(String attributeName, Object attributeValue)
  ②ModelAndView addAllObject(Map<String, ?> modelMap)
• 设置视图:
  ①void setView(View view)
  ②void setViewName(String viewName)j

@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView() {
	String viewName = SUCCESS;
	ModelAndView modelAndView = new ModelAndView(viewName);
	// 添加模型数据到ModelAndView中
	modelAndView.addObject("time", new Date());
	return modelAndView;
}

Map 及 Model：

• Spring MVC 在内部使用了一个org.springframework.ui.Model 接口存储模型数据
• 具体步骤：
  ①Spring MVC 在调用方法前会创建一个隐含的模型对象作为模型数据的存储容器。
  ②如果方法的入参为Map或Model或ModelMap类型，Spring MVC 会将隐含模型的引用传递给这些入参。在方法体内，开发者可以通过这个入参对象访问到模型中的所有数据，也可以向模型中添加新的属性数据

//目标方法可以添加Map类型，实际上也可以时 Model 类型或者 ModelMap 类型的参数
@RequestMapping("/testMap")
public String testMap(Map<String, Object> map) {
	map.put("names", Arrays.asList("Tom", "Jerry", "Mike"));
	return SUCCESS;
}

@SessionAttributes：

• 若希望在多个请求之间共用某个模型属性数据，则可以在控制器类上标注一个 @SessionAttributes, Spring MVC将在模型中对应的属性暂存到 HttpSession 中。
• @SessionAttributes除了可以通过属性名指定需要放到会话中的属性外，还可以通过模型属性的对象类型指定哪些模型属性需要放到会话中。
• 注意: 该注解只能放在类的上面. 而不能修饰放方法。
  ①@SessionAttributes(types=User.class) 会将隐含模型中所有类型 为 User.class 的属性添加到会话中。
  ②@SessionAttributes(value={“user1”, “user2”})
  ③@SessionAttributes(types={User.class, Dept.class})
  ④@SessionAttributes(value={“user1”, “user2”}, types={Dept.class})

//注意控制类前面加@SessionAttributes
@SessionAttributes(value = { "user" }, types = { String.class })
@RequestMapping("/springmvc")
@Controller
public class SpringMVCTest {
	@RequestMapping("/testSessionAttributes")
	public String testSessionAttributes(Map<String, Object> map) {
		User user = new User("tom", "123456", "test@qq.com", 15);
		map.put("user", user);// 使用value属性值
		map.put("school", "FSPT");// 使用types属性值
		return SUCCESS;
	}
}

@ModelAttribute：

• 在方法定义上使用 @ModelAttribute 注解：Spring MVC在调用目标处理方法前，会先逐个调用在方法级上标注了@ModelAttribute 的方法。
• 在方法的入参前使用 @ModelAttribute 注解：
  ①可以从隐含对象中获取隐含的模型数据中获取对象，再将请求参数绑定到对象中，再传入入参
  ② 将方法入参对象添加到模型中

//有ModelAttribute标记的方法，会在每个目标方法执行之前被SpringMVC调用 
@ModelAttribute
public void getUser(@RequestParam(value = "id", required = false) Integer id, Map<String, Object> map) {
	if (id != null) {
	// 模拟从数据库中获取对象
	User user = new User(1, "Tom", "123456", "tom@123.com", 12);
	System.out.println("从数据库获取一个对象" + user);
	map.put("user", user);
	}
}

@ModelAttribute源代码分析的流程：

• 调用 @ModelAttribute 注解修饰的方法. 实际上把 @ModelAttribute 方法中 Map 中的数据放在了 implicitModel 中.
• 解析请求处理器的目标参数, 实际上该目标参数来自于 WebDataBinder 对象的 target 属性
  ①创建 WebDataBinder 对象:
  1、 确定 objectName 属性: 若传入的 attrName 属性值为 “”, 则 objectName 为类名第一个字母小写.
  注意: attrName. 若目标方法的 POJO 属性使用了 @ModelAttribute 来修饰, 则 attrName 值即为 @ModelAttribute 的 value 属性值
  2、 确定 target 属性:
  在 implicitModel 中查找 attrName 对应的属性值. 若存在, ok。若不存在: 则验证当前 Handler 是否使用了 @SessionAttributes 进行修饰, 若使用了, 则尝试从 Session 中 获取 attrName 所对应的属性值. 若 session 中没有对应的属性值, 则抛出了异常。若 Handler 没有使用 @SessionAttributes 进行修饰, 或 @SessionAttributes 中没有使用 value 值指定的 key和 attrName 相匹配, 则通过反射创建了 POJO 对象
  ②SpringMVC 把表单的请求参数赋给了 WebDataBinder 的 target 对应的属性.
  ③SpringMVC 会把 WebDataBinder 的 attrName 和 target 给到 implicitModel. 近而传到 request 域对象中.
  ④把 WebDataBinder 的 target 作为参数传递给目标方法的入参.

@SessionAttributes引发的异常：

• 如果在处理类定义处标注了@SessionAttributes(“xxx”)，则尝试从会话中获取该属性，并将其赋给该入参，然后再用请求消息填充该入参对象。如果在会话中找不到对应的属性，
• 则抛出 HttpSessionRequiredException 异常。

Map、Model、ModelMap、ModelAndView和隐含模型详解:

• 首先，在了解这三者之前，需要知道一点：SpringMVC在调用方法前会创建一个隐含的数据模型（Model），作为模型数据的存储容器，成为”隐含模型”。
• 如果controller方法的参数为Moedl或ModelMap或Map类型，则springMVC会将隐含模型的引用传递给这些参数。在处理方法内部，开发者就可以通过这个参数对象访问。
• 模型中的所有数据，也可以向模型中添加新的属性数据。也就是说在每一次的前后台请求的时候会随带这一个背包（Model），不管你有没有用，这个背包确实是存在的，用来盛放我们请求交互传递的值。
• 在前端向后台请求时，Model 和 ModelMap和Map的实例都是spirng mvc框架来自动创建的，用户无需自己创建。
• 无论是Mode还是ModelMap还是Map底层都是使用BindingAwareModelMap，所以两者基本没什么区别，我们只需拿来使用即可。而ModelAndView则需要我们手动进行new，springMVC不会帮我们创建。
• 相同点：
  ①它们的作用相同，都是用于传递控制方法存储数据到展示页面（JSP页面），通过EL表达式或者C标签库的{name } 来获取对对象的key进行取值。
• 区别：
  ①Map、Model、ModelMap不需要我们手动创建，springmvc框架自动创建并作为控制器方法参数传入；而ModelAndView需要手动创建。
  ②Model、Map、ModelMap只是用来传输数据的，并不会进行业务的寻址。ModelAndView却是可以进行业务寻址的，就是设置对应的要请求的静态文件，这里的静态文件指的是类似jsp的文件。

@SessionAttributes放在类上为什么要有Map、Model、ModelMap、ModelAndView来做参数或new来储值？
@ModelAttribute为什么放在返回值是空的方法上要以Map作为参数？

• 其实返回值是String,也根本不影响，因为Map.put(),已经把user对 象存到了模型对象中。

视图和视图解析器

步骤：

• 视图处理器走的是转发而不是重定向或response返回，也就是将controller中的model转发到指定视图。

视图和视图解析器：

• 请求处理方法执行完成后，最终返回一个 ModelAndView对象。对于那些返回 String，View 或 ModeMap等类型的处理方法，Spring MVC 也会在内部将它们装配成一个ModelAndView 对象，它包含了逻辑名和模型对象的视图。
• Spring MVC 借助视图解析器（ViewResolver）得到最终的视图对象（View），最终的视图可以是 JSP ，也可能是Excel、JFreeChart 等各种表现形式的视图。
• 对于最终究竟采取何种视图对象对模型数据进行渲染，处理器并不关心，处理器工作重点聚焦在生产模型数据的工作上，从而实现 MVC 的充分解耦。

视图：

• 视图的作用是渲染模型数据，将模型里的数据以某种形式呈现给客户。
• 为了实现视图模型和具体实现技术的解耦，Spring 在org.springframework.web.servlet
  包中定义了一个高度抽象的 View接口：
  
• 视图对象由视图解析器负责实例化。由于视图是无状态的，所以他们不会有线程安全的问题。

springMVC中controller的几种返回类型：

• 返回ModelAndView
  ①返回ModelAndView时最常见的一种返回结果。需要在方法结束的时候定义一个ModelAndView对象，并对Model和View分别进行设置。
• 返回String：字符串代表逻辑视图名
  ①真实的访问路径=“前缀”+逻辑视图名+“后缀”
  注意：如果返回的String代表逻辑视图名的话，那么Model的返回方式如下：

public String testController(Model model){
	//相当于ModelAndView的addObject方法
	model.addAttribute(attrName,attrValue);
	return "逻辑视图名";
   }

• 返回String：代表redirect重定向
  ①redirect的特点和servlet一样，使用redirect进行重定向那么地址栏中的URL会发生变化，同时不会携带上一次的request

public String testController(Model model){
 return "redirect:path";//path代表重定向的地址
 }

• 返回String：代表forward转发
  ①通过forward进行转发，地址栏中的URL不会发生改变，同时会将上一次的request携带到写一次请求中去

 public String testController(Model model){
 return "forward:path";//path代表转发的地址
 }

• 返回String：代表返回的内容
  ①页面不跳转，而是直接把字符串的内容显示到页面上。
  ②使用@RestController注解等于使用@Controller和@ResponseBody两个注解且写在类上的，表示该类下所有方法都默认加上@ResponseBody注解

    @RestController(value = "/index.html")
    public String loginPage(){
        return "login";
    }

• 返回void
  ①返回这种结果的时候可以在Controller方法的形参中定义HTTPServletRequest和HTTPServletResponse对象进行请求的接收和响应
  1）使用request转发页面
  request.getRequestDispatcher(“转发路径”).forward(request,response);
  2）使用response进行页面重定向
  response.sendRedirect(“重定向路径”);
  3）也可以使用response指定响应结果
  response.setCharacterEncoding(“UTF-8”);
  response.setContentType(“application/json;charset=utf-8”);
  response.getWriter.write(“json串”);
• 返回任意类型
  ①原理也是使用response指定响应结果，但前提是使用@ResponseBody注解。

常用的视图实现类：

视图解析器：

• SpringMVC 为逻辑视图名的解析提供了不同的策略，可以在 Spring WEB上下文中配置一种或多种解析策略，并指定他们之间的先后顺序。每一种映射策略对应一个具体的视图解析器实现类。
• 视图解析器的作用比较单一：将逻辑视图解析为一个具体的视图对象。
• 所有的视图解析器都必须实现 ViewResolver 接口：
  
• 程序员可以选择一种视图解析器或混用多种视图解析器
• 每个视图解析器都实现了 Ordered 接口并开放出一个 order 属性，可以通过 order 属性指定解析器的优先顺序，order越小优先级越高。
• SpringMVC 会按视图解析器顺序的优先顺序对逻辑视图名进行解析，直到解析成功并返回视图对象，否则将抛出ServletException 异常。

常用的视图解析器实现类：

InternalResourceViewResolver视图解析器:

• JSP 是最常见的视图技术，可以使用InternalResourceViewResolver 作为视图解析器。

<!-- 配置视图解析器 -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/views/"></property>
		<property name="suffix" value=".jsp"></property>
	</bean>

• 若项目中使用了 JSTL，则 SpringMVC 会自动把视图由InternalResourceView 转为 JstlView。
• 若使用 JSTL 的 fmt 标签则需要在 SpringMVC 的配置文件中配置国际化资源文件。

<!-- 配置国际化资源文件 -->
	<bean id="messageSource"
		class="org.springframework.context.support.ResourceBundleMessageSource">
		<property name="basename" value="i18n"></property>
	</bean>

• 若希望直接响应通过 SpringMVC 渲染的页面，可以使用 mvc:view-controller标签实现(对应WEB-INF目录下面的JSP页面，我们知道是不能直接使用URL访问到。需要通过转发的方式，而我们一般都是在控制器中做转发映射，对应一些我们不需要其他操作的JSP页面，我们可以使用<mvc:view-controller path=""/>来配置，这样就可以不用在控制器中再去做转发映射)

<mvc:view-controller path="springmvc/testJstlView" view-name="success"/>

Excel 视图:

• 若希望使用 Excel 展示数据列表，仅需要扩展SpringMVC 提供的 AbstractExcelView 或AbstractJExcel View 即可。实现 buildExcelDocument() 方法，在方法中使用模型数据对象构建Excel 文档就可以了。
• AbstractExcelView 基于 POI API，而AbstractJExcelView 是基于 JExcelAPI 的。
• 视图对象需要配置 IOC 容器中的一个 Bean，使用BeanNameViewResolver 作为视图解析器即可。
• 若希望直接在浏览器中直接下载 Excel 文档，则可以设置响应头 Content-Disposition
  的值为attachment;filename=xxx.xls。

转发和重定向概述：

• 一般情况下，控制器方法返回字符串类型的值会被当成逻辑视图名处理进行转发。
• 如果返回的字符串中带 forward: 或 redirect: 前缀 时，SpringMVC不再直接交给视图解析器解析。SpringMVC会对他们进行特殊处理：将 forward:和redirect: 当成指示符，其后的字符串作为 URL 来处理。
  ①redirect:success.jsp：会完成一个到 success.jsp 的重定向的操作(重点)
  ②forward:success.jsp：会完成一个到 success.jsp 的转发操作

SpringMVC 表单标签

简述：

• 在JSP中通过 SpringMVC 的表单标签可以实现将模型数据中的属性和 HTML 表单元素相绑定，
• 以实现表单数据更便捷编辑和表单值的回显。

处理静态资源

静态资源处理简述:

• 优雅的 REST 风格的资源URL 不希望带 .html 或 .do 等后缀，因此一般不通过DispatcherServlet来请求静态资源。
• 若将 DispatcherServlet 请求映射配置为 /，则 Spring MVC 将捕获WEB 容器的所有请求，包括静态资源的请求，SpringMVC 会将他们当成一个普通请求处理，因找不到对应处理器将导致错误。
• 第一种方法可以在 SpringMVC 的配置文件中配置 <mvc:default-servlet-handler/> 的方式解决静态资源的问题。
  ①<mvc:default-servlet-handler/> 将在 SpringMVC上下文中定义一个DefaultServletHttpRequestHandler，它会对进入 DispatcherServlet 的请求进行筛查，如果发现是没有经过映射的请求，就将该请求交由 WEB 应用服务器默认的 Servlet 处理，如果不是静态资源的请求，才由DispatcherServlet 继续处理。
  ②一般 WEB 应用服务器默认的 Servlet 的名称都是 default。若所使用的WEB 服务器的默认 Servlet 名称不是default，则需要通过 default-servlet-name 属性显式指定。
• 第二种方法就是采用<mvc:resources />。
  ①<mvc:default-servlet-handler />将静态资源的处理经由Spring MVC框架交回Web应用服务器处理。而<mvc:resources />更进一步，由Spring MVC框架自己处理静态资源，并添加一些有用的附加值功能。
  ②首先，<mvc:resources />允许静态资源放在任何地方，如WEB-INF目录下、类路径下等，你甚至可以将JavaScript等静态文件打到JAR包中。通过location属性指定静态资源的位置，由于location属性是Resources类型，因此可以使用诸如"classpath:"等的资源前缀指定资源位置。传统Web容器的静态资源只能放在Web容器的根路径下，<mvc:resources />完全打破了这个限制。
  ②其次，<mvc:resources />依据当前著名的Page Speed、YSlow等浏览器优化原则对静态资源提供优化。你可以通过cacheSeconds属性指定静态资源在浏览器端的缓存时间，一般可将该时间设置为一年，以充分利用浏览器端的缓存。在输出静态资源时，会根据配置设置好响应报文头的Expires 和 Cache-Control值。
  ③在接收到静态资源的获取请求时，会检查请求头的Last-Modified值，如果静态资源没有发生变化，则直接返回303相应状态码，提示客户端使用浏览器缓存的数据，而非将静态资源的内容输出到客户端，以充分节省带宽，提高程序性能。

数据绑定

数据绑定流程：

• Spring MVC 主框架将 ServletRequest 对象及目标方法的入参实例传递给 WebDataBinderFactory实例，以创建 DataBinder 实例对象
• DataBinder 调用装配在 Spring MVC 上下文中的ConversionService 组件进行数据类型转换、数据格式化。将 Servlet 中的请求信息填充到入参对象中。
• 调用 Validator 组件对已经绑定了请求消息的入参对象进行数据合法性校验，并最终生成数据绑定结果BindingData 对象 。
• Spring MVC 抽取 BindingResult 中的入参对象和校验错误对象，将它们赋给处理方法的响应入参。
• 源码实现：

webDataBinder binder = binderFactory.createBinder(request，attribute，name);
if (binder.getTarget() != nu11) {
	bindRequestParameters(binder, request);
	validateIfApplicable(binder, parameter);
	if (binder.getBindingResult().hasErrors()) {
		if (isBindExceptionRequired(binder, parameter)) {
			throw new BindException(binder.getBindingResult());
		}
	}
}

• 链接：springMVC对简单对象,Set,List,Map的数据绑定及类型转换
• 数据绑定总结：
  ①Spring MVC 通过反射机制对目标处理方法进行解析，将请求消息绑定到处理方法的入参中。
  ②数据绑定的核心部件是DataBinder，运行机制如下：
  

数据转换

数据转换概述：

• Spring MVC 上下文中内建了很多转换器，可完成大多数 Java 类型的转换工作。
• ConversionService converters =

– java.lang.Boolean -> java.lang.String : 
org.springframework.core.convert.support.ObjectToStringConverter@f874ca 
– java.lang.Character -> java.lang.Number : CharacterToNumberFactory@f004c9 
– java.lang.Character -> java.lang.String : ObjectToStringConverter@68a961 
– java.lang.Enum -> java.lang.String : EnumToStringConverter@12f060a 
– java.lang.Number -> java.lang.Character : NumberToCharacterConverter@1482ac5 
– java.lang.Number -> java.lang.Number : NumberToNumberConverterFactory@126c6f 
– java.lang.Number -> java.lang.String : ObjectToStringConverter@14888e8 
– java.lang.String -> java.lang.Boolean : StringToBooleanConverter@1ca6626 
– java.lang.String -> java.lang.Character : StringToCharacterConverter@1143800 
– java.lang.String -> java.lang.Enum : StringToEnumConverterFactory@1bba86e 
– java.lang.String -> java.lang.Number : StringToNumberConverterFactory@18d2c12 
– java.lang.String -> java.util.Locale : StringToLocaleConverter@3598e1 
– java.lang.String -> java.util.Properties : StringToPropertiesConverter@c90828 
– java.lang.String -> java.util.UUID : StringToUUIDConverter@a42f23 
– java.util.Locale -> java.lang.String : ObjectToStringConverter@c7e20a 
– java.util.Properties -> java.lang.String : PropertiesToStringConverter@367a7f 
– java.util.UUID -> java.lang.String : ObjectToStringConverter@112b07f 
……

自定义类型转换器：

• ConversionService 是 Spring 类型转换体系的核心接口。

• 可以利用 ConversionServiceFactoryBean 在 Spring 的 IOC 容器中定义一个ConversionService。Spring将自动识别出IOC容器中的ConversionService，并在 Bean属性配置及Spring MVC 处理方法入参绑定等场合使用它进行数据的转换。
  ①可通过 ConversionServiceFactoryBean 的 converters 属性注册自定义的类型转换器。

• Spring 定义了3种类型的转换器接口，实现任意一个转换器接口都可以作为自定义转换器注册到ConversionServiceFactroyBean 中：
  ①Converter<S,T>：将 S 类型对象转为 T 类型对象
  ②ConverterFactory：将相同系列多个 “同质” Converter 封装在一起。如果希望将一种类型的对象转换为另一种类型及其子类的对象（例如将 String 转换为 Number 及 Number 子类 （Integer、Long、Double 等）对象）可使用该转换器工厂类
  ③GenericConverter：会根据源类对象及目标类对象所在的宿主类 中的上下文信息进行类型转换

• 自定义转换器示例：
  ①<mvc:annotation-driven conversion-service= “conversionService”/>会将自定义的 ConversionService 注册到 Spring MVC 的上下文中

public class UserConverter implements Converter<String,User>{
	//source为传递进来的String值，如100-shoto-abc123-true
	@Override
	public User convert(String source) {
		if (source != null) {
			String[] userStr = source.split("-");
			Integer uid = Integer.parseInt(userStr[0]);
			String username = userStr[1];
			String password = userStr[2];
			Boolean isGender = Boolean.parseBoolean(userStr[3]);
			return new User(uid, username, password, isGender);
		}
		return null;
	}
}

<!-- 使用annotation-driven将conversionService注册到SpringMVC上下文中 -->
<mvc:annotation-driven conversion-service="conversionServiceFactoryBean"></mvc:annotation-driven>	
	
<!-- 配置自定义数据类型转换器 -->
<bean id="conversionServiceFactoryBean" class="org.springframework.context.support.ConversionServiceFactoryBean">
	<property name="converters">
		<list>
			<bean id="userConverter" class="com.shoto.springmvc.converters.UserConverter"/>
		</list>
	</property>
</bean>

@RequestMapping("/handle24")
public String handle24(@RequestParam("user") User user){
	System.out.println(user);
	return "success";
}

@InitBinder简述：

• 由 @InitBinder标识的方法可以对 WebDataBinder 对象进行初始化。WebDataBinder 是DataBinder 的子类，用于完成由表单字段到 JavaBean 属性的绑定。
• @InitBinder方法不能有返回值，它必须声明为void。
• @InitBinder方法的参数通常是是 WebDataBinder。

/**
 * 不自动绑定对象中的roleSet属性,另行处理。
 */
@InitBinder
public void initBinder(WebDataBinder dataBinder){
	dataBinder.setDisal1owedFields ( "roleSet" );
}

数据格式化

数据格式化简介：

• 对属性对象的输入/输出进行格式化，从其本质上讲依然属于 “类型转换” 的范畴。
• Spring 在格式化模块中定义了一个实现ConversionService 接口的FormattingConversionService实现类，该实现类扩展 了 GenericConversionService，因此它既具有类型转换的功能，又具有格式化的功能。
• FormattingConversionService拥有一个FormattingConversionServiceFactroyBean 工厂类，后者用于在 Spring 上下文中构造前者。
• FormattingConversionServiceFactroyBean 内部已经注册了：
  ①NumberFormatAnnotationFormatterFactroy：支持对数字类型的属性使用@NumberFormat 注解
  ②JodaDateTimeFormatAnnotationFormatterFactroy：支持对日期类型的属性使用 @DateTimeFormat注解
• 装配了 FormattingConversionServiceFactroyBean 后，就可以在 Spring MVC入参绑定及模型数据输出时使用注解驱动了。<mvc:annotation-driven/>默认创建的ConversionService实例即为FormattingConversionServiceFactroyBean

日期格式化与数值格式化：

• @DateTimeFormat注解可对java.util.Date、java.util.Calendar、java.long.Long时间类型进行标注：
  ①pattern 属性：类型为字符串，指定解析/格式化字段数据的模式。如：”yyyy-MM-dd hh:mm:ss”
  ②iso 属性：类型为 DateTimeFormat.ISO，指定解析/格式化字段数据的ISO模式。包括四种：<1>ISO.NONE（不使用） – 默 认
  <2>ISO.DATE(yyyy-MM-dd)
  <3>ISO.TIME(hh:mm:ss.SSSZ)
  <4>ISO.DATE_TIME(yyyy-MM-dd hh:mm:ss.SSSZ)
  ③style 属性：字符串类型。通过样式指定日期时间的格式，由两位字符组成，第一位表示日期的格式，第二位表示时间的格式：
  <1>S：短日期/时间格式
  <2>M：中日期/时间格式
  <3>L：长日期/时间格式
  <4>F：完整日期/时间格式
  <5>-：忽略日期或时间格式
• @NumberFormat注解可对类似数字类型的属性进行标注，它拥有两个互斥的属性：
  ①style：类型为 NumberFormat.Style，用于指定样式类型。包括三种：
  <1>Style.NUMBER（正常数字类型）
  <2>Style.CURRENCY（货币类型）
  <3>Style.PERCENT（百分数类型）
  ②pattern：类型为 String，自定义样式，如patter="#,###"。
• 示例：

------------------表单代码：------------------
<form action="formatDateAndNumber" method="POST">
	User ID：<input type="text" name="uid"/><br/>
	Username：<input type="text" name="username"/><br/>
	PassWord：<input type="password" name="password"/><br/>
	is Fale：<input type="text" name="isGender"/><br/>
	salary：<input type="text" name="salary"/><br/>
	birthday：<input type="text" name="birthday"/><br/>
	<input type="submit" value="Submit"/>
</form>

------------------javaBean代码：------------------
private Integer uid;
private String username;
private String password;
private Boolean isGender;
@NumberFormat(pattern="###,###,###.##")
private Double salary;
@DateTimeFormat(iso = ISO.DATE)//格式是yyyy-MM-dd
private Date birthday;

------------------Controller代码：--------------------
@RequestMapping(value="/formatDateAndNumber",method=RequestMethod.POST)
public String formatDateAndNumber(User user) {
	//输出：User [uid=100, username=abc, password=abc123, isGender=true, 
	//salary=100452.12, birthday=Thu Feb 14 08:00:00 CST 2019]
	System.out.println(user);
	return "success";
}

--------------------------需要在MVC配置文件中进行如下配置：------------------
<mvc:annotation-driven></mvc:annotation-driven>

数据校验

JSR 303简介：

• Java Specification Requests------- Java规范提案
• JSR 303 是 Java 为 Bean 数据合法性校验提供的标准框架，它已经包含在 JavaEE 6.0 中
• JSR 303 通过在 Bean 属性上标注类似于 @NotNull、@Max 等标准的注解指定校验规则，并通过标准的验证接口对 Bean进行验证。
  

Hibernate Validator 扩展注解：

• Hibernate Validator 是 JSR 303 的一个参考实现，除支持所有标准的校验注解外，它还支持以下的扩展注解
  

SpringMVC数据校验：

• Spring 4.0 拥有自己独立的数据校验框架，同时支持 JSR 303 标准的校验框架。

• Spring 在进行数据绑定时，可同时调用校验框架完成数据校验工作。在 Spring MVC 中，可直接通过注解驱动的方式进行数据校验

• Spring 的 LocalValidatorFactroyBean 既实现了 Spring 的Validator 接口，也实现了 JSR 303 的 Validator 接口。只要在Spring容器中定义了一个LocalValidatorFactoryBean，即可将其注入到需要数据校验的Bean中。

• Spring 本身并没有提供 JSR303 的实现，所以必须将JSR303 的实现者的 jar 包放到类路径下

• <mvc:annotation-driven/> 会默认装配好一个LocalValidatorFactoryBean，通过在处理方法的入参上标注 @valid 注解即可让 Spring MVC 在完成数据绑定后执行数据校验的工作。

• 在已经标注了 JSR303 注解的表单/命令对象前标注一个@Valid，Spring MVC框架在将请求参数绑定到该入参对象后，就会调用校验框架根据注解声明的校验规则实施校验。

• Spring MVC是通过对处理方法签名的规约来保存校验结果的：前一个表单/命令对象的校验结果保存到随后的入参中，这个保存校验结果的入参必须是BindingResult 或Errors 类型，这两个类都位于 org.springframework.validation 包中。

• 需校验的 Bean 对象和其绑定结果对象或错误对象时成对出现的，它们之间不允许声明其他的入参。

• Errors 接口提供了获取错误信息的方法，如 getErrorCount() 或getFieldErrors(String field)，BindingResult 扩展了 Errors 接口

• 常用方法：

FieldError getFieldError(String field);
List<FieldError> getFieldErrors();
Object getFieldValue(String field);
Int getErrorCount(); 

在页面上显示错误：

• Spring MVC 除了会将表单/命令对象的校验结果保存到对应的:BindingResult 或 Errors对象中外，还会将所有校验结果保存到“隐含模型”
• 即使处理方法的签名中没有对应于表单/命令对象的结果入参，校验结果也会保存在 “隐含对象” 中。
• 隐含模型中的所有数据最终将通过 HttpServletRequest的属性列表暴露给 JSP 视图对象，因此在 JSP 中可以获取错误信息
• 在 JSP 页面上可通过 <form:errors path=“userName”> 显示错误消息

Spring数据校验框架与JSR303校验框架：

• Spring Validation验证框架对参数的验证机制提供了@Validated（Spring's JSR-303规范，是标准JSR-303的一个变种），javax提供了@Valid（标准JSR-303规范），配合BindingResult可以直接提供参数验证结果。
• 在检验Controller的入参是否符合规范时，使用@Validated或者@Valid在基本验证功能上没有太多区别。但是在分组、注解地方、嵌套验证等功能上两个有所不同：
  ①分组：
  <1>@Validated：提供了一个分组功能，可以在入参验证时，根据不同的分组采用不同的验证机制，这个网上也有资料，不详述。
  <2>@Valid：作为标准JSR-303规范，还没有吸收分组的功能。
  ②注解地方：
  <1>@Validated：可以用在类型、方法和方法参数上。但是不能用在成员属性（字段）上
  <2>@Valid：可以用在方法、构造函数、方法参数和成员属性（字段）上
  <3>两者是否能用于成员属性（字段）上直接影响能否提供嵌套验证的功能。
  ③嵌套验证
  <1>@Validated不能用在成员属性（字段）上，但是@Valid能加在成员属性（字段）上，而且@Valid类注解上也说明了它支持嵌套验证功能。
  <2>在比较两者嵌套验证时，先说明下什么叫做嵌套验证。比如我们现在有个实体叫做Item：

public class Item {
    @NotNull(message = "id不能为空")
    @Min(value = 1, message = "id必须为正整数")
    private Long id;

    @NotNull(message = "props不能为空")
    @Size(min = 1, message = "至少要有一个属性")
    private List<Prop> props;
}

//Item带有很多属性，属性里面有属性id，属性值id，属性名和属性值，如下所示：

public class Prop {
    @NotNull(message = "pid不能为空")
    @Min(value = 1, message = "pid必须为正整数")
    private Long pid;

    @NotNull(message = "vid不能为空")
    @Min(value = 1, message = "vid必须为正整数")
    private Long vid;

    @NotBlank(message = "pidName不能为空")
    private String pidName;

    @NotBlank(message = "vidName不能为空")
    private String vidName;
}

//属性这个实体也有自己的验证机制，比如属性和属性值id不能为空，属性名和属性值不能为空等。
//现在我们有个ItemController接受一个Item的入参，想要对Item进行验证，如下所示：

@RestController
public class ItemController {

    @RequestMapping("/item/add")
    public void addItem(@Validated Item item, BindingResult bindingResult) {
        doSomething();
    }
}
//在上图中，如果Item实体的props属性不额外加注释，只有@NotNull和@Size，无论入参采用@Validated还是
//@Valid验证，Spring Validation框架只会对Item的id和props做非空和数量验证，不会对props字段里的
//Prop实体进行字段验证，也就是@Validated和@Valid加在方法参数前，都不会自动对参数进行嵌套验证。也就是
//说如果传的List<Prop>中有Prop的pid为空或者是负数，入参验证不会检测出来。

//为了能够进行嵌套验证，必须手动在Item实体的props字段上明确指出这个字段里面的实体也要进行验证。由于
//@Validated不能用在成员属性（字段）上，但是@Valid能加在成员属性（字段）上，而且@Valid类注解上也说明
//了它支持嵌套验证功能，那么我们能够推断出：@Valid加在方法参数时并不能够自动进行嵌套验证，而是用在需要
//嵌套验证类的相应字段上，来配合方法参数上@Validated或@Valid来进行嵌套验证。

//我们修改Item类如下所示：

public class Item {
    @NotNull(message = "id不能为空")
    @Min(value = 1, message = "id必须为正整数")
    private Long id;

    @Valid // 嵌套验证必须用@Valid
    @NotNull(message = "props不能为空")
    @Size(min = 1, message = "props至少要有一个自定义属性")
    private List<Prop> props;
}

//然后我们在ItemController的addItem函数上再使用@Validated或者@Valid，就能对Item的入参进行嵌套验
//证。此时Item里面的props如果含有Prop的相应字段为空的情况，Spring Validation框架就会检测出来，
//bindingResult就会记录相应的错误。

@Valid和@Validated源码分析：

@Target({ElementType.METHOD, ElementType.FIELD, ElementType.CONSTRUCTOR, 
ElementType.PARAMETER, ElementType.TYPE_USE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Valid {
}

@Target({ElementType.TYPE, ElementType.METHOD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Validated {
    Class<?>[] value() default {};

<mvc:annotation-driven/>详解

<mvc:annotation-driven/>详解:

• spring文档上这样解释<mvc:annotation-driven/>：annotation-driven注册了一系列基础bean，和一些classpath上依赖进来的bean
  ①基础bean只能提供最基础的服务
  ②其它的扩展功能，比如JSON、XML、Valid等等，根据classpath有没有相关的依赖来决定要不要添加对应的bean或者属性
  ③例如：写一个最简单的返回ModelAndView的Controller，不加annotation-driven，你会发现它是可以运行的，但如果改成返回Json对象加上ResponseBody就会报错。
• 链接：springmvc的<mvc:annotation-driven/>

从源码分析：

• 不论加不加annotation-driven，servlet初始化流程都是这样开始的
  ①web容器（任意支持servlet规范的容器，比如tomcat）调用loadServlet，进而调用了DispatcherServlet顶级父类HttpServletBean的init方法，接着向子类调用去new一个webApplicationContext并refresh。
  ②refresh时根据配置文件的条目，找对应的handler去处理比如<mvc:annotation-driven>处理类是AnnotationDrivenBeanDefinitionParser，<context:component-scan>处理类是ComponentScanBeanDefinitionParser
• 不加annotation-driven的情况容器创建完成后
  ①会进行事件广播触发DispatcherServlet的OnRefresh方法OnRefresh会注册一大堆的bean到容器中。
  ②如果之前容器里面已经有了相同类型的bean，那么就不做任何事情。如果没有就注册一些默认的bean到容器中提供基础功能了。
  ③都有哪些默认的bean呢？

在org\springframework\spring-webmvc\5.2.6.RELEASE\spring-webmvc-
5.2.6.RELEASE.jar!\org\springframework\web\servlet\DispatcherServlet.properties文件中

列举几个常见的bean：
HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping

org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping

org.springframework.web.servlet.function.support.RouterFunctionMapping

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter

org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter

org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter

org.springframework.web.servlet.function.support.HandlerFunctionAdapter

org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver

org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver

org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

• 如果加了annotation-driven：
  ①<mvc:annotation-driven>的处理类AnnotationDrivenBeanDefinitionParser也会注册一大堆的bean到容器中：
  ②接下来去调用OnRefresh时发现这些bean已经注册了，所以不会去注册DispatcherServlet.properties里面记载的默认bean。
  ③这说明annotation-driven覆盖了默认配置。

跟上面对照一下来看看：

HandlerMapping：
<1>RequestMappingHandlerMapping
<2>BeanNameUrlHandlerMapping 

HandlerAdapter：
<1>RequestMappingHandlerAdapter
<2>HttpRequestHandlerAdapter
<3>SimpleControllerHandlerAdapter 

HandlerExceptionResolver：
<1>ExceptionHandlerExceptionResolver
<2>ResponseStatusExceptionResolver
<3>DefaultHandlerExceptionResolver

• 所以这两种方式注册出来的基础bean几乎是一致的，所以才会造成加不加这个annotation-driven，基本功能不受到影响的结果
• 另外annotation-driven的作用就是提供扩展功能
  ①延续上面在没有加annotation-driven时，Controller返回JSON报错的例子，来说明classpath这种功能扩展方式的原理：
  <1>假如classpath中有jackson相关依赖，AnnotationDrivenBeanDefinitionParser处理类就会把jackson2Present设为true，注册MappingJackson2HttpMessageConverter这个messageConverter。

<mvc:annotation-driven/>总结:

• <mvc:annotation-driven />会自动注册RequestMappingHandlerMapping、RequestMappingHandlerAdapter、ExceptionHandlerExceptionResolver 三个bean。
• 还将提供以下支持：
  ①支持使用 ConversionService 实例对表单参数进行类型转换
  ②支持使用 @NumberFormat annotation、@DateTimeFormat注解完成数据类型的格式化
  ③支持使用 @Valid 注解对 JavaBean 实例进行 JSR 303 验证
  ④支持使用 @RequestBody 和 @ResponseBody 注解

处理 JSON：使用 HttpMessageConverter

步骤：

• 加入 jar 包
• 编写目标方法，使其返回 JSON 对应的对象或集合
• 在方法上添加 @ResponseBody 注解

HttpMessageConverter<T>简介：

• HttpMessageConverter<T> 是 Spring3.0 新添加的一个接口，负责将请求信息转换为一个对象（类型为 T），将对象（类型为 T）输出为响应信息
  
• DispatcherServlet 默认装配RequestMappingHandlerAdapter，而RequestMappingHandlerAdapter 默认装配如下HttpMessageConverter：
  
• 加入 jackson jar 包后， RequestMappingHandlerAdapter装配的HttpMessageConverter 如下：
  
• 使用 HttpMessageConverter<T>将请求信息转化并绑定到处理方法的入参中或将响应结果转为对应类型的响应信息，Spring 提供了两种途径：
  ①使用@RequestBody / @ResponseBody 对处理方法进行标注
  ②使用HttpEntity<T> / ResponseEntity<T>作为处理方法的入参或返回值
• 当控制器处理方法使用到 @RequestBody/@ResponseBody或HttpEntity<T>/ResponseEntity<T> 时, Spring首先根据请求头或响应头的Accept 属性选择匹配的 HttpMessageConverter, 进而根据参数类型或泛型类型的过滤得到匹配的 HttpMessageConverter, 若找不到可用的HttpMessageConverter 将报错。
• @RequestBody 和 @ResponseBody 不需要成对出现

@ResponseBody详解：

• @responseBody注解的作用是将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML数据。
• 注意：在使用此注解之后不会再走视图处理器，而是直接将数据写入到输出流中，他的效果等同于通过response对象输出指定格式的数据。
• 注意：
  ①@ResponseBody是作用在方法上的。
  ②在使用 @RequestMapping后，返回值通常解析为跳转路径，但是加上 @ResponseBody后返回结果不会被解析为跳转路径，而是直接写入 HTTP response body 中。 比如异步(也就是AJAX)获取 json 数据，加上@ResponseBody 后，会直接返回 json 数据。@RequestBody 将 HTTP 请求正文插入方法中，使用适合的HttpMessageConverter 将请求体写入某个对象。

@RequestBody详解：

• @RequestBody作用在入参中，和@requestParam一样。
• 使用@RequestBody，底层会自动将JSON字符串转换成相对应的对象。但前提是该对象存在！

国际化

•默认情况下，SpringMVC 根据 Accept-Language 参数判断客户端的本地化类型。
• 当接受到请求时，SpringMVC 会在上下文中查找一个本地化解析器（LocalResolver），找到后使用它获取请求 所对应的本地化类型信息。
• SpringMVC 还允许装配一个动态更改本地化类型的拦截 器，这样通过指定一个请求参数就可以控制单个请求的本地化类型

AcceptHeaderLocaleResolver：根据 HTTP 请求头的Accept-Language 参数确定本地化类型，如果没有显式定义本地化解析器， SpringMVC 使用该解析器。
• CookieLocaleResolver：根据指定的 Cookie 值确定本地化类 型
• SessionLocaleResolver：根据 Session 中特定的属性确定本地化类型
• LocaleChangeInterceptor：从请求参数中获取本次请求对应的本地化类型

文件上传

简介：

• 文件的上传与下载基本上是web项目中会用到的技术，在web学习中我们用到的是 Apache fileupload这个组件来实现上传，在springmvc中对它进行了封装，让我们使用起来比较方便，但是底层还是由Apache fileupload来实现的。springmvc中由MultipartFile接口来实现文件上传。
• Spring MVC 为文件上传提供了直接的支持，这种支持是通过即插即用的 MultipartResolver实现的。Spring用Jakarta Commons FileUpload 技术实现了一个MultipartResolver 实现类：CommonsMultipartResovler
• Spring MVC 上下文中默认没有装配 MultipartResovler，因此默认情况下不能处理文件的上传工作，如果想使用Spring 的文件上传功能，需现在上下文中配置 MultipartResolver

配置MultipartResolver：

• defaultEncoding: 必须和用户 JSP 的 pageEncoding 属性一致，以便正确解析表单的内容
• 为了让 CommonsMultipartResovler 正确工作，必须先将 Jakarta Commons FileUpload 及
  Jakarta Commons io的类包添加到类路径下。

<bean id= "multipartResolver"
class= "org.springframework.web.multipart.commons.CommonsMultipartResolver">
<property name= "defaultEncoding "value= "UTF-8"></property>
<property name= "maxUploadSize" value= "5242880"></property>
</bean>

• 案例：

<form method= "post" action= "hello/upload.action" enctype= "multipart/form-data ">
	Desc: <input type= "text" name= "desc" >
	File: <input type= "file " name= "file"/><input type= "submit " value= "Submit"/>
</form>

@RequestMapping("/upload")
public String upload(@RequestParam("desc") String desc,
  @RequestParam("file") MultipartFile file) throws llegalStateException, 	
  IOException{
  	if(!file.isEmpty0){
		System.out.printIn("desc");
		file.transferTo(new File("d:\\templl" + file.getOriginalFilename(O));
	}
	return "success";
}

拦截器

拦截器简介：

• 拦截器是基于java的反射机制的，底层原理和AOP一样面向切面编程，创建一个代理类。
  ①它依赖于web框架，在SpringMVC中就是依赖于SpringMVC框架。在实现上,基于Java的反射机制，属于面向切面编程（AOP）的一种运用，就是在service或者一个方法前，调用一个方法，或者在方法后，调用一个方法，比如动态代理就是拦截器的简单实现，在调用方法前打印出字符串（或者做其它业务逻辑的操作），也可以在调用方法后打印出字符串，甚至在抛出异常的时候做业务逻辑的操作。
  ②由于拦截器是基于web框架的调用，因此可以使用Spring的依赖注入（DI）进行一些业务操作，同时一个拦截器实例在一个controller生命周期之内可以多次调用。
  ③但是缺点是只能对controller请求进行拦截，对其他的一些比如直接访问静态资源的请求则没办法进行拦截处理。
• SpringMVC也可以使用拦截器对请求进行拦截处理。
• 用户可以自定义拦截器来实现特定的功能，自定义的拦截器必须实现HandlerInterceptor接口
  ①preHandle()：这个方法在业务处理器处理请求之前被调用，在该方法中对用户请求 request 进行处理。如果程序员决定该拦截器对 请求进行拦截处理后还要调用其他的拦截器，或者是业务处理器去进行处理，则返回true；如果程序员决定不需要再调用其他的组件去处理请求，则返回false。
  ②postHandle()：这个方法在业务处理器处理完请求后，但是DispatcherServlet向客户端返回响应前被调用，在该方法中对用户请求request进行处理。
  ③afterCompletion()：这个方法在 DispatcherServlet 完全处理完请求后被调用，可以在该方法中进行一些资源清理的操作
  

开发一个拦截器步骤：

• 编写一个类继承HandlerInterceptor接口
• 实现接口方法
• 在配置文件中配置
• 案例：

//公共拦截器
public class BaseInterceptor implements HandlerInterceptor{  
     
	//在DispatcherServlet之前执行 
    public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {  
        System.out.println("BaseInterceptor preHandle executed");  
        return true;  
    }  
 
     //在controller执行之后的DispatcherServlet之后执行  
    public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3) throws Exception {  
        System.out.println("BaseInterceptor postHandle executed");  
    }  
     
    //在页面渲染完成返回给客户端之前执行 
    public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3)  
            throws Exception {  
        System.out.println("BaseInterceptor afterCompletion executed");  
    }  
} 

//特定拦截器
public class TestInterceptor implements HandlerInterceptor {  
 
    public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {  
        System.out.println("TestInterceptor preHandle executed");  
        return true;  
    }  
 
    public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3) throws Exception {  
        System.out.println("TestInterceptor postHandle executed");  
    }  
 
    public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3) throws Exception {  
        System.out.println("TestInterceptor afterCompletion executed");  
    }  
} 

<!-- 拦截器配置 -->  
<mvc:interceptors>  
	<!-- 对所有请求都拦截，公共拦截器可以有多个 -->  
	<bean name="baseInterceptor" class="com.scorpios.interceptor.BaseInterceptor" />  
	
	<mvc:interceptor> 
		<!-- 对/test.html进行拦截 -->       
   		<mvc:mapping path="/test.html"/>  
   		<!-- 特定请求的拦截器只能有一个 -->  
   		<bean class="com.scorpios.interceptor.TestInterceptor" />  
	</mvc:interceptor>  
	
</mvc:interceptors>  

异常处理

简介：

• Spring MVC 通过HandlerExceptionResolver处理程序的异常，包括 Handler映射、数据绑定以及目标方法执行时发生的异常。
• SpringMVC 提供的 HandlerExceptionResolver 的实现类：
  
• DispatcherServlet 默认装配的 HandlerExceptionResolver：
  ①没有使用< mvc:annotation-driven/> 配置：
  
  ②使用了 <mvc:annotation-driven/> 配置：
  

ExceptionHandlerExceptionResolver：

• 主要处理 Handler 中用 @ExceptionHandler 注解定义的方法，这个注解只能获取当前Controller中的异常。
• @ExceptionHandler 注解定义的方法优先级问题：例如发生的是NullPointerException，但是声明的异常有RuntimeException 和Exception，此候会根据异常的最近继承关系找到继承深度最浅的那个 @ExceptionHandler注解方法，即标记了RuntimeException 的方法
• ExceptionHandlerMethodResolver内部若找不到@ExceptionHandler 注解的话，会找 @ControllerAdvice 中的@ExceptionHandler注解方法

@ControllerAdvice
public class GloableException {

    /**
     * @ExceptionHandler:属性value是数组，里面写异常的全路径的字节码对象
     * @param e 接收异常的类型
     * @return 返回值类型必须是ModelAndView
     */
    @ExceptionHandler(value = {java.lang.ArithmeticException.class,java.lang.NullPointerException.class})
    public ModelAndView hadlerExecption(Exception e){    //返回值类型必须是ModelAndView
        System.out.println(e);
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg",e);  //携带错误信息跳转页面
        mv.setViewName("error");
        return mv;
    }
}

ResponseStatusExceptionResolver：

• 链接：Spring@ResponseStatus
• 在异常及异常父类中找到 @ResponseStatus 注解，然后使用这个注解的属性进行处理。
• 定义一个 @ResponseStatus 注解修饰的异常类

@ResponseStatus(Httpstatus. UNAUTHORIZED,reason = "not  an error , just info")
public class UnauthorizedException extends RuntimeException {
}

• 若在处理器方法中抛出了上述异常：
  ①若ExceptionHandlerExceptionResolver 不解析述异常。由于触发的异常UnauthorizedException带有@ResponseStatus注解。因此会被ResponseStatusExceptionResolver解析到。最后响应HttpStatus.UNAUTHORIZED 代码给客户端。HttpStatus.UNAUTHORIZED代表响应码401，无权限。
  ②关于其他的响应码请参考 HttpStatus 枚举类型源码
  ③错误页面展示：
  

DefaultHandlerExceptionResolve：

• 对一些特殊的异常进行处理，比如NoSuchRequestHandlingMethodException、HttpRequestMethodNotSupportedException、HttpMediaTypeNotSupportedException、HttpMediaTypeNotAcceptableException等

SimpleMappingExceptionResolver：

• 如果希望对所有异常进行统一处理，可以使用SimpleMappingExceptionResolver，它将异常类名映射为视图名，即发生异常时使用对应的视图报告异常。

<bean id= "simpleMappingExceptionResolver" 
class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
	<!-- 为所有的异常定义默认的异常处理页面，exceptionMappings未定义的异常使用本默认配置 -->  
    <property name="defaultErrorView" value="error"></property>  
    <!-- 定义异常处理页面用来获取异常信息的变量名，默认名为exception -->  
    <property name="exceptionAttribute" value="ex"></property>  
    <!-- 
　　　　定义需要特殊处理的异常，用类名或完全路径名作为key，异常页文件名作为值，
　　　　将不同的异常映射到不同的页面上。
　　 -->  
    <property name="exceptionMappings">  
        <props>  
            <prop key="IOException">error/ioexp</prop>  
            <prop key="java.sql.SQLException">error/sqlexp</prop>  
        </props>  
    </property>  
</bean>

总结：

• 有以下几种方法：
  ①使用SimpleMappingExceptionResolver在配置文件中注册，可以配置自定义异常或常见异常。
  ②使用@ExceptionHandler注册但默认只在当前Controller中，加上@ControllerAdvice可以注册到全局。（底层由ExceptionHandlerExceptionResolver解析。）
  ③使用web.xml的error-page注册。
  ④自定义 HandlerExceptionResolver 类处理异常
• web.xml中元素的加载顺序 元素节点的加载顺序与它们在 web.xml 文件中的先后顺序无关，通常是ServletContext -> listener -> filter -> servlet---->------>error-page
  ①所以spring-servlet.xml的加载顺序比error-page的快，异常会当有相同配置的错误时，会优先spring-servlet.xml中配置。只有当spring-servlet.xml没有处理的错误异常，才会在web.xml的error-page节点中查找对应异常。
• 关于ResponseStatusExceptionResolver和DefaultHandlerExceptionResolve：
  ①ResponseStatusExceptionResolver是使用@ResponseStatus来实现的，它不能指定视图，但可以指定错误码和错误信息。
  ②DefaultHandlerExceptionResolve是SpringMVC底层实现的：对一些特殊的异常进行处理。
• 自定义 HandlerExceptionResolver 类处理异常：

/**
 - 通过实现 HandlerExceptionResolver 接口做全局异常处理
 */
@Configuration
public class GlobalException implements HandlerExceptionResolver {
	@Override
	public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler,
			Exception ex) {
		ModelAndView mv = new ModelAndView();
		// 判断不同异常类型，做不同视图跳转
		if (ex instanceof ArithmeticException) {
			mv.setViewName("error1");
		}
		if (ex instanceof NullPointerException) {
			mv.setViewName("error2");
		}
		mv.addObject("error", ex.toString());
		return mv;
	}
}

• 对比：
  ①@ExceptionHandler：@ExceptionHandler在Controller级别工作,它仅对该特定Controller有效,而不是整个应用程序的全局.
  ②HandlerExceptionResolver：这将解决应用程序抛出的任何异常.它用于将标准Spring异常解析为其相应的HTTP状态代码.它无法控制响应的主体,意味着它没有向Response的主体设置任何内容.它确实在响应上映射状态代码,但是主体为空，而且HandlerExceptionResolver对异常的处理需要手动判断，并且所有的错误都在一个方法中处理，耦合度太大。
  ③@ControllerAdvice：@ControllerAdvice用于Spring MVC应用程序中的全局错误处理.它还可以完全控制响应主体和状态代码.

SpringMVC -Mock 测试

什么是 mock 测试：

• 在测试过程中，对于某些不容易构造或者不容易获取的对象，用一个虚拟的对象来创建以便测试的测试方法，就是 mock测试
• 虚拟的对象就是 mock 对象。
• mock 对象就是真实对象在调试期间的代替品。

为什么使用 mock 测试：

• 避免开发模块之间的耦合
• 轻量、简单、灵活

MockMVC 介绍：

• 基于 RESTful 风格的 SpringMVC 的测试，我们可以测试完整的 Spring MVC 流程，即从 URL
  请求到控制器处理，再到视图渲染都可以测试。

使用说明：

• MockMvcBuilder
  ①MockMvcBuilder 是用来构造 MockMvc 的构造器，其主要有两个实现：
  <1>StandaloneMockMvcBuilder
  <2>DefaultMockMvcBuilder
  <3>对于我们来说直接使用静态工厂 MockMvcBuilders 创建即可。

• MockMvcBuilders
  ①负责创建 MockMvcBuilder 对象，有两种创建方式：
  <1>standaloneSetup(Object… controllers)：通过参数指定一组控制器，这样就不需要从上下文获取了。
  <2>webAppContextSetup(WebApplicationContext wac)：指定 WebApplicationContext，将会从该上下文获取相应的控制器并得到相应的 MockMvc。

• MockMvc
  ①对于服务器端的 SpringMVC 测试支持主入口点。通过 MockMvcBuilder构造，MockMvcBuilder由 MockMvcBuilders建造者的静态方法去建造。
  ②核心方法：perform(RequestBuilder rb) – 执行一个 RequestBuilder 请求，会自动执行 SpringMVC 的流程并映射到相应的控制器执行处理，该方法的返回值是一个 ResultActions。

• ResultActions
  ①andExpect：添加 ResultMatcher 验证规则，验证控制器执行完成后结果是否正确；
  ②andDo：添加 ResultHandler 结果处理器，比如调试时打印结果到控制台；
  ③andReturn：最后返回相应的 MvcResult；然后进行自定义验证 / 进行下一步的异步处理；

• MockMvcRequestBuilders
  ①用来构建请求的，其主要有两个子类 MockHttpServletRequestBuilder 和 MockMultipartHttpServletRequestBuilder（如文件上传使用），即用来 Mock 客户端请求需要的所有数据。

• MockMvcResultMatchers
  ①用来匹配执行完请求后的结果验证
  ②如果匹配失败将抛出相应的异常
  ③包含了很多验证 API 方法

• MockMvcResultHandlers
  ①结果处理器，表示要对结果做点什么事情
  ②比如此处使用 MockMvcResultHandlers.print() 输出整个响应结果信息

• MvcResult
  ①单元测试执行结果，可以针对执行结果进行自定义验证逻辑。

案例：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/*.xml")
@WebAppConfiguration
public class ItemMockTest {

    @Autowired
    private WebApplicationContext context;

    private MockMvc mockMvc;

    @Before
    public void init() {
        mockMvc = MockMvcBuilders.webAppContextSetup(context).build();
    }
}

• @WebAppConfiguration注解：可以在单元测试的时候，不用启动 Servlet 容器，就可以获取一个 Web 应用上下文。
• 详细连接：Spring MVC 单元测试

SpringMVC底层原理

具体流程：

底层流程：

流程解释：

• 用户发送请求到前端控制器（DispatcherServlet）。
• 前端控制器请求 HandlerMapping 查找 Handler，可以根据 xml 配置、注解进行查找。
• 处理器映射器 HandlerMapping 向前端控制器返回 Handler
• 前端控制器调用处理器适配器去执行 Handler
• 处理器适配器执行 Handler
• Handler 执行完成后给适配器返回 ModelAndView
• 处理器适配器向前端控制器返回 ModelAndView
  ①ModelAndView 是SpringMVC 框架的一个底层对象，包括 Model 和 View
• 前端控制器请求试图解析器去进行视图解析
  ①根据逻辑视图名来解析真正的视图。
• 视图解析器向前端控制器返回 view
• 前端控制器进行视图渲染
  ①就是将模型数据（在 ModelAndView 对象中）填充到 request 域
• 前端控制器向用户响应结果

组件解释：

• 前端控制器DispatcherServlet（不需要程序员开发）。
  ①作用：接收请求，响应结果，相当于转发器，中央处理器。有了DispatcherServlet减少了其它组件之间的耦合度。
• 处理器映射器HandlerMapping（不需要程序员开发）
  ①作用：根据请求的url查找Handler。
• 处理器适配器HandlerAdapter（不需要程序员开发）
  ①作用：按照特定规则（HandlerAdapter要求的规则）去执行Handler。
• 处理器Handler（需要程序员开发）。
  ①注意：编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler
• 视图解析器ViewResolver（不需要程序员开发）
  ①作用：进行视图解析，根据逻辑视图名解析成真正的视图（view）
• 视图View（需要程序员开发jsp）。
  ①注意：View是一个接口，实现类支持不同的View类型（jsp、freemarker、pdf…）
  ②不需要程序员开发的，需要程序员自己做一下配置即可
• SpringMVC三大核心组件：
  ①HandlerMapping处理器映射器
  ②HandlerAdapter处理器适配器
  ③ViewResolver视图解析器

总结：

• 前后端分离后视图View也已经不需要我们去开发，那么重点关注在处理器Handler上，
• 除此之外我们还要对处理器适配器HandlerAdapter重点关注。因为它涉及数据绑定、调用哪一个视图解析器等等。
• HandlerAdapter是具体执行Handler时所适配其他组建的对象，通俗点讲适配器HandlerAdapter的作用是我们执行处理器Handler方法时帮我们匹配所需的组件。

HandlerAdapter工作流程与运行原理：

• HandlerAdapter是处理适配器，它调用具体的方法对用户发来的请求来进行处理。
• SpringMVC 通过HandlerAdapter的handler方法来调用请求处理函数，它的工作运行原理如下：
  ①DispatcherServlte会根据配置文件信息注册HandlerAdapter，如果在配置文件中没有配置，那么 DispatcherServlte会获取HandlerAdapter的默认配置，如果是读取默认配置的话，DispatcherServlte会读取 DispatcherServlte.properties文件,该文件中配置了三种 HandlerAdapter：
  <1>HttpRequestHandlerAdapter
  <2>SimpleControllerHandlerAdapter
  <3>AnnotationMethodHandlerAdapter
  ②DispatcherServlte会将这三个HandlerAdapter对象存储到它的handlerAdapters这个集合属性中，这样就完成了HandlerAdapter的注册。
  ③DispatcherServlte会根据handlerMapping传过来的controller与已经注册好了的HandlerAdapter 一一匹配，看哪一种HandlerAdapter是支持该controller类型的，如果找到了其中一种HandlerAdapter是支持传过来的 controller类型，那么该HandlerAdapter会调用自己的handle方法，handle方法运用Java的反射机制执行controller的具体方法来获得ModelAndView。
  ④例如SimpleControllerHandlerAdapter是支持实现了controller接口的控制器，如果自己写的控制器实现了controller接口，那么SimpleControllerHandlerAdapter就会去执行自己写控制器中的具体方法来完成请求。
  
• HandlerAdapter组件中的具体类说明：
  ①AbstractHandlerMethodAdapter，该类是HandlerAdapter接口的简单抽象类，实现了接口定义的方法。但也并未做真正的实现，而是留给了子类。
  ②RequestMappingHandlerAdapter，该类继承了 AbstractHandlerMethodAdapter 类，真正意义上实现了 HandlerAdapter 接口定义的功能。该方法的具体过程如下：
  <1>校验请求，即检查是否支持当前 rqeuest 的 method 和 session
  <2>判断控制器是否存在 @SessionAttributes 注解，有则设置缓存，否则准备响应
  <3>处理器调用，返回 ModelAndView 。
  ③ServletInvocableHandlerMethod，该类实现了 HandlerMethod 类,HandlerMethod创建ServletInvocableHandlerMethod，接下来调用ServletInvocableHandlerMethod的invokeAndHandle方法，其实最终是通过反射机制调用Controller中的方法。
• 具体方法说明：

-------------------------处理器调用invokeHandlerMethod方法-------------------------

protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, 
    HandlerMethod handlerMethod) throws Exception {

    ServletWebRequest webRequest = new ServletWebRequest(request, response);

    // 1.数据绑定
    WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);

    // 2.创建 ModelFactory 
    // 添加了 @ModelAttribute，@SessionAttributes 等注解内容
    ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);

    // 3.创建 ServletInvocableHandlerMethod，并绑定相关属性
    ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
    invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
    invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
    invocableMethod.setDataBinderFactory(binderFactory);
    invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);

    // 4.创建 ModelAndViewContainer
    ModelAndViewContainer mavContainer = new ModelAndViewContainer();
    mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
    modelFactory.initModel(webRequest, mavContainer, invocableMethod);
    mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);

    // 省略部分源码...

    // 5.调用控制器方法
    invocableMethod.invokeAndHandle(webRequest, mavContainer);


    // 6.返回 ModelAndView
    return getModelAndView(mavContainer, modelFactory, webRequest);
}

--------------------------getModelAndView方法------------------------

private ModelAndView getModelAndView(ModelAndViewContainer mavContainer,ModelFactory modelFactory, 
    NativeWebRequest webRequest) throws Exception {

    // 更新 Mdoel 
    modelFactory.updateModel(webRequest, mavContainer);

    // 判断请求是否处理器完毕
    if (mavContainer.isRequestHandled()) {
        return null;
    }

    // 关键 -> 创建 ModelAndView
    ModelMap model = mavContainer.getModel();
    ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model);

    // 判断 view 是不是字符串
    if (!mavContainer.isViewReference()) {
        mav.setView((View) mavContainer.getView());
    }

    // 重定向相关
    if (model instanceof RedirectAttributes) {
        Map flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
        HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
        RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
    }

    return mav;
}

SpringMVC 对比 Struts2

简介：

• Spring MVC 的入口是 Servlet, 而 Struts2 是 Filter
• Spring MVC 会稍微比 Struts2 快些. Spring MVC 是基于方法设计, 而 Sturts2 是基于类,
  每次发一次请求都会实例一个 Action.
• Spring MVC 使用更加简洁, 开发效率Spring MVC确实比 struts2 高: 支持 JSR303, 处理 ajax
  的请求更方便
• Struts2 的 OGNL 表达式使页面的开发效率相比Spring MVC 更高些.