SpringMVC

README

一、目录

0、简介

1、@RequestMapping 注解

2、获取请求参数

3、域对象共享数据

4、视图

5、RESTful

6、HttpMessageConverter

7、拦截器和异常处理

8、完全注解开发

9、执行流程

二、配置文件

1、pom.xml

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.16</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.11</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>org.thymeleaf</groupId>
    <artifactId>thymeleaf-spring5</artifactId>
    <version>3.0.15.RELEASE</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.2</version>
</dependency>
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.4</version>
</dependency>

2、web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!--处理编码-->
    <filter>
        <filter-name>characterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!--配置 org.springframework.web.filter.HiddenHttpMethodFilter: 可以把 POST 请求转为 DELETE 或 POST 请求 -->
    <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: 表示从类路径查找配置文件，java 工程默认 src 下, Maven 工程默认 src/main/resources 下-->
            <param-value>classpath:springMVC.xml</param-value>
        </init-param>
        <!--
            作为框架的核心组件，在启动过程中有大量的初始化操作要做
            而这些操作放在第一次请求时才执行会严重影响访问速度
            将前端控制器 DispatcherServlet 的初始化时间提前到服务启动时
        -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <!--
            设置 SpringMVC 的核心控制器所能处理的请求的请求路径
            / 所匹配的请求可以是 /login 或 .html 或 .js 或 .css 方式的请求路径
            但是 / 不能匹配 .jsp 请求路径的请求
        -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

3、springMVC.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

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

    <!--配置Thymeleaf视图解析器-->
    <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
        <property name="order" value="1"/>
        <property name="characterEncoding" value="UTF-8"/>
        <property name="templateEngine">
            <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
                <property name="templateResolver">
                    <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
                        <!--视图前缀-->
                        <property name="prefix" value="/WEB-INF/templates/"/>
                        <!--视图后缀-->
                        <property name="suffix" value=".html"/>
                        <property name="templateMode" value="HTML5"/>
                        <property name="characterEncoding" value="UTF-8"/>
                    </bean>
                </property>
            </bean>
        </property>
    </bean>
    <!--InternalResourceViewResolver-->
    <!--<bean id="InternalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">-->
    <!--    <property name="prefix" value="/WEB-INF/templates/"/>-->
    <!--    <property name="suffix" value=".jsp"/>-->
    <!--</bean>-->

    <!--视图控制器：当前请求映射对应的控制器方法中没有其他请求过程的处理，只需设置一个视图名称时，就可以使用`view-controller`-->
    <mvc:view-controller path="/" view-name="index"></mvc:view-controller>
    <!--处理静态资源-->
    <mvc:default-servlet-handler/>
    <!--开启 MVC 的注解驱动-->
    <mvc:annotation-driven/>
    <!--配置文件上传解析器，将上传文件自动封装为MutilpartFile对象-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>

    <!--自定义拦截器-->
    <!--方式一-->
    <!--<mvc:interceptors>-->
    <!--    <bean id="myInterceptor" class="com.vectorx.springmvc.s00_helloworld.interceptor.MyInterceptor"></bean>-->
    <!--</mvc:interceptors>-->
    <!--方式二-->
    <!--<mvc:interceptors>-->
    <!--    <ref bean="myInterceptor"></ref>-->
    <!--</mvc:interceptors>-->
    <!--<mvc:interceptors>-->
    <!--    <ref bean="myInterceptor"></ref>-->
    <!--    <ref bean="myInterceptor2"></ref>-->
    <!--</mvc:interceptors>-->
    <!--方式三-->
    <!--<mvc:interceptors>-->
    <!--    <mvc:interceptor>-->
    <!--        <mvc:mapping path="/**"/>-->
    <!--        <mvc:exclude-mapping path="/"/>-->
    <!--        <ref bean="myInterceptor"></ref>-->
    <!--    </mvc:interceptor>-->
    <!--</mvc:interceptors>-->

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

三、完全注解开发

WebInit——web.xml

/**
 * web工程的初始化类，代替web.xml
 */
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};
    }

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

    /**
     * 注册过滤器
     *
     * @return
     */
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        characterEncodingFilter.setForceResponseEncoding(true);
        HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
        return new Filter[]{characterEncodingFilter, hiddenHttpMethodFilter};
    }
}

WebConfig——springMVC.xml

/**
 * SpringMVC的配置类清单
 * 1、扫描组件
 * 2、视图解析器
 * 3、view-controller
 * 4、default-servlet-handler
 * 5、MVC注解驱动
 * 6、文件上传解析器
 * 7、拦截器
 * 8、异常处理解析器
 */
@Configuration
// ========== 1、扫描组件 ==========
@ComponentScan("com.vectorx.springmvc.controller")
// ========== 5、MVC注解驱动 ==========
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    // ========== 2、视图解析器 ==========
    /**
     * 生成模板解析器
     *
     * @return
     */
    @Bean
    public ITemplateResolver templateResolver() {
        SpringResourceTemplateResolver templateResolver = new SpringResourceTemplateResolver();
        templateResolver.setPrefix("/WEB-INF/templates/");
        templateResolver.setSuffix(".html");
        templateResolver.setTemplateMode(TemplateMode.HTML);
        templateResolver.setCharacterEncoding("UTF-8");
        return templateResolver;
    }

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

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

    // ========== 3、view-controller ==========
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("index");
    }

    // ========== 4、default-servlet-handler ==========
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    // ========== 6、文件上传解析器 ==========
    @Bean
    public MultipartResolver multipartResolver() {
        MultipartResolver multipartResolver = new CommonsMultipartResolver();
        return multipartResolver;
    }

    // ========== 7、拦截器 ==========
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TestInterceptor()).addPathPatterns("/**");
    }

    // ========== 8、异常处理解析器 ==========
    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
        Properties properties = new Properties();
        properties.setProperty(ArithmeticException.class.getCanonicalName(), "error");
        exceptionResolver.setExceptionMappings(properties);
        exceptionResolver.setExceptionAttribute("ex");
        resolvers.add(exceptionResolver);
    }
}

01、SpringMVC简介

1、课程介绍

2、什么是 MVC？

MVC 是一种软件架构思想，将软件分为模型、视图、控制器三部分

  • M（Model，模型层）：处理数据的 JavaBean 类

  • 实体类 Bean：存储业务数据

  • 业务处理 Bean：Service 或 Dao，处理业务逻辑和数据访问

  • V（View，视图层）：展示数据的 HTML 页面，与用户进行交互

  • C（Controller，控制层）：接受请求和响应的 Servlet

MVC 工作流程

  1. 用户通过视图层发送请求到服务器，在服务器中请求被Controller 接收

  2. Controller 调用相应的 Model 层处理请求

  3. Model 层处理完毕将结果返回到 Controller

  4. Controller 再根据请求处理的结果找到相应的 View 视图

  5. View 视图渲染数据后最终响应给浏览器

3、什么是 SpringMVC？

SpringMVC 是 Spring 的一个后续产品，是Spring的一个子项目

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

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

4、SpringMVC 的特点

  • Spring 家族原生产品：与 IOC 容器等基础设施无缝对接

  • 基于原生的 Servlet：通过了功能强大的前端控制器 DispatcherServlet，对请求和响应进行统一处理

  • 全面解决方案：表述层各细分领域需要解决的问题全方位覆盖

  • 代码清新简洁：大幅度提升开发效率

  • 即插即用：内部组件化程度高，组件可插拨，想要什么功能配置相应组件即可

  • 性能卓著：尤其适合现代大型、超大型互联网项目要求

5、HelloWorld

5.1、开发环境

  • IDE：idea 2021.1

  • 构建工具：maven-3.8.3

  • 服务器：tomcat7

  • Spring版本：5.3.16

5.2、创建 Maven 工程

1）新建工程，默认 NEXT

2）填写工程名称、保存为止和 GAV 坐标，点击 FINISH

3）pom.xml中添加并导入依赖

<dependencies>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.16</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/ch.qos.logback/logback-classic -->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.11</version>
        <scope>test</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
        <scope>provided</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.thymeleaf/thymeleaf-spring5 -->
    <dependency>
        <groupId>org.thymeleaf</groupId>
        <artifactId>thymeleaf-spring5</artifactId>
        <version>3.0.15.RELEASE</version>
    </dependency>
</dependencies>

根据依赖的传递性，相关的依赖也会被导入

4）项目工程结构中添加 web 模块，注意web.xml的路径要放在src\main\webapp下

完成后的目录结构

5.3、配置 web.xml

为什么要配置web.xml？注册 SpringMVC 的前端控制器 DispatcherServlet

1）默认配置方式

此配置作用下，SpringMVC 的配置文件默认位于 WEB-INF 下，默认名称为<servlet-name>-servlet.xml

例如，以下配置所对应 SpringMVC 的配置文件位于 WEB-INF 下，文件名为springMVC-servlet.xml

<!--配置 SpringMVC 的前端控制器，对浏览器发送的请求统一进行处理-->
<servlet>
    <servlet-name>springMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>springMVC</servlet-name>
    <!--
      设置 SpringMVC 的核心控制器所能处理的请求的请求路径
      / 所匹配的请求可以是 /login 或 .html 或 .js 或 .css 方式的请求路径
      但是 / 不能匹配 .jsp 请求路径的请求
    -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

默认配置方式对位置和名称都是默认的，这样并不好！Maven 工程配置文件应该统一放置在resources下，应该如何来实现呢？来看下面的“扩展配置方式”

2）扩展配置方式

  • 通过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: 表示从类路径查找配置文件，java 工程默认src下,maven 工程默认 src/main/resources 下-->
        <param-value>classpath:springMVC.xml</param-value>
    </init-param>
    <!--
        作为框架的核心组件，在启动过程中有大量的初始化操作要做
        而这些操作放在第一次请求时才执行会严重影响访问速度
        将前端控制器 DispatcherServlet 的初始化时间提前到服务启动时
    -->
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>springMVC</servlet-name>
    <!--
        设置 SpringMVC 的核心控制器所能处理的请求的请求路径
        / 所匹配的请求可以是 /login 或 .html 或 .js 或 .css 方式的请求路径
        但是 / 不能匹配 .jsp 请求路径的请求
    -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

