SpringMVC

SpringMVC

1、SpringMVC简介

1.1、什么是MVC

MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分 M:Model，模型层，指工程中的JavaBean，作用是处理数据 V:View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据 C:Controller，控制层，指工程中的servlet，作用是接收请求和响应浏览器

1.2、什么是SpringMVC

SpringMVC是Spring的一个后续产品，是Spring的一个子项目 SpringMVC 是 Spring 为表述层（表述层表示前台页面和后台servlet）开发提供的一整套完备的解决方案。目前业界普遍选择了 SpringMVC 作为 Java EE 项目 表述层开发的首选方案。

1.3、SpringMVC的特点

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

 

2、HelloWorld

2.1、开发环境

 

2.2、创建maven工程

1. 添加web模块：

   1. 创建空白maven工程（或直接使用webapp模版）

   2. 创建webapp文件夹：项目/src/main/webapp

   3. 项目结构-->模块-->部署描述符-->创建web.xml文件（注意路径为项目/src/main/webapp/WEB-INF/web.xml）

2. 更改打包方式为war

3. 引入依赖

<!--==================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.springmvc</groupId>
    <artifactId>springMVC</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--设置打包方式：war-->
    <packaging>war</packaging>

    <!--导入依赖-->
    <dependencies>
        <!-- SpringMVC -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.1</version>
        </dependency>
        <!-- 日志 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        <!-- ServletAPI -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope> <!--设置成provided说明服务器已提供，本项目不会将这个依赖打包-->
        </dependency>
        <!-- Spring5和Thymeleaf整合包 -->
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring5</artifactId>
            <version>3.0.12.RELEASE</version>
        </dependency>
    </dependencies>

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

</project>

 

2.3、配置web.xml

注册SpringMVC的前端控制器DispatcherServlet

• 默认配置方式

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

