java框架学习笔记——SpringMVC

官方文档：https://docs.spring.io/spring/docs/5.2.0.RELEASE/spring-framework-reference/web.html#spring-web

1. SpringMVC简介

1.1 什么是MVC

MVC是一种软件架构的思想，包括模型(Model)、视图(View)、控制器(Controller)，是将业务逻辑、数据、显示分离的方法来组织代码。将业务逻辑、数据、显示分离。

Model：数据模型，提供要展示的数据，因此包含数据和行为，指工程中的JavaBean，作用是处理数据

JavaBean分为两类：

• 一类称为实体类Bean：专门存储业务数据的，如 Student、User 等
• 一类称为业务处理 Bean：指 Service 或 Dao 对象，专门用于处理业务逻辑和数据访问。

View：视图层，负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。

Controller：控制层，接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。 也就是说控制器做了个调度员的工作。

1.2 Spring MVC

Spring MVC（全称 Spring Web MVC）是 Spring 框架提供的一款基于 MVC 模式的轻量级 Web 开发框架，是 Spring 为表示层（UI）开发提供的一整套完备的解决方案。

注：三层架构分为表示层（UI）、业务逻辑层（BLL）、数据访问层（DAL），表示层则包含前台页面和后台 Servlet

Spring MVC 使用 MVC 架构模式的思想，将 Web 应用进行职责解构，把一个复杂的 Web 应用划分成模型（Model）、控制器（Contorller）以及视图（View）三层，有效地简化了 Web 应用的开发，降低了出错风险，同时也方便了开发人员之间的分工配合。

Spring MVC 本质是对 Servlet 的进一步封装，其最核心的组件是 DispatcherServlet，它是 Spring MVC 的前端控制器，主要负责对请求和响应的统一地处理和分发。

Spring MVC的特点：

1. 轻量级，简单易学
2. 高效 , 基于请求响应的MVC框架
3. 与Spring兼容性好，无缝结合
4. 约定优于配置
5. 功能强大：RESTful、数据验证、格式化、本地化、主题等
6. 简洁灵活

1.3 Spring MVC 的常用组件

组件	提供者	描述
DispatcherServlet	框架提供	前端控制器，它是整个 Spring MVC 流程控制中心，负责统一处理请求和响应，调用其他组件对用户请求进行处理。
HandlerMapping	框架提供	处理器映射器，根据请求的 url、method 等信息查找相应的 Handler。
Handler	开发人员提供	处理器，通常被称为 Controller（控制器）。它可以在 DispatcherServlet 的控制下，对具体的用户请求进行处理。
HandlerAdapter	框架提供	处理器适配器，负责调用具体的控制器方法，对用户发来的请求来进行处理。
ViewResolver	框架提供	视图解析器，其职责是对视图进行解析，得到相应的视图对象。常见的视图解析器有 ThymeleafViewResolver、InternalResourceViewResolver 等。
View	开发人员提供	视图，它作用是将模型（Model）数据通过页面展示给用户。

2. Hello SPring MVC

2.1 基础配置

（1）新建Module，添加web模块支持

（2）导入依赖

<dependencies>
    
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-webmvcartifactId>
        <version>5.3.1version>
    dependency>

    
    <dependency>
        <groupId>javax.servletgroupId>
        <artifactId>javax.servlet-apiartifactId>
        <version>3.1.0version>
        <scope>providedscope>
    dependency>

    
    <dependency>
        <groupId>org.thymeleafgroupId>
        <artifactId>thymeleaf-spring5artifactId>
        <version>3.0.12.RELEASEversion>
    dependency>
dependencies>

(3) 配置web.xml ， 注册前端控制器DispatcherServlet

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    
    <servlet>
        <servlet-name>springmvcservlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
 
          
        <init-param>
            <param-name>contextConfigLocationparam-name>
             
            <param-value>classpath:springMVC.xmlparam-value>
        init-param>
         <!-- 
         	作为框架的核心组件，在启动过程中有大量的初始化操作要做
        	而这些操作放在第一次请求时才执行会严重影响访问速度
        	因此需要通过此标签将启动控制DispatcherServlet的初始化时间提前到服务器启动时
 			
        <load-on-startup>1load-on-startup>
    servlet>
     
    
    
    <servlet-mapping>
        <servlet-name>springmvcservlet-name>
        <url-pattern>/url-pattern>
    servlet-mapping>
web-app>

(4) 创建springMVC配置文件

<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="xiong.mvc.controller"/>

    
    <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>

在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。

(5) 创建请求控制器

由于前端控制器对浏览器发送的请求进行了统一的处理，但是具体的请求有不同的处理过程，因此需要创建处理具体请求的类，即请求控制器

请求控制器中每一个处理请求的方法称为控制器方法

@Controller // 交给Spring的IoC容器管理
public class HelloController {

    // @RequestMapping注解：处理请求和控制器方法之间的映射关系,
	// @RequestMapping注解的value属性可以通过请求地址匹配请求，/表示的当前工程的上下文路径, 默认是访问index页
	// localhost:8080/springMVC/  这个路径是在Tomcat中配置
    @RequestMapping(value = "/")  
    public String index() {
        //返回视图名称
        return "index";
    }
    
    @RequestMapping("/hello")  //这个value的值是请求地址，可以随意写，真正访问的是返回的视图
    public String index() {
        return "hello";
    }
}

方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成WEB-INF/templates/hello.html

2.2 总结

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

3. @RequestMapping注解

3.1 功能

@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来，建立映射关系。

SpringMVC 接收到指定的请求，就会来找到在映射关系中对应的控制器方法来处理这个请求。

3.2 位置

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

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

@Controller
@RequestMapping("/test")
public class RequestMappingController {

    //此时请求映射所映射的请求的请求路径为：/test/testRequestMapping
    @RequestMapping("/testRequestMapping")
    public String testRequestMapping(){
        return "success";
    }

}

3.3 value属性

@RequestMapping注解的value属性通过请求的请求地址匹配请求映射

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

@RequestMapping注解的value属性必须设置，至少一个通过请求地址匹配请求映射

@RequestMapping(value = {"/testRequestMapping", "/test"})
public String testRequestMapping(){
    return "success";
}

3.4 method属性

@RequestMapping注解的method属性通过请求的请求方式（get或post）匹配请求映射

@RequestMapping注解的method属性是一个RequestMethod类型的数组，表示该请求映射能够匹配多种请求方式的请求

若当前请求的请求地址满足请求映射的value属性，但是请求方式不满足method属性，则浏览器报错405：Request method ‘POST’ not supported

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

注：

1、对于处理指定请求方式的控制器方法，SpringMVC中提供了@RequestMapping的派生注解

处理get请求的映射–>@GetMapping

处理post请求的映射–>@PostMapping

处理put请求的映射–>@PutMapping

处理delete请求的映射–>@DeleteMapping

2、常用的请求方式有get，post，put，delete