注：<url-pattern>标签中使用/和/*的区别：

/所匹配的请求可以是/login或.html或.js或.css方式的请求路径，但是/不能匹配.jsp请求路径的请求

因此就可以避免在访问.jsp页面时，该请求被 DispatcherServlet 处理，从而找不到相应的页面的情况

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

5.4、创建请求控制器

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

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

因为 SpringMVC 的控制器由一个 POJO（普通 Java 类）担任，因此需要通过@Controller注解将其标识为一个控制层组件，交给 Spring 的 IOC 容器管理，此时 SpringMVC 才能够识别控制器的存在

@Controller
public class HelloController {
}

5.5、创建 SpringMVC 配置文件

<!--自动扫描包-->
<context:component-scan base-package="com.vectorx.springmvc"></context:component-scan>
<!--配置Thymeleaf视图解析器-->
<bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
    <property name="order" value="1"/>
    <property name="characterEncoding" value="UTF-8"/>
    <property name="templateEngine">
        <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
            <property name="templateResolver">
                <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
                    <!--视图前缀-->
                    <property name="prefix" value="/WEB-INF/templates/"/>
                    <!--视图后缀-->
                    <property name="suffix" value=".html"/>
                    <property name="templateMode" value="HTML5"/>
                    <property name="characterEncoding" value="UTF-8"/>
                </bean>
            </property>
        </bean>
    </property>
</bean>

5.6、测试

1）访问首页

创建首页index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>
<h1>首页</h1>
</body>
</html>

在请求控制器中创建处理请求的方法

//@RequestMapping 注解：处理请求和控制器方法之间的映射关系
//@RequestMapping 注解的 value 属性可以通过请求地址匹配请求，/ 表示的当前工程的上下文路径
// localhost：8080/springMVC/
@RequestMapping("/")
public String index() {
    //返回视图名称
    return "index";
}

访问首页

2）访问指定页面

在主页index.html创建超链接

<a href="/target">访问指定页面target.html</a>

但是这种写法是不行的，可以看到，当鼠标悬浮在超链接上时，左下角的跳转路径提示信息从 8080 下访问的

这是因为我们是以/开头的，它分为浏览器解析和服务器解析两种方式，而超链接中的绝对路径就是由浏览器解析的，而不是从上下文路径访问

虽然我们可以通过添加上下文的方式实现，因为上下文路径可以改，所以这种方式肯定是杜绝的

<a href="/SpringMVC/target">访问指定页面target.html</a>

那应该如何处理呢？这里就可以使用thymeleaf来动态获取上下文路径

  • 首先需要在<html>标签中引入thymeleaf的命名空间xmlns:th="http://www.thymeleaf.org"

  • 然后使用th:前缀修饰标签属性，这里使用th:href来修饰<a>标签的<href>属性

  • 最后th:href中的属性值中包裹一层@{}，这里值为@{/target.html}

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

同时，后台请求控制器也要加上对target请求进行处理的控制器方法

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

访问指定页面

跳转成功

6、SpringMVC 请求处理底层原理

  • 浏览器发送请求，若请求地址符合前端控制器的url-pattern，该请求就会被前端控制器 DispatcherServlet 处理

  • 前端控制器会读取 SpringMVC 的核心配置文件，通过扫描组件找到控制器，将请求地址和控制器中@RequestMapping注解的value属性值进行匹配。若匹配成功，该注解所标识的控制器方法就是处理请求的方法

  • 处理请求的方法需要返回一个字符串类型的视图名称，该视图名称会被视图解析器解析，加上前缀和后缀组成视图的路径，通过 Thymeleaf 对视图进行渲染，最终转发到视图所对应页面

附录：SpringMVC 工程创建整体流程

概览

  • 1）配置pom.xml、web.xml、springMVC.xml

  • 2）创建前台页面和后台请求控制器

详解

1）添加pom.xml依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.vectorx</groupId>
    <artifactId>springmvc-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.16</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.11</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring5</artifactId>
            <version>3.0.15.RELEASE</version>
        </dependency>
    </dependencies>
</project>

2）创建web.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springMVC.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

3）创建springMVC.xml配置文件

<context:component-scan base-package="com.vectorx.springmvc"></context:component-scan>
<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>

4）创建前台页面

index.html

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

target.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>HelloWorld</title>
</head>
<body>
<h1>Hello World!</h1>
</body>
</html>

5）创建Controller请求控制器

@Controller
public class HelloController {
    @RequestMapping("/")
    public String index() {
        //返回视图名称
        return "index";
    }
    @RequestMapping("/target")
    public String toTarget() {
        return "target";
    }
}

总结

最后奉上本节导图，内容仅供参考

02、@RequestMapping 注解

1、功能

从注解名称上我们可以看到，@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来，建立映射关系

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

控制器中有多个方法对应同一个请求的情况

这是一种特殊情况，我们定义至少两个控制类，其中定义的控制器方法上@ReqeustMapping指定同一请求路径

@Controller
public class HelloController {
    @RequestMapping("/")
    public String index() {
        return "index";
    }
}
@Controller
public class RequestMappingController {
    @RequestMapping("/")
    public String index() {
        return "target";
    }
}

如果存在两个或多个控制器，其控制器方法的@RequestMapping一致，即多个控制器方法试图都想要处理同一个请求时，这时启动 Tomcat 时会抛出BeanCreationException异常，并指明There is already 'helloController' bean method即 helloController 中存在处理同意请求的控制器方法

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping': Invocation of init method failed; nested exception is java.lang.IllegalStateException: Ambiguous mapping. Cannot map 'requestMappingController' method 
com.vectorx.springmvc.s00_helloworld.RequestMappingController#index()
to { [/]}: There is already 'helloController' bean method
com.vectorx.springmvc.s00_helloworld.HelloController#index() mapped.

但是这显然是不合理的，当一个系统方法很多，很难完全避免两个或多个同名方法的存在，那该怎么办呢？

2、位置

查看@RequestMapping注解的源码，可以清楚地看到@Target中有TYPE和METHOD两个属性值，表示其可以作用在类或方法上

也就是说@RequestMapping不仅可以在控制器方法上进行使用，也可以在控制器类上进行使用。那两种方式有什么区别呢？

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

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

@Controller
@RequestMapping("/requestMappingController")
public class RequestMappingController {
    @RequestMapping("/success")
    public String success() {
        return "success";
    }
}

前台创建超链接，超链接跳转路径 = 控制器上@RequestMapping映射请求的初始路径 + 控制器方法上@RequestMapping映射请求的具体路径，即/requestMappingController/success，再将其使用Tymeleaf的@{}语法包裹起来，这样Tymeleaf会为我们自动加上上下文路径

<a th:href="@{/requestMappingController/success}">访问指定页面success.html</a>

测试结果

这样就可以为不同的控制器方法，在设置映射请求的请求路径时，指定不同的初始信息，从而避免控制器中有多个方法对应同一个请求的情况，这也就解决了之前的问题

3、value 属性

@RequestMapping注解的value属性有哪些用途呢？

  • 请求映射：通过请求的请求地址匹配请求映射

  • 匹配多个请求：是一个字符串类型的数组，表示该请求映射能够匹配多个请求地址所对应的

  • 必须设置：至少通过一个请求地址匹配请求映射

匹配多个请求

查看@RequestMapping注解的源码，会发现其value属性返回值为 String 类型的数组，这也说明了之所以@RequestMapping注解的value属性可以匹配多个请求的原因。通过为value属性指定多个值的方式，就可以对个多个请求建立请求映射

在控制器方法上的@RequestMapping中新增一个/test请求映射

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

前台创建一个/test的请求路径的超链接，以便进行测试

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

测试结果

这样，同一个控制器方法就可以实现对多个请求进行统一处理

4、method 属性

@RequestMapping注解的method属性有哪些用途呢？

  • 通过请求的请求方式（GET或POST）匹配请求映射

1、常用的请求方式有 4 种：GET、POST、PUT、DELETE

  • GET 用于查询数据

  • POST 用于添加数据

  • PUT 用于更新数据

  • DELETE 用户删除数据

但是很多情况下，习惯上会让 POST 承担更多的职责，即通过 POST 进行增、删、改的操作，可以说是“一个人揽了三个人的活”

2、还有 4 种不常用的请求：HEAD、PATCH、OPTIONS、TRACE

  • HEAD 获取响应的报头，检查超链接的有效性、网页是否被修改，多用于自动搜索机器人获取网页的标志信息，获取 rss 种子信息，或者传递安全认证信息等

  • PATCH 用于更新数据

  • OPTIONS 用于测试服务器，解决同源策略和跨域请求问题

  • TRACE 用于测试或诊断

有的资料还会介绍 CONNECT 请求，好像用于 HTTP 代理的，很少人听过，当然用的更少（我也是刚知道，有懂的求科普）

  • 是一个RequestMethod类型的数组，表示该请求映射能够匹配多种请求方式的请求

源码为证：RequestMethod[] method() default {};

同时注意到method属性默认值为空数组，是否说明控制器方法不添加method属性时，不同的请求方法都能够匹配呢？

1）无 method 时匹配哪些请求方式？

通过测试验证猜想

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

测试结果：事实证明，控制器方法不添加method属性时，可以接收GET和POST的请求，那么应该是默认不对请求方式限制了

本着严谨的态度，再测试下是否在不添加method属性时，默认也支持PUT和DELETE请求

不过，PUT和DELETE请求比较特殊，需要使用到隐藏域，且method固定为POST

<form th:action="@{/requestMappingController/test}" method="post">
    <input type="hidden" name="_method" value="put"/>
    <input type="submit" value="测试RequestMapping注解的method属性-->PUT">
</form>
<br/>
<form th:action="@{/requestMappingController/test}" method="post">
    <input type="hidden" name="_method" value="delete"/>
    <input type="submit" value="测试RequestMapping注解的method属性-->DELETE">
</form>

同时在web.xml中需要添加隐藏域请求方式的过滤器配置

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

测试结果也是成功的

存疑点：本来也想测试下HEAD、PTACH、OPTIONS和TRACE这几种不常用的请求方式的，但是发现 form 表单好像不支持这些请求方式。即使使用隐藏域，也会变成GET的请求方式。很疑惑这些请求方式要怎么模拟，有懂的求科普。这里记录下，留个印象，以待后续考古o(╯□╰)o

2）不满足 method 会怎样？

值得注意的是

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

HTTP Status 405 - Request method 'POST' not supported

代码验证

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

验证结果：确实报了 405。同理可以将method属性值中GET改成POST、PUT和DELETE对应进行验证即可，这里就不一一验证了

虽然无关紧要，但就是好奇为嘛我的是中文提示(灬°ω°灬)

发现这个版本 tomcat 的 lib 包中有 i18n 相关 jar 包，原来是做了国际化，“不一定有用”的知识又增加了~

3）派生注解

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

  • 处理GET请求的映射->@GetMapping

  • 处理POST请求的映射->@PostMapping

  • 处理PUT请求的映射->@PutMapping

  • 处理DELETE请求的映射->@DeleteMapping

这里对于派生注解很容易理解，用数学上的等价解释就是

通过代码进行测试

后台代码

@Controller
@RequestMapping("/requestMappingController")
public class RequestMappingController {
    @GetMapping("/success")
    public String successGet() {
        return "successget";
    }
    @PostMapping("/success")
    public String successPost() {
        return "successpost";
    }
    @PutMapping("/success")
    public String successPut() {
        return "successput";
    }
    @DeleteMapping("/success")
    public String successDelete() {
        return "successdelete";
    }
}

前台代码

<a th:href="@{/requestMappingController/success}">测试GetMapping</a>
<br/><br/>
<form th:action="@{/requestMappingController/success}" method="post">
    <input type="submit" value="测试PostMapping">
</form>
<br/>
<form th:action="@{/requestMappingController/success}" method="post">
    <input type="hidden" name="_method" value="put"/>
    <input type="submit" value="测试PutMapping">
</form>
<br/>
<form th:action="@{/requestMappingController/success}" method="post">
    <input type="hidden" name="_method" value="delete"/>
    <input type="submit" value="测试DeleteMapping">
</form>

别忘了，新增四个测试页面successget.html、successpost.html、successput.html和successdelete.html，在这个四个不同页面中标注不同的内容以示区分

验证结果：可以看到，GET/POST/PUT/DELETE等请求方式，均能够被正常接收和处理

4）form 表单支持哪些请求方式？

  • 常用的请求方式有GET，POST，PUT，DELETE，但是目前浏览器只支持GET和POST（OS：刚才还有点疑惑的，这里好像“水落石出了”）

  • 若在 form 表单提交时，为method设置了其他请求方式的字符串（PUT或DELETE），则按照默认的GET请求方式处理

  • 若要发送PUT和DELETE请求，则需要通过 Spring 提供的过滤器HiddenHttpMethodFilter，在 restful 部分会讲到（OS：我上面刚自己研究了下，没想到老师这里会讲^_^）

如果去除过滤器HiddenHttpMethodFilter的配置，同时注释掉隐藏域的代码，并将method为post值改成put和delete

<form th:action="@{/requestMappingController/success}" method="put">
    <!--    <input type="hidden" name="_method" value="put"/>-->
    <input type="submit" value="测试PutMapping">
</form>
<br/>
<form th:action="@{/requestMappingController/success}" method="delete">
    <!--    <input type="hidden" name="_method" value="delete"/>-->
    <input type="submit" value="测试DeleteMapping">
</form>

按照上述的说法，会按照默认的GET请求方式处理，这里进行验证

可以发现，本应走PUT和DELETE方式的请求，都被GET请求方式的控制器方法处理了。如果这里控制器中连相应GET请求方式都没有定义的话，肯定是报 405 了。这里注释掉@GetMapping的请求方法

//@GetMapping("/success")
//public String successGet() {
//    return "successget";
//}

验证结果：显而易见

5、params 属性

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

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

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

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

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

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

若当前请求满足@RequestMapping注解的value和method属性，但是不满足params属性，此时页面显示400错误，即请求不匹配

1）param

这里指定params的值指定为username，这就要求请求中必须携带username的请求参数

@RequestMapping(
    value = {"/testParams"},
    params = {"username"}
)
public String testParams() {
    return "success";
}

前台测试代码：分别不加请求参数和加上请求参数，进行测试

<a th:href="@{/requestMappingController/testParams}">测试RequestMapping注解的params属性==>testParams</a><br/>
<a th:href="@{/requestMappingController/testParams?username=admin}">测试RequestMapping注解的params属性==>testParams?username=admin</a>

测试结果

可以发现，当配置了params属性并指定相应的请求参数时，请求中必须要携带相应的请求参数信息，否则前台就会报抛出400的错误信息，符合预期

HTTP Status 400：Parameter conditions "username" not met for actual request parameters

不过在Tymeleaf中使用问号的方式会有错误提示，虽然不影响功能，但不想要错误提示的话，最好通过(...,...)的方式进行包裹，多个参数间通过,隔开

<a th:href="@{/requestMappingController/testParams(username='admin', password=123456)}">测试RequestMapping注解的params属性==>testParams(username='admin', password=123456)</a><br/>

测试验证

可以发现，通过括号包裹的方式，Tymeleaf最终会帮我们将其解析成?username=admin&password=123456的格式

存疑点：实测发现，``testParams(username='admin', password=123456)改成testParams(username=admin, password=123456)，即admin`不加单引号也是可以的，这与课堂上所讲的并不一致，此点存疑

2）!param

这里将params = {"username"}中username前加上!即可，即params = {"!username"}，这就要求请求中的请求参数中不能携带username请求参数

@RequestMapping(
    value = {"/testParams"},
    params = {"!username"}
)
public String testParams() {
    return "success";
}

测试结果

可以发现，没有携带username请求参数的请求变得能够正常访问，而携带了username请求参数的请求反而出现了400的异常信息，符合预期

HTTP Status 400：Parameter conditions "!username" not met for actual request parameters: username={admin}, password={123456}

3）param=value

这里params的值指定为username=admin的形式，即要求请求中不仅要携带username的请求参数，且值为admin

@RequestMapping(
    value = {"/testParams"},
    params = {"username=admin"}
)
public String testParams() {
    return "success";
}

测试结果

可以发现，不携带username请求参数的请求和携带username请求参数但不为admin的请求，均提示400的请求错误，符合预期

4）param!=value

这里将params的值指定为username!=admin，即要求请求中不仅要携带username的请求参数，且值不能为admin

@RequestMapping(
    value = {"/testParams"},
    params = {"username!=admin"}
)
public String testParams() {
    return "success";
}

测试结果

实际测试结果发现：不携带username请求参数的请求和携带username请求参数但值不为admin的请求，可以正常访问；而携带username请求参数但值为admin的请求，不能正常访问，不完全符合预期

存疑点：不携带username请求参数的请求能够正常访问，这一点不符合课程中讲解的内容，此点存疑

6、headers 属性

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

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

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

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

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

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

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

测试代码

@RequestMapping(
    value = {"/testHeaders"},
    headers = {"Host=localhost:8081"}
)
public String testHeaders() {
    return "success";
}

测试结果

因为我本地tomcat启动端口是8080，所以是匹配不成功的，此时显示404错误，符合预期

再将端口号修改为8080

@RequestMapping(
    value = {"/testHeaders"},
    headers = {"Host=localhost:8080"}
)
public String testHeaders() {
    return "success";
}

测试结果

这一次，因为端口号一致，所以成功跳转，符合预期

7、Ant 风格路径

  • ?：表示任意的单个字符

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

  • **：表示任意的一层或多层目录。注意：在使用**时，只能使用/**/xxx的方式

探子来报：**经实测，0 层目录也可以，这里严谨来说，应该是“表示任意层目录”

1）?

后台测试代码

//ant风格路径
@RequestMapping("/a?a/testAnt")
public String testAnt() {
    return "success";
}

前台测试代码

Ant风格路径——?：<br/>
<a th:href="@{/requestMappingController/testAnt}">测试ant风格路径_/a?a/testAnt==>/testAnt</a><br/>
<a th:href="@{/requestMappingController/a1a/testAnt}">测试ant风格路径_/a?a/testAnt==>/a1a/testAnt</a><br/>
<a th:href="@{/requestMappingController/aaa/testAnt}">测试ant风格路径_/a?a/testAnt==>/aaa/testAnt</a><br/>
<a th:href="@{/requestMappingController/aaaa/testAnt}">测试ant风格路径_/a?a/testAnt==>/aaaa/testAnt</a><br/>
<a th:href="@{/requestMappingController/a/a/testAnt}">测试ant风格路径_/a?a/testAnt==>/a/a/testAnt</a><br/>
<a th:href="@{/requestMappingController/a?a/testAnt}">测试ant风格路径_/a?a/testAnt==>/a?a/testAnt</a><br/>

测试结果

可以发现，/a?a/testAnt能够匹配的路径有

  • /a1a/testAnt

  • /aaa/testAnt

不能匹配的路径有

  • /testAnt

  • /aaaa/testAnt

  • /a/a/testAnt

  • /a?a/testAnt

即证明，?修饰的路径，有且必须有一个字符代替?的位置，即只能匹配单个字符，且不能为/和?这两种特殊字符（因为/和?在 url 路径中比较特殊，除此之外其他单个字符均可），符合预期

2）*

后台测试代码

//ant风格路径
@RequestMapping("/a*a/testAnt")
public String testAnt() {
    return "success";
}

前台测试代码

Ant风格路径——*：<br/>
<a th:href="@{/requestMappingController/aa/testAnt}">测试ant风格路径_/a*a/testAnt==>/aa/testAnt</a><br/>
<a th:href="@{/requestMappingController/a1a/testAnt}">测试ant风格路径_/a*a/testAnt==>/a1a/testAnt</a><br/>
<a th:href="@{/requestMappingController/aaaaa/testAnt}">测试ant风格路径_/a*a/testAnt==>/aaaaa/testAnt</a><br/>

测试结果

可以发现，/a*a/testAnt能够匹配的路径有

  • /aa/testAnt

  • /a1a/testAnt

  • /aaaaa/testAnt

即证明，*修饰的路径，允许 0 个或多个字符代替*的位置，符合预期

3）**

上面说到，在使用**时，只能使用/**/xxx的方式，这里对其进行验证

后台测试代码

//ant风格路径
@RequestMapping("/a**a/testAnt")
public String testAnt() {
    return "success";
}

前台测试代码

Ant风格路径——**：<br/>
<a th:href="@{/requestMappingController/aa/testAnt}">测试ant风格路径_/a**a/testAnt==>/aa/testAnt</a><br/>
<a th:href="@{/requestMappingController/a1a/testAnt}">测试ant风格路径_/a**a/testAnt==>/a1a/testAnt</a><br/>
<a th:href="@{/requestMappingController/a1a/testAnt}">测试ant风格路径_/a**a/testAnt==>/a11a/testAnt</a><br/>
<a th:href="@{/requestMappingController/a**a/testAnt}">测试ant风格路径_/a**a/testAnt==>/a**a/testAnt</a><br/>
<a th:href="@{/requestMappingController/aaaaa/testAnt}">测试ant风格路径_/a**a/testAnt==>/aaaaa/testAnt</a><br/>
<a th:href="@{/requestMappingController/a/a/testAnt}">测试ant风格路径_/a**a/testAnt==>/a/a/testAnt</a><br/>
<a th:href="@{/requestMappingController/a/d/e/a/testAnt}">测试ant风格路径_/a**a/testAnt==>/a/d/e/a/testAnt</a><br/>

测试结果

可以发现，/a**a/testAnt能够匹配的路径有

  • /aa/testAnt

  • /a1a/testAnt

  • /a11a/testAnt

  • /a**a/testAnt

  • /aaaaa/testAnt

不能匹配的路径有

  • /a/a/testAnt

  • /a/d/e/a/testAnt

不符合预期

存疑点：这里/a**a/多层路径不能匹配，而 0 个或多个字符能够匹配，这与课程中的“两颗星真的就是两颗星”不符，其匹配规则与/a*a/一致，即/a**a/ <==> /a*a/，两颗星与一颗星作用相同，此点存疑

上述只是对**的错误用法时的匹配规则，下面才是真正对**的正确用法验证，请看

后台测试代码

//ant风格路径
@RequestMapping("/**/testAnt")
public String testAnt() {
    return "success";
}

前台测试代码

Ant风格路径——**：<br/>
<a th:href="@{/requestMappingController/testAnt}">测试ant风格路径_/a**a/testAnt==>/testAnt</a><br/>
<a th:href="@{/requestMappingController/a/testAnt}">测试ant风格路径_/a**a/testAnt==>/a/testAnt</a><br/>
<a th:href="@{/requestMappingController/a/a/a/a/testAnt}">测试ant风格路径_/a**a/testAnt==>/a/a/a/a/testAnt</a><br/>

测试结果

可以发现，不管中间添加多少层路径都是能够匹配成功的，符合预期

8、路径中的占位符

  • 原始方式：/deleteUser？id=1

  • rest 方式：/deleteuser/11

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

无注解形参

  • 测试条件：①只使用{xxx}占位符而不使用@PathVariable注解；②形参名称与请求中的占位符名称同名

  • 测试目的：①请求能否匹配成功；②同名形参是否能够接收到请求路径中的占位符

后台测试代码

@RequestMapping("/testRest/{id}/{username}")
public String testRest(String id, String username) {
    System.out.println("id=" + id + ", username=" + username);
    return "success";
}

前台测试代码

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

测试结果

后台日志

id=null, username=null

可以发现，请求能够匹配成功，但是同名形参无法接收到占位符的值

带注解形参

查看PathVariable注解源码

可以看到，它只能作用在方法参数上，那么怎么用就一目了然了

后台测试代码

@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

可以发现，请求能够匹配成功，形参通过@PathVariable注解接收到了占位符的值

不设置占位符

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

测试结果

可以看到，没有占位符时，直接显示了404错误，即表示路径中存在占位符的控制器方法不能匹配未设置占位符的请求

也就是说，路径中存在占位符的控制器方法，只能接收带了对应占位符的请求

占位符为空值或空格

<a th:href="@{/requestMappingController/testRest///}">测试路径中的占位符_空值==>/testRest///</a><br/>
<a th:href="@{/requestMappingController/testRest/ / /}">测试路径中的占位符_空格==>/testRest/ / /</a><br/>

测试结果

同时占位符为空格的情况是，后台打印了日志：id= , username=

可以看到，

  • 空值匹配失败，报了404错误

  • 空格匹配成功，路劲中对其解析成了对应的URL编码，即%20

小结

由以上情况测试结果可以得出

  • SpringMVC 支持路径中含有占位符的形式

  • 占位符只能通过@PathVariable注解获取（就目前所学知识而言）

  • 占位符可以匹配特殊字符——空格，但不能匹配空字符

总结

@RequestMapping注解

  • 功能：将请求和处理请求的控制器方法关联起来，建立映射关系

  • 位置：作用在类上（请求路径的初始信息）；作用在方法上（请求路径的具体信息）

  • value属性：可以匹配多个请求路径，匹配失败报404

  • method属性：支持GET、POST、PUT、DELETE，默认不限制，匹配失败报405

  • params属性：四种方式，param、!param、param==value、param!=value，匹配失败报400

  • headers属性：四种方式，header、!header、header==value、header!=value，匹配失败报400

  • 支持 Ant 风格路径：?（单个字符）、*（0 或多个字符）和**（0 或多层路径）

  • 支持路径中的占位符：{xxx}占位符、@PathVariable赋值形参

以下导图仅供参考

03、SpringMVC 获取请求参数

1、通过 Servlet API 获取

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

后台测试代码

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

前台测试代码

<a th:href="@{/paramController/testServletAPI(username='admin',password='123456')}">通过 Servlet API 获取</a><br/>

测试结果

后台日志信息

username=admin,password=123456

Q：为何将HttpServletRequest request传入 testServletAPI() 方法中就可以使用？

A：SpringMVC 的 IOC 容器帮我们注入了HttpServletRequest请求对象，同时DispatherServlet为我们调用 testServletAPI() 方法时自动给request参数赋了值，因此可以在方法形参位置传入请求对象HttpServletRequest就可以直接使用其getParameter()方法获取参数

尽管上述 Servlet API 原生方式可以获取请求参数，但是这样做就没有必要了。因为 SpringMVC 中帮我们封装好了更加便捷的方式获取请求参数

2、通过控制器方法形参获取

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

注意：在@RequestMapping注解的“路径中的占位符”一节中，我们测试过了 restful 风格在不使用@PathVariable转而通过同名形参的方式，试图获取占位符的值，不过 SpringMVC 并没有很智能地给我们为同名参数赋值。但是这里 SpringMVC 允许我们使用同名形参为请求参数赋值。这是占位符和请求参数的一个区别，需要注意区分！！！

2.1、同名形参

后台测试代码

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

前台测试代码

<a th:href="@{/paramController/testParam(username='admin',password='123456')}">通过控制器方法形参获取</a><br/>

测试结果

后台日志信息

username=admin,password=123456

2.2、同名形参多值

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

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

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

当某个请求参数有多个值时，比如前台含有复选框的情况，还能否使用这种方式呢？“实践出真知”，现在就进行测试

后台测试代码

@RequestMapping("/testParam2")
public String testParam2(String username, String password, String hobby) {
    System.out.println("username=" + username + ", password=" + password + ", hobby=" + hobby);
    return "success";
}

前台测试代码

<!--为了更直观地在地址栏中看到请求参数，这里使用get类型请求方式-->
<form th:action="@{paramController/testParam2}" method="get">
    用户名：<input type="text" name="username"><br/>
    密码：<input type="password" name="password"><br/>
    爱好：<input type="checkbox" name="hobby" value="Spring">Spring
    <input type="checkbox" name="hobby" value="SpringMVC">SpringMVC
    <input type="checkbox" name="hobby" value="SpringBoot">SpringBoot
    <br/><input type="submit" value="测试请求参数">
</form>

测试结果

前台请求路径中复选框的值为hobby=Spring&hobby=SpringMVC&hobby=SpringBoot，即出现了多个hobby=value的情况

后台日志信息

username=hah, password=111111, hobby=Spring,SpringMVC,SpringBoot

可见 SpringMVC 的控制器方法，对多个hobby值使用了,进行拼接并赋值给同名形参

扩展：如果这里使用 Servlet API 进行获取请求参数，就不能使用getParameter()方法获取 hobby 值了，而要使用getParameterValues()方法

后台代码测试

后台日志信息：通过getParameter()只能获取到 hobby 的第一个值，而getParameterValues()可以以数组的形式返回 hobby 的所有值

当然还是那句话：不建议在 SpringMVC 中使用原生 Servlet API 方法！！！这里稍作回顾和了解即可

@RequestMapping("/testServletAPI2")
public String testServletAPI2(HttpServletRequest request) {
 String hobby = request.getParameter("hobby");
 String[] hobby2 = request.getParameterValues("hobby");
 System.out.println("hobby=" + hobby + ", hobby2=" + Arrays.toString(hobby2));
 return "success";
}
username=sdfg, password=sdfg, hobby=Spring, hobby2=[Spring, SpringMVC, SpringBoot]

另外，控制器方法中使用String类型的数组接收 hobby 值也是可以的

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

后台日志信息

username=aaaaaaaaa, password=aaaaaaaa, hobby=[Spring, SpringMVC, SpringBoot]

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所指定的请求参数没有传输或传输的值为空值时，则使用默认值为形参赋值

实际开发中，请求参数与控制器方法形参未必一致，一旦出现这种情况，还能否接收到请求参数了呢？

这里简单地将前台name="username"改为name="user_name"进行测试，看下后台日志信息，果然没有接收到 user_name 这个请求参数

username=null, password=aaaaaaaa, hobby=[Spring, SpringMVC, SpringBoot]

扩展思考：这里也侧面证明一件事，SpringMVC 中对请求参数的赋值是根据是否同名来决定的，而不会根据参数在方法上的第几个位置决定，也就是说 SpringMVC 没有考虑将请求参数个数、类型与顺序与控制器方法形参个数、类型与顺序进行绑定。如果我们来设计 SpringMVC，应该考虑这种方案么？

个人觉得，这种方案虽然可以实现与 Java 重载方法的一一绑定关系，但实际操作起来有一定难度：

  • 比如数字类型可以当作 String 处理，也可以当作 Integer 处理，不好区分

  • 退一步来讲，如果考虑重载方法，SpringMVC 底层势必要对类中所有重载方法进行循环，判断是否满足个数、类型和顺序的要求，性能上一定有所影响

而限制请求路径和请求方式不能完全相同的话，就没有这种苦恼了。即使是重载方法，通过不同请求路径或请求方法来界定到底访问哪个方法就可以了

SpringMVC 借助注解的方式，将请求参数与控制器方法形参关系绑定的决定权，交到开发者的手中。这种开发思维启发我们，如果有些功能不能很好地在底层进行实现，甚至可能会留下很多隐患时，还不如交给实际使用者，由他们去决定，否则很容易被使用者诟病（没有，我没有暗示某语言啊(●'◡'●)）

此时使用@RequestParam注解就可以实现请求参数与控制器方法形参的绑定

后台测试代码

@RequestMapping("/testParam3")
public String testParam3(@RequestParam("user_name") String username, String password, String[] hobby) {
    System.out.println("username=" + username + ", password=" + password + ", hobby=" + Arrays.toString(hobby));
    return "success";
}

后台日志信息

username=ss, password=aaaaa, hobby=[Spring, SpringMVC, SpringBoot]

关于@RequestParam怎么使用，可以看下源码

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestParam {
    @AliasFor("name")
    String value() default "";

    @AliasFor("value")
    String name() default "";

    boolean required() default true;

    String defaultValue() default ValueConstants.DEFAULT_NONE;
}

  • name和value：绑定的请求参数名，互为别名，用哪个都一样

  • required属性：默认为true，表示必须要有此参数，不传则报错；不确定是否传参又不想报错，赋值为false即可

  • defaultValue属性：不管required是true还是false，只要请求参数值为空（""或null），就为形参附上此值

3.1、required

required默认为true，即要求该请求参数不能为空。因为是默认值，所以添加required="true"与不写required属性是一样的

这里先测试下默认情况下不传对应请求参数时系统的反应如何，只需要将user_name一行注释即可，或直接在浏览器地址栏删除该请求参数也一样

测试结果

报错信息：400错误的请求，必须的请求参数'user_name'...不存在

HTTP Status 400 - Required request parameter 'user_name' for method parameter type String is not present

经测试，不论是为 username 传空值还是不传值，都是400错误

/testParam3?user_name=&password=11&hobby=Spring&hobby=SpringMVC
/testParam3?password=11&hobby=Spring&hobby=SpringMVC

如果将required设置为false，还会报错吗？

后台测试代码：只需要对@RequestParam("user_name")稍作改动，修改为@RequestParam(value = "user_name", required = false)即可

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

测试结果：可以发现，这次并没有报400错误

后台日志信息

username=null, password=1111, hobby=[Spring, SpringMVC]

这是不传 user_name 的情况，如果是传空值呢？

测试结果：同样访问成功，没有报400错误

后台日志信息

username=, password=111, hobby=[Spring, SpringMVC]

Q：不是说默认是true吗？为什么在没有使用@RequestParam注解时，也能正常访问呢？

A：这个默认值本身就是在使用@RequestParam注解时生效的，如果都没有使用到@RequestParam，就没有相应限制了

3.2、defaultValue

后台测试代码

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

请求路径：传空值和不传值两种情况

/testParam3?user_name=&password=asdf&hobby=Spring&hobby=SpringMVC
/testParam3?password=asdf&hobby=Spring&hobby=SpringMVC

后台日志信息

username=heh, password=asdf, hobby=[Spring, SpringMVC]

可以发现，不管是为 username 传空值还是不传值，最终都会被赋上默认值

这里将required修改为true，即默认值的情况，发现也是可以请求成功的

注意：required一节测试中，在required的默认值情况下，没有为请求参数赋值传值或传空值，会产生400的错误。

而只要为请求参数设置默认值，即使用@RequestParam注解的defaultValue属性赋上值，就不会有400错误了。

换句话说，只要设置了defaultValue属性值，required属性就失效形同虚设了

4、@RequestHeader

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

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

因为@RequestHeader与@RequestParam别无二致，所以这里我们简单测试下效果

后台测试代码

@RequestMapping("/testHeader")
public String testHeader(
    @RequestHeader(value = "Host") String host,
    @RequestHeader(value = "Test", required = false, defaultValue = "RequestHeader") String test) {
    System.out.println("Host=" + host + ", test=" + test);
    return "success";
}

请求路径

http://localhost:8080/SpringMVC/paramController/testParam4

后台日志信息

Host=localhost:8080, test=RequestHeader

5、@CookieValue

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

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

注意：

  • 在JSP中，Session依赖于Cookie，Session是服务器端的会话技术，Cookie是客户端的会话技术。

  • 会话技术默认的生命周期是浏览器开启和浏览器关闭，只要浏览器不关闭，Cookie将一直存在。

  • 调用getSession()方法时，首先会检测请求报文中是否有携带JSESSIONID的Cookie。如果没有，说明当前会话是第一次创建Session对象，则

  • 在服务端创建一个Cookie，以键值对形式存储。键是固定的JSESSIONID，值是一个 UUID 随机序列

  • 在服务端创建一个HttpSession对象，并放在服务器所维护的 Map 集合中。Map 的键是JSESSIONID的值，值就是HttpSession对象

  • 最后把Cookie相应给浏览器客户端，此时JSESSIONID的Cookie存在于响应报文中。每次浏览器向服务器发送请求都会携带Cookie，此后JSESSIONID的Cookie将存在于请求报文中

为了能获取到Cookie值，需要先调用下getSession()方法。我们直接在之前的 testServletAPI() 方法中稍作修改

@RequestMapping("/testServletAPI")
public String testServletAPI(HttpServletRequest request) {
    HttpSession session = request.getSession();
    // ...
}

首次发送请求后，F12 查看前台该请求的响应报文信息

会发现在Set-Cookie属性中存在JSESSIONID=xxx的信息

Set-Cookie: JSESSIONID=C3DFF845C38BF655C02DDA0BD2DD5638; Path=/SpringMVC; HttpOnly

后面每次发送请求，JSESSIONID的Cookie将会放在请求报文信息

会发现在Cookie属性中存在JSESSIONID=xxx的信息

Cookie: JSESSIONID=C3DFF845C38BF655C02DDA0BD2DD5638

经过上面的折腾，我们产生了Cookie数据，现在我们就可以使用@CookieValue注解进行操作了。正片开始~

后台测试代码

@RequestMapping("/testCookie")
public String testCookie(
    @CookieValue(value = "JSESSIONID") String jSessionId,
    @CookieValue(value = "Test", required = false, defaultValue = "CookieValue") String test) {
    System.out.println("jSessionId=" + jSessionId + ", test=" + test);
    return "success";
}

前台请求报文信息

后台日志信息

jSessionId=C3DFF845C38BF655C02DDA0BD2DD5638, test=CookieValue

6、通过实体类获取

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

前台测试代码

<form th:action="@{/paramController/testBean}" method="post">
    用户名：<input type="text" name="username"><br/>
    密码：<input type="password" name="password"><br/>
    性别：<input type="radio" name="gender" value="男人">男
    <input type="radio" name="gender" value="女人">女<br/>
    年龄：<input type="text" name="age"><br/>
    邮箱：<input type="text" name="email"><br/>
    <input type="submit" value="测试请求参数">
</form>

后台测试代码

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

User 类：要求属性名与请求参数名一致

public class User {
    private String username;
    private String password;
    private String gender;
    private String age;
    private String email;
    // Setter、Getter方法略

    @Override
    public String toString() {
        return "User{" +"username='" + username + '\'' + ", password='" + password + '\'' + ", gender='" + gender + '\'' +", age='" + age + '\'' + ", email='" + email + '\'' +'}';
    }
}

测试结果

后台日志信息

User{username='aa', password='11', gender='女人', age='12', email='123@qq.com'}
User{username='aa', password='11', gender='男人', age='12', email='123@qq.com'}

貌似基本成功了，但却出现了乱码的情况，什么原因呢？

7、处理乱码问题

注意：在 Servlet 阶段，是通过request.setCharacterEncoding("UTF-8");的方式解决乱码问题的。虽然 SpringMVC 中可以使用HttpServletRequest对象，但是没有效果。原因也很简单，是因为请求参数获取在前，设置编码格式在后

事实胜于雄辩，简单测试下

后台测试代码

@RequestMapping("/testServletAPI3")
public String testServletAPI3(HttpServletRequest request) throws UnsupportedEncodingException {
    request.setCharacterEncoding("UTF-8");
    String username = request.getParameter("username");
    System.out.println("username=" + username);
    return "success";
}

前台测试代码

<form th:action="@{/paramController/testServletAPI3}" method="post">
    用户名：<input type="text" name="username"><br/>
    <input type="submit" value="测试请求参数">
</form>

后台日志信息

username=张三

可能你会说，上面的测试都是post请求，如果是get请求呢？问得好，下次不要问了

<a th:href="@{/paramController/testServletAPI3(username='张三')}">通过setCharacterEncoding设置编码</a><br/>

后台日志信息

username=张三

Q：这是为什么呢？怎么get请求还搞特殊？

A：这是因为 Tomcat 的 conf 目录下的 server.xml中配置了URIEncoding="UTF-8"的原因。这样get请求的乱码问题就可以一次性解决了

如果一开始就没有配置，那get请求也会乱码，所以拜托不是get请求搞特殊了喂！

Q：既然在server.xml配置下编码格式就行了，为什么只支持get请求啊？还说不是搞特殊？

A：...你赢了

Q：退一步来说，post请求能不能在请求参数获取之后再去处理也可以吧，只要知道其本身的编码

A：试一下咯

<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" URIEncoding="UTF-8"/>

我们先通过 在线乱码恢复 看下，乱码的文本实际编码是什么

很显然，乱码本身为ISO-8859-1格式，我们转换为UTF-8编码格式即可

后台测试代码

// 对其进行iso-8859-1解码并重新UTF-8编码
username = new String(username.getBytes("ISO-8859-1"), "UTF-8");
System.out.println("username=" + username);

后台日志信息

username=张三

有上述测试可知，要想处理乱码问题，思路有二：

  1. 获取请求参数之后，手动解码编码。但是这种方式要求每次处理post请求的请求参数都要手动处理，太不人性化了吧。你嫌烦，我还嫌烦呢（❌）

  2. 获取请求参数之前“做手脚”：发送请求之前，也就是在Servlet处理请求之前（👌）

那什么组件时在Servlet之前执行的呢？

众所周知 （我不知道），JavaWeb 服务器中三大组件：监听器、过滤器、Servlet。很显然，监听器和过滤器都在Servlet之前

  • ServletContextListener监听器：只是来监听ServletContext的创建和销毁，都是只执行一次

  • Filter过滤器：只要设置了过滤路径，只要当前所访问的请求地址满足过滤路径，那么都会被过滤器过滤

很显然，用过滤器就可以做到在发送请求之前“做手脚”，这样所有请求都要经过过滤器的处理，再交给DispatherServlet处理

但是，这个过滤不需要我们写，SpringMVC 已为我们准备好了，只要再web.xml中进行配置即可

我们先对web.xml进行配置

<!--处理编码-->
<filter>
    <filter-name>characterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
        <param-name>forceResponseEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

重启后测试，看下后台日志信息

username=张三

Perfect! 配置很简单，测试结果立竿见影，乱码问题得到了解决

“知其然，知其所以然”

这个神奇的CharacterEncodingFilter到底干了什么？我们一起来看下源码一探究竟

我们知道，在<init-param>标签中配置的属性值，其实就是为对应类进行的属性注入。这里可以很清楚地看到encoding和forceResponseEncoding两个属性值，同时注意到encoding被@Nullable注解修饰，表示其可以为空，forceResponseEncoding默认为false，即不配置不生效

另外，看一个Filter最重要的找它的doFilter()方法

可以看到，CharacterEncodingFilter类中并没有doFilter()方法，那去它的基类中找找吧~

直接读源码

@Override
public final void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
    throws ServletException, IOException {
    // 就是判断是不是http请求和相应，不管
    if (!(request instanceof HttpServletRequest) || !(response instanceof HttpServletResponse)) {
        throw new ServletException("OncePerRequestFilter just supports HTTP requests");
    }
    // 拿到一些了对象和参数，继续往下看看有什么用处
    HttpServletRequest httpRequest = (HttpServletRequest) request;
    HttpServletResponse httpResponse = (HttpServletResponse) response;
    String alreadyFilteredAttributeName = getAlreadyFilteredAttributeName();
    boolean hasAlreadyFilteredAttribute = request.getAttribute(alreadyFilteredAttributeName) != null;
    // 三个条件判断，一一看下
    // 1、跳过转发或不过滤的，就直接进行过滤链的下一个请求（确信）
    if (skipDispatch(httpRequest) || shouldNotFilter(httpRequest)) {
        filterChain.doFilter(request, response);
    }
    // 2、已经过滤属性的，多了一层判断，貌似时处理错误转发的？（不太懂）
    else if (hasAlreadyFilteredAttribute) {
        if (DispatcherType.ERROR.equals(request.getDispatcherType())) {
            doFilterNestedErrorDispatch(httpRequest, httpResponse, filterChain);
            return;
        }
        filterChain.doFilter(request, response);
    }
    // 3、其他情况（应该就是正常情况吧）：设置下属性，再走 doFilterInternal 方法（还有印象吗？这个方法我们在其子类CharacterEncodingFilter中看到过的，那就顺藤摸瓜）
    else {
        request.setAttribute(alreadyFilteredAttributeName, Boolean.TRUE);
        try {
            doFilterInternal(httpRequest, httpResponse, filterChain);
        }
        finally {
            request.removeAttribute(alreadyFilteredAttributeName);
        }
    }
}

回到CharacterEncodingFilter中看下doFilterInternal()方法

@Override
protected void doFilterInternal(
    HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
    throws ServletException, IOException {
    // 获取编码格式，很明显就是获取web.xml中的配置值了（确信）
    String encoding = getEncoding();
    if (encoding != null) {
        // 二选一：配置了forceRequestEncoding为true或者请求的字符编码没有被设置，就给请求对象设置编码格式
        if (isForceRequestEncoding() || request.getCharacterEncoding() == null) {
            request.setCharacterEncoding(encoding);
        }
        // 配置了forceResponseEncoding为true，就给响应对象设置编码格式
        if (isForceResponseEncoding()) {
            response.setCharacterEncoding(encoding);
        }
    }
    filterChain.doFilter(request, response);
}

可以看出

  • 没有在web.xml设置编码格式就不管了，爱咋咋地

  • 设置了encoding就看下是请求对象还是响应对象

  • 请求对象：如果打开了forceRequestEncoding即强制请求编码开关，就给设置下编码；就算没打开这个开关，只要请求对象还没有设置过字符编码格式，那就给它设置下

  • 响应对象：只有打开了forceResponseEncoding即强制响应编码开关，才给设置编码

总结

获取请求的方式有两种：

  • 通过 Servlet API 获取（不推荐）

  • 通过控制器方法获取（就是要用它，不然学 SpringMVC 干什么，不是）

SpringMVC 获取请求参数的注解：@RequestParam、@RequestHeader、@CookieValue

  • 都是作用在控制器方法上的形参的（就是获取请求参数的，还能作用在别的地方？）

  • 都有三个属性：value/name、required、defaultValue（这不是四个吗？呸）

  • 主要解决形参和请求参数名不同名的问题，其次是必填问题，最后是缺省值的问题（顺序确定对吗？别误人子弟了，不是，我错了）

如果请求参数与控制器方法形参同名，就可以不用上述的@RequestParam注解

如果请求参数有多个值，通过字符串类型或字符数组类型都可以获取

如果请求参数与控制器方法形参对象属性同名，同理。即满足同名条件时，SpringMVC 中允许通过实体类接收请求参数

Q：那请求头和Cookie呢，同名也可以不加注解么？

A：大哥，这刚开始我是没想到的，不过我又回头试了下，确信不可以！

最后附上导图，仅供参考

04、域对象共享数据

1、三种域对象

  • Request：一次请求

  • Session：一次会话。从浏览器开启到浏览器关闭（只跟浏览器是否关闭有关，与服务器是否关闭无关）

  • 钝化：浏览器未关闭而服务器关闭，Session数据序列化到磁盘上

  • 活化：浏览器仍然关闭而服务器开启，将钝化内容读取到Session中

  • Application/Servlet Context：上下文对象，整个应用范围。服务器开启时创建，服务器关闭时销毁，从头到尾只创建一次（只跟服务器是否关闭有关，与浏览器是否关闭无关）

选择域对象时，应该选择能实现功能、范围最小的域对象

2、向 request 域对象共享数据

2.1、通过 Servlet API

后台测试代码

@RequestMapping("/testRequestByServletAPI")
public String testRequestByServletAPI(HttpServletRequest request) {
    request.setAttribute("testRequestScope", "hello, Servlet API!");
    return "successrequest";
}

前台测试代码

index.html

<a th:href="@{/scopeController/testRequestByServletAPI}">通过Servlet API</a>

successrequest.html

<p th:text="${testRequestScope}"></p>

测试结果

可以发现，转发的页面中成功获取到了在后台通过Request对象向request域中设置的属性值并正确展示

2.2、通过 ModelAndView

食用方式：在 SpringMVC 中，不管用的何种方式，本质上最后都会封装到ModelAndView。同时要注意使用ModelAndView向 request 域对象共享数据时，需要返回ModelAndView自身

后台测试代码

@RequestMapping("/testRequestByModelAndView")
public ModelAndView testRequestByModelAndView() {
    /**
     * ModelAndView有Model和View两个功能
     * Model用于向请求域共享数据
     * View用于设置视图，实现页面跳转
     */
    ModelAndView mv = new ModelAndView();
    //向请求域共享数据
    mv.addObject("testRequestScope", "hello, ModelAndView!");
    //设置视图，实现页面跳转
    mv.setViewName("successrequest");
    return mv;
}

前台测试代码

<a th:href="@{/scopeController/testRequestByModelAndView}">通过 ModelAndView</a><br/>

测试结果

2.3、通过 Model

食用方式：形式与HttpServletRequest类似

后台测试代码

@RequestMapping("/testRequestByModel")
public String testRequestByModel(Model model) {
    //向请求域共享数据
    model.addAttribute("testRequestScope", "hello, ModelAndView!");
    return "successrequest";
}

前台测试代码

<a th:href="@{/scopeController/testRequestByModel}">通过 Model</a><br/>

测试结果

2.4、通过 Map

食用方式：形式与Model方式类似

后台测试代码

@RequestMapping("/testRequestByMap")
public String testRequestByMap(Map<String, Object> map) {
    //向请求域共享数据
    map.put("testRequestScope", "hello, Map!");
    return "successrequest";
}

前台测试代码

<a th:href="@{/scopeController/testRequestByMap}">通过 Map</a><br/>

测试结果

2.5、通过 ModelMap

食用方式：形式与Model方式类似

后台测试代码

@RequestMapping("/testRequestByModelMap")
public String testRequestByModelMap(ModelMap modelMap) {
    //向请求域共享数据
    modelMap.addAttribute("testRequestScope", "hello, ModelMap!");
    return "successrequest";
}

前台测试代码

<a th:href="@{/scopeController/testRequestByModelMap}">通过 ModelMap</a><br/>

测试结果

2.6、Model、ModelMap 和 Map

分别在上述对应的控制器方法中，添加打印 Model、ModelMap 和 Map 三个对象及其对应类名的逻辑

System.out.println(model + "======" + model.getClass().getName());
System.out.println(map + "======" + map.getClass().getName());
System.out.println(modelMap + "======" + modelMap.getClass().getName());

通过分别点击前台超链接，并查看后台日志信息

{testRequestScope=hello, Model!}======org.springframework.validation.support.BindingAwareModelMap
{testRequestScope=hello, Map!}======org.springframework.validation.support.BindingAwareModelMap
{testRequestScope=hello, ModelMap!}======org.springframework.validation.support.BindingAwareModelMap

可以发现

  • Model、ModelMap 和 Map 三个对象输入格式是一致的，都为键值对形式

  • 通过反射方法获取到的类都是同一个，即BindingAwareModelMap

查看BindingAwareModelMap的继承关系

阅读源码，梳理出Model、Map、ModelMap三者的核心继承关系

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

可以发现

  • BindingAwareModelMap继承ModelMap并实现Model接口

  • ModelMap继承LinkedHashMap，而毫无疑问LinkedHashMap实现了Map接口

Model、Map和ModelMap三者的关系到此就一目了然了，其 UML 类图如下：

结论：Model、Map、ModelMap类型的形参本质上都是BindingAwareModelMap

3、向 session 域共享数据

食用方式：形式与HttpServletRequest方式类似，形参为HttpSession。需要注意的是 SpringMVC 虽然提供了一个@SessionAttribute注解，但并不好用，因此反而建议直接使用原生 Servlet 中的HttpSession对象

后台测试代码

@RequestMapping("/testSession")
public String testSession(HttpSession session) {
    //向session域共享数据
    session.setAttribute("testSessionScope", "hello, HttpSession!");
    return "successsession";
}

前台测试代码

index.html

<a th:href="@{/scopeController/testSession}">通过 Servlet API 向 Session 域对象共享数据</a><br/>

successsession.html

<p th:text="${session.testSessionScope}"></p>

测试结果

4、向 application 域共享数据

食用方式：形式与HttpSession方式类似，只不过需要先从session对象中获取ServletContext上下文对象，即application域对象，再做操作

后台测试代码

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

前台测试代码

index.html

<a th:href="@{/scopeController/testApplication}">通过 Servlet API 向 Application 域对象共享数据</a><br/>

successapplication.html

<p th:text="${application.testApplicationScope}"></p>

测试结果

总结

域对象有三种：request（请求域）、session（会话域）和application（上下文）

向request域对象共享数据方式：本质都是ModelAndView

  • Servlet API（不推荐）：HttpServletRequest

  • ModelAndView：需要返回自身

  • Model、Map、ModelMap：本质都是BindingAwareModelMap

向session域共享数据：HttpSession

向application域共享数据：ServletContext

附上导图，仅供参考

05、SpringMVC 视图

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

SpringMVC 视图的种类很多，默认有转发视图InternalResourceView和重定向视图RedirectView

当工程引入jstl的依赖，转发视图会自动转换为JstlView（JSP 内容了解即可）

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

注意：只有在视图名称没有任何前缀时，视图被Thymeleaf视图解析器解析之后，创建的才是ThymeleafView。当视图名称包含前缀（如forward:或redirect:）时，分别对应的时InternalResourceView转发视图和RedirectView重定向视图

1、ThymeleafView

当控制器方法中所设置的视图名称没有任何前缀时，此时的视图名称会被 SpringMVC 配置文件中所配置的视图解析器解析，视图名称拼接视图前缀和视图后缀所得到的最终路径，会通过转发的方式实现跳转

后台测试代码

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

前台测试代码

<a th:href="@{/viewController/testThymeleaftView}">测试 ThymeleaftView</a><br/>

断点调试，查看创建的View视图对象为ThymeleafView对象

2、转发视图

SpringMVC 中默认的转发视图是InternalResourceView

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

例如：forward:/、forward:/viewController/testThymeleaftView

后台测试代码

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

前台测试代码

<a th:href="@{/viewController/testForward}">测试 InternalResourceView</a><br/>

断点调试，查看创建的View视图对象为InternalResourceView对象

3、重定向视图

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

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

例如：forward:/、forward:/viewController/testThymeleaftView

后台测试代码

@RequestMapping("/testRedirect")
public String testRedirect() {
    return "redirect:/viewController/testThymeleaftView";
}

前台测试代码

<a th:href="@{/viewController/testRedirect}">测试 RedirectView</a><br/>

断点调试，查看创建的View视图对象为RedirectView对象

4、转发和重定向

转发和重定向的区别

  • 1）转发对于浏览器来说只发送一次请求（另一次请求实际上在服务器内部发生，只是客户端中看不到而已）；重定向对于浏览器来说发送两次请求（不管是转发还是重定向，在服务器中其实都是两次请求）

  • 2）转发在浏览器地址栏中呈现的是发送请求时的地址；重定向在浏览器地址栏中呈现的是重定向后的地址

  • 3）转发时request域对象为同一个；重定向时request域对象不是同一个

  • 4）转发可以访问WEB-INF下资源；重定向不能访问WEB-INF下资源（因为WEB-INF下资源具有安全性、隐藏性，只能通过服务器内部访问，不能通过服务器外部访问）

  • 5）转发不可以跨域；重定向可以跨域（因为转发是在服务器内部发生的，所以只能访问服务器内部资源；而重定向是浏览器发送的两次请求，可以访问任意资源。如可以重定向到某度，但不能转发到某度）

以表格方式来对比转发和重定向

页面跳转方式 转发 重定向
请求次数（对浏览器而言） 1️⃣ 2️⃣
浏览器地址栏地址 请求地址 重定向地址
request 域对象是否同一个 ✔️ ❌
是否可访问 WEB-INF 下资源 ✔️ ❌
是否可跨域 ❌ ✔️

5、视图控制器 view-controller

当前请求映射对应的控制器方法中，仅仅用来实现页面跳转，而没有其他请求过程的处理，即只需设置一个视图名称时，就可以将控制器方法使用view-controller标签进行表示

例如：我们在HelloController中配置的一个控制器方法，对应view请求，返回view视图

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

此时通过在SpringmMVC 配置文件中添加<mvc:view-controller>标签，就可以代替上述控制器方法（将上述方法注释即可）

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

其中

  • path对应控制器方法上@RequestMapping中路径

  • view-name对应控制器方法返回的视图名称

此时再来访问/view，同样会被Thymeleaf视图解析器解析，拼接上视图前缀和视图后缀后，找到对应路径下的view.html页面

注意：在 SpringMVC 配置文件中配置了view-controller之后，控制器中所有的请求映射都会失效

测试结果

怎么解决这个问题呢？我们需要在 SpringMVC 配置文件中开启 MVC 的注解驱动

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

测试结果

额外的：MVC 的注解驱动功能很多，例如

1、如果加上了默认的 Servlet 处理静态资源（如 JS、CSS 等），控制器请求映射会失效，这时需要配置 MVC 的注解驱动

2、JAVA 对象转换为 JSON 对象，同样需要配置 MVC 的注解驱动

因为使用场景很多，所以一般情况下 MVC 注解驱动默认是需要配置的。但是注意，需要了解在不同情况下 MVC 注解驱动的功能是什么

6、InternalResourceViewResolver

因为这里是使用JSP作为对InternalResourceViewResolver视图解析器的讲解，所以仅做了解即可

SpringMVC 配置文件：这里使用InternalResourceViewResolver代替ThymeleafViewResolver

<bean id="InternalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/templates/"/>
    <property name="suffix" value=".jsp"/>
</bean>

后台测试代码

@Controller
public class JspController {
    @RequestMapping("/success")
    public String success() {
        return "success";
    }
}

前台测试代码

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Jsp</title>
    </head>
    <body>
        <a href="${pageContext.request.contextPath}/success">success.jsp</a>
    </body>
</html>

success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Success</title>
    </head>
    <body>
        <h1>Success</h1>
    </body>
</html>

测试结果

总结

本节内容较少，主要掌握

  • SpringMVC 中默认的视图：InternalResourceView、RedirectView

  • 使用forward:前缀：InternalResourceView视图

  • 使用redirect:前缀：RedirectView视图

  • Thymeleaf对应ThymeleafView视图（无任何前缀时），jstl对应JstlView

  • 注意转发和重定向的区别：请求次数、浏览器地址栏地址、request域对象、访问WEB-INF下资源、跨域等方面

  • InternalResourceViewResolver视图解析器的使用

附上导图，仅供参考

06、RESTful

1、RESTful 简介

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

  • 表现层/表示层：前端的视图页面到后端的控制层即为“表现层”

  • 资源：Web 工程部署到服务器上后，当前 Web 工程中的内容在服务器上都叫“资源”（万物皆资源）

  • 状态：资源的表现形式，例如，HTML/JSP 页面、CSS/JS 文件、图片/音频/视频等皆为资源的“状态”

  • 转移：浏览器发送请求到服务器，服务端就将请求的资源“转移”到客户端

RESTful：基于REST构建的 API 就是RESTful风格

1.1、资源

  • 资源是一种看待服务器的方式，即将服务器看作是由很多离散的资源组成。每个资源是服务器上一个可命名的抽象概念

  • 因为资源是一个抽象的概念，所以它不仅仅能代表服务器文件系统中的一个文件、数据库中的一张表等等具体的东西，也可以将资源设计的要多抽象有多抽象，只要想象力允许而且客户端应用开发者能够理解

  • 与面向对象设计类似，资源是以名词为核心来组织的，首先关注的是“名词”。一个资源可以由一个或多个URI来标识。URI既是资源的名称，也是资源在 Web 上的地址。对某个资源感兴趣的客户端应用，可以通过资源的URI与其进行交互

URI（Uniform Resource Identifier）：统一资源标志符

URL（Uniform Resource Locator）：统一资源定位符

URI是一个抽象的、高层次的概念，而URL是具体的方式。简单来说，URL是一种URI

1.2、资源的表述

  • 资源的表述是一段对于资源在某个特定时刻的状态的描述。可以在客户端-服务器端之间转移（交换）

  • 资源的表述可以有多种格式，例如HTML/XML/JSON/纯文本/图片/视频/音频等等

  • 资源的表述格式可以通过协商机制来确定。请求-响应方向的表述通常使用不同的格式

1.3、状态转移

  • 状态转移说的是：在客户端和服务器端之间转移（transfer）代表资源状态的表述

  • 通过转移和操作资源的表述，来间接实现操作资源的目的

2、RESTful 实现

RESTful的实现，具体说就是：HTTP 协议里面，四个表示操作方式的动词GET、POST、PUT、DELETE

它们分别对应四种基本操作：

  • GET用来获取资源

  • POST用来新建资源

  • PUT用来更新资源

  • DELETE用来删除资源

REST风格URL地址不使用问号键值对方式携带请求参数，而是：

提倡使用统一的风格设计，从前到后各个单词使用斜杠分开，将要发送给服务器的数据作为地址的一部分，以保证整体风格的一致性URL

以往，我们访问资源的方式五花八问。例如，

  • 获取用户信息通过getUserById/selectUserById/findUserById/等

  • 删除用户信息通过deleteUserById/removeUserById等

  • 更新用户信息通过updateUser/modifyUser/saveUser等

  • 新增用户信息通过addUser/createUser/insertUser等

上述操作的资源都是用户信息。按照RESTful思想，既然操作的资源一样，那么请求路径就应该一样

用一张表格来对比传统方式和REST风格对资源操作的区别

操作 传统方式 REST 风格
查询 getUserById?id=1 user/1-->get请求
保存 saveUser user-->post请求
删除 deleteUserById?id=1 user/1-->delete请求
更新 updateUser user-->put请求

3、使用 RESTful 模拟操作用户资源

需求分析：使用 RESTful 模拟用户资源的增删改查，通过路径中的占位符传递请求参数，通过不同的请求方式对应资源的不同操作

RESTful 路径 请求方式 操作
/user GET 查询所有用户信息
/user/1 GET 根据用户ID查询用户信息
/user POST 添加用户信息
/user/1 DELETE 根据用户ID删除用户信息
/user PUT 修改用户信息

3.1、用户的查询、添加

后台代码实现

RESTfulController.java

@Controller
@RequestMapping("restfulcontroller")
public class RESTfulController {
    @RequestMapping(value = "/user", method = RequestMethod.GET)
    public String getAllUser() {
        System.out.println("查询所有用户信息");
        return "success";
    }

    @RequestMapping(value = "/user/{id}", method = RequestMethod.GET)
    public String getUserById(@PathVariable("id") String id) {
        System.out.println("根据用户ID查询用户信息：" + id);
        return "success";
    }

    @RequestMapping(value = "/user", method = RequestMethod.POST)
    public String insertUser(User user) { // User 沿用之前的对象
        System.out.println("添加用户信息：" + user);
        return "success";
    }

    /** 注：由于 PUT、DELETE 请求比较特殊，后面再做补充 */
}

前台测试代码

restful.html

<a th:href="@{/restfulcontroller/user}">查询所有用户信息</a><br/>
<a th:href="@{/restfulcontroller/user/1}">根据用户ID查询用户信息</a><br/>
<form th:action="@{/restfulcontroller/user}" method="post">
    用户名：<input type="text" name="username"><br/>
    密码：<input type="password" name="password"><br/>
    性别：<input type="radio" name="gender" value="male">男<input type="radio" name="gender" value="female">女<br/>
    年龄：<input type="number" name="age"><br/>
    邮箱：<input type="text" name="email"><br/>
    <input type="submit" value="添加用户">
</form>

为了能够访问到restful.html前台页面资源，可以通过在控制器中定义一个控制器方法来返回其视图，也可以通过在04-SpringMVC 视图中提到的view-controller视图控制器代替。因为这里只是为了实现页面跳转，没有其他请求过程的处理，所以可以通过在 SpringMVC 配置文件中使用<view-controller>标签进行设置

<mvc:view-controller path="/restful" view-name="restful"></mvc:view-controller>

测试结果

后台日志信息

查询所有用户信息
根据用户ID查询用户信息：1
添加用户信息：User{username='admin', password='11111', gender='male', age='18', email='123@qq.com'}

3.2、用户的修改、删除

在01-@RequestMapping 注解 中，我们提到过form表单默认只支持GET和POST请求，如果直接通过method属性指定为PUT和DELETE，会默认以GET请求方式处理

而想要实现PUT和DELETE请求，需要在web.xml中配置 SpringMVC 提供的HiddenHttpMethodFilter过滤器，并在前台页面使用隐藏域来设置PUT和DELETE类型的请求方式

当然，也可以使用AJAX发送PUT和DELETE请求，但是需要注意PUT和DELETE仅部分浏览器支持

为了更清楚地了解HiddenHttpMethodFilter过滤器到底干了什么，这里对其源码进行剖析

public class HiddenHttpMethodFilter extends OncePerRequestFilter {
    private static final List<String> ALLOWED_METHODS = Collections.unmodifiableList(Arrays.asList(HttpMethod.PUT.name(),HttpMethod.DELETE.name(),HttpMethod.PATCH.name()));
    public static final String DEFAULT_METHOD_PARAM = "_method";
    private String methodParam = DEFAULT_METHOD_PARAM;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
        throws ServletException, IOException {
        HttpServletRequest requestToUse = request;
        // 要求原请求方式为 POST 请求
        if ("POST".equals(request.getMethod()) && request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE) == null) {
            // methodParam值：_method
            // paramValue值：_method属性值
            String paramValue = request.getParameter(this.methodParam);
            if (StringUtils.hasLength(paramValue)) {
                // _method属性值转为全大写形式，put==>PUT，delete==>DELETE
                String method = paramValue.toUpperCase(Locale.ENGLISH);
                // 判断_method属性值是否为{"PUT","DELETE","PATCH"}中的一个
                if (ALLOWED_METHODS.contains(method)) {
                    // “偷梁换柱”，包装为一个新的请求对象
                    requestToUse = new HttpMethodRequestWrapper(request, method);
                }
            }
        }
        filterChain.doFilter(requestToUse, response);
    }

    private static class HttpMethodRequestWrapper extends HttpServletRequestWrapper {
        private final String method;
        public HttpMethodRequestWrapper(HttpServletRequest request, String method) {
            super(request);
            this.method = method;
        }
        @Override
        public String getMethod() {
            return this.method;
        }
    }
}

“源码在手，天下我有”。接下来，将理论付诸实践

配置文件

web.xml配置HiddenHttpMethodFilter过滤器

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

后台代码实现

@RequestMapping(value = "/user", method = RequestMethod.PUT)
public String updateUser(User user) {
    System.out.println("修改用户信息：" + user);
    return "success";
}
// 这里的写法格式没有问题，但业务逻辑其实大有问题，下面再详细说
@RequestMapping(value = "/user", method = RequestMethod.DELETE)
public String deleteUser(User user) {
    System.out.println("删除用户信息：" + user);
    return "success";
}

前台测试代码

在添加用户的表单基础上，添加隐藏域<input type="hidden" name="_method" value="put">

<form th:action="@{/restfulcontroller/user}" method="post">
    <input type="hidden" name="_method" value="put">
    用户名：<input type="text" name="username"><br/>
    密码：<input type="password" name="password"><br/>
    性别：<input type="radio" name="gender" value="male">男<input type="radio" name="gender" value="female">女<br/>
    年龄：<input type="number" name="age"><br/>
    邮箱：<input type="text" name="email"><br/>
    <input type="submit" value="修改用户">
</form>
<hr/>
<!-- 这里的写法格式没有问题，但业务逻辑其实大有问题，下面再详细说 -->
<form th:action="@{/restfulcontroller/user}" method="post">
    <input type="hidden" name="_method" value="delete">
    用户名：<input type="text" name="username"><br/>
    密码：<input type="password" name="password"><br/>
    性别：<input type="radio" name="gender" value="male">男<input type="radio" name="gender" value="female">女<br/>
    年龄：<input type="number" name="age"><br/>
    邮箱：<input type="text" name="email"><br/>
    <input type="submit" value="删除用户">
</form>

测试结果

修改用户

删除用户

后台日志信息

修改用户信息：User{username='user', password='11111', gender='female', age='1', email='111@qq.com'}
删除用户信息：User{username='user', password='11111', gender='female', age='1', email='111@qq.com'}

到这里，应该需要指明的是我们在设计RESTful实现时，对删除用户信息的要求下面这样的

RESTful 路径 请求方式 操作
/user/1 DELETE 根据用户ID删除用户信息

换句话说，这里应该通过超链接而非表单形式，即通过用户ID来对用户信息进行删除操作。而一般情况下，我们是通过行编辑删除某一行数据，或是通过选中表单的数据来进行批量删除，这些功能在详细案例时会详细介绍

4、CharacterEncodingFilter 和 HiddenHttpMethodFilter 的配置顺序

目前，我们在web.xml配置文件中对CharacterEncodingFilter和HiddenHttpMethodFilter的配置顺序如下

<!--处理编码-->
<filter>
    <filter-name>characterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
        <param-name>forceResponseEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
<!-- 略 -->
<!--配置 org.springframework.web.filter.HiddenHttpMethodFilter: 可以把 POST 请求转为 DELETE 或 POST 请求 -->
<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>

如果，将两者顺序颠倒互换，即

<!--配置 org.springframework.web.filter.HiddenHttpMethodFilter: 可以把 POST 请求转为 DELETE 或 POST 请求 -->
<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>
<!-- 略 -->
<!--处理编码-->
<filter>
    <filter-name>characterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
        <param-name>forceResponseEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

看看顺序改变之后，对请求的编码会有什么影响

后台日志信息

修改用户信息：User{username='张三', password='123456', gender='male', age='18', email='123@qq.com'}

可以发现，中文的“张三”乱码了，这是为什么呢？

在02-SpringMVC 获取请求参数一节中的7、处理乱码问题中，我们尝试在获取请求参数之前，通过request.setCharacterEncoding("UTF-8");来设置请求编码格式，但是没有生效。分析的原因是“请求参数获取在前，设置编码格式在后”导致的。

我们也提出了 2 种解决方案：

  • 1、获取请求参数之后，手动解码编码。但是这种显然不合理，所以直接 pass

  • 2、获取请求参数之前“做手脚”。这种方式就是 SpringMVC 中提供的CharacterEncodingFilter过滤器，来对请求编码做统一处理

现在的问题就是：在CharacterEncodingFilter之前配置了HiddenHttpMethodFilter导致了失效

所以我们需要搞清楚，为什么CharacterEncodingFilter的配置顺序会影响到编码的效果？或者说为什么HiddenHttpMethodFilter会使之失效？

通过上面对HiddenHttpMethodFilter源码的剖析，它会获得_method这个请求参数，这就导致执行到CharacterEncodingFilter过滤器时，已经是获取请求参数之后了，所以会导致上述中文乱码问题

因此，我们必须要将CharacterEncodingFilter过滤器尽量配置在其他过滤器之前。这样就能保证在任何过滤器获取请求之前，获得的失已经处理过编码格式的请求参数了

我们再将CharacterEncodingFilter和HiddenHttpMethodFilter的配置顺序还原至之前的状态，即CharacterEncodingFilter在前而HiddenHttpMethodFilter在后的情况，进行测试再查看后台日志信息

修改用户信息：User{username='张三', password='', gender='male', age='18', email='123@qq.com'}

这时，当请求参数中包含中文时，就不会出现乱码的情况了

总结

本节重点掌握内容

  • 明确REST和RESTful的关系，明确表现层、资源、状态、转移这几个概念的含义

  • REST，表现层资源状态转移

  • RESTful，基于REST构建的 API 就是RESTful风格

  • 明确RESTful的实现，是通过不同的请求方式来对应资源的不同操作，通过路径中的占位符传递请求参数

  • 熟练掌握如何通过RESTful进行资源的增删改查操作，以及如何处理PUT和DELETE这两种特殊的请求方式

  • 明确CharacterEncodingFilter和HiddenHttpMethodFilter的配置顺序，明白两个过滤器的源码处理逻辑

附上导图，仅供参考

06、RESTful--案例

1、准备工作

Step1、创建工程

File-New-Project，默认Next

填写项目工程基本信息，点击FINISH

Step2、完善 POM

修改打包方式为war，并引入相关依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.vectorx</groupId>
    <artifactId>SpringMVC_RESTful</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.16</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.11</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring5</artifactId>
            <version>3.0.15.RELEASE</version>
        </dependency>
    </dependencies>
</project>

Step3、web.xml

File-Project Structure-Modules，在Deployment Descriptors中点击+号添加Deployment Descriptor Location，默认路径中不带src\main\webapp\，需要手动添加

在web.xml中添加两个过滤器和一个前端控制器：

  • 编码过滤器：CharacterEncodingFilter（注意顺序）

  • 处理PUT和DELETE的请求过滤器：HiddenHttpMethodFilter

  • 前端控制器：DispatcherServlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!--配置编码过滤器-->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!--配置处理 PUT 和 DELETE 的请求过滤器-->
    <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>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springMVC.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

Step4、SpringMVC 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--自动扫描包-->
    <context:component-scan base-package="com.vectorx.restful"></context:component-scan>

    <!--配置Thymeleaf视图解析器-->
    <bean id="ThymeleafViewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
        <property name="order" value="1"></property>
        <property name="characterEncoding" value="UTF-8"></property>
        <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>
                        <property name="suffix" value=".html"></property>
                        <property name="templateMode" value="HTML5"></property>
                        <property name="characterEncoding" value="UTF-8"></property>
                    </bean>
                </property>
            </bean>
        </property>
    </bean>

    <!--配置视图控制器-->
    <mvc:view-controller path="/" view-name="index"></mvc:view-controller>

    <!--配置MVC注解驱动-->
    <mvc:annotation-driven/>
</beans>

Step5、创建 Controller、Dao、Bean

EmployeeController

@Controller
@RequestMapping("/employeeController")
public class EmployeeController {
    @Autowired
    private EmployeeDao employeeDao;
}

EmployeeDao

public interface EmployeeDao {
    /**
     * 增改员工信息
     *
     * @param employee
     */
    void save(Employee employee);

    /**
     * 删除员工信息
     *
     * @param id
     */
    void deleteById(Integer id);

    /**
     * 获取所有员工信息
     *
     * @return
     */
    List<Employee> getAll();

    /**
     * 根据员工id获取员工信息
     *
     * @param id
     * @return
     */
    Employee getById(Integer id);
}

EmployeeDaoImpl

@Repository
public class EmployeeDaoImpl implements EmployeeDao {
    private static Map<Integer, Employee> employeeMap;
    private static Integer initId = 1000;

    static {
        employeeMap = new HashMap<>();
        employeeMap.put(++initId, new Employee(initId, "张三", "zhangsan@qq.com", 1));
        employeeMap.put(++initId, new Employee(initId, "李四", "lisi@qq.com", 0));
        employeeMap.put(++initId, new Employee(initId, "王五", "wangwu@qq.com", 0));
        employeeMap.put(++initId, new Employee(initId, "赵六", "zhaoliu@qq.com", 1));
    }

    @Override
    public void save(Employee employee) {
        if (employee.getId() == null) {
            employee.setId(++initId);
        }
        employeeMap.put(employee.getId(), employee);
    }

    @Override
    public void deleteById(Integer id) {
        employeeMap.remove(id);
    }

    @Override
    public List<Employee> getAll() {
        return new ArrayList<>(employeeMap.values());
    }

    @Override
    public Employee getById(Integer id) {
        return employeeMap.get(id);
    }
}

Employee

public class Employee {
    private Integer id;
    private String lastName;
    private String email;
    private Integer gender;

    public Employee() {
    }

    public Employee(Integer id, String lastName, String email, Integer gender) {
        this.id = id;
        this.lastName = lastName;
        this.email = email;
        this.gender = gender;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Integer getGender() {
        return gender;
    }

    public void setGender(Integer gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", lastName='" + lastName + '\'' +
                ", email='" + email + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
}

2、功能清单

功能 URL路径 请求方式
访问首页 / GET
查询所有员工 /employee GET
删除员工 /employee/1 DELETE
跳转到添加员工页面 /toAdd GET
添加员工 /employee POST
跳转到修改员工页面 /employee/2 GET
修改员工 /employee PUT

3、访问首页

index.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>
<h1>首页</h1>
<a th:href="@{/employeeController/employee}">查看员工信息</a>
</body>
</html>

测试

4、列表功能

EmployeeController.java

@GetMapping("/employee")
public String getAllEmployee(Model model) {
    List<Employee> employeeList = employeeDao.getAll();
    model.addAttribute("employeeList", employeeList);
    return "employeelist";
}

employeelist.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>员工信息</title>
        <style type="text/css">
            table {
                width: 50%;
                border: 1px black solid;
                border-collapse: collapse;
                vertical-align: middle;
                text-align: center;
            }
            tbody tr:nth-child(odd) {
                background-color: rgb(211, 216, 188);
            }
            th, td {
                border: 1px black solid;
            }
        </style>
    </head>
    <body>
        <table>
            <tr>
                <th colspan="5">员工信息</th>
            </tr>
            <tr>
                <th>ID</th>
                <th>姓名</th>
                <th>邮箱</th>
                <th>性别</th>
                <th>操作</th>
            </tr>
            <tr th:each="employee : ${employeeList}">
                <td th:text="${employee.id}"></td>
                <td th:text="${employee.lastName}"></td>
                <td th:text="${employee.email}"></td>
                <td th:text="${employee.gender == 1 ? '男' : '女'}"></td>
                <td>
                    <a href="">修改</a>
                    <a href="">删除</a>
                </td>
            </tr>
        </table>
    </body>
</html>

效果

5、删除功能

在webapp下新建static/css和static/js，用来放置css文件和js文件

  • 引入static/js/vue.js

  • static/css/employeelist.css作为外部样式文件

  • static/js/employeelist.js作为外部js文件

employeelist.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>员工信息</title>
        <link th:href="@{/static/css/employeelist.css}" rel="stylesheet" type="text/css"/>
    </head>
    <body>
        <table id="employeeTable">
            <tr>
                <th colspan="5">员工信息</th>
            </tr>
            <tr>
                <th>ID</th>
                <th>姓名</th>
                <th>邮箱</th>
                <th>性别</th>
                <th>操作</th>
            </tr>
            <tr th:each="employee : ${employeeList}">
                <td th:text="${employee.id}"></td>
                <td th:text="${employee.lastName}"></td>
                <td th:text="${employee.email}"></td>
                <td th:text="${employee.gender == 1 ? '男' : '女'}"></td>
                <td>
                    <a href="">修改</a>
                    <!--<a th:href="@{/employeeController/employee/}+${employee.id}">删除</a>-->
                    <a @click="deleteEmployee" th:href="@{'/employeeController/employee/'+${employee.id}}">删除</a>
                </td>
            </tr>
        </table>
        <form method="post" id="deleteForm">
            <input type="hidden" name="_method" value="delete"/>
        </form>
        <script type="text/javascript" th:src="@{/static/js/vue.js}"></script>
        <script type="text/javascript" th:src="@{/static/js/employeelist.js}"></script>
    </body>
</html>

employeelist.css

table {
    width: 50%;
    border: 1px black solid;
    border-collapse: collapse;
    /* 垂直水平居中 */
    vertical-align: middle;
    text-align: center;
}

/* 间隔变色 */
tbody tr:nth-child(odd) {
    background-color: rgb(211, 216, 188);
}

th, td {
    border: 1px black solid;
}

employeelist.js

var vue = new Vue({
    el: "#employeeTable",
    methods: {
        deleteEmployee: function (event) {
            if (confirm('确认删除吗？')) {
                var deleteForm = document.getElementById("deleteForm");
                deleteForm.action = event.target.href;
                deleteForm.submit();
            }
            event.preventDefault();
        }
    }
});

SpringMVC 配置文件

<!--开放静态资源访问-->
<mvc:default-servlet-handler/>

效果

6、添加功能

employeelist.html

<!-- 略 -->
<tr>
    <th>ID</th>
    <th>姓名</th>
    <th>邮箱</th>
    <th>性别</th>
    <th>操作 <a th:href="@{/employeeController/toAdd}">添加</a><br/></th>
</tr>
<!-- 略 -->

employeeadd.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>添加员工</title>
    </head>
    <body>
        <h1>添加员工</h1>
        <form th:action="@{/employeeController/employee}" method="post">
            姓名：<input type="text" name="lastName"/><br/>
            邮箱：<input type="text" name="email"/><br/>
            性别：<input type="radio" name="gender" value="1">男
            <input type="radio" name="gender" value="0">女<br/>
            <input type="submit" value="添加">
        </form>
    </body>
</html>

EmployeeController.java

@GetMapping("/toAdd")
public String toAdd() {
    return "employeeadd";
}

@PostMapping("/employee")
public String addEmployee(Employee employee) {
    employeeDao.save(employee);
    return "redirect:/employeeController/employee";
}

效果

7、修改功能

employeelist.html

<!-- 略 -->
<a th:href="@{/employeeController/employee/}+${employee.id}">修改</a>
<!-- 略 -->

employeeedit.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>修改员工</title>
    </head>
    <body>
        <h1>修改员工</h1>
        <form th:action="@{/employeeController/employee}" method="post">
            <input type="hidden" name="_method" th:value="put">
            <input type="hidden" name="id" th:value="${employee.id}">
            姓名：<input type="text" name="lastName" th:value="${employee.lastName}"/><br/>
            邮箱：<input type="text" name="email" th:value="${employee.email}"/><br/>
            性别：<input type="radio" name="gender" value="1" th:field="${employee.gender}">男
            <input type="radio" name="gender" value="0" th:field="${employee.gender}">女<br/>
            <input type="submit" value="修改">
        </form>
    </body>
</html>

EmployeeController.java

@GetMapping("/employee/{id}")
public String getEmployeeById(@PathVariable("id") Integer id, Model model) {
    Employee employee = employeeDao.getById(id);
    model.addAttribute("employee", employee);
    return "employeeedit";
}

@PutMapping("/employee")
public String editEmployee(Employee employee) {
    employeeDao.save(employee);
    return "redirect:/employeeController/employee";
}

效果

注意点

当前 SpringMVC 配置文件中存在这样几个配置

<!--配置视图控制器-->
<mvc:view-controller path="/" view-name="index"></mvc:view-controller>

<!--开放静态资源访问-->
<mvc:default-servlet-handler/>

<!--配置MVC注解驱动-->
<mvc:annotation-driven/>

各个配置的作用

  • view-controller：简化页面跳转实现

  • default-servlet-handler：开放静态资源访问

  • annotation-driven：这里主要有 2 个作用

  • 1）解决因配置视图控制器导致其他请求失效（404）的问题

  • 2）解决因配置静态资源访问导致其他请求失效（404）的问题

回忆：在 04-SpringMVC 视图 - 5、视图控制器 view-controller 中有介绍过“MVC 注解驱动”功能作用

annotation-driven需要与view-controller、default-servlet-handler配合使用

annotation-driven与view-controller的关系

  • 当配置了view-controller而不配置annotation-driven，那么除了视图控制器中配置的请求，其他控制器方法将无法访问，即其他请求失效（404）

  • 当配置了view-controller也配置了annotation-driven，那么视图控制器中配置的请求和其他控制器方法都能够正常访问

annotation-driven与default-servlet-handler的关系

  • 当配置了default-servlet-handler而不配置annotation-driven，那么所有请求都将交给DefaultServlet处理，DispatcherServlet将失效

  • 当配置了default-servlet-handler也配置了annotation-driven，那么所有请求将先交给DispatcherServlet处理，处理不了再交给DefaultServlet处理

07、HttpMessageConverter

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

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

1、@RequestBody

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

后台测试代码

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

前台测试代码

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

测试结果

后台日志信息

requestBody: username=admin&password=123456

2、RequestEntity

RequestEntity：封装请求报文的一种类型，需要在控制器方法的形参中设置该类型的形参，当前请求的请求报文就会赋值给该形参

可以通过getHeaders()获取请求头信息，通过getBody()获取请求体信息

后台测试代码

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

前台测试代码

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

测试结果

后台日志信息

requestHeader: [host:"localhost:8080", connection:"keep-alive", content-length:"30", cache-control:"max-age=0", sec-ch-ua:"" Not A;Brand";v="99", "Chromium";v="99", "Google Chrome";v="99"", sec-ch-ua-mobile:"?0", sec-ch-ua-platform:""Windows"", 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/99.0.4844.51 Safari/537.36", accept:"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9", sec-fetch-site:"same-origin", sec-fetch-mode:"navigate", sec-fetch-user:"?1", sec-fetch-dest:"document", referer:"http://localhost:8080/SpringMVC/", accept-encoding:"gzip, deflate, br", accept-language:"zh-CN,zh;q=0.9", Content-Type:"application/x-www-form-urlencoded;charset=UTF-8"]
requestBody: username=admin&password=123456

3、@ResponseBody

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

3.1、通过 HttpServletResponse 响应浏览器数据

后台测试代码

@GetMapping("/testResponseByServletAPI")
public void testResponseByServletAPI(HttpServletResponse response) throws IOException {
    response.getWriter().print("hello, response");
}

前台测试代码

<a th:href="@{/httpController/testResponseByServletAPI}">通过 HttpServletResponse 响应浏览器数据</a>

测试结果

3.2、通过 @ResponseBody 响应浏览器数据

后台测试代码

@GetMapping("/testResponseBody")
@ResponseBody
public String testResponseBody() throws IOException {
    return "success";
}

前台测试代码

<a th:href="@{/httpController/testResponseBody}">通过 @ResponseBody 响应浏览器数据</a>

测试结果

3.3、通过 @ResponseBody 响应 User

后台测试代码

@GetMapping("/testResponseUser")
@ResponseBody
public User testResponseUser() throws IOException {
    return new User("admin", "123456");
}

前台测试代码

<a th:href="@{/httpController/testResponseUser}">通过 @ResponseBody 响应 User</a>

测试结果

我这里报了406 - 不可接收的错误

存疑点：课程中报的是500 - No converter found for return value of type: class xxx，不知道是什么原因，此处存疑

Q：那么如何解决这个问题？

A：不要响应 Java 对象，而是转换成 Json 对象

3.4、SpringMVC 处理 JSON

处理方式：引入jackson依赖

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.2</version>
</dependency>

这里不修改任何代码，直接重新部署项目，再来测试下

这里需要强调的是，并不是只引入jackson依赖就够了。实际上，@ResponseBody处理json的步骤如下

  • 1）引入jackson依赖

  • 2）开启 MVC 注解驱动

  • 此时在HandlerAdaptor中会自动装配一个消息转换器MappingJackson2HttpMessageConverter，可以将响应到浏览器的 Java 对象转换json格式的字符串

  • 3）使用@ResponseBody注解标识控制器方法

  • 4）将 Java 对象作为控制器方法的返回值返回

  • 这里会自动转换为json类型的字符串

上述步骤缺一不可，少一步都实现不了效果

回顾：我们之前章节中就说过 MVC 注解驱动的功能很多，在 04-SpringMVC 视图 中处理了视图控制器问题，在 05-RESTful 案例 中处理静态资源问题，而在本章节中处理了 Java 对象转换为 JSON 对象的问题。这里再总结一下 MVC 注解驱动的作用：

1、解决视图控制器view-controller造成其他请求失效的问题

2、解决默认 Servlet 处理器default-servlet-handler造成DispatcherServlet失效的问题

3、解决 Java 对象转换为 Json 对象的问题

扩展：Json 对象和 Json 数组

1、Json 对象用{}包裹，如{"username":"admin","password":"123456"}

2、Json 数组用[]包裹，如["username":"admin","password":"123456"]

3、Json 对象和 Json 数组可以相互嵌套，即

  • Json 对象中可以包含 Json 对象和 Json 数组，如["username":"admin","password":"123456", "ext" : {"age": 18, "gender": "1"}]、["username":"admin","password":"123456", "ext" : ["age": 18, "gender": "1"]]

  • Json 数组中也可以包含 Json 对象和 Json 数组，如{"username":"admin","password":"123456", "ext" : {"age": 18, "gender": "1"}}、{"username":"admin","password":"123456", "ext" : ["age": 18, "gender": "1"]}

3.5、SpringMVC 处理 AJAX

后台测试代码

@PostMapping("/testAxios")
@ResponseBody
public String testAxios(User user) {
    return user.getUsername() + "," + user.getPassword();
}

前台测试代码

httpmessageconverter.html

<div id="app">
    <a @click="testAxios" th:href="@{/httpController/testAxios}">SpringMVC 操作 AJAX</a>
</div>
<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" th:src="@{/static/js/httpmessageconverter.js}"></script>

httpmessageconverter.js

var vue = new Vue({
    el: "#app",
    methods: {
        testAxios: function (event) {
            testAxios(event.target.href);
        }
    }
});

function testAxios(url) {
    axios({
        method: "post",
        url: url,
        params: {
            username: "admin",
            password: "123456"
        }
    }).then(function (response) {
        alert(response.data);
    });
    event.preventDefault();
}

测试效果

3.6、@RestController 注解

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

这里简单修改下后台代码，将@Controller注解替换为@RestController注解，并去除控制器方法上的@ResponseBody注解

@RestController
@RequestMapping("/httpController")
public class HttpController {
    @PostMapping("/testAxios")
    public String testAxios(User user) {
        return user.getUsername() + "," + user.getPassword();
    }
}

测试效果

可以发现，虽然控制器方法上没有加@ResponseBody注解，但是效果是一样的，依然可以将控制器方法的返回值作为响应报文的响应体返回给浏览器

4、ResponseEntity

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

4.1、文件下载

后台测试代码

@Controller
@RequestMapping("/fileUploadDownloadController")
public class FileUploadDownloadController {
    @GetMapping("/testDownload")
    public ResponseEntity<byte[]> testDownload(HttpSession session) {
        ServletContext context = session.getServletContext();
        // 文件位置和名称
        final String path = "/static/img/";
        String fileName = "1.png";
        // 响应体
        String realPath = context.getRealPath(path + fileName);
        byte[] bytes = readFile(realPath);
        // 响应头
        MultiValueMap<String, String> headers = new HttpHeaders();
        headers.set("Content-Disposition", "attachment;filename=" + fileName);
        // 响应状态码
        HttpStatus status = HttpStatus.OK;
        // 响应实体
        return new ResponseEntity<>(bytes, headers, status);
    }

    /**
     * 读取文件流
     *
     * @param realPath
     * @return
     */
    private byte[] readFile(String realPath) {
        System.out.println(realPath);
        final int initSize = 0;
        byte[] bytes = new byte[initSize];
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(realPath));) {
            bytes = new byte[bis.available()];
            bis.read(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bytes;
    }
}

前台测试代码

<a th:href="@{/fileUploadDownloadController/testDownload}">测试下载文件</a>

测试效果

记低级失误：

1、将

@Controller

@RequestMapping("/fileUploadDownloadController")

写成了

@Controller("/fileUploadDownloadController")

导致了请求直接报404找不到对应资源，需要格外注意！！！

2、读取文件代码缺少bis.read(bytes);导致字节数组只做了初始化而没有赋值，导致下载文件出现“损坏”的问题，需要格外注意！！！

4.2、文件上传

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

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

1）添加依赖

commons-fileupload的 jar 包是上传功能必不可少的

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

2）配置文件上传解析器

SpringMVC 配置文件中添加CommonsMultipartResolver的依赖注入

<!--配置文件上传解析器，将上传文件自动封装为MutilpartFile对象-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>

3）后台代码

使用MultipartFile对象接收上传文件

@PostMapping("/testUpload")
public String testUpload(MultipartFile photo, HttpSession session) throws IOException {
    // 目标目录
    String photoPath = session.getServletContext().getRealPath("photo");
    File file = new File(photoPath);
    if (!file.exists()) {
        file.mkdir();
    }
    // 目标文件名
    String fileName = photo.getOriginalFilename();
    // 上传文件到服务器
    photo.transferTo(new File(photoPath + File.separator + fileName));
    return "success";
}

4）前台代码

要求请求方式必须为post，并且enctype属性值必须为multipart/form-data

Q：enctype 是什么？

A：enctype 即encode type，表示编码类型，它规定了在发送到服务器之前应该如何对表单数据进行编码

默认地，form 表单数据编码默认值为application/x-www-form-urlencoded。除此之外，enctype还可以设置为text/plain

这三种类型总结一下就是：

  • application/x-www-form-urlencoded：默认值，URL 编码

  • multipart/form-data：文件类型

  • text/plain：纯文本格式类型

<form th:action="@{/fileUploadDownloadController/testUpload}" method="post" enctype="multipart/form-data">
    头像：<input type="file" name="photo"/><br/>
    <input type="submit" value="上传"/>
</form>

测试结果

查看文件是否上传成功

5）处理同名问题

如果多次上传同名文件，会发现原文件会被同名新文件替换（覆盖）掉，如何解决这个问题呢？

其实，处理同名问题有多种方式，这里采用UUID生成随机序列来实现，只需要做简单的修改即可

@PostMapping("/testUpload")
public String testUpload(MultipartFile photo, HttpSession session) throws IOException {
    // 目标目录
    String photoPath = session.getServletContext().getRealPath("photo");
    File file = new File(photoPath);
    if (!file.exists()) {
        file.mkdir();
    }
    // 目标文件名
    String srcName = photo.getOriginalFilename();
    String suffixName = srcName.substring(srcName.lastIndexOf("."));
    String prefixName = UUID.randomUUID().toString();
    String destName = prefixName + suffixName;
    // 上传文件到服务器
    photo.transferTo(new File(photoPath + File.separator + destName));
    return "success";
}

再次测试

可以看到，最新上传的文件名为一串随机序列，这样就避免同名文件上传出现覆盖的问题了

总结

本节知识点

HttpMessageConverter 请求报文转换器

  • 请求报文转为 JAVA 对象：@RequestBody、RequestEntity
  • JAVA 对象转为请求报文：@ResponseBody、ResponseEntity

另外

  • jackson-databind：处理json
  • commons-fileupload：上传必备

附上导图，仅供参考

08、拦截器和异常处理

1、拦截器

1.1、拦截器的配置

SpringMVC 中的拦截器用于拦截控制器方法的执行，需要实现HandlerInterceptor，并在 SpringMVC 的配置文件中进行配置

方式一

后台测试代码

public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor==>preHandle");
        return HandlerInterceptor.super.preHandle(request, response, handler);
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor==>postHandle");
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor==>afterCompletion");
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

配置拦截器

<mvc:interceptors>
    <bean id="myInterceptor" class="com.vectorx.springmvc.s00_helloworld.interceptor.MyInterceptor"></bean>
</mvc:interceptors>

访问任意路径，后台日志信息

MyInterceptor==>preHandle
MyInterceptor==>postHandle
MyInterceptor==>afterCompletion

方式二

后台测试代码

@Component
public class MyInterceptor implements HandlerInterceptor {
    // 略同
}

配置拦截器

<mvc:interceptors>
    <ref bean="myInterceptor"></ref>
</mvc:interceptors>

访问任意路径，后台日志信息

MyInterceptor==>preHandle
MyInterceptor==>postHandle
MyInterceptor==>afterCompletion

方式三

后台测试代码

@Component
public class MyInterceptor implements HandlerInterceptor {
    // 略同
}

配置拦截器

<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <mvc:exclude-mapping path="/"/>
        <ref bean="myInterceptor"></ref>
    </mvc:interceptor>
</mvc:interceptors>

此时除了访问/即首页时不会走拦截器，其他请求都会走拦截器，其后台日志信息

MyInterceptor==>preHandle
MyInterceptor==>postHandle
MyInterceptor==>afterCompletion

注意：这里的path路径配置的是/**，表示任意层路径的请求，符合Ant风格的路径。这与web.xml中url-pattern的/*匹配效果一致，但写法不同

小结

  • 方式一和方式二都是对DispatcherServlet所处理的所有请求进行拦截

  • 方式三可以有选择拦截请求，通过ref或bean设置拦截器，通过mvc:mapping设置需要拦截的请求，通过mvc:exclude-mapping设置需要排除（即不需要拦截）的请求

1.2、拦截器的三个抽象方法

  • preHandle：控制器方法执行之前执行preHandle()，其 boolean 类型的返回值表示是否拦截或放行

  • 返回 true 表示放行，即调用控制器方法

  • 返回 false 表示拦截，即不调用控制器方法

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

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

1.3、多个拦截器的执行顺序

若每个拦截器的preHandle()都返回true

此时多个拦截器的执行顺序和拦截器在 SpringMVC 的配置文件的配置顺序有关：

preHandle()会按照配置的顺序执行，而postHandle()和afterComplation()会按照配置的反序执行

配置顺序

<mvc:interceptors>
    <ref bean="myInterceptor"></ref>
    <ref bean="myInterceptor2"></ref>
</mvc:interceptors>

后台日志信息

MyInterceptor==>preHandle
MyInterceptor2==>preHandle
MyInterceptor2==>postHandle
MyInterceptor==>postHandle
MyInterceptor2==>afterCompletion
MyInterceptor==>afterCompletion

可以看出，preHandle顺序执行，postHandle和afterCompletion反序执行

若某个拦截器的preHandle()返回了false

preHandle()返回 false 和它之前的拦截器的preHandle()都会执行，postHandle()都不执行，返回 false 的拦截器之前的拦截器的afterComplation()会执行

后台测试代码

@Component
public class MyInterceptor2 implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor2==>preHandle");
        return false;
    }
    // 略同
}

后台日志信息

MyInterceptor==>preHandle
MyInterceptor2==>preHandle
MyInterceptor==>afterCompletion

2、异常处理

2.1、基于配置的异常处理

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

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

SpringMVC 提供了自定义的异常处理器SimpleMappingExceptionResolver

配置文件

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

后台测试代码

@RequestMapping("testException")
public String testException() {
    int i = 1 / 0;
    return "success";
}

测试结果

2.2、基于注解的异常处理

  • @ControllerAdvice标识当前类为异常处理的组件

  • @ExceptionHandler设置所标识方法处理的异常

配置注解

// 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";
    }
}

测试结果

总结

本节重点掌握

  • 拦截器的自定义方法、三种配置方式、三个抽象方法及执行顺序

  • 异常处理解析器的两种方式：基于配置和基于注解

附上导图，仅供参考

07拦截器和异常处理png

09、完全注解开发

1、AbstractAnnotationConfigDispatcherServletlnitializer

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

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

Spring3.2 引入了一个便利的 WebApplicationlnitializer基础实现，名为AbstractAnnotationConfigDispatcherServletlnitializer

当类扩展了AbstractAnnotationConfigDispatcherServletlnitializer并将其部署到 Servlet3.0 容器时，容器会自动发现它，并用它来配置Servlet 上下文

2、初始化类

/**
 * web工程的初始化类，代替web.xml
 */
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};
    }

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

    /**
     * 注册过滤器
     *
     * @return
     */
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        characterEncodingFilter.setForceResponseEncoding(true);
        HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
        return new Filter[]{characterEncodingFilter, hiddenHttpMethodFilter};
    }
}

3、SpringMVC 配置类

SpringMVC 配置类清单

  • 1、扫描组件

  • 2、视图解析器

  • 3、view-controller

  • 4、default-servlet-handler

  • 5、MVC注解驱动

  • 6、文件上传解析器

  • 7、拦截器

  • 8、异常处理解析器

// 标识为配置类
@Configuration
// ========== 1、扫描组件 ==========
@ComponentScan("com.vectorx.springmvc.controller")
// ========== 5、MVC注解驱动 ==========
@EnableWebMvc
public class WebConfig {}

4、视图解析器

@Configuration
@ComponentScan("com.vectorx.springmvc.controller")
@EnableWebMvc
public class WebConfig {
    // ========== 2、视图解析器 ==========

    /**
     * 生成模板解析器
     *
     * @return
     */
    @Bean
    public ITemplateResolver templateResolver() {
        SpringResourceTemplateResolver templateResolver = new SpringResourceTemplateResolver();
        templateResolver.setPrefix("/WEB-INF/templates/");
        templateResolver.setSuffix(".html");
        templateResolver.setTemplateMode(TemplateMode.HTML);
        templateResolver.setCharacterEncoding("UTF-8");
        return templateResolver;
    }

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

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

5、WebMvcConfigurer

@Configuration
@ComponentScan("com.vectorx.springmvc.controller")
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    // 略...

    // ========== 3、view-controller ==========
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("index");
    }
    // ========== 4、default-servlet-handler ==========
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    // ========== 7、拦截器 ==========
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TestInterceptor()).addPathPatterns("/**");
    }

    // ========== 8、异常处理解析器 ==========
    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
        Properties properties = new Properties();
        properties.setProperty("java.lang.ArithmeticException", "error");
        exceptionResolver.setExceptionMappings(properties);
        exceptionResolver.setExceptionAttribute("ex");
        resolvers.add(exceptionResolver);
    }
}

6、文件上传解析器

@Configuration
@ComponentScan("com.vectorx.springmvc.controller")
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    // 略...

    // ========== 6、文件上传解析器 ==========
    @Bean
    public MultipartResolver multipartResolver() {
        MultipartResolver multipartResolver = new CommonsMultipartResolver();
        return multipartResolver;
    }
}

测试

访问首页

测试异常

附录：SpringMVC 配置类总览

// 标识为配置类
@Configuration
// ========== 1、扫描组件 ==========
@ComponentScan("com.vectorx.springmvc.controller")
// ========== 5、MVC注解驱动 ==========
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    // ========== 2、视图解析器 ==========

    /**
     * 生成模板解析器
     *
     * @return
     */
    @Bean
    public ITemplateResolver templateResolver() {
        SpringResourceTemplateResolver templateResolver = new SpringResourceTemplateResolver();
        templateResolver.setPrefix("/WEB-INF/templates/");
        templateResolver.setSuffix(".html");
        templateResolver.setTemplateMode(TemplateMode.HTML);
        templateResolver.setCharacterEncoding("UTF-8");
        return templateResolver;
    }

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

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

    // ========== 3、view-controller ==========
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("index");
    }

    // ========== 4、default-servlet-handler ==========
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    // ========== 6、文件上传解析器 ==========
    @Bean
    public MultipartResolver multipartResolver() {
        MultipartResolver multipartResolver = new CommonsMultipartResolver();
        return multipartResolver;
    }

    // ========== 7、拦截器 ==========
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TestInterceptor()).addPathPatterns("/**");
    }

    // ========== 8、异常处理解析器 ==========
    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
        Properties properties = new Properties();
        properties.setProperty(ArithmeticException.class.getCanonicalName(), "error");
        exceptionResolver.setExceptionMappings(properties);
        exceptionResolver.setExceptionAttribute("ex");
        resolvers.add(exceptionResolver);
    }
}

总结

本届重点掌握

  • web 工程初始化的配置方法

  • SpringMVC 配置类的组件配置方法

附上导图，仅供参考

10、SpringMVC 执行流程

1、SpringMVC 常用组件

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

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

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

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

  • Handler：处理器，需要工程师开发

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

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

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

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

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

  • View：视图

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

2、DispatcherServlet 初始化过程

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

2.1、初始化 WebApplicationContext

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

protected WebApplicationContext initWebApplicationContext() {
    WebApplicationContext rootContext =
        WebApplicationContextUtils.getWebApplicationContext(getServletContext());
    WebApplicationContext wac = null;
    if (this.webApplicationContext != null) {
        wac = this.webApplicationContext;
        if (wac instanceof ConfigurableWebApplicationContext) {
            ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
            if (!cwac.isActive()) {
                if (cwac.getParent() == null) {
                    cwac.setParent(rootContext);
                }
                configureAndRefreshWebApplicationContext(cwac);
            }
        }
    }
    if (wac == null) {
        wac = findWebApplicationContext();
    }
    if (wac == null) {
        // 创建ApplicationContext
        wac = createWebApplicationContext(rootContext);
    }
    if (!this.refreshEventReceived) {
        synchronized (this.onRefreshMonitor) {
            // 刷新ApplicationContext
            onRefresh(wac);
        }
    }
    if (this.publishContext) {
        String attrName = getServletContextAttributeName();
        // 将IOC容器在应用域共享
        getServletContext().setAttribute(attrName, wac);
    }
    return wac;
}

2.2、创建 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());
    // 设置父容器：将Spring上下文对象作为SpringMVC上下文对象的父容器
    wac.setParent(parent);
    String configLocation = getContextConfigLocation();
    if (configLocation != null) {
        wac.setConfigLocation(configLocation);
    }
    configureAndRefreshWebApplicationContext(wac);
    return wac;
}

2.3、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、DispatcherServlet 调用组件处理请求

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

3.2、doService

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

protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
    logRequest(request);
    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));
            }
        }
    }

    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 previousRequestPath = null;
    if (this.parseRequestPath) {
        previousRequestPath = (RequestPath) request.getAttribute(ServletRequestPathUtils.PATH_ATTRIBUTE);
        ServletRequestPathUtils.parseAndCache(request);
    }
    try {
        // 重点关注
        doDispatch(request, response);
    }
    finally {
        if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
            if (attributesSnapshot != null) {
                restoreAttributesAfterInclude(request, attributesSnapshot);
            }
        }
        if (this.parseRequestPath) {
            ServletRequestPathUtils.setParsedRequestPath(previousRequestPath, request);
        }
    }
}

3.3、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);
            // 包含handler、interceptorList、interceptorIndex 
            //         handler：浏览器发送的请求所匹配的控制器方法
            //         interceptorList：处理控制器方法的所有拦截器集合 
            //         interceptorIndex：拦截器索引，控制拦截器aftercompletion()的执行
            mappedHandler = getHandler(processedRequest);
            if (mappedHandler == null) {
                noHandlerFound(processedRequest, response);
                return;
            }
            // 创建处理器适配器，负责调用控制器方法
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
            String method = request.getMethod();
            boolean isGet = HttpMethod.GET.matches(method);
            if (isGet || HttpMethod.HEAD.matches(method)) {
                long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                    return;
                }
            }
            // 调用拦截器preHandle方法，正序执行
            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;
            }
            // 由处理器适配器调用具体的控制器方法，最终获得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) {
            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()) {
            if (mappedHandler != null) {
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
            }
        }
        else {
            if (multipartRequestParsed) {
                cleanupMultipart(processedRequest);
            }
        }
    }
}

3.4、processDispatchResult

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

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);
        }
    }
    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()) {
        return;
    }
    if (mappedHandler != null) {
        // 调用拦截器afterCompletion方法，反序执行
        mappedHandler.triggerAfterCompletion(request, response, null);
    }
}

4、SpringMVC 执行流程

1）用户向服务器发送请求，请求被 SpringMVC 前端控制器DispatcherServlet捕获

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

若不存在，再判断是否配置了mvc:default-servlet-handler

  • i.如果没配置，则控制台报映射查找不到，客户端展示 404 错误
DEBUG org.springframework.web.servlet.Dispatcherservlet - GET "/springMVC/testHaha", parameters={}
WARN org.springframework.web.servlet.PageNotFound - No mapping for GET /springMVC/testHaha 
DEBUG org.springframework.web.servlet.Dispatcherservlet - Completed 404 NOT_FOUND
  • ii.如果有配置，则访问目标资源（一般为静态资源，如：JS，CSS，HTML），找不到客户端也会展示404错误
DEBUG org.springframework.web.servlet.Dispatcherservlet - GET "/springMVC/testHaha", parameters={}
handler.SimpleUrlHandlerMapping Mapped to org.springframework.web.servlet.resource.DefaultServletHttpRequestHandlerDispatcherservlet - Completed 404 NOT_FOUND

若存在，则执行一下流程

3）根据该 URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain执行链对象的形式返回

4）DispatcherServlet根据获得的Handler，选择一个合适的HandlerAdapter

5）如果成功获得HandlerAdapter，此时将开始执行拦截器的preHandler()方法【正向】

6）提取 Request 中的模型数据，填充Handler入参，开始执行Handler（Controller）方法，处理请求。在填充Handler的入参过程中，根据你的配置，Spring 将帮你做一些额外的工作：

  • a）HttpMessageConveter：将请求消息（如 json、xml 等数据）转换成一个对象，将对象转换为指定的响应信息

  • b）数据转换：对请求消息进行数据转换。如 String 转换成 Integer、Double 等

  • c）数据格式化：对请求消息进行数据格式化。如将字符串转换成格式化数字或格式化日期等

  • d）数据验证：验证数据的有效性（长度、格式等），验证结果存储到 BindingResult 或 Error 中

7）Handler执行完成后，向DispatcherServlet返回一个ModelAndView对象

8）此时将开始执行拦截器的postHandle()方法【逆向】

9）根据返回的ModelAndView（此时会判断是否存在异常，如果存在异常，则执行HandlerExceptionResolver进行异常处理）选择一个适合的ViewResolver进行视图解析，根据Model和View，来渲染视图

10）渲染视图完毕执行拦截器的afterCompletion()方法【逆向】

11）将渲染结果返回给客户端

总结

本届重点掌握

  • SpringMVC 常用组件

  • DispatcherServlet 的初始化过程和调用方法

  • SpringMVC 执行流程

附上导图，仅供参考e

posted @ 2022-11-16 13:31  nakano_may  阅读(64)  评论(0)    收藏  举报