SpringMVC 总结

1. 配置

1.1 MVC 概念

MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分

M：Model，模型层，指工程中的 JavaBean，它负责数据逻辑（业务规则）的处理和实现数据操作（即在数据库中存取数据）
JavaBean 分为两类：
- 一类称为实体类 Bean：专门存储业务数据的，如 Student、User 等
- 一类称为业务处理 Bean：指 Service 或 Dao 对象，专门用于处理业务逻辑和数据访问
V：View，视图层，指工程中的 HTML 或 JSP 等页面，负责格式化数据并把它们呈现给用户，包括数据展示、用户交互、数据验证、界面设计等功能
C：Controller，控制层，指工程中的 Servlet，负责接收并转发请求，对请求进行处理后，指定视图并将响应结果发送给客户端

MVC 的工作流程：

用户通过视图层发送请求到服务器，在服务器中请求被 Controller 接收
Controller 调用相应的 Model 层处理请求，处理完毕将结果返回到 Controller
Controller 再根据请求处理的结果找到相应的 View 视图，渲染数据后最终响应给浏览器

1.2 SpringMVC 概念

SpringMVC是Spring的一个后续产品，是 Spring 的一个子项目
SpringMVC 是 Spring 为表述层开发提供的一整套完备的解决方案。在表述层框架历经 Strust、WebWork、Strust2 等诸多产品的历代更迭之后，目前业界普遍选择了SpringMVC 作为 Java EE 项目表述层开发的首选方案

注：三层架构分为表述层（或表示层）、业务逻辑层、数据访问层，表述层表示前台页面和后台 Servlet

1.3 SpringMVC的特点

Spring 家族原生产品，与 IOC 容器等基础设施无缝对接
基于原生的Servlet，通过了功能强大的前端控制器DispatcherServlet，对请求和响应进行统一处理
表述层各细分领域需要解决的问题全方位覆盖，提供全面解决方案
代码清新简洁，大幅度提升开发效率
内部组件化程度高，可插拔式组件即插即用，想要什么功能配置相应组件即可
性能卓著，尤其适合现代大型、超大型互联网项目要求

1.4 配置 web.xml

默认配置方式此配置作用下，SpringMVC 的配置文件默认位于 WEB-INF 下，默认名称为 <servlet-name>-servlet.xml，例如，以下配置所对应 SpringMVC 的配置文件位于 WEB-INF 下，文件名为 springMVC-servlet.xml

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <!-- 配置 SpringMVC 的前端控制器，对浏览器发送的请求统一进行处理 -->
	<servlet>
		<servlet-name>springMVC</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servletclass>
	</servlet>

	<servlet-mapping>
		<servlet-name>springMVC</servlet-name>
		<!--
			设置 springMVC 的核心控制器所能处理的请求的请求路径
			/ 所匹配的请求可以是 /login 或 .html 或 .js 或 .css 方式的请求路径
			但是 / 不能匹配 .jsp 请求路径的请求
		-->
		<url-pattern>/</url-pattern>
	</servlet-mapping>
</web-app>

扩展配置方式可通过 init-param 标签设置 SpringMVC 配置文件的位置和名称，通过 load-on-startup 标签设置 SpringMVC 前端控制器 DispatcherServlet 的初始化时间

<!-- 配置 SpringMVC 的前端控制器，对浏览器发送的请求统一进行处理 -->
<servlet>
    <servlet-name>springMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 通过初始化参数指定 SpringMVC 配置文件的位置和名称 -->
    <init-param>
        <!-- contextConfigLocation 为固定值 -->
        <param-name>contextConfigLocation</param-name>
        <!-- 使用 classpath: 表示从类路径查找配置文件，例如 Maven 工程中的src/main/resources -->
        <param-value>classpath:springMVC.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>springMVC</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