但是目前浏览器只支持get和post，若在form表单提交时，为method设置了其他请求方式的字符串（put或delete），则按照默认的请求方式get处理

若要发送put和delete请求，则需要通过spring提供的过滤器HiddenHttpMethodFilter，在RESTful部分会讲到

3.5 params属性

@RequestMapping注解的params属性通过请求的请求参数匹配请求映射

@RequestMapping注解的params属性是一个字符串类型的数组，可以通过四种表达式设置请求参数和请求映射的匹配关系

“param”：要求请求映射所匹配的请求必须携带param请求参数

“!param”：要求请求映射所匹配的请求必须不能携带param请求参数

“param=value”：要求请求映射所匹配的请求必须携带param请求参数且param=value

“param!=value”：要求请求映射所匹配的请求必须携带param请求参数但是param!=value

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

注：若当前请求满足@RequestMapping注解的value和method属性，但是不满足params属性，此时页面回报错400：Parameter conditions “username, password!=123456” not met for actual request parameters: username={***}, password={123456}

3.6 headers属性

@RequestMapping注解的headers属性通过请求的请求头信息匹配请求映射

@RequestMapping注解的headers属性是一个字符串类型的数组，可以通过四种表达式设置请求头信息和请求映射的匹配关系

“header”：要求请求映射所匹配的请求必须携带header请求头信息

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

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

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

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

3.7 SpringMVC支持ant风格的路径

？：表示任意的单个字符

*：表示任意的0个或多个字符

**：表示任意的一层或多层目录

注意：在使用时，只能使用//xxx的方式

3.8 SpringMVC支持路径中的占位符（重点）

原始方式：/deleteUser?id=1

rest方式：/deleteUser/1

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

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

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

4. SpringMVC获取请求参数

4.1 通过ServletAPI获取

将HttpServletRequest作为控制器方法的形参，此时HttpServletRequest类型的参数表示封装了当前请求的请求报文的对象(底层自动实现装配)

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

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

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

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

@RequestMapping("/testParam")
public String testParam(String username, String password, String[] hobby){
    System.out.println("username:"+username+",password:"+password + ", hobby:" + hobby);
    return "success";
}
//-> username:'admin',password:123456, hobby:['唱','跳','rap']
//如果形参为String hobby ，则输出为 username:'admin',password:123456, hobby:'唱','跳','rap'

注：

若请求所传输的请求参数中有多个同名的请求参数，此时可以在控制器方法的形参中设置字符串数组或者字符串类型的形参接收此请求参数

若使用字符串数组类型的形参，此参数的数组中包含了每一个数据

若使用字符串类型的形参，此参数的值为每个数据中间使用逗号拼接的结果

4.3 @RequestParam

@RequestParam是将请求参数和控制器方法的形参创建映射关系

@RequestParam注解一共有三个属性：

value：指定为形参赋值的请求参数的参数名

/**
 * Alias for {@link #name}.
 */
@AliasFor("name")
String value() default "";

required：设置是否必须传输此请求参数，默认值为true

若设置为true时，则当前请求必须传输value所指定的请求参数，若没有传输该请求参数，且没有设置defaultValue属性，则页面报错400：Required String parameter ‘xxx’ is not present；若设置为false，则当前请求不是必须传输value所指定的请求参数，若没有传输，则注解所标识的形参的值为null

/**
	 * Whether the parameter is required.
	 * 
Defaults to {@code true}, leading to an exception being thrown
	 * if the parameter is missing in the request. Switch this to
	 * {@code false} if you prefer a {@code null} value if the parameter is
	 * not present in the request.
	 * 
Alternatively, provide a {@link #defaultValue}, which implicitly
	 * sets this flag to {@code false}.
	 */
	boolean required() default true;

defaultValue：不管required属性值为true或false，当value所指定的请求参数没有传输或传输的值为""时，则使用默认值为形参赋值

/**
	 * The default value to use as a fallback when the request parameter is
	 * not provided or has an empty value.
	 * 
Supplying a default value implicitly sets {@link #required} to
	 * {@code false}.
	 */
	String defaultValue() default ValueConstants.DEFAULT_NONE;

• 使用

@RequestMapping("/testParam")
public String testParam(
    @RequestParam("user_name") String username,  //实参是user_name,形参是username，@RequestParam创建两个的映射关系
    String password, 
    String[] hobby){
    System.out.println("username:"+username+",password:"+password + ", hobby:" + hobby);
    return "success";
}


public String test(  
@RequestParam(value="user", required=true, defaultValue="wang") String user)  

源码注解

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestParam {}

4.4 @RequestHeader

@RequestHeader是将请求头信息和控制器方法的形参创建映射关系

@RequestHeader注解一共有三个属性：value、required、defaultValue，用法同@RequestParam