<!--================web.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 请求路径的请求
            /* 表示包括 .jsp 的所有请求
        -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>

 

• 扩展配置方式（推荐使用）

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

  • 推荐使用扩展配置方式

<!--================web.xml=================-->
		<!-- 扩展配置方式： -->
		<!-- 配置SpringMVC的前端控制器，对浏览器发送的请求统一进行处理 -->
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 通过初始化参数指定SpringMVC配置文件的位置和名称 -->
        <init-param>
            <!-- contextConfigLocation为固定值 --> 
            <param-name>contextConfigLocation</param-name>
            <!-- 使用classpath:表示从类路径查找配置文件，例如maven工程中的src/main/resources -->
            <param-value>classpath:springMVC.xml</param-value>
        </init-param>
        <!--
            作为框架的核心组件，在启动过程中有大量的初始化操作要做 
            而这些操作放在第一次请求时才执行会严重影响访问速度 
            因此需要通过此标签将启动控制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>

 

2.4、创建请求控制器

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

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

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

package com.spring.mvc.controller;

import org.springframework.stereotype.Controller;

@Controller
public class HelloContorller {
}

 

2.5、创建springMVC配置文件

<!--================springMVC.xml=================-->
		<!--开启扫描组件-->
    <context:component-scan base-package="com.spring.mvc.controller"/>

    <!-- 配置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"> <!--内部bean，对模版赋值-->
                <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" />
                        <!--目标页面在/WEB-INF/templates/下，无法直接访问，要通过视图解析器-->
                    </bean>
                </property>
            </bean>
        </property>
    </bean>

    <!--
        处理静态资源，例如html、js、css、jpg
        若只设置该标签，则只能访问静态资源，其他请求则无法访问
        此时必须设置<mvc:annotation-driven/>解决问题
    -->
    <mvc:default-servlet-handler/>

    <!-- 开启mvc注解驱动 -->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <!-- 处理响应中文内容乱码 -->
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <property name="defaultCharset" value="UTF-8" />
                <property name="supportedMediaTypes">
                    <list>
                        <value>text/html</value>
                        <value>application/json</value>
                    </list>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

2.6、测试HelloWorld

• 实现对首页的访问：在请求控制器中创建处理请求的方法

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

 

• 通过超链接跳转到指定页面

在主页index.html中设置超链接(由http://localhost:8080/hello链接到target.html)

<!--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="@{/hello}">HelloWorld</a><br/>
</body>
</html>

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

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

 

2.7、总结

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

 

3、@RequestMapping注解

3.1、@RequestMapping注解的功能

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

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

@RequestMapping的请求地址应唯一，即一个控制器对应一个地址，否则会报错

3.2、@RequestMapping注解的位置

@RequestMapping标识一个类:设置映射请求的请求路径的初始信息（常用于区分不同模块）

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

先读取初始信息再读取具体信息

//============TestController.java================
@Controller
@RequestMapping("/test")
public class TestController {

  	// 此时请求映射所映射的请求的请求路径为:/test/testRequestMapping
    // 即<a th:href="@{/test/testRequestMapping}">测试访问RequestMapping</a>
    @RequestMapping("/testRequestMapping")
    public String testRequestMapping(){
        return "success";
    }

}

 

3.3、@RequestMapping注解的value属性

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

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

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

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

 

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

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

}

 

3.4、@RequestMapping注解的method属性

@RequestMapping注解的method属性通过请求的请求方式(get或post)匹配请求映射，默认匹配任何请求方式的请求

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

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

		<!--超链接默认使用get方式-->
		<a th:href="@{/test}">测试访问RequestMapping的get方法</a>
		<!--使用post方式-->
    <form th:action="@{/test}" method="post">
        <input type="submit" value="测试访问RequestMapping的post方法">
    </form>

 

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

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

}

 

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

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

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

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

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

 

在请求地址相同时可以通过不同的请求方式对应实现不同的功能，但目前浏览器只支持get和post方式，在form表单提交时如果设置了其他请求方式，默认会按get处理

如果要发送put或delete请求，需要通过spring的过滤器HiddenHttpMethodFilter，在restful部分讲解

 

3.5、@RequestMapping注解的params属性

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

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

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

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

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

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

<!--推荐使用thymeleaf请求地址+括号的方式传入请求参数-->
<a th:href="@{/test?username=admin}">测试RequestMapping的params属性1</a><br/>
<a th:href="@{/test(username='admin',password=123456)}">测试RequestMapping的params属性2</a><br/>

 

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

    @RequestMapping(
            value = {"/test", "/testRequestMapping"},
            method = {RequestMethod.GET, RequestMethod.POST},
            params = {"username","password!=1234"} // 要求请求必须携带username参数,且密码不能为1234
    )
    public String testRequestMapping(){
        return "success";
    }

}

 

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

3.6、@RequestMapping注解的headers属性

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

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

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

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

3.7、SpringMVC支持ant风格的路径

?:表示任意的单个字符

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

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

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

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

原始方式传参:/deleteUser?id=1

restful方式传参:/deleteUser/1

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

如果使用了占位符，请求地址必须要和@RequestMapping注解的value属性相匹配，有占位符则请求地址中也必须要有这一层路径

<a th:href="@{/testPath/1/admin}">测试占位符传参</a>

 

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

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

}

 

4、SpringMVC获取请求参数

获取客户端发来的请求所带的请求参数，下一步调用service层方法进行处理

4.1、通过ServletAPI获取

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

@RequestMapping("/testParam")
// 形参位置的request代表当前请求
public String testParam(HttpServletRequest request){
    String username = request.getParameter("username");
    String password = request.getParameter("password");
    System.out.println("username:"+username+",password:"+password);
    return "success";
}

尽量少用这种方式

rest方式传参无法使用这种方式

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

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

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

@Controller
public class ParamController {

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

}

 

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

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

4.3、@RequestParam

@RequestParam是将请求参数和控制器方法的形参创建映射关系（适用于请求参数名和控制器方法形参名不一致的情况）

• @RequestParam注解一共有三个属性:

  1. value:指定为形参赋值的请求参数的参数名

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

  3. defaultValue:当value所指定的请求参数没有传输或传输的值为""时，使用默认值为形参赋值 （任何情况下都应该设置默认值）

@Controller
public class ParamController {

    @RequestMapping("/param")
    public String testParam(
      			// 将请求参数user_name和控制器方法形参username创建映射关系
            @RequestParam(value = "user_name", required=false, defaultValue="admin") String username, 
            String password){
        System.out.println("username = " + username);
        System.out.println("password = " + password);
        return "success";
    }

}

 

4.4、@RequestHeader

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

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

@Controller
public class ParamController {

    @RequestMapping("/param")
    public String testParam(
            @RequestParam(value = "user_name", required = false, defaultValue = "admin") String username,
            String password,
      			// 将请求头和控制器方法形参host创建映射关系
            @RequestHeader("Host") String host){
        System.out.println("username = " + username);
        System.out.println("password = " + password);
        System.out.println("host = " + host); // localhost:8080
        return "success";
    }

}

 

4.5、@CookieValue

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

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

在一个会话中，cookie存在于服务器的第一次响应及后续客户端的每一次请求中

@Controller
public class ParamController {

    @RequestMapping("/param")
    public String testParam(
            @RequestParam(value = "user_name", required = false, defaultValue = "admin") String username,
            String password,
            @RequestHeader("Host") String host,
      			// 将cookie和控制器方法形参cookie创建映射关系
            @CookieValue("Idea-5f33292b") String cookie
    ){
        System.out.println("username = " + username);
        System.out.println("password = " + password);
        System.out.println("host = " + host);
        System.out.println("cookie = " + cookie);
        return "success";
    }

}

 

如何在Spring Boot中使用Cookies

 

4.6、通过POJO获取请求参数

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

注意要为实体类创建对应的无参构造、有参构造、get set方法

 

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

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

乱码问题：

• get方式产生乱码-->tomcat设置

  

• post方式产生乱码-->（要在DispatchServlet获取到请求参数之前设置编码，否则不起作用）

  • 服务器加载顺序： 监听器（只执行一次，监听创建和销毁）-->过滤器（每次请求时都加载）-->servlet，所以选择过滤器进行编码设置

  • SpringMVC中处理编码问题的过滤器（重点） 注意：SpringMVC中处理编码的过滤器一定要配置到其他过滤器之前，否则无效

  <!--web.xml-->
      <!--SpringMVC中处理编码问题的过滤器-->
      <filter>
          <filter-name>CharacterEncodingFilter</filter-name>
          <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
          <init-param>
              <param-name>encoding</param-name> <!--对CharacterEncodingFilter中的encoding赋值-->
              <param-value>UTF-8</param-value> <!--根据filterChain可以确认过滤器的doFilter方法从而找到encoding变量-->
          </init-param>
          <init-param>
              <param-name>forceResponseEncoding</param-name> <!--设置响应时的编码(根据CharacterEncodingFilter源码可知需要设置forceResponseEncoding)-->
              <param-value>true</param-value>
          </init-param>
      </filter>
      <filter-mapping>
          <filter-name>CharacterEncodingFilter</filter-name>
          <url-pattern>/*</url-pattern>
      </filter-mapping>

   

5、域对象共享数据

调用service方法处理完成后，向客户端返回数据

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

使用request.setAttribute向request域设置键值对

<!--index.html-->
<a th:href="@{/testServletAPI}">测试ServletAPI向request域对象共享数据</a>
<!--success.html-->
<h1>Success</h1>
<p th:text="${testScope}"></p>

// ScopeController.java
@Controller
public class ScopeController {

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

}

 

5.2、使用ModelAndView向request域对象共享数据（推荐）

建议使用ModelAndView

无论使用以下何种方式向request域对象共享数据，最终都会封装为ModelAndView对象

• ModelAndView有Model和View的功能

  • Model：向请求域共享数据

  • View：设置视图，实现页面跳转

如果使用了ModelAndView，则ModelAndView必须作为方法的返回值

<!--index.html-->
<a th:href="@{/testModelAndView}">测试ModelAndView向request域对象共享数据</a><br/>
<!--success.html-->
<h1>Success</h1>
<p th:text="${testScope}"></p>

@Controller
public class ScopeController {

    @RequestMapping("/testModelAndView")
    public ModelAndView modelAndView(){
        ModelAndView mav = new ModelAndView();
        // 向请求域共享数据
        mav.addObject("testScope", "ModelAndView");
        // 设置视图，实现页面跳转
        mav.setViewName("success");
        return mav;
    }

}

 

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

如果只使用Model，则在形参的位置设置Model形参，设置视图的方式和原来相同

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

 

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

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

 

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

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

 

5.6、Model、ModelMap、Map的关系

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

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

 

5.7、向session域共享数据

建议使用ServletAPI HttpSession的方式

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

 

5.8、向application域共享数据

获取ServletContext对象并共享

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

 

6、SpringMVC的视图

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

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

当工程引入jstl的依赖，转发视图会自动转换为JstlView

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

什么是视图？

视图的简单理解如下：

经过视图，客户端不须要知道底层table的表结构及其之间的关系。视图提供了一个统一访问数据的接口。

6.1、ThymeleafView

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

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

 

视图类型由视图名称前缀决定

6.2、转发视图

SpringMVC中默认的转发视图是InternalResourceView（网络资源视图）

• SpringMVC中创建转发视图的情况:

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

  • 例如"forward:/"，"forward:/employee"

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

@Controller
public class ScopeController {

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

}

 

6.3、重定向视图

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

• SpringMVC中创建重定向视图的情况:

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

  • 例如"redirect:/"重定向到首页，"redirect:/employee"

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

@Controller
public class ScopeController {

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

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

}

 

6.4、视图控制器view-controller

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

<!--springMVC.xml-->
<!--配置mvc视图控制器view-controller-->
<!--
		path:设置处理的请求地址 
		view-name:设置请求地址所对应的视图名称
-->
<mvc:view-controller path="/" view-name="index"></mvc:view-controller>

以上配置相当于下面这段代码

@Controller
public class HelloContorller {

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

}

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

<!--springMVC.xml-->
<!--开启mvc注解驱动-->
<mvc:annotation-driven />

❓问题：mvc注解驱动有什么用

 

6.5、InternalResourceView

使用jsp而不是thymeleaf时，通过配置InternalResourceViewResolver来实现转发

区别只在于视图解析器

另外超链接也和thymeleaf的形式不同，需要使用el表达式

 

7、RESTful

RESTful是一种风格

7.1、RESTful简介

REST: Resource Representational State Transfer ，表现层资源状态转移。直白地翻译过来就是 “资源”在网络传输中以某种“表现形式”进行“状态转移” 。

表现层：前端页面+后端控制层

资源：“万物皆资源”，资源是一种看待服务器的方式，即，将服务器看作是由很多离散的资源组成。每个资源是服务器上一个可命名的抽象概念。因为资源是一个抽象的概念，所以它不仅仅能代表服务器文件系统中的一个文件、数据库中的一张表等等具体的东西，可以将资源设计的要多抽象有多抽象，只要想象力允许而且客户端 应用开发者能够理解。与面向对象设计类似，资源是以名词为核心来组织的，首先关注的是名词。一个资源可以由一个或多个URI来标识。URI既是资源的名称，也是资源在Web上的地址。对某个资源感兴趣的客户端应用，可以通过资源的URI与其进行交互。

资源的表现形式：资源的表现形式是一段对于资源在某个特定时刻的状态的描述。可以在客户端-服务器端之间转移(交换)。资源的表述可以有多种格式，例如HTML/XML/JSON/纯文本/图片/视频/音频等等。资源的表述格 式可以通过协商机制来确定。请求-响应方向的表述通常使用不同的格式。

状态转移：状态转移说的是在客户端和服务器端之间转移(transfer)代表资源状态的表述（数据传输、资源传输）。通过转移和操作资源的表述，来间接实现操作资源的目的。大白话来说 REST 中的状态转移更多地描述的服务器端资源的状态，比如你通过增删改查（通过 HTTP 动词实现）引起资源状态的改变。ps:互联网通信协议 HTTP 协议，是一个无状态协议，所有的资源状态都保存在服务器端。

什么是RESTful架构：

1. 每一个 URI 代表一种资源；

2. 客户端和服务器之间，传递这种资源的某种表现形式比如 json，xml，image,txt 等等；

3. 客户端通过特定的 HTTP 动词，对服务器端资源进行操作，实现"表现层状态转化"。

7.2、RESTful的实现

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

它们分别对应四种基本操作:GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE 用来删除资源。

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

根据请求方式来确定操作类型

7.3、HiddenHttpMethodFilter

SpringMVC 提供了过滤器 HiddenHttpMethodFilter 帮助我们将 POST 请求转换为 DELETE 或 PUT 请求

• HiddenHttpMethodFilter 处理put和delete请求的条件:

  • 当前请求的请求方式必须为post

  • 当前请求必须传输请求参数_method

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

在web.xml中注册HiddenHttpMethodFilter：

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

使用HiddenHttpMethodFilter时需要通过设置_method参数来设置请求方式

<form th:action="@{/user}" method="post">
  <input type="hidden" name="_method" value="PUT"> <!--设置隐藏域-->
</form>

 

多个过滤器的执行顺序由<filter-mapping>的配置顺序决定

 

7.4、RESTful api规范🌟

路径（接口命名）

1. 网址中不能有动词，只能有名词，API 中的名词也应该使用复数。 因为 REST 中的资源往往和数据库中的表对应，而数据库中的表都是同种记录的"集合"（collection）。如果 API 调用并不涉及资源（如计算，翻译等操作）的话，可以用动词。比如：GET /calculate?param1=11&param2=33 。

2. 不用大写字母，建议用中杠 - 不用下杠 _ 。比如邀请码写成 invitation-code而不是 invitation_code 。

3. 善用版本化 API。当我们的 API 发生了重大改变而不兼容前期版本的时候，我们可以通过 URL 来实现版本化，比如 http://api.example.com/v1、http://apiv1.example.com 。版本不必非要是数字，只是数字用的最多，日期、季节都可以作为版本标识符，项目团队达成共识就可。

4. 接口尽量使用名词，避免使用动词。 RESTful API 操作（HTTP Method）的是资源（名词）而不是动作（动词）。

过滤信息

如果我们在查询的时候需要添加特定条件的话，建议使用 url 参数的形式。例如：

 GET    /classes?state=active&name=guidegege
 GET    /classes?page=1&size=10 //指定第1页，每页10个数据

状态码

2xx：成功	3xx：重定向	4xx：客户端错误	5xx：服务器错误
200 成功	301 永久重定向	400 错误请求	500 服务器错误
201 创建	304 资源未修改	401 未授权	502 网关错误
		403 禁止访问	504 网关超时
		404 未找到
		405 请求方法不对

HATEOAS

 

8、RESTful案例

要自己做一次

 <!--超链接-->
 <a th:href="@{'/employee/'+${employee.id}}">update</a>

 

 <!--访问静态资源所需要的配置(这两个需要同时开启，否则mvc注解不生效)-->
 ​
 <!--开放对静态资源的访问(即使用默认的servlet处理器)-->
 <mvc:default-servlet-handler />
 ​
 <!--开启mvc注解驱动-->
 <mvc:annotation-driven />

 

 

9、HttpMessageConverter

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

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

9.1、@RequestBody

请求报文：请求头、请求空行、请求体（post方式特有的存放数据的位置）

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

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

@Controller
public class HttpController {

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

}

 

9.2、RequestEntity

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

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

 

@Controller
public class HttpController {

    @RequestMapping("/testRequestEntity")
    public String testRequestEntity(RequestEntity<String> requestEntity){  // 设置字符串泛型，以字符串的形式返回结果
        System.out.println("requestHeaders = " + requestEntity.getHeaders()); // 还可以进一步get获取请求头的其他信息
        System.out.println("requestBody() = " + requestEntity.getBody());
        return "success";
    }

}

 

9.3、@ResponseBody

原生ServletAPI响应的方式：

@RequestMapping("/testResponse")
public void testResponse(HttpServletResponse response) throws IOException {
  	response.getWriter().print("hello,response"); 
    // 这种方法直接将print中的内容作为响应体响应给浏览器
}

 

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

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

@Controller
public class HttpController {

    @RequestMapping("/testResponseBody")
    // 在方法上加上@ResponseBody注解后，方法的返回值就是响应给浏览器的数据
    @ResponseBody 
    public String testResponseBody(){
        return "success";	// 此处的success是响应数据，而不是视图名称
    }

}

 

由于http协议限制，无法直接向浏览器响应一个对象，只能响应字符串，所以如果要响应对象时需要使用json

 

9.4、SpringMVC处理json

使用json将对象响应给浏览器

• @ResponseBody处理json的步骤:

  1. 导入jackson的依赖

     <!--pom.xml-->
     <dependency>
         <groupId>com.fasterxml.jackson.core</groupId>
         <artifactId>jackson-databind</artifactId>
         <version>2.12.1</version>
     </dependency>

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

     <!--springMVC.xml-->
     <mvc:annotation-driven/>

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

     @Controller
     public class HttpController {
     
         @RequestMapping("/testResponseUser")
         @ResponseBody
         public User testResponseUser(){
             return new User(1001, "admin", "123456", 22, "male");
             // 这里会自动转换为Json格式的字符串
           	// {"id":1001,"username":"admin","password":"123456","age":22,"sex":"male"}      
             // Json对象和Json数组的区分：看最外层括号，对象{} 数组[]
         }
     
     }

 

9.5、SpringMVC处理ajax

在页面中发送ajax请求，再将数据响应给浏览器

 

 

9.6、@RestController注解

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

@RestController=@Controller+@ResponseBody

 

9.7、ResponseEntity

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

 

10、文件上传和下载

10.1、文件下载

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

<a th:href="@{/testDown}">下载</a>

@RequestMapping("/testDown")
public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws IOException {

    //获取ServletContext对象
    ServletContext servletContext = session.getServletContext();
    //获取服务器中文件的真实路径(getRealPath表示工程在服务器上的部署路径)
    String realPath = servletContext.getRealPath("/static/img/1.jpg");
  
    //创建输入流
    InputStream is = new FileInputStream(realPath);
    //创建字节数组  is.available()获取输入流对应的文件的所有字节数
    byte[] bytes = new byte[is.available()];
    //将流读到字节数组中
    is.read(bytes);
  
    //创建HttpHeaders对象设置响应头信息
    MultiValueMap<String, String> headers = new HttpHeaders();
    //设置要下载方式以及下载文件的名字 (只有文件名可以改，attachment表示以附件的形式下载)
    headers.add("Content-Disposition", "attachment;filename=1.jpg");
  
    //设置响应状态码 200
    HttpStatus statusCode = HttpStatus.OK;
  
    //创建ResponseEntity对象 参数为响应体、响应头、状态码
    ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers, statusCode);
  
    //关闭输入流
    is.close();
  
    return responseEntity;
}

 

10.2、文件上传

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

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

Springboot上传文件可以用这种方法

• 上传步骤：

  1. html页面

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

  2. 添加依赖commons-fileupload

     <!--pom.xml-->
     <!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
     <dependency>
         <groupId>commons-fileupload</groupId>
         <artifactId>commons-fileupload</artifactId>
         <version>1.3.1</version>
     </dependency>

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

     <!--springMVC.xml-->
     <!--配置文件解析器：必须通过文件解析器的解析才能将文件转换为MultipartFile对象-->
     <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
     </bean>
     <!--这里必须将id设置为multipartResolver才能正确获取文件解析器bean-->

  4. 控制器方法

     @Controller
     public class FileUpAndDownController {
     
         @RequestMapping("/testUp")
         public String testUp(MultipartFile photo, HttpSession session) throws IOException {
             // System.out.println(photo.getName()); // 获取html中的name
             // System.out.println(photo.getOriginalFilename()); // 获取文件名
     
             // 获取上传文件的文件名
              String fileName = photo.getOriginalFilename();
     
             // 处理文件重名问题 UUID是32位的随机序列
             String suffixName = fileName.substring(fileName.lastIndexOf(".")); // 获取文件后缀
             fileName = UUID.randomUUID().toString() + suffixName;
     
             // 获取服务器中photo目录的路径
             ServletContext servletContext = session.getServletContext();
             String photoPath = servletContext.getRealPath("photo");
             File file = new File(photoPath); // 通过File对象保存图片的存储路径
             // 如果photo目录不存在则创建
             if (!file.exists()){
                 file.mkdir();
             }
             String finalPath = photoPath + File.separator + fileName; // File.separator对应路径的分隔符
             
             // transferTo+(File类型的上传路径) 实现上传功能
             photo.transferTo(new File(finalPath));
             
             return "success";
         }
     
     }

 

10.3、Springboot实现文件下载

//====================DownloadController.java======================
@Controller
public class DownloadController {
    /**
     * 下载文件
     * @return
     */
    @GetMapping("/download")
    @ResponseBody
    public ResponseEntity<org.springframework.core.io.Resource> downAttachment() {
        // 进行下载.
        DownloadService downloadService = new DownloadService();
        return downloadService.downloadToStream(0);
    }
}

//====================DownloadService.java======================
@Service
public class DownloadService {

    /**
     * 以流的形式下载文件
     * @param id 文件id
     * @return
     */
    public ResponseEntity<Resource> downloadToStream(Integer id) {

        // 获取要下载的文件（真实绝对路径）
        File file = new File("/Users/colin13/Desktop/banner.txt");

        // 判断文件是否存在
        if (!file.exists()) {
            ByteArrayResource byteArrayResource = new ByteArrayResource("文件不存在或异常".getBytes(StandardCharsets.UTF_8));
            return ResponseEntity.status(HttpStatus.NOT_FOUND)
                    .header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
                    .body(byteArrayResource);
        }

        // 以下为关键步骤🌟
        // 返回下载信息
        HttpHeaders headers = new HttpHeaders();
        String fileName = file.getName();

        // 设置以附件的形式下载文件
        headers.setContentDispositionFormData("attachment", StringUtils.encodeAllIgnoreSlashes(fileName));

        return ResponseEntity
                .ok()
                .headers(headers)
                .contentLength(file.length())
                .contentType(MediaType.APPLICATION_OCTET_STREAM) // 设置响应类型
                .body(new FileSystemResource(file));
    }

}

 

 

11、拦截器

过滤器作用在浏览器和DispatchServlet之间，拦截器作用在DispatchServlet和Controller之间（Controller也叫handler，即处理器方法）

SpringMVC中的拦截器用于拦截控制器方法的执行，拦截器的三个方法分别在控制器方法执行之前、控制器方法执行之后、渲染视图之后执行

11.1、拦截器的配置

SpringMVC中的拦截器需要实现HandlerInterceptor

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

    <!--开启扫描拦截器组件-->
    <context:component-scan base-package="com.spring.mvc.interceptor"/>

    <!--配置拦截器-->
    <mvc:interceptors>
        <!--拦截DispatchServlet处理的所有请求的拦截器-->
        <!--方式一：直接设置bean标签-->
        <!--<bean class="com.spring.mvc.interceptor.FirstInterceptor"></bean>-->
        <!--方式二：使用ref，这种方式需要先给拦截器加上组件注解@Component-->
        <!--<ref bean="firstInterceptor"></ref>-->

        <!--自定拦截规则的拦截器-->
        <mvc:interceptor>
            <!-- /*表示拦截一层请求，/**表示拦截所有请求 -->
            <mvc:mapping path="/**"/>
            <!-- 排除主页面 -->
            <mvc:exclude-mapping path="/"/>
            <!-- 设置使用的拦截器 -->
            <ref bean="firstInterceptor"></ref>
        </mvc:interceptor>
    </mvc:interceptors>

<!-- 
		以上配置方式可以通过ref或bean标签设置拦截器，
		通过mvc:mapping设置需要拦截的请求，
		通过mvc:exclude-mapping设置需要排除的请求，即不需要拦截的请求
-->

 

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

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

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

  2. postHandle:控制器方法执行之后执行postHandle()

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

 

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

查看源码可以理解执行顺序，preHandle()所在循环为顺序，postHandle()和afterComplation()所在循环为倒序，且要注意索引值interceptorIndex的变化

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

  • 此时多个拦截器的执行顺序和拦截器在SpringMVC的配置文件的配置顺序有关: preHandle()会按照配置的顺序执行，而postHandle()和afterComplation()会按照配置的反序执行

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

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

 

12、异常处理器

12.1、基于配置的异常处理

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

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

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

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

 

    @RequestMapping("/testError")
    public String testError(){
        System.out.println(1/0);
        return "success";
    }

 

12.2、基于注解的异常处理

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

    //@ExceptionHandler用于设置所标识方法处理的异常
    @ExceptionHandler(value = {ArithmeticException.class, NullPointerException.class})
    //形参位置的ex表示当前请求处理中出现的异常对象（异常信息）
    public String testException(Exception ex, Model model){
        //保存异常信息并添加到model中
        model.addAttribute("ex", ex);
        return "error";
    }

}

 

13、注解配置SpringMVC

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

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

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

Spring提供了这个接口的实现，名为SpringServletContainerInitializer，这个类反过来又会查找实现WebApplicationInitializer的类并将配置的任务交给它们来完成。Spring3.2引入了一个便利的WebApplicationInitializer基础实现，名为AbstractAnnotationConfigDispatcherServletInitializer，当我们的类扩展了AbstractAnnotationConfigDispatcherServletInitializer并将其部署到Servlet3.0容器的时候，容器会自动发现它，并用它来配置Servlet上下文。

//=============com/spring/mvc/config/WebInit.java================
// 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};
    }

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

    /**
     * 添加过滤器
     * @return
     */
    @Override
    protected Filter[] getServletFilters() {
        // 编码过滤器
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("utf-8");
        characterEncodingFilter.setForceEncoding(true);
        // 请求方法过滤器
        HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();

        return new Filter[]{characterEncodingFilter, hiddenHttpMethodFilter};
    }
}

 

13.2、创建SpringConfig配置类，代替spring的配置文件

 

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

要实现WebMvcConfigurer

//=========com/spring/mvc/config/WebConfig.java==========
// 代替SpringMVC的配置文件
// 配置类标识
@Configuration
// 扫描组件
@ComponentScan("com.spring.mvc")
// 开启MVC注解驱动
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    /**
     * 使用默认的servlet处理静态资源，开放对静态资源的访问
     * @param configurer
     */
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

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

    /**
     * 配置拦截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 创建拦截器
        FirstInterceptor firstInterceptor = new FirstInterceptor();
        // 设置拦截规则
        registry.addInterceptor(firstInterceptor).addPathPatterns("/**");
        registry.addInterceptor(firstInterceptor).excludePathPatterns("/test");
    }

    /**
     * 配置视图控制，相当于view-controller
     * @param registry
     */
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        // 将路径"/"映射到视图index
        registry.addViewController("/").setViewName("index");
    }

    /**
     * 配置异常映射
     * @param resolvers
     */
    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
        Properties prop = new Properties();
        prop.setProperty("java.lang.ArithmeticException", "error");
        exceptionResolver.setExceptionMappings(prop);
        // 保存异常信息
        exceptionResolver.setExceptionAttribute("exception");
        resolvers.add(exceptionResolver);
    }

    /**
     * 以下为视图解析器的配置
     * 三个bean对象之间存在依赖关系，要先后创建
     * 用到的参数通过自动装配进行赋值
     * @return
     */
    //配置生成模板解析器
    @Bean
    public ITemplateResolver templateResolver() {
        WebApplicationContext webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
        // ServletContextTemplateResolver需要一个ServletContext作为构造参数，可通过 WebApplicationContext 的方法获得
        ServletContextTemplateResolver templateResolver = new ServletContextTemplateResolver(webApplicationContext.getServletContext());
        templateResolver.setPrefix("/WEB-INF/templates/");
        templateResolver.setSuffix(".html");
        templateResolver.setCharacterEncoding("UTF-8");
        templateResolver.setTemplateMode(TemplateMode.HTML);
        return templateResolver;
    }
    //生成模板引擎并为模板引擎注入模板解析器
    @Bean
    public SpringTemplateEngine templateEngine(ITemplateResolver templateResolver) {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(templateResolver);
        return templateEngine;
    }
    //生成视图解析器并未解析器注入模板引擎
    @Bean
    public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
        ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
        viewResolver.setCharacterEncoding("UTF-8");
        viewResolver.setTemplateEngine(templateEngine);
        return viewResolver;
    }
    
}

 

期间报错HTTP Status 500 - Servlet.init() for servlet dispatcher threw exception，将@ComponentScan("com.spring.mvc.controller")改为@ComponentScan("com.spring.mvc")后正常

 

13.4、测试功能

 

14、SpringMVC执行流程

14.1、SpringMVC常用组件

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

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

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

  • 作用：建立请求和处理器方法的映射关系

• Handler: 也叫Controller，处理器，需要工程师开发

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

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

  • 作用:通过HandlerAdapter对处理器(控制器方法)进行执行，即用来调用处理器方法

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

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

• View: 视图，不需要工程师开发，由框架或视图技术提供

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

 

14.2、DispatcherServlet初始化过程

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

 

 

14.3、DispatcherServlet调用组件处理请求

 

 

 

14.4、SpringMVC的执行流程

1. 用户向服务器发送请求，请求被SpringMVC 前端控制器 DispatcherServlet捕获。

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

   1. 不存在

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

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

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

   2. 存在则执行下面的流程

3. 根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象(包括Handler对象以及Handler对象对应的拦截器)，最后以HandlerExecutionChain执行链对象的形式返回。

4. DispatcherServlet 根据获得的Handler，选择一个合适的HandlerAdapter。

5. 如果成功获得HandlerAdapter，此时将开始执行拦截器的preHandler(...)方法【正向】

6. 提取Request中的模型数据，填充Handler入参，开始执行Handler(Controller)方法，处理请求。 在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作:

   1. HttpMessageConveter: 将请求消息(如Json、xml等数据)转换成一个对象，将对象转换为指定 的响应信息

   2. 数据转换:对请求消息进行数据转换。如String转换成Integer、Double等

   3. 数据格式化:对请求消息进行数据格式化。 如将字符串转换成格式化数字或格式化日期等

   4. 数据验证: 验证数据的有效性(长度、格式等)，验证结果存储到BindingResult或Error中

7. Handler执行完成后，向DispatcherServlet 返回一个ModelAndView对象。

8. 此时将开始执行拦截器的postHandle(...)方法【逆向】。

9. 根据返回的ModelAndView(此时会判断是否存在异常:如果存在异常，则执行 HandlerExceptionResolver进行异常处理)选择一个适合的ViewResolver进行视图解析，根据Model 和View，来渲染视图。

10. 渲染视图完毕执行拦截器的afterCompletion(...)方法【逆向】。

11. 将渲染结果返回给客户端。

12.