<url-pattern> 标签中使用 / 和 /* 的区别：* / 所匹配的请求可以是 /login 或 .html 或 .js 或 .css 方式的请求路径，但是 / 不能匹配 .jsp 请求路径的请求。因此就可以避免在访问 JSP 页面时，该请求被 DispatcherServlet 处理，从而找不到相应的页面

/* 则能够匹配所有请求，在使用过滤器时，若需要对所有请求进行过滤，就需要使用 /* 的写法

完整配置：

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
	http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

  <display-name>Archetype Created Web Application</display-name>

   <!-- 配置统一编码格式 -->
  <filter>
    <filter-name>CharacterEncoding</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
      <param-name>forceResponseEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>CharacterEncoding</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

	<!-- 配置 HiddenHttpMethodFilter，实现 RestFul -->
  <filter>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- 配置 SpringMVC 的前端控制器，对浏览器发送的请求统一进行处理 -->
  <servlet>
    <servlet-name>springMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 通过初始化参数指定 SpringMVC 配置文件的位置和名称 -->
    <init-param>
      <!-- contextConfigLocation 为固定值 -->
      <param-name>contextConfigLocation</param-name>
      <!-- 使用 classpath: 表示从类路径查找配置文件，例如 Maven 工程中的src/main/resources -->
      <param-value>classpath:springmvc-config.xml</param-value>
    </init-param>
    <!--
        作为框架的核心组件，在启动过程中有大量的初始化操作要做
        而这些操作放在第一次请求时才执行会严重影响访问速度
        因此需要通过此标签将启动控制 DispatcherServlet 的初始化时间提前到服务器启动时
    -->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>springMVC</servlet-name>
    <!--
        设置 springMVC 的核心控制器所能处理的请求的请求路径
        / 所匹配的请求可以是 /login 或 .html 或 .js 或 .css 方式的请求路径
        但是 / 不能匹配 .jsp 请求路径的请求
   -->
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

1.5 配置 springmvc-config.xml

<!-- 开启注解扫描，自动扫描包 -->
<context:component-scan base-package="fan" />

<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>
<!-- 处理静态资源，例如 html、js、css、jpg
  若只设置该标签，则只能访问静态资源，其他请求则无法访问
  此时必须设置<mvc:annotation-driven/>解决问题 -->
<mvc:default-servlet-handler/>
<!-- 开启 mvc 注解驱动 -->
<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/html</value>
					<value>application/json</value>
				</list>
			</property>
		</bean>
	</mvc:message-converters>
</mvc:annotation-driven>

1.6 控制器

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

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

1.7 Thymeleaf 页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
	首页
	<a th:href="@{/target}">hello</a>
</body>
</html>

1.8 工作流程小结

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

2. 视图解析器 ViewResolver

视图解析器（ViewResolver）是 Spring MVC 的重要组成部分，负责将逻辑视图名解析为具体的视图对象。 Spring MVC 提供了很多视图解析类，其中每一项都对应 Java Web 应用中特定的某些视图技术。常用的视图解析类如下

2.1 URLBasedViewResolver

UrlBasedViewResolver 是对 ViewResolver 的一种简单实现，主要提供了一种拼接 URL 的方式来解析视图
通过 prefix 属性指定前缀，suffix 属性指定后缀。当 ModelAndView 对象返回具体的 View 名称时，它会将前缀 prefix 和后缀 suffix 与具体的视图名称拼接，得到一个视图资源文件的具体加载路径，从而加载真正的视图文件并反馈给用户
使用 UrlBasedViewResolver 除了要配置前缀和后缀属性之外，还需要配置“viewClass”，表示解析成哪种视图。 示例代码如下：

<bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">          
  <!--不能省略-->  
  <property name="viewClass" value="org.springframework.web.servlet.view.InternalResourceViewResolver"/> 
    <!--前缀-->
    <property name="prefix" value="/WEB-INF/jsp/"/>
    <!--后缀-->
    <property name="suffix" value=".jsp"/>  
</bean>

2.2 InternalResourceViewResolver

InternalResourceViewResolver 为“内部资源视图解析器”，是日常开发中最常用的视图解析器类型。它是 URLBasedViewResolver 的子类，拥有 URLBasedViewResolver 的一切特性
InternalResourceViewResolver 能自动将返回的视图名称解析为 InternalResourceView 类型的对象。InternalResourceView 会把 Controller 处理器方法返回的模型属性都存放到对应的 request 属性中，然后通过 RequestDispatcher 在服务器端把请求 forword 重定向到目标 URL
也就是说，使用 InternalResourceViewResolver 视图解析时，无需再单独指定 viewClass 属性。 示例代码如下：

<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  <!--可以省略-->  
  <property name="viewClass" value="org.springframework.web.servlet.view.InternalResourceViewResolver"/>
    <!--前缀-->
    <property name="prefix" value="/WEB-INF/jsp/"/>
    <!--后缀-->
    <property name="suffix" value=".jsp"/>  
</bean>

2.3 FreeMarkerViewResolver

FreeMarkerViewResolver 是 UrlBasedViewResolver 的子类，可以通过 prefix 属性指定前缀，通过 suffix 属性指定后缀

FreeMarkerViewResolver 最终会解析逻辑视图配置，返回 freemarker 模板。不需要指定 viewClass 属性

<bean class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver">
    <property name="prefix" value="fm_"/>
    <property name="suffix" value=".ftl"/>
</bean>

下面指定 FreeMarkerView 类型最终生成的实体视图（模板文件）的路径以及其他配置。需要给 FreeMarkerViewResolver 设置一个 FreeMarkerConfig 的 bean 对象来定义 FreeMarker 的配置信息
```
<bean class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
    <property name="templateLoaderPath" value="/WEB-INF/ftl" />
</bean>
```
定义了 templateLoaderPath 属性后，Spring 可以通过该属性找到 FreeMarker 模板文件的具体位置。当有模板位于不同的路径时，可以配置 templateLoaderPath 属性，来指定多个资源路径

然后定义一个 Controller，让其返回 ModelAndView，同时定义一些返回参数和视图信息：

@Controller
@RequestMapping("viewtest")
public class ViewController {
    @RequestMapping("freemarker")
    public ModelAndView freemarker() {
        ModelAndView mv = new ModelAndView();
        mv.addObject("username", "BianChengBang");
        mv.setViewName("freemarker");
        return mv;
    }
}

当 FreeMarkerViewResolver 解析逻辑视图信息时，会生成一个 URL 为“前缀+视图名+后缀”（这里即“fm_freemarker.ftl”）的 FreeMarkerView 对象，然后通过 FreeMarkerConfigurer 的配置找到 templateLoaderPath 对应文本文件的路径，在该路径下找到该文本文件，从而 FreeMarkerView 就可以利用该模板文件进行视图的渲染，并将 model 数据封装到即将要显示的页面上，最终展示给用户

在 /WEB-INF/ftl 文件夹下创建 fm_freemarker.ftl，代码如下：

<html>
<head>
<title>FreeMarker</title>
</head>
<body>
    <b>Welcome!</b>
    <i>${username }</i>
</body>
</html>

3.Spring MVC 执行流程

在这里插入图片描述
SpringMVC 的执行流程如下：

用户点击某个请求路径，发起一个 HTTP request 请求，该请求会被提交到 DispatcherServlet（前端控制器）
由 DispatcherServlet 请求一个或多个 HandlerMapping（处理器映射器），并返回一个执行链（HandlerExecutionChain）
DispatcherServlet 将执行链返回的 Handler 信息发送给 HandlerAdapter（处理器适配器）
HandlerAdapter 根据 Handler 信息找到并执行相应的 Handler（常称为 Controller）
Handler 执行完毕后会返回给 HandlerAdapter 一个 ModelAndView 对象（Spring MVC的底层对象，包括 Model 数据模型和 View 视图信息）；
HandlerAdapter 接收到 ModelAndView 对象后，将其返回给 DispatcherServlet
DispatcherServlet 接收到 ModelAndView 对象后，会请求 ViewResolver（视图解析器）对视图进行解析
ViewResolver 根据 View 信息匹配到相应的视图结果，并返回给 DispatcherServlet
DispatcherServlet 接收到具体的 View 视图后，进行视图渲染，将 Model 中的模型数据填充到 View 视图中的 request 域，生成最终的 View（视图）
视图负责将结果显示到浏览器（客户端）

3.1 Spring MVC 常用组件

Spring MVC 涉及到的组件有 DispatcherServlet（前端控制器）、HandlerMapping（处理器映射器）、HandlerAdapter（处理器适配器）、Handler（处理器）、ViewResolver（视图解析器）和 View（视图）

3.1.1 前端控制器 DispatcherServlet

Spring MVC 的所有请求都要经过 DispatcherServlet 来统一分发
DispatcherServlet 相当于一个转发器或中央处理器，控制整个流程的执行，对各个组件进行统一调度，以降低组件之间的耦合性，有利于组件之间的拓展。

3.1.2 处理器映射器 HandlerMapping

根据请求的 URL 路径，通过注解或者 XML 配置，寻找匹配的处理器（Handler）信息

3.1.3 处理器适配器 HandlerAdapter

根据映射器找到的处理器（Handler）信息，按照特定规则执行相关的处理器（Handler）

3.1.4 处理器 Handler

与 Java Servlet 扮演的角色一致。其作用是执行相关的请求处理逻辑，并返回相应的数据和视图信息，将其封装至 ModelAndView 对象中

3.1.5 视图解析器 View Resolver

进行解析操作，通过 ModelAndView 对象中的 View 信息将逻辑视图名解析成真正的视图 View（如通过一个 JSP 路径返回一个真正的 JSP 页面）

3.1.6 视图 View

本身是一个接口，实现类支持不同的 View 类型（JSP、FreeMarker、Excel 等）

以上组件中，需要开发人员进行开发的是处理器（Handler，常称Controller）和视图（View）。通俗的说，要开发处理该请求的具体代码逻辑，以及最终展示给用户的界面。

3.2 DispatcherServlet 初始化过程

DispatcherServlet 本质上是一个 Servlet，所以天然的遵循 Servlet 的生命周期。所以宏观上是 Servlet 生命周期来进行调度。
在这里插入图片描述

a>初始化WebApplicationContext
所在类：org.springframework.web.servlet.Framework

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();
    }
    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;
}

创建WebApplicationContextext
所在类：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);
}

3.3 SpringMVC 的执行流程

用户向服务器发送请求，请求被 SpringMVC 前端控制器 DispatcherServlet 捕获
DispatcherServlet 对请求 URL 进行解析，得到请求资源标识符（URI），判断请求 URI 对应的映射：
- 不存在
  - 再判断是否配置了 mvc:default-servlet-handler
  - 如果没配置，则控制台报映射查找不到，客户端展示 404 错误
  - 如果有配置，则访问目标资源（一般为静态资源，如：JS, CSS, HTML），找不到客户端也会展示 404 错误
- 存在则执行下面的流程
根据该 URI，调用 HandlerMapping 获得该 Handler 配置的所有相关的对象（包括 Handler 对象以及 Handler 对象对应的拦截器），最后以 HandlerExecutionChain 执行链对象的形式返回
DispatcherServlet 根据获得的 Handler，选择一个合适的 HandlerAdapter
如果成功获得 HandlerAdapter，此时将开始执行拦截器的 preHandler(...) 方法【正向】
提取 Request 中的模型数据，填充 Handler 入参，开始执行 Handler（Controller) 方法，处理请求。在填充 Handler 的入参过程中，根据你的配置，Spring 将帮你做一些额外的工作：
- HttpMessageConveter：将请求消息（如 Json、XML 等数据）转换成一个对象，将对象转换为指定的响应信息
- 数据转换：对请求消息进行数据转换。如 String 转换成 Integer、Double 等
- 数据格式化：对请求消息进行数据格式化。如将字符串转换成格式化数字或格式化日期等
- 数据验证：验证数据的有效性（长度、格式等），验证结果存储到 BindingResult 或 Error 中
Handler 执行完成后，向 DispatcherServlet 返回一个 ModelAndView 对象
此时将开始执行拦截器的 postHandle(...) 方法【逆向】
根据返回的 ModelAndView（此时会判断是否存在异常：如果存在异常，则执行 HandlerExceptionResolver 进行异常处理）选择一个适合的 ViewResolver 进行视图解析，根据 Model 和 View，来渲染视图
渲染视图完毕执行拦截器的 afterCompletion(...) 方法【逆向】
将渲染结果返回给客户

4. RequestMapping 注解

4.1 @RequestMapping 注解的功能

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

4.2 @RequestMapping 注解的位置

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

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

4.3 value 属性

通过请求的请求地址匹配请求映射，注解的 value 属性必须设置，至少通过请求地址匹配请求映射
value 属性是 @RequestMapping 注解的默认属性，因此如果只有 value 属性时，可以省略该属性名，如果有其它属性，则必须写上 value 属性名称
@RequestMapping 注解的 value 属性是一个字符串类型的数组，表示该请求映射能够匹配多个请求地址所对应的请求
value 属性支持通配符匹配，如 @RequestMapping(value="toUser/*") 表示 http://localhost:8080/toUser/1 或 http://localhost:8080/toUser/hahaha 都能够正常访问

<a th:href="@{/testRequestMapping}">测试@RequestMapping的value属性-->/testRequestMapping</a><br>
<a th:href="@{/test}">测试@RequestMapping的value属性-->/test</a><br>

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

4.4 path 属性

path 属性和 value 属性都用来作为映射使用。
即 @RequestMapping(value="toUser") 和 @RequestMapping(path="toUser") 都能访问 toUser() 方法
path 属性支持通配符匹配，如 @RequestMapping(path="toUser/*") 表示 http://localhost:8080/toUser/1 或 http://localhost:8080/toUser/hahaha 都能够正常访问

4.5 name 属性

name 属性相当于方法的注释，使方法更易理解。如 @RequestMapping(value ="toUser", name = "获取用户信息")

4.6 method 属性

method 属性用于表示该方法支持哪些 HTTP 请求。如果省略 method 属性，则说明该方法支持全部的 HTTP 请求
@RequestMapping 注解的 method 属性通过请求的请求方式（get 或 post）匹配请求映射
@RequestMapping 注解的 method 属性是一个 RequestMethod 类型的数组，表示该请求映射能够匹配多种请求方式的请求

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

<a th:href="@{/test}">测试@RequestMapping的value属性-->/test</a><br>
<form th:action="@{/test}" method="post">
    <input type="submit">
</form>

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

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

处理 GET 请求的映射，查询 --> @GetMapping
处理 POST 请求的映射，新增 --> @PostMapping
处理 PUT 请求的映射，修改 --> @PutMapping
处理 DELETE请求的映射，删除 --> @DeleteMapping

常用的请求方式有 GET，POST，PUT，DELETE。但是目前浏览器只支持 GET 和 POST，若在 Form 表单提交时，为 method 设置了其他请求方式的字符串（PUT 或 DELETE），则按照默认的请求方式 GET 处理，若要发送 PUT 和 DELETE 请求，则需要通过 Spring 提供的过滤器 HiddenHttpMethodFilter

4.7 params 属性

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

"param"：要求请求映射所匹配的请求必须携带 param 请求参数
"!param"：要求请求映射所匹配的请求必须不能携带 param 请求参数
"param=value"：要求请求映射所匹配的请求必须携带 param 请求参数且param=value
"param!=value"：要求请求映射所匹配的请求必须携带 param 请求参数但param!=value

<a th:href="@{/test(username='admin',password=123456)">测试@RequestMapping的params属性-->/test</a><br>

@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={admin}, password={123456}

4.8 headers 属性

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

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

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

4.9 consumers 属性

consumers 属性用于指定处理请求的提交内容类型（Content-Type），例如 application/json、text/html
如: @RequestMapping(value = "toUser",consumes = "application/json")

4.10 produces 属性

produces 属性用于指定返回的内容类型，返回的内容类型必须是 request 请求头（Accept）中所包含的类型。 如：@RequestMapping(value = "toUser", produces = "application/json")
除此之外，produces 属性还可以指定返回值的编码。 如： @RequestMapping(value = "toUser", produces = "application/json, charset=utf-8")，表示返回 UTF-8 编码。

4.11 SpringMVC支持ant风格的路径

？：表示任意的单个字符，?，/ 两个特殊字符不行
*：表示任意的 0 个或多个字符
**：表示任意的一层或多层目录

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

@RequestMapping("/a?a/target")
// @RequestMapping("/**/target")
public String toTarget(){
	return "target";
}