@RequestMapping(value = "/hello.html)
public String hello(@RequestHeader(value="Host") String host){}

在上面的代码片段中，定义了一个映射到/hello.htm的hello控制器方法。用 @RequestHeader注解将请求头中”Host“的变量与”host“变量绑定。当此某个请求映射到了此控制器方法，Spring会检查请求头中的”Host“变量，并将其与”host“变量绑定。如果 @RequestHeader绑定的变量，在请求头中不存在，Spring会将控制器中的参数初始化为null。

4.5 @CookieValue

@CookieValue是将请求的Cookie数据和控制器方法的形参创建映射关系

@CookieValue注解一共有三个属性：value、required、defaultValue，用法同@RequestParam

@RequestMapping(value = "/hello.html)
public String hello(
    @RequestHeader(value="Host"
    @CookieValue("JSESSIONID") String JSESSIONID) String host){}

4.6 通过POJO获取请求参数

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

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

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

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

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

• 方案一

<filter>
    <filter-name>CharacterEncodingFilterfilter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
    
    <init-param>
        <param-name>encodingparam-name>
        <param-value>UTF-8param-value>
    init-param>
    <init-param>
        <param-name>forceResponseEncodingparam-name>
        <param-value>trueparam-value>
    init-param>
filter>
<filter-mapping>
    <filter-name>CharacterEncodingFilterfilter-name>
    
    <url-pattern>/*url-pattern>
filter-mapping>

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

• CharacterEncodingFilter 原理

服务器启动时创建Filter，将init-param中的参数加载，注入到CharacterEncodingFilter 类中，浏览器每次发送请求都会经过这个过滤器，然后调用doFilterInternal

CharacterEncodingFilter 类图

CharacterEncodingFilter继承OncePerRequestFilter，OncePerRequestFilter是个抽象类，其中的抽象方法doFilterInternal被CharacterEncodingFilter实现，同时OncePerRequestFilter实现了doFilter方法，调用了doFilterInternal方法。

doFilterInternal方法

@Override
protected void doFilterInternal(
		HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
		throws ServletException, IOException {

		if (this.encoding != null && (this.forceEncoding || request.getCharacterEncoding() == null)) {
			request.setCharacterEncoding(this.encoding); //设置请求编码
       
			if (this.forceEncoding) {
				response.setCharacterEncoding(this.encoding); //设置响应编码，forceEncoding必须设置为true
			}
		}
		filterChain.doFilter(request, response);
}

• 方案二

<mvc:default-servlet-handler/>


<mvc:annotation-driven>
    <mvc:message-converters>
        
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <property name="defaultCharset" value="UTF-8" />
            <property name="supportedMediaTypes">
                <list>
                    <value>text/htmlvalue>
                    <value>application/jsonvalue>
                list>
            property>
        bean>
    mvc:message-converters>
mvc:annotation-driven>

5. 域对象共享数据

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

@RequestMapping("/testServletAPI")
public String testServletAPI(HttpServletRequest request){
    request.setAttribute("testScope", "hello,servletAPI");  //将数据保存到request作用域中，页面能够获取值，即后台向前台传值
    return "success";
}

5.2 使用ModelAndView向request域对象共享数据 [重点]

当控制器处理完请求时，通常会将包含视图名称或视图对象以及一些模型属性的ModelAndView对象返回到DispatcherServlet.

ModelAndView对象被放置在Request对象中，可以在页面中利用${keyName}直接访问存在model中的对象。第一个参数是页面名称。

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

• 源码解析

  public class ModelAndView {  
    
      /** View instance or view name String */  
      private Object view  //该属性用来存储返回的视图信息
      /** Model Map */  
      private ModelMap model;//该属性用来存储处理后的结果数据
    
    
    
  /** 
   * Default constructor for bean-style usage: populating bean 
   * properties instead of passing in constructor arguments. 
   * @see #setView(View) 
   * @see #setViewName(String) 
   */  
  public ModelAndView() {  
  }  
    
  /** 
   * Convenient constructor when there is no model data to expose. 
   * Can also be used in conjunction with addObject. 
   * @param viewName name of the View to render, to be resolved 
   * by the DispatcherServlet's ViewResolver 
   * @see #addObject 
   */  
  public ModelAndView(String viewName) {  
      this.view = viewName;  
  }  
    
  /** 
   * Convenient constructor when there is no model data to expose. 
   * Can also be used in conjunction with addObject. 
   * @param view View object to render 
   * @see #addObject 
   */  
  public ModelAndView(View view) {  
      this.view = view;  
  }  
    
  /** 
   * Creates new ModelAndView given a view name and a model. 
   * @param viewName name of the View to render, to be resolved 
   * by the DispatcherServlet's ViewResolver 
   * @param model Map of model names (Strings) to model objects 
   * (Objects). Model entries may not be null, but the 
   * model Map may be null if there is no model data. 
   */  
  public ModelAndView(String viewName, Map<String, ?> model) {  
      this.view = viewName;  
      if (model != null) {  
          getModelMap().addAllAttributes(model);  
      }  
  }  
    
  /** 
   * Creates new ModelAndView given a View object and a model. 
   * Note: the supplied model data is copied into the internal 
   * storage of this class. You should not consider to modify the supplied 
   * Map after supplying it to this class 
   * @param view View object to render 
   * @param model Map of model names (Strings) to model objects 
   * (Objects). Model entries may not be null, but the 
   * model Map may be null if there is no model data. 
   */  
  public ModelAndView(View view, Map<String, ?> model) {  
      this.view = view;  
      if (model != null) {  
          getModelMap().addAllAttributes(model);  
      }  
  }  
    
  /** 
   * Convenient constructor to take a single model object. 
   * @param viewName name of the View to render, to be resolved 
   * by the DispatcherServlet's ViewResolver 
   * @param modelName name of the single entry in the model 
   * @param modelObject the single model object 
   */  
  public ModelAndView(String viewName, String modelName, Object modelObject) {  
      this.view = viewName;  
      addObject(modelName, modelObject);  
  }  
    
  /** 
   * Convenient constructor to take a single model object. 
   * @param view View object to render 
   * @param modelName name of the single entry in the model 
   * @param modelObject the single model object 
   */  
  public ModelAndView(View view, String modelName, Object modelObject) {  
      this.view = view;  
      addObject(modelName, modelObject);  
  }  
    
    
  /** 
   * Set a view name for this ModelAndView, to be resolved by the 
   * DispatcherServlet via a ViewResolver. Will override any 
   * pre-existing view name or View. 
   */  
  public void setViewName(String viewName) {  
      this.view = viewName;  
  }  
    
  /** 
   * Return the view name to be resolved by the DispatcherServlet 
   * via a ViewResolver, or null if we are using a View object. 
   */  
  public String getViewName() {  
      return (this.view instanceof String ? (String) this.view : null);  
  }  
    
  /** 
   * Set a View object for this ModelAndView. Will override any 
   * pre-existing view name or View. 
   */  
  public void setView(View view) {  
      this.view = view;  
  }  
    
  /** 
   * Return the View object, or null if we are using a view name 
   * to be resolved by the DispatcherServlet via a ViewResolver. 
   */  
  public View getView() {  
      return (this.view instanceof View ? (View) this.view : null);  
  }  
    
  /** 
   * Indicate whether or not this ModelAndView has a view, either 
   * as a view name or as a direct {@link View} instance. 
   */  
  public boolean hasView() {  
      return (this.view != null);  
  }  
    
  /** 
   * Return whether we use a view reference, i.e. true 
   * if the view has been specified via a name to be resolved by the 
   * DispatcherServlet via a ViewResolver. 
   */  
  public boolean isReference() {  
      return (this.view instanceof String);  
  }  
    
  /** 
   * Return the model map. May return null. 
   * Called by DispatcherServlet for evaluation of the model. 
   */  
  protected Map<String, Object> getModelInternal() {  
      return this.model;  
  }  
    
  /** 
   * Return the underlying ModelMap instance (never null). 
   */  
  public ModelMap getModelMap() {  
      if (this.model == null) {  
          this.model = new ModelMap();  
      }  
      return this.model;  
  }  
    
  /** 
   * Return the model map. Never returns null. 
   * To be called by application code for modifying the model. 
   */  
  public Map<String, Object> getModel() {  
      return getModelMap();  
  }  
    
    
  /** 
   * Add an attribute to the model. 
   * @param attributeName name of the object to add to the model 
   * @param attributeValue object to add to the model (never null) 
   * @see ModelMap#addAttribute(String, Object) 
   * @see #getModelMap() 
   */  
  public ModelAndView addObject(String attributeName, Object attributeValue) {  
      getModelMap().addAttribute(attributeName, attributeValue);  
      return this;  
  }  
    
  /** 
   * Add an attribute to the model using parameter name generation. 
   * @param attributeValue the object to add to the model (never null) 
   * @see ModelMap#addAttribute(Object) 
   * @see #getModelMap() 
   */  
  public ModelAndView addObject(Object attributeValue) {  
      getModelMap().addAttribute(attributeValue);  
      return this;  
  }  
    
  /** 
   * Add all attributes contained in the provided Map to the model. 
   * @param modelMap a Map of attributeName -> attributeValue pairs 
   * @see ModelMap#addAllAttributes(Map) 
   * @see #getModelMap() 
   */  
  public ModelAndView addAllObjects(Map<String, ?> modelMap) {  
      getModelMap().addAllAttributes(modelMap);  
      return this;  
  }  
    
    
  /** 
   * Return diagnostic information about this model and view. 
   */  
  @Override  
  public String toString() {  
      StringBuilder sb = new StringBuilder("ModelAndView: ");  
      if (isReference()) {  
          sb.append("reference to view with name '").append(this.view).append("'");  
      }  
      else {  
          sb.append("materialized View is [").append(this.view).append(']');  
      }  
      sb.append("; model is ").append(this.model);  
      return sb.toString();  
  }
  

  通过ModelAndView构造方法可以指定返回的页面名称，也可以通过setViewName()方法跳转到指定的页面 , 使用addObject()设置需要返回的值，addObject()有几个不同参数的方法，可以默认和指定返回对象的名字。

5.3 使用Model向request域对象共享数据

@RequestMapping("/testModel")
public String testModel(Model model){
    model.addAttribute("testScope", "hello,Model");
    return "success";
}

5.4 使用map向request域对象共享数据

@RequestMapping("/testMap")
public String testMap(Map<String, Object> map){
    map.put("testScope", "hello,Map");
    return "success";
}

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

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

我们把结果页面上需要的数据放到ModelMap对象中即可，他的作用类似于request对象的setAttribute方法的作用，用来在一个请求过程中传递处理的数据。

5.6 Model、ModelMap、Map的关系

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

最终都使用的是BindingAwareModelMap对象, 且都会被封装成ModelAndView

5.7 向session域共享数据

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

5.8 向application域共享数据

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

6. SpringMVC的视图

SpringMVC中的视图是View接口，视图的作用渲染数据，将模型Model中的数据展示给用户

SpringMVC的视图解析流程为：
　　1. 调用目标方法，SpringMVC将目标方法返回的String、View、ModelMap或是ModelAndView都转换为一个ModelAndView对象；
　　2. 然后通过视图解析器（ViewResolver）对ModelAndView对象中的View对象进行解析，将该逻辑视图View对象解析为一个物理视图View对象；
　　3. 最后调用物理视图View对象的render()方法进行视图渲染，得到响应结果。

6.1 视图解析器（ViewResolver）

视图解析器的作用是将逻辑视图转为物理视图，所有的视图解析器都必须实现ViewResolver接口。

• ThymeleafView

若使用的视图技术为Thymeleaf，在SpringMVC的配置文件中配置了Thymeleaf的视图解析器，由此视图解析器解析之后所得到的是ThymeleafView

  
    <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>

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

视图名称拼接视图前缀和视图后缀所得到的最终路径，会通过转发的方式实现跳转。

• 转发视图

SpringMVC中默认的转发视图是InternalResourceView

SpringMVC中创建转发视图的情况：

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

例如"forward:/"，“forward:/employee”

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

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

控制器方法 testToForward 中，进行了转发forward:/testThymeleafView，去掉forward:之后，就可以转发到/testThymeleafView上。

也就是说，当我访问 http://localhost:8080/springmvc/testToForward，应该跳转显示出 success 页。

• 重定向视图

  SpringMVC中默认的重定向视图是RedirectView

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

  例如"redirect:/"，“redirect:/employee”

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

  

重定向访问/testRedirect时，页面看到的是 success 页面，地址栏里也变成了/testThymeleafView，而转发视图地址栏不变

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

转发和重定向区别

• 转发浏览器是发生一次请求，重定向是2次。
• 转发可以获取请求域中的数据，但是重定向不可以。因为转发用到一次请求，也就是用到的request对象是同一个。重定向是发送2次请求，是2个request对象。
• 转发可以访问 WEB-INF 中的资源，但是重定向不可以。因为 WEB-INF 下面的资源具有隐藏性，只能通过服务器内部来访问，不能通过浏览器来访问。
• 转发不可以跨域，重定向可以。转发是发生在服务器内部的，就只能访问内部的资源。而浏览器发送了2次请求，通过浏览器可以访问任何资源。

6.2 视图控制器view-controller

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

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

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

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

7. HttpMessageConverter

HttpMessageConverter，报文信息转换器，将请求报文转换为Java对象，或将Java对象转换为响应报文

HttpMessageConverter提供了两个注解和两个类型：@RequestBody，@ResponseBody，RequestEntity，ResponseEntity

7.1 @RequestBody

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

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

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

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

7.2 RequestEntity

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

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

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

7.3 @ResponseBody

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

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

结果：浏览器页面显示hello world

注： 这个返回值不再是视图名称，而是直接被作为响应体响应到浏览器上（可以简单理解为返回值直接输出到浏览器上显示）

7.4 ResponseEntity

ResponseEntity用于控制器方法的返回值类型，该控制器方法的返回值就是响应到浏览器的响应报文, 标识整个http响应：状态码、头部信息以及响应体内容

ResponseEntity继承了HttpEntity类，HttpEntity代表一个http请求或者响应实体，其内部有两个成员变量：header及body，代表http请求或响应的header及body。

public class ResponseEntity<T> extends HttpEntity<T> {
 
	private final Object status;
 
	public ResponseEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers, HttpStatus status) {
		super(body, headers);
		Assert.notNull(status, "HttpStatus must not be null");
		this.status = status;
	}
}

@RequestMapping("/hello")
ResponseEntity<String> hello() {
    return new ResponseEntity<>("Hello World!", HttpStatus.OK);
}

7.5 SpringMVC处理json

java转换为json 的过程一般会称为 “序列化”

json转换为java 的过程一般会称为 “反序列化”

我们编写的所有Controller的方法的返回值都是String类型，那么如何来保证返回的数据的是json格式呢

使用**@ResponseBody注解**

1. 导入jackson的依赖

<dependency>
    <groupId>com.fasterxml.jackson.coregroupId>
    <artifactId>jackson-databindartifactId>
    <version>2.12.1version>
dependency>

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

<mvc:annotation-driven />

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

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

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

那前端传过来的json数据怎么接收

1. 以RequestParam接收

   前端传来的是json数据不多时：[id:id],可以直接用@RequestParam来获取值

   @RequestMapping(value="/json")
   @ResponseBody
   public String updateAttr(@RequestParam ("id") int id) {
       System.out.println(id);
       return "success";
   }
   

2. 以实体类方式接收

@RequestMapping(value="/json")
@ResponseBody
public  User requestJson02(@RequestBody User user){
    System.out.println(user.toString());
    return user2;
 
}

3. 以Map接收

@RequestMapping(value="/json")
@ResponseBody
public  User requestJson03(@RequestBody Map<String,String> map){
    System.out.println(map);
    return user2;
 
}

4. 以List接收

当前端传来这样一个json数组：[{id,name},{id,name},{id,name},…]时，用List接收

@RequestMapping(value="/json")
@ResponseBody
public String updateAttr(@RequestBody List<User> list) {
    for(User user:list){
        System.out.println(user.toString());
    }
    return "success";
}

7.6 @RestController注解

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

8. 文件上传和下载

8.1 文件下载

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

两种方式：

二进制：

@RequestMapping("/download")
public ResponseEntity<byte[]> download(@RequestParam String fileName) throws IOException {
        byte[] bytes = xxx;
        return new ResponseEntity<>(bytes, headers, HttpStatus.OK);
}

流式风格:

@RequestMapping("/download")
public ResponseEntity<byte[]> download(@RequestParam String fileName) throws IOException {
        byte[] bytes = xxx;
        return ResponseEntity.ok()
                .headers(headers)
                .body(bytes);
}        

实例：

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

8.2 文件上传

文件上传要求form表单的请求方式必须为post，并且添加属性enctype=“multipart/form-data”

SpringMVC中将上传的文件封装到MultipartFile对象中，通过此对象可以获取文件相关信息

上传步骤：

1. 添加依赖

<dependency>
    <groupId>commons-fileuploadgroupId>
    <artifactId>commons-fileuploadartifactId>
    <version>1.3.1version>
dependency>

2. 在SpringMVC的配置文件中添加配置

<!--必须通过文件解析器的解析才能将文件转换为MultipartFile对象-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
     <!-- 请求的编码格式，必须和jSP的pageEncoding属性一致，以便正确读取表单的内容，默认为ISO-8859-1 -->
    <property name="defaultEncoding" value="utf-8"/>
    <!-- 上传文件大小上限，单位为字节（10485760=10M） -->
    <property name="maxUploadSize" value="10485760"/>
    <property name="maxInMemorySize" value="40960"/>
</bean>

【注意！！！这个bena的id必须为：multipartResolver ， 否则上传文件会报400的错误！】

CommonsMultipartFile 的 常用方法：

• String getOriginalFilename()：获取上传文件的原名
• InputStream getInputStream()：获取文件流
• void transferTo(File dest)：将上传文件保存到一个目录文件中

3. 控制器方法

MultipartFile是一个接口，CommonsMultipartFile是MultipartFile接口的实现类 ！

使用MultipartFile作为形参接收上传文件时，直接用即可。CommonsMultipartFile作为形参接收上传文件时，必需添加@RequestParam注解（否则会报错：exception is java.lang.NoSuchMethodException: org.springframework.web.multipart.commons.CommonsMultipartFile）

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

• multipart/form-data：这种编码方式会以二进制流的方式来处理表单数据，这种编码方式会把文件域指定文件的内容也封装到请求参数中，不会对字符编码。
• application/x-www=form-urlencoded：默认方式，只处理表单域中的 value 属性值，采用这种编码方式的表单会将表单域中的值处理成 URL 编码方式。

<form enctype="multipart/form-data" method="post">
    <input type="file" name="file"/>
    <input type="submit">
form>

9. 拦截器

9.1 拦截器的配置

• SpringMVC中的拦截器用于拦截控制器方法的执行

• SpringMVC中的拦截器需要实现HandlerInterceptor

• SpringMVC的拦截器必须在SpringMVC的配置文件中进行配置

<bean class="com.atguigu.interceptor.FirstInterceptor">bean>

<ref bean="firstInterceptor">ref>


<mvc:interceptor>
    
    <mvc:mapping path="/**"/>
    <mvc:exclude-mapping path="/testRequestEntity"/>
    <ref bean="firstInterceptor">ref>
mvc:interceptor>

9.2 拦截器的三个抽象方法

preHandle：控制器方法执行之前执行preHandle()，其boolean类型的返回值表示是否拦截或放行，返回true为放行，即调用控制器方法；返回false表示拦截，即不调用控制器方法

postHandle：控制器方法执行之后执行postHandle()

afterComplation：处理完视图和模型数据，渲染视图完毕之后执行afterComplation()

多个拦截器的执行顺序:

• 若每个拦截器的preHandle()都返回true, 此时多个拦截器的执行顺序和拦截器在SpringMVC的配置文件的配置顺序有关：preHandle()会按照配置的顺序执行，而postHandle()和afterComplation()会按照配置的反序执行

• 若某个拦截器的preHandle()返回了false, preHandle()返回false和它之前的拦截器的preHandle()都会执行，postHandle()都不执行，返回false的拦截器之前的拦截器的afterComplation()会执行

9.3 自定义拦截器

public class MyInterceptor implements HandlerInterceptor {
    //在请求处理的方法之前执行
    //如果返回true执行下一个拦截器
    //如果返回false就不执行下一个拦截器
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
        System.out.println("------------处理前------------");
        return true;
    }
    //在请求处理方法执行之后执行
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
        System.out.println("------------处理后------------");
    }
    //在dispatcherServlet处理后执行(视图渲染完成后),做清理工作.
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
        System.out.println("------------清理------------");
    }
}

9.4 调用流程

源码解析：

• 拦截器的接口类

/**
*  拦截器接口
*/
public interface HandlerInterceptor {
 
    //请求前拦截
	boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception;
 
    //提交请求拦截
	void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
			throws Exception;
    
    //请求完成后拦截
	void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception;
 
}

• HandlerInterceptorAdapter（拦截器适配器）

public abstract class HandlerInterceptorAdapter implements AsyncHandlerInterceptor {
	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		return true;
	}
    
	@Override
	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
			throws Exception {
	}
    
	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
	}
    
	/**
	 * This implementation is empty.
     * 来自实现AsyncHandlerInterceptor 的方法
	 */
	@Override
	public void afterConcurrentHandlingStarted(
			HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
	}
 
}

1. HandlerMapping初始化

/**
	 * 完成Servlet一系列初始化工作，包括视图解析器、处理器映射器、处理器适配器
*/
protected void initStrategies(ApplicationContext context) {
		initMultipartResolver(context);
		initLocaleResolver(context);
		initThemeResolver(context);
        // 初始化RequestMapping，拦截器是作用在RequestMapping
		initHandlerMappings(context);
		initHandlerAdapters(context);
		initHandlerExceptionResolvers(context);
		initRequestToViewNameTranslator(context);
		initViewResolvers(context);
		initFlashMapManager(context);
}

2. DispatcherServlet执行调用

doService作为Servlet主要执行者，通过调用doDispatch来真正执行请求处理。

@Override
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
		if (logger.isDebugEnabled()) {
			String resumed = WebAsyncUtils.getAsyncManager(request).hasConcurrentResult() ? " resumed" : "";
			logger.debug("DispatcherServlet with name '" + getServletName() + "'" + resumed +
					" processing " + request.getMethod() + " request for [" + getRequestUri(request) + "]");
		}
 
		// 对请求属性快照的保持和存储后的使用,
		Map<String, Object> attributesSnapshot = null;
		if (WebUtils.isIncludeRequest(request)) {
			attributesSnapshot = new HashMap<String, Object>();
			Enumeration<?> attrNames = request.getAttributeNames();
			while (attrNames.hasMoreElements()) {
				String attrName = (String) attrNames.nextElement();
				if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
					attributesSnapshot.put(attrName, request.getAttribute(attrName));
				}
			}
		}
 
		//对SpringMVC框架中处理器Handle和视图渲染，提前做准备工作
		request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
		request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
		request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
		request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());
        // FlashMap是对重定向的参数传递的处理
		FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
		if (inputFlashMap != null) {
			request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
		}
		request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
		request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
 
		try {
            
           //***请求的实际处理方法***
			doDispatch(request, response);
            
		}
		finally {
			if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
				// Restore the original attribute snapshot, in case of an include.
				if (attributesSnapshot != null) {
					restoreAttributesAfterInclude(request, attributesSnapshot);
				}
			}
		}
	}

2. doDispatch完成拦截器的添加和拦截器拦截处理

• 通过getHandler(HttpServletRequest request)获取到HandlerExecutionChain处理器执行链，将拦截器注入到HandlerExecutionChain属性
• 分别调用HandlerExecutionChain的三个方法，applyPreHandle、applyPostHandle、triggerAfterCompletion，实现前置拦截/请求提交拦截和请求完成后拦截。使用责任链的设计模式，实际调用的是HandleInterceptor的三个接口，分别对应preHandle、postHandle、afterCompletion

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;
     // 获取当前请求的WebAsyncManager，如果没找到则创建并与请求关联
		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
		try {
			ModelAndView mv = null;
			Exception dispatchException = null;
			try {
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);
				//***获取到请求执行链，拦截器的添加在里面完成***---进入方法
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null || mappedHandler.getHandler() == null) {
					noHandlerFound(processedRequest, response);
					return;
				}
				// 遍历所有的 HandlerAdapter，找到可以处理该 Handler 的 HandlerAdapter
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
 
				// Process last-modified header, if supported by the handler.
				String method = request.getMethod();
				boolean isGet = "GET".equals(method);
				if (isGet || "HEAD".equals(method)) {
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (logger.isDebugEnabled()) {
						logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
					}
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}
                //1.请求前拦截处理,执行 preHandle()
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}
				// Actually invoke the handler.
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
 
				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}
 
				applyDefaultViewName(processedRequest, mv);
                //2.请求提交的拦截处理---postHandle()（责任链模式，调用拦截器链的执行）
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			catch (Exception ex) {
				dispatchException = ex;
			}
			catch (Throwable err) {
				// As of 4.3, we're processing Errors thrown from handler methods as well,
				// making them available for @ExceptionHandler methods and other scenarios.
				dispatchException = new NestedServletException("Handler dispatch failed", err);
			}
            // 3.请求结果视图渲染完成后，调用mappedHandler.triggerAfterCompletion（），实现请求完成后拦截
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Exception ex) {
             // 遍历拦截器，执行它们的 afterCompletion()
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Throwable err) {
             // 遍历拦截器，执行它们的 afterCompletion()
			triggerAfterCompletion(processedRequest, response, mappedHandler,
					new NestedServletException("Handler processing failed", err));
		}
		finally {
			if (asyncManager.isConcurrentHandlingStarted()) {
				// Instead of postHandle and afterCompletion
				if (mappedHandler != null) {
					mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				}
			}
			else {
				// Clean up any resources used by a multipart request.
				if (multipartRequestParsed) {
					cleanupMultipart(processedRequest);
				}
			}
		}
	}

10. 异常处理器

10.1 异常处理器

SpringMVC提供了一个处理控制器方法执行过程中所出现的异常的接口：HandlerExceptionResolver

HandlerExceptionResolver接口的实现类有：DefaultHandlerExceptionResolver和SimpleMappingExceptionResolver

SpringMVC提供了自定义的异常处理器SimpleMappingExceptionResolver，使用方式：

<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <property name="exceptionMappings">
        <props>
            
            <prop key="java.lang.ArithmeticException">errorprop>
        props>
    property>
    
    <property name="exceptionAttribute" value="ex">property>
bean>

10.2 基于注解的异常处理

//@ControllerAdvice将当前类标识为异常处理的组件
@ControllerAdvice
public class ExceptionController {

    //@ExceptionHandler用于设置所标识方法处理的异常
    @ExceptionHandler(ArithmeticException.class)
    //ex表示当前请求处理中出现的异常对象
    public String handleArithmeticException(Exception ex, Model model){
        model.addAttribute("ex", ex);
        return "error";
    }

}

11. 注解配置SpringMVC

使用配置类和注解代替web.xml和SpringMVC配置文件的功能

11.1 创建初始化类，代替web.xml

在Servlet3.0环境中，容器会在类路径中查找实现javax.servlet.ServletContainerInitializer接口的类，如果找到的话就用它来配置Servlet容器。

Spring提供了这个接口的实现，名为SpringServletContainerInitializer，这个类反过来又会查找实现WebApplicationInitializer的类并将配置的任务交给它们来完成。

Spring3.2引入了一个便利的WebApplicationInitializer基础实现，名为AbstractAnnotationConfigDispatcherServletInitializer，当我们的类扩展了AbstractAnnotationConfigDispatcherServletInitializer并将其部署到Servlet3.0容器的时候，容器会自动发现它，并用它来配置Servlet上下文。

public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {

    /**
     * 指定spring的配置类
     * @return
     */
    @Override
    protected Class[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    /**
     * 指定SpringMVC的配置类
     * @return
     */
    @Override
    protected Class[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }

    /**
     * 指定DispatcherServlet的映射规则，即url-pattern
     * @return
     */
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    /**
     * 添加过滤器
     * @return
     */
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter();
        encodingFilter.setEncoding("UTF-8");
        encodingFilter.setForceRequestEncoding(true);
        HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
        return new Filter[]{encodingFilter, hiddenHttpMethodFilter};
    }
}

11.2 创建WebConfig配置类，代替SpringMVC的配置文件

/**
*	1.扫描组件	2.视图解析器		3.view-controller	4. default-servlet-handler
*	5.mvc注解驱动		6.文件上传解析器	7.异常处理	8.拦截器
**/
@Configuration
//扫描组件
@ComponentScan("com.atguigu.mvc.controller")
//开启MVC注解驱动
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    //使用默认的servlet处理静态资源
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    //配置文件上传解析器
    @Bean
    public CommonsMultipartResolver multipartResolver(){
        return new CommonsMultipartResolver();
    }

    //配置拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        FirstInterceptor firstInterceptor = new FirstInterceptor();
        registry.addInterceptor(firstInterceptor).addPathPatterns("/**");
    }
    
    //配置视图控制
    
    /*@Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("index");
    }*/
    
    //配置异常映射
    /*@Override
    public void configureHandlerExceptionResolvers(List resolvers) {
        SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
        Properties prop = new Properties();
        prop.setProperty("java.lang.ArithmeticException", "error");
        //设置异常映射
        exceptionResolver.setExceptionMappings(prop);
        //设置共享异常信息的键
        exceptionResolver.setExceptionAttribute("ex");
        resolvers.add(exceptionResolver);
    }*/

    //配置生成模板解析器
    @Bean
    public ITemplateResolver templateResolver() {
        WebApplicationContext webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
        // ServletContextTemplateResolver需要一个ServletContext作为构造参数，可通过WebApplicationContext 的方法获得
        ServletContextTemplateResolver templateResolver = new ServletContextTemplateResolver(
                webApplicationContext.getServletContext());
        templateResolver.setPrefix("/WEB-INF/templates/");
        templateResolver.setSuffix(".html");
        templateResolver.setCharacterEncoding("UTF-8");
        templateResolver.setTemplateMode(TemplateMode.HTML);
        return templateResolver;
    }

    //生成模板引擎并为模板引擎注入模板解析器
    @Bean
    public SpringTemplateEngine templateEngine(ITemplateResolver templateResolver) {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(templateResolver);
        return templateEngine;
    }

    //生成视图解析器并未解析器注入模板引擎
    @Bean
    public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
        ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
        viewResolver.setCharacterEncoding("UTF-8");
        viewResolver.setTemplateEngine(templateEngine);
        return viewResolver;
    }


}

11.3 测试功能

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

12. SpringMVC执行流程

12.1 SpringMVC常用组件

• DispatcherServlet：前端控制器，不需要工程师开发，由框架提供

作用：统一处理请求和响应，整个流程控制的中心，由它调用其它组件处理用户的请求

• HandlerMapping：处理器映射器，不需要工程师开发，由框架提供

作用：根据请求的url、method等信息查找Handler，即控制器方法

• Handler：处理器（实际上是controller），需要工程师开发

作用：在DispatcherServlet的控制下Handler对具体的用户请求进行处理

• HandlerAdapter：处理器适配器，不需要工程师开发，由框架提供

作用：通过HandlerAdapter对处理器（控制器方法）进行执行

• ViewResolver：视图解析器，不需要工程师开发，由框架提供

作用：进行视图解析，得到相应的视图，例如：ThymeleafView、InternalResourceView、RedirectView

• View：视图

作用：将模型数据通过页面展示给用户

当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。

12.2 DispatcherServlet初始化过程

Spring MVC框架像许多其他MVC框架一样, 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。

​ DispatcherServlet 本质上是一个 Servlet，所以天然的遵循 Servlet 的生命周期。所以宏观上是 Servlet 生命周期来进行调度。

• 初始化WebApplicationContext

所在类：org.springframework.web.servlet.FrameworkServlet

protected WebApplicationContext initWebApplicationContext() {
    WebApplicationContext rootContext =
        WebApplicationContextUtils.getWebApplicationContext(getServletContext());
    WebApplicationContext wac = null;

    if (this.webApplicationContext != null) {
        // A context instance was injected at construction time -> use it
        wac = this.webApplicationContext;
        if (wac instanceof ConfigurableWebApplicationContext) {
            ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
            if (!cwac.isActive()) {
                // The context has not yet been refreshed -> provide services such as
                // setting the parent context, setting the application context id, etc
                if (cwac.getParent() == null) {
                    // The context instance was injected without an explicit parent -> set
                    // the root application context (if any; may be null) as the parent
                    cwac.setParent(rootContext);
                }
                configureAndRefreshWebApplicationContext(cwac);
            }
        }
    }
    if (wac == null) {
        // No context instance was injected at construction time -> see if one
        // has been registered in the servlet context. If one exists, it is assumed
        // that the parent context (if any) has already been set and that the
        // user has performed any initialization such as setting the context id
        wac = findWebApplicationContext();
    }
    
    //第一次WebApplicationContext为空，进入此处创建WebApplicationContext
    if (wac == null) {
        // No context instance is defined for this servlet -> create a local one
        // 创建WebApplicationContext
        wac = createWebApplicationContext(rootContext);
    }

    if (!this.refreshEventReceived) {
        // Either the context is not a ConfigurableApplicationContext with refresh
        // support or the context injected at construction time had already been
        // refreshed -> trigger initial onRefresh manually here.
        synchronized (this.onRefreshMonitor) {
            // 刷新WebApplicationContext
            onRefresh(wac);
        }
    }

    if (this.publishContext) {
        // Publish the context as a servlet context attribute.
        // 将IOC容器在应用域共享
        String attrName = getServletContextAttributeName();
        getServletContext().setAttribute(attrName, wac);
    }

    return wac;
}

• 创建WebApplicationContext

所在类：org.springframework.web.servlet.FrameworkServlet

protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
    Class<?> contextClass = getContextClass();
    if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
        throw new ApplicationContextException(
            "Fatal initialization error in servlet with name '" + getServletName() +
            "': custom WebApplicationContext class [" + contextClass.getName() +
            "] is not of type ConfigurableWebApplicationContext");
    }
    // 通过反射创建 IOC 容器对象
    ConfigurableWebApplicationContext wac =
        (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);

    wac.setEnvironment(getEnvironment());
    // 设置父容器
    wac.setParent(parent);
    String configLocation = getContextConfigLocation();
    if (configLocation != null) {
        wac.setConfigLocation(configLocation);
    }
    configureAndRefreshWebApplicationContext(wac);

    return wac;
}

• DispatcherServlet初始化策略

FrameworkServlet创建WebApplicationContext后，刷新容器，调用onRefresh(wac)，此方法在DispatcherServlet中进行了重写，调用了initStrategies(context)方法，初始化策略，即初始化DispatcherServlet的各个组件

所在类：org.springframework.web.servlet.DispatcherServlet

protected void initStrategies(ApplicationContext context) {
   initMultipartResolver(context);
   initLocaleResolver(context);
   initThemeResolver(context);
   initHandlerMappings(context);
   initHandlerAdapters(context);
   initHandlerExceptionResolvers(context);
   initRequestToViewNameTranslator(context);
   initViewResolvers(context);
   initFlashMapManager(context);
}

12.3 DispatcherServlet调用组件处理请求

• processRequest()

  FrameworkServlet重写HttpServlet中的service()和doXxx()，这些方法中调用了processRequest(request, response)

  所在类：org.springframework.web.servlet.FrameworkServlet

  protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
  
      long startTime = System.currentTimeMillis();
      Throwable failureCause = null;
  
      LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
      LocaleContext localeContext = buildLocaleContext(request);
  
      RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
      ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);
  
      WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
      asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());
  
      initContextHolders(request, localeContext, requestAttributes);
  
      try {
          // 执行服务，doService()是一个抽象方法，在DispatcherServlet中进行了重写
          doService(request, response);
      }
      catch (ServletException | IOException ex) {
          failureCause = ex;
          throw ex;
      }
      catch (Throwable ex) {
          failureCause = ex;
          throw new NestedServletException("Request processing failed", ex);
      }
  
      finally {
          resetContextHolders(request, previousLocaleContext, previousAttributes);
          if (requestAttributes != null) {
              requestAttributes.requestCompleted();
          }
          logResult(request, response, failureCause, asyncManager);
          publishRequestHandledEvent(request, response, startTime, failureCause);
      }
  }
  

• doService()

  所在类：org.springframework.web.servlet.DispatcherServlet

  @Override
  protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
      logRequest(request);
  
      // Keep a snapshot of the request attributes in case of an include,
      // to be able to restore the original attributes after the include.
      Map<String, Object> attributesSnapshot = null;
      if (WebUtils.isIncludeRequest(request)) {
          attributesSnapshot = new HashMap<>();
          Enumeration<?> attrNames = request.getAttributeNames();
          while (attrNames.hasMoreElements()) {
              String attrName = (String) attrNames.nextElement();
              if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
                  attributesSnapshot.put(attrName, request.getAttribute(attrName));
              }
          }
      }
  
      // Make framework objects available to handlers and view objects.
      request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
      request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
      request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
      request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());
  
      if (this.flashMapManager != null) {
          FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
          if (inputFlashMap != null) {
              request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
          }
          request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
          request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
      }
  
      RequestPath requestPath = null;
      if (this.parseRequestPath && !ServletRequestPathUtils.hasParsedRequestPath(request)) {
          requestPath = ServletRequestPathUtils.parseAndCache(request);
      }
  
      try {
          // 处理请求和响应
          doDispatch(request, response);
      }
      finally {
          if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
              // Restore the original attribute snapshot, in case of an include.
              if (attributesSnapshot != null) {
                  restoreAttributesAfterInclude(request, attributesSnapshot);
              }
          }
          if (requestPath != null) {
              ServletRequestPathUtils.clearParsedRequestPath(request);
          }
      }
  }
  

• doDispatch()

  所在类：org.springframework.web.servlet.DispatcherServlet

  protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
      HttpServletRequest processedRequest = request;
      HandlerExecutionChain mappedHandler = null;
      boolean multipartRequestParsed = false;
  
      WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
  
      try {
          ModelAndView mv = null;
          Exception dispatchException = null;
  
          try {
              processedRequest = checkMultipart(request);
              multipartRequestParsed = (processedRequest != request);
  
              // Determine handler for the current request.
              /*
                  mappedHandler：调用链
                  包含handler、interceptorList、interceptorIndex
                  handler：浏览器发送的请求所匹配的控制器方法
                  interceptorList：处理控制器方法的所有拦截器集合
                  interceptorIndex：拦截器索引，控制拦截器afterCompletion()的执行
              */
              mappedHandler = getHandler(processedRequest);
              if (mappedHandler == null) {
                  noHandlerFound(processedRequest, response);
                  return;
              }
  
              // Determine handler adapter for the current request.
                 // 通过控制器方法创建相应的处理器适配器，调用所对应的控制器方法
              HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
  
              // Process last-modified header, if supported by the handler.
              String method = request.getMethod();
              boolean isGet = "GET".equals(method);
              if (isGet || "HEAD".equals(method)) {
                  long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                  if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                      return;
                  }
              }
              
              // 调用拦截器的preHandle()
              if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                  return;
              }
  
              // Actually invoke the handler.
              // 由处理器适配器调用具体的控制器方法，最终获得ModelAndView对象
              mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
  
              if (asyncManager.isConcurrentHandlingStarted()) {
                  return;
              }
  
              applyDefaultViewName(processedRequest, mv);
              // 调用拦截器的postHandle()
              mappedHandler.applyPostHandle(processedRequest, response, mv);
          }
          catch (Exception ex) {
              dispatchException = ex;
          }
          catch (Throwable err) {
              // As of 4.3, we're processing Errors thrown from handler methods as well,
              // making them available for @ExceptionHandler methods and other scenarios.
              dispatchException = new NestedServletException("Handler dispatch failed", err);
          }
          // 后续处理：处理模型数据和渲染视图
          processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
      }
      catch (Exception ex) {
          triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
      }
      catch (Throwable err) {
          triggerAfterCompletion(processedRequest, response, mappedHandler,
                                 new NestedServletException("Handler processing failed", err));
      }
      finally {
          if (asyncManager.isConcurrentHandlingStarted()) {
              // Instead of postHandle and afterCompletion
              if (mappedHandler != null) {
                  mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
              }
          }
          else {
              // Clean up any resources used by a multipart request.
              if (multipartRequestParsed) {
                  cleanupMultipart(processedRequest);
              }
          }
      }
  }
  

• processDispatchResult()

  private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
                                     @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
                                     @Nullable Exception exception) throws Exception {
  
      boolean errorView = false;
  
      if (exception != null) {
          if (exception instanceof ModelAndViewDefiningException) {
              logger.debug("ModelAndViewDefiningException encountered", exception);
              mv = ((ModelAndViewDefiningException) exception).getModelAndView();
          }
          else {
              Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
              mv = processHandlerException(request, response, handler, exception);
              errorView = (mv != null);
          }
      }
  
      // Did the handler return a view to render?
      if (mv != null && !mv.wasCleared()) {
          // 处理模型数据和渲染视图
          render(mv, request, response);
          if (errorView) {
              WebUtils.clearErrorRequestAttributes(request);
          }
      }
      else {
          if (logger.isTraceEnabled()) {
              logger.trace("No view rendering, null ModelAndView returned.");
          }
      }
  
      if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
          // Concurrent handling started during a forward
          return;
      }
  
      if (mappedHandler != null) {
          // Exception (if any) is already handled..
          
          // 这里调用了拦截器的afterCompletion()
          mappedHandler.triggerAfterCompletion(request, response, null);
      }
  }
  

12.4 执行流程

1. DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。

我们假设请求的url为 : http://localhost:8080/SpringMVC/hello

如上url拆分成三部分：

http://localhost:8080

SpringMVC：部署在服务器上的web站点

hello表示控制器

通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。

2. DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI），判断请求URI对应的映射：

• 不存在

i. 再判断是否配置了mvc:default-servlet-handler

ii. 如果没配置，则控制台报映射查找不到，客户端展示404错误

iii. 如果有配置，则访问目标资源（一般为静态资源，如：JS,CSS,HTML），找不到客户端也会展示404错误

• 存在则执行下面的流程

1. HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler，获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain执行链对象的形式返回。
2. HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello。
3. HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。
4. HandlerAdapter表示处理器适配器，DispatcherServlet 根据获得的Handler，选择一个合适的HandlerAdapter，其按照特定的规则去执行Handler。
5. Handler让具体的Controller执行。
6. Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。
7. HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
8. DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
9. 视图解析器将解析的逻辑视图名传给DispatcherServlet。
10. DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
11. 最终视图呈现给用户。

终于抄……学完了，学了又好像没学

本文参考：

Spring-MVC-Demo (mowangblog.github.io)

狂神SSM教程- 专栏 -KuangStudy