4.12 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:adm

5. SpringMVC 获取请求参数

5.1 原生 ServletAPI 获取

将 HttpServletRequest 作为控制器方法的形参，此时 HttpServletRequest 类型的参数表示封装了当前请求的请求报文的对象

<a th:href="@{/param(username = '张三', password = 123)}">111</a>

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

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

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

<a th:href="@{/testParam(username='admin',password=123456)}">测试获取请求参数-->/testParam</a><br>
<form th:action="@{/testParam}" method="post">
    用户名：<input type="text" name="username" placeholder="username"><br>
    密码：<input type="password" name="password" placeholder="password"><br>
    爱好：<input type="checkbox" name="hobby" value="a">a
    <input type="checkbox" name="hobby" value="b">b
    <input type="checkbox" name="hobby" value="c">c<br>
    <input type="submit">
</form>

@RequestMapping("/testParam")
public String param(String username, String password, String[] hobby){
	System.out.println("username:" + username + ",password:" + password + ",hobby" + Arrays.toString(hobby));
	return "success";
}

若请求所传输的请求参数中有多个同名的请求参数，此时可以在控制器方法的形参中设置字符串数组或者字符串类型的形参接收此请求参数
若使用字符串数组类型的形参，此参数的数组中包含了每一个数据
若使用字符串类型的形参，此参数的值为每个数据中间使用逗号拼接的结果

5.3 @RequestParam

@RequestParam 是将请求参数和控制器方法的形参创建映射关系，一共有三个属性：

value：指定为形参赋值的请求参数的参数名
required：设置是否必须传输此请求参数，默认值为 true
若设置为 true 时，则当前请求必须传 value 所指定的请求参数，若没有传输该请求参数，且没有设置 defaultValue 属性，则页面报错400：Required String parameter 'xxx' is not present
若设置为 false，则当前请求不是必须传 value 所指定的请求参数，若没有传输，则注解所标识的形参的值为 null
defaultValue：不管 required 属性值为 true 或 false，当 value 所指定的请求参数没有传输或传输的值为 "" 时，则使用默认值为形参赋值

@RequestMapping("/testParam")
public String param(@RequestParam(value = "username", required = false, defaultValue = "hehe") String username, 
                    @RequestParam("password") String password, 
                    @RequestParam("hobby") String[] hobby){
	System.out.println("username:" + username + ",password:" + password + ",hobby" + Arrays.toString(hobby));
	return "success";
}

5.4 @RequestHeader

@RequestHeader 是将请求头信息和控制器方法的形参创建映射关系
@RequestHeader 注解一共有三个属性：value、required、defaultValue，用法同@RequestParam

5.5 @CookieValue

@CookieValue 是将 Cookie 数据和控制器方法的形参创建映射关系
@CookieValue注解一共有三个属性：value、required、defaultValue，用法同@RequestParam

5.6 通过 POJO 获取请求参数

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

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

5.7 @ModelAttribute

@ModelAttribute 注解用于将多个请求参数封装到一个实体对象中，从而简化数据绑定流程，而且自动暴露为模型数据，在视图页面展示时使用
而 “通过实体 Bean 接收请求参数” 中只是将多个请求参数封装到一个实体对象，并不能暴露为模型数据（需要使用 model.addAttribute 语句才能暴露为模型数据）

通过 @ModelAttribute 注解接收请求参数适用于 GET 和 POST 提交请求方式，示例代码如下：

@RequestMapping("/login")
public String login(@ModelAttribute("user") User user, Model model) {
   
    if ("bianchengbang".equals(name)
            && "123456".equals(pwd)) {
     
        model.addAttribute("message", "登录成功");
        return "main"; // 登录成功，跳转到 main.jsp
    } else {
        model.addAttribute("message", "用户名或密码错误");
        return "login";
    }
}

因为模型对象要先于 Controller 方法之前创建，所以被 @ModelAttribute 注解的方法会在 Controller 每个方法执行之前都执行。因此一个 Controller 映射多个 URL 时，要谨慎使用。

5.8 获取请求参数乱码问题

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

<filter>
    <filter-name>CharacterEncoding</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name> // 设置请求编码
      <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
      <param-name>forceResponseEncoding</param-name> // 设置响应编码
      <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>CharacterEncoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

在这里插入图片描述

6. 域共享数据

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

请求域（request scope），仅限于当前请求过程，包括转发（forward）或被包含（include）的情况

@RequestMapping("/testServletAPI")
public String testServletAPI(HttpServletRequest request){
    request.setAttribute("testScope", "hello,servletAPI");
    return "success";
}

6.2 使用 ModelAndView 向 request 域对象共享数据

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

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

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

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

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

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

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

6.6 Model、ModelMap、Map 的关系

Model、ModelMap、Map 类型的参数其实本质上都是 BindingAwareModelMap 类型的

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

6.7 向 session 域共享数据

会话域（session scope），限于当前会话，即当前服务器与客户端连接期间，当关闭浏览器或者退出浏览器时，当前会话则失效

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

6.8 向 application（应用）域共享数据

应用域（application scope），有效于整个服务器启动期间，关闭浏览器或退出都不会失效，在服务器关闭时失效

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

7. 视图（转发与重定向）

SpringMVC 中的视图是 View 接口，视图的作用渲染数据，将模型 Model 中的数据展示给用户
SpringMVC 视图的种类很多，默认有转发视图（forward:）和重定向视图（redirect:）
当工程引入 jstl 的依赖，转发视图会自动转换为 JstlView
若使用的视图技术为 Thymeleaf，在 SpringMVC 的配置文件中配置了 Thymeleaf 的视图解析器，由此视图解析器解析之后所得到的是 ThymeleafView

7.1 ThymeleafView

当控制器方法中所设置的视图名称没有任何前缀时，此时的视图名称会被SpringMVC 配置文件中所配置的视图解析器解析，视图名称拼接视图前缀和视图后缀所得到的最终路径，会通过转发的方式实现跳转。控制器类中处理方法的 return 语句默认就是转发实现，只不过实现的是转发到视图。

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

处理当前结果：
在这里插入图片描述
渲染视图：

获取当前视图：

7.2 转发视图

SpringMVC中默认的转发视图是InternalResourceView

转发过程：
客户浏览器发送 HTTP 请求，Web 服务器接受此请求，调用内部的一个方法在容器内部完成请求处理和转发动作，将目标资源发送给客户。在这里转发的路径必须是同一个 Web 容器下的 URL，其不能转向到其他的 Web 路径上，中间传递的是自己的容器内的 request
SpringMVC 中创建转发视图的情况：
当控制器方法中所设置的视图名称以 "forward:" 为前缀时，创建InternalResourceView 视图，此时的视图名称不会被 SpringMVC 配置文件中所配置的视图解析器解析，而是会将前缀 "forward:" 去掉，剩余部分作为最终路径通过转发的方式实现跳转
浏览器发送一次请求，地址不变，发生在服务器内部，不能跨域

例如："forward:/"，"forward:/employe

@RequestMapping("test")
public String test(){
	return "forward:toSuccess";
}
@RequestMapping("toSuccess")
public String toSuccess(Model model){
	model.addAttribute("test","testModel");
	return "success";
}

7.3 重定向视图

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

重定向过程：
客户浏览器发送 HTTP 请求，Web 服务器接受后发送 302 状态码响应及对应新的 location 给客户浏览器，客户浏览器发现是 302 响应，则自动再发送一个新的 HTTP 请求，请求 URL 是新的 location 地址，服务器根据此请求寻找资源并发送给客户
SpringMVC 中创建重定向视图的情况：
当控制器方法中所设置的视图名称以 "redirect:" 为前缀时，创建 RedirectView 视图，此时的视图名称不会被 SpringMVC 配置文件中所配置的视图解析器解析，而是会将前缀 "redirect:" 去掉，剩余部分作为最终路径通过重定向的方式实现跳转
浏览器发送两次请求，地址改变，WEB-INF目录下内容不能被重定向，具有安全性，可以跨域

例如："redirect:/"，"redirect:/employee"

@RequestMapping("test")
public String test(){
	return "redirect:toSuccess";
}
@RequestMapping("toSuccess")
public String toSuccess(Model model){
	model.addAttribute("test","testModel");
	return "success";
}

在这里插入图片描述

7.4 视图控制器

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

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

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

在 Spring MVC 框架中，不管是重定向或转发，都需要符合视图解析器的配置，如果直接转发到一个不需要 DispatcherServlet 的资源，则需要配置静态资源路径

8. RESTful

8.1 RESTful 简介

REST：Representational State Transfer，表现层资源状态转移

资源****资源是一种看待服务器的方式，即，将服务器看作是由很多离散的资源组成。每个资源是服务器上一个可命名的抽象概念
因为资源是一个抽象的概念，所以它不仅仅能代表服务器文件系统中的一个文件、数据库中的一张表等等具体的东西，可以将资源设计的要多抽象有多抽象，只要想象力允许而且客户端应用开发者能够理解
与面向对象设计类似，资源是以名词为核心来组织的，首先关注的是名词
一个资源可以由一个或多个 URI 来标识。URI 既是资源的名称，也是资源在 Web 上的地址。对某个资源感兴趣的客户端应用，可以通过资源的 URI 与其进行交互
资源的表述****资源的表述是一段对于资源在某个特定时刻的状态的描述，可以在客户端-服务器端之间转移（交换）
资源的表述可以有多种格式，例如 HTML/XML/JSON/纯文本/图片/视频/音频等等。资源的表述格式可以通过协商机制来确定。请求-响应方向的表述通常使用不同的格式
状态转移
状态转移说的是：在客户端和服务器端之间转移（transfer）代表资源状态的表述。通过转移和操作资源的表述，来间接实现操作资源的目的

8.2 RESTful 的实现

具体说，就是 HTTP 协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。分别对应四种基本操作：GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE用来删除资源

REST 风格提倡 URL 地址使用统一的风格设计，从前到后各个单词使用斜杠分开，不使用问号键值对方式携带请求参数，而是将要发送给服务器的数据作为 URL 地址的一部分，以保证整体风格的一致性
在这里插入图片描述

8.3 HiddenHttpMethodFilter

由于浏览器只支持发送 GET 和 POST 方式的请求，SpringMVC 提供了 HiddenHttpMethodFilter 将 POST 请求转换为 DELETE 或 PUT 请求

HiddenHttpMethodFilter 处理 PUT 和 DELETE 请求的条件：

当前请求的请求方式必须为 POST
当前请求必须传输请求参数 _method

满足以上条件，HiddenHttpMethodFilter 过滤器就会将当前请求的请求方式转换为请求参数 _method 的值，因此请求参数 _method 的值才是最终的请求方式

在 web.xml 中注册 HiddenHttpMethodFilte

<filter>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

@RequestMapping(value = "/user", method = RequestMethod.PUT)
public String user(String username, String password){
    System.out.println("username" + username + ",password" + password);
    return "success";
}

<form method="post"> // post 请求
    <input type="hidden" name="_method" value="put"> // 设置_method
 	  email:<input type="text" name="email"><br>
    gender:<input type="radio" name="gender" value="1">male
    <input type="radio" name="gender" value="0">female<br>
    <input type="submit" value="add"><br>
</form>

目前为止，SpringMVC 中提供了两个过滤器：CharacterEncodingFilter 和 HiddenHttpMethodFilter

在 web.xml 中注册时，必须先注册 CharacterEncodingFilter，再注册 HiddenHttpMethodFilter

在 CharacterEncodingFilter 中通过 request.setCharacterEncoding(encoding) 方法设置字符集。request.setCharacterEncoding(encoding) 方法要求前面不能有任何获取请求参数的操作，而 HiddenHttpMethodFilter 恰恰有一个获取请求参数的操作 String paramValue = request.getParameter(this.methodParam);

9. HttpMessageConverter

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

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

9.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=1234

9.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";
}

9.3 @ResponseBody

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

@RequestMapping("/testResponseBody")
@ResponseBody
public String testResponseBody(){
    return "success";
}
// 浏览器页面显示 success

9.4 SpringMVC 处理 JSON

9.4.1 JSON 概述

与 XML 一样，JSON 也是基于纯文本的数据格式。它有对象结构和数组结构两种数据结构

对象结构
对象结构以 {开始、以} 结束，中间部分由 0 个或多个以英文,分隔的 key/value 对构成，key 和 value 之间以英文:分隔。 对象结构的语法结构如下：
```
{
    key1:value1,
    key2:value2,
    ...
}
```
其中，key 必须为 String 类型，value 可以是 String、Number、Object、Array 等数据类型。例如，一个 person 对象包含姓名、密码、年龄等信息，使用 JSON 的表示形式如下：
```
{
    "pname":"张三",
    "password":"123456",
    "page":40
}
```
数组结构
数组结构以 [开始、以] 结束，中间部分由 0 个或多个以英文,分隔的值的列表组成。 数组结构的语法结构如下：
```
[
    value1,
    value2,
    ...
]
```
上述两种（对象、数组）数据结构也可以分别组合构成更加复杂的数据结构。例如，一个 student 对象包含 sno、sname、hobby 和 college 对象，其 JSON 的表示形式如下：
```
{
    "sno":"201802228888",
    "sname":"张三",
    "hobby":["篮球","足球"]，
    "college":{
        "cname":"清华大学",
        "city":"北京"
    }
}
```

9.4.2 @ResponseBody 处理 JSON 的步骤

导入 jackson 的依赖

<!-- 开源的jackson，Spring MVC 内置的 JSON 转换工具 -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.12.4</version>
</dependency>
<!-- fastjson，用 Java 语言编写的高性能 JSON 处理器，由阿里巴巴公司开发。不需要依赖其它的 jar 文件，
就能直接在 JDK 上运行。FastJson 在复杂类型的 Bean 转换 JSON 上会出现一些问题，可能会出现引用的类型，
导致 JSON 转换出错，需要制定引用。-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.62</version>
</dependency>

在SpringMVC的核心配置文件中开启 MVC 的注解驱动，此时在 HandlerAdaptor 中会自动装配一个消息转换器：MappingJackson2HttpMessageConverter，可以将响应到浏览器的 Java 对象转换为 JSON 格式的字符串
```
<mvc:annotation-driven />
```
在处理器方法上使用@ResponseBody注解进行标识
将 Java 对象直接作为控制器方法的返回值返回，就会自动转换为 JSON 格式的字符串

@RequestMapping("/testResponseUser")
@ResponseBody
public User testResponseUser(){
    return new User(1001,"admin","123456",23,"男");
}
// {"id":1001,"username":"admin","password":"123456","age":23,"sex":"男"}

9.5 SpringMVC 处理 ajax

请求超链接：

<div id="app">
    <a th:href="@{/testAjax}" @click="testAjax">testAjax</a><br>
</div>

通过 Vue 和 Axios 处理点击事件：

<script type="text/javascript" th:src="@{/static/js/vue.js}"></script>
<script type="text/javascript" th:src="@{/static/js/axios.min.js}"></script>
<script type="text/javascript">
    var vue = new Vue({
        el:"#app",
        methods:{
            testAjax:function (event) {
                axios({
                    method:"post",
                    url:event.target.href,
                    params:{
                        username:"admin",
                        password:"123456"
                    }
                }).then(function (response) {
                    alert(response.data);
                });
                event.preventDefault();
            }
        }
    });
</script>

控制器方法：

@RequestMapping("/testAjax")
@ResponseBody
public String testAjax(String username, String password){
    System.out.println("username:"+username+",password:"+password);
    return "hello,ajax";
}

9.6 @RestController 注解

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

9.7 ResponseEntity

ResponseEntity 用于控制器方法的返回值类型，该控制器方法的返回值就是响应到浏览器的响应报文

9.8 ResponseEntity 和 ResponseBody 的区别

ResponseEntity 的优先级高于 @ResponseBody
在不是 ResponseEntity 的情况下才去检查有没有 @ResponseBody 注解。如果响应类型是 ResponseEntity 可以不写 @ResponseBody 注解，写了也没有关系。@ResponseBody 可以直接返回 JSON 结果，
ResponseEntity 表示整个 HTTP 响应：状态代码，标题和正文。因此，可以使用它来完全配置 HTTP 响应，它是一个对象。@ResponseEntity 不仅可以返回 JSON 结果，还可以定义返回的 HttpHeaders 和 HttpStatus

10. 文件上传和下载

10.1 文件下载

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

@RequestMapping("/testDown")
public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws IOException {
    //获取ServletContext对象
    ServletContext servletContext = session.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;
}

10.2 文件上传

文件上传要求 Form 表单的请求方式必须为 POST，并且添加属 enctype="multipart/form-data"，SpringMVC 中将上传的文件封装到 MultipartFile 对象中，通过此对象可以获取文件相关信息

添加依赖：

<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
</dependency>

在 SpringMVC 的配置文件中添加配置，文件上传解析器，根据 id 获取，固定值

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

控制器方法：

@RequestMapping("/testUp")
public String testUp(MultipartFile photo, HttpSession session) throws IOException {
    //获取上传的文件的文件名
    String fileName = photo.getOriginalFilename();
    //处理文件重名问题
    String hzName = fileName.substring(fileName.lastIndexOf("."));
     fileName = UUID.randomUUID().toString() + hzName;
    //获取服务器中photo目录的路径
    ServletContext servletContext = session.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” 类型，表单的 enctype 属性指定的是表单数据的编码方式，该属性有以下 3 个值：
- application/x-www-form-urlencoded：这是默认的编码方式，它只处理表单域里的 value 属性值
- multipart/form-data：该编码方式以二进制流的方式来处理表单数据，并将文件域指定文件的内容封装到请求参数里
- text/plain：该编码方式只有当表单的 action 属性为 “mailto：”URL 的形式时才使用，主要适用于直接通过表单发送邮件的方式
```
<form action="${pageContext.request.contextPath }/fileupload" method="post" enctype="multipart/form-data">
        选择文件：<input type="file" name="myfile"><br> 
        文件描述：<input type="text" name="description"><br> 
        <input type="submit" value="提交">
</form>
```

11. 拦截器、异常处理器

11.1 拦截器的配置

SpringMVC 中的拦截器用于拦截控制器方法的执行
SpringMVC 中的拦截器需要实现 HandlerInterceptor
- 通过实现 HandlerInterceptor 接口或继承 HandlerInterceptor 接口的实现类（例如 HandlerInterceptorAdapter）来定义
- 通过实现 WebRequestInterceptor 接口或继承 WebRequestInterceptor 接口的实现类来定义

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

<mvc:interceptors>
	<bean class="fan.FirstInterceptor"></bean>
	<ref bean="firstInterceptor"></ref>
<!-- 以上两种配置方式都是对 DispatcherServlet 所处理的所有的请求进行拦截 -->
    <mvc:interceptor>
    	<!-- 配置拦截器作用的路径 /* 表示一层目录，/** 表示拦截所有请求 -->
        <mvc:mapping path="/**"/>
        <!-- 配置不需要拦截作用的路径 -->
        <mvc:exclude-mapping path="/testRequestEntity"/>
        <!-- 定义 <mvc:interceptor> 元素中，表示匹配指定路径的请求才进行拦截 -->
        <ref bean="firstInterceptor"></ref>
    </mvc:interceptor>
</mvc:interceptors>
<!-- 
    以上配置方式可以通过 ref 或 bean 标签设置拦截器，通过 mvc:mapping 设置需要拦截的请求，
    通过 mvc:exclude-mapping 设置需要排除的请求，即不需要拦截的请求
-->

<mvc:interceptor> 元素的子元素必须按照 <mvc:mapping.../>、<mvc:exclude-mapping.../>、<bean.../> 的顺序配置

11.2 拦截器的三个抽象方法

SpringMVC 中的拦截器有三个抽象方法：

preHandle： 控制器方法执行之前执行 preHandle()，其 boolean 类型的返回值表示是否拦截或放行，返回 true 为放行，即调用控制器方法；返回 false 表示拦截，即不调用控制器方法
postHandle： 控制器方法执行之后执行 postHandle()
afterComplation： 处理完视图和模型数据，渲染视图完毕之后执行 afterComplation()

在这里插入图片描述

public class FirstInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle...");
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle...");
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion...");
    }
}

11.3 多个拦截器的执行顺序

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

在这里插入图片描述

11.4 基于配置的异常处理

SpringMVC 提供了一个处理控制器方法执行过程中所出现的异常的接口：HandlerExceptionResolver
HandlerExceptionResolver 接口的实现类有：DefaultHandlerExceptionResolver 默认异常处理器和 SimpleMappingExceptionResolver 简单异常处理器
SpringMVC 提供了自定义的异常处理器 SimpleMappingExceptionResolver

<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <property name="exceptionMappings">
        <props>
            <!--
                properties的键表示处理器方法执行过程中出现的异常
                properties的值表示若出现指定异常时，设置一个新的视图名称，跳转到指定页面
            -->
            <prop key="java.lang.ArithmeticException">error</prop>
        </props>
    </property>
    <!--
        exceptionAttribute属性设置一个属性名，将出现的异常信息在请求域中进行共享
    -->
    <property name="exceptionAttribute" value="ex"></property>
</bean>

11.5 基于注解的异常处理

//@ControllerAdvice将当前类标识为异常处理的组件
@ControllerAdvice
public class ExceptionController {
    //@ExceptionHandler用于设置所标识方法处理的异常
    @ExceptionHandler(value = {ArithmeticException.class, NullPointerException.class})
    //ex表示当前请求处理中出现的异常对象
    public String testException(Exception ex, Model model){
        model.addAttribute("ex", ex);
        return "error";
    }
}

12. 注解配置 SpringMVC

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

12.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};
    }
}

10.2 创建 SpringConfig 配置类，代替 Spring 的配置文件

@Configuration
public class SpringConfig {
    // ssm整合之后，Spring 的配置信息写在此类中
}

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

@Configuration
//扫描组件
@ComponentScan("fan.com.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<HandlerExceptionResolver> 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;
    }
}

posted @ 2022-12-21 13:52 凡223 阅读(10) 评论(0) 编辑收藏举报

刷新页面返回顶部

fan223

SpringMVC 总结

1. 配置

1.1 MVC 概念

1.2 SpringMVC 概念

1.3 SpringMVC的特点

1.4 配置 web.xml

1.5 配置 springmvc-config.xml

1.6 控制器

1.7 Thymeleaf 页面

1.8 工作流程小结

2. 视图解析器 ViewResolver

2.1 URLBasedViewResolver

2.2 InternalResourceViewResolver

2.3 FreeMarkerViewResolver

3.Spring MVC 执行流程

3.1 Spring MVC 常用组件

3.1.1 前端控制器 DispatcherServlet

3.1.2 处理器映射器 HandlerMapping

3.1.3 处理器适配器 HandlerAdapter

3.1.4 处理器 Handler

3.1.5 视图解析器 View Resolver

3.1.6 视图 View

3.2 DispatcherServlet 初始化过程

3.3 SpringMVC 的执行流程

4. RequestMapping 注解

4.1 @RequestMapping 注解的功能

4.2 @RequestMapping 注解的位置

4.3 value 属性

4.4 path 属性

4.5 name 属性

4.6 method 属性

4.7 params 属性

4.8 headers 属性

4.9 consumers 属性

4.10 produces 属性

4.11 SpringMVC支持ant风格的路径

4.12 SpringMVC 支持路径中的占位符

5. SpringMVC 获取请求参数

5.1 原生 ServletAPI 获取

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

5.3 @RequestParam

5.4 @RequestHeader

5.5 @CookieValue

5.6 通过 POJO 获取请求参数

5.7 @ModelAttribute

5.8 获取请求参数乱码问题

6. 域共享数据

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

6.2 使用 ModelAndView 向 request 域对象共享数据

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

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

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

6.6 Model、ModelMap、Map 的关系

6.7 向 session 域共享数据

6.8 向 application（应用）域共享数据

7. 视图（转发与重定向）

7.1 ThymeleafView

7.2 转发视图

7.3 重定向视图

7.4 视图控制器

8. RESTful

8.1 RESTful 简介

8.2 RESTful 的实现

8.3 HiddenHttpMethodFilter

9. HttpMessageConverter

9.1 @RequestBody

9.2 RequestEntity

9.3 @ResponseBody

9.4 SpringMVC 处理 JSON

9.4.1 JSON 概述

9.4.2 @ResponseBody 处理 JSON 的步骤

9.5 SpringMVC 处理 ajax

9.6 @RestController 注解

9.7 ResponseEntity

9.8 ResponseEntity 和 ResponseBody 的区别

10. 文件上传和下载

10.1 文件下载

10.2 文件上传

11. 拦截器、异常处理器