1.SpringMVC简介

1.总结

视图控制器的处理结果会包装成ModelAndView然后然后交给视图解析器，视图解析器可以是themeleaf视图解析器，也可以时传统的servlet视图解析器，映射到jsp文件。关于视图解析器时在springMVC中配置的，因为视图控制器也是在springmvc中配置的。web配置一个springMV的统一的DispatcherServlet，然后在进一步交给控制器来处理。处理的结果为ModelAndView视图和数据，交给视图解析器来处理，展示相应的文件

1.两种视图解析器的配置

传统的servlet

        <context:component-scan base-package="com.demo03.control"/>
<!--        配置传统的servlet视图解析器-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/templates/"/>
            <property name="suffix" value=".jsp"/>
        </bean>

2.thymeleaf视图解析器

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

2.控制器的配置

控制器的配置主要方式有两种，一种是注入bean对象，可以进行一定的业务逻辑处理。另一种是视图标签配置(mvc:view-controller)，不需要进行业务逻辑的处理。

注入bean方法的返回值有两种形式，一种是返回一个ModelAndView视图，另一种是返回一个String字符窜，实际上是视图的名称,交给系统进一步处理成ModelAndView视图。

此外当使用mvc:view-controller标签配置视图时，需要开启注解驱动，才能进行包扫描。如果没有任何标签配置，默认为注解驱动，只需要开启包扫描就好。方式如下：

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

1. 配置驱动(优先级低于bean配置)

<context:component-scan base-package="com.demo02.control"/>
<mvc:view-controller path="/" view-name="test_view"></mvc:view-controller>
<!--    开启注解驱动-->
        <mvc:annotation-driven/>

2.bean配置

<context:component-scan base-package="com.demo02.control"/>

@Controller
public class UserController {

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

}

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

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


    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--        配置SpringMVC的配置文件的位置和名称-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <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>
        <!--
            斜线表示当前发送的所有请求
            但是不包括jsp文件，
            和/*有所区别-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

2.SpringMVC的特点

配置文件和spring无缝连接
基于原生的Servlet,通过了功能强大的前端控制器DispatchServlet,对请求和响应进行了统一的处理
代码简单，开发效率很大的提高了
内部组件化程度高，可以随意插入组件。
性能好

3.细碎知识点

1.script脚本

script脚本不支持折叠。

<script th:src="@{/static/js/vue.js}" type="text/javascript"></script>

html文件是自上而下的执行方式，但引入的css和javascript的顺序有所不同，css引入执行加载时，程序仍然往下执行，而执行到<script>脚本则中断线程，待该script脚本执行结束之后程序才继续往下执行。

如果dom没生成，不会被选中，所以我们可以加个onload指定记载完dom之后再执行代码。

onload=function (){
    //里面放需要执行的代码
}

2.单选框回显

themeleaf中${}解析request域中的数据

gender: <input type="radio" name="gender" value="0" th:field="${employee.gender}">male
<input type="radio" name="gender" value="1" th:field="${employee.gender}">female<br>

如果th:field的值和radio的值相同就会自动选中。

二.HelloWord

1.创建空的web的项目，并将打包方式设置为war包。

2.添加依赖。

    <dependencies>
<!--        Spring-MVC-->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.10</version>
        </dependency>
<!--        日志-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

<!--        SpringAPI tomcat自己已经提供了这个jar包，所以我们的范围选成provided，打包的时候不会加入到war包中,由服务器提供-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
<!--spring和thymeleaf的整合-->
        <!--thymeleaf是个视图技术-->
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring5</artifactId>
            <version>3.0.12.RELEASE</version>
        </dependency>

    </dependencies>

thymeleaf就是控制前端显示内容的jar包。

3.配置webapp和web.xml,web.xml是用来控制web请求的配置文件。

srpingmvc实际就是一个统一处理的servlet

首先配置SpringMVC的前端控制器

<!--    配置SpringMVC的前端控制器,对浏览器发出的请求统一处理-->
    <servlet>
        <servlet-name>SrpingMVc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <!--       
            斜线表示当前发送的所有请求
            但是不包括jsp文件，
            和/*有所区别-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>

jsp的本质就是个servlet,他需要经过服务器指定特殊的servlet来处理，所以不需要经过springMVC/DispatcherServlet处理。如果被处理就找不到*.jsp页面了。一般的jsp语言可以直接写在webapp目录下面，可以直接通过路径访问到，WEB-INF是一个不可以外部访问的资源文件夹，可以内部访问然后展示出来，其他文件夹里面的内容可以通过路径访问，是开放的。

<url-pattern>/*会拦截JSP，静态文件，不拦截Servlet，拦截陌生URL

<url-pattern>/</url-pattern>拦截静态文件，不拦截JSP和Servlet，拦截陌生URL,静态资源会被拦截

默认的配置文件，SpringMVC的配置文件默认应该放到WEB-INF下，默认名称为-servlet.xml，就是springmvc-servlet.xml

扩展配置方式

可以通过配置初始化参数的方式，指定扩展配置文件的位置

<!--    配置SpringMVC的前端控制器,对浏览器发出的请求统一处理-->
    <servlet>
        <servlet-name>SrpingMVc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--        配置SpringMVC的配置文件的位置和名称-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springMVC.xml</param-value>
        </init-param>
<!--        将前端控制器DispatcherServlet的初始化时间提前到服务器启动时。-->
        <load-on-startup>1</load-on-startup>
    </servlet>

4.创建请求控制器

通过普通的java类来承担，需要加上注解@Controller

5.配置视图解析器

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

同时，对应的需要在html中添加对应的标签。

<html lang="en" xmlns:th="http://www.thymeleaf.org">
    
</html>

6.其他配置

配置tomcat，部署war包，正常来说，页面中的请求分为有绝对路径，可能需要加上上下文，用th的标签可以帮我们自动加上固定的上下文路径。：

    <a th:href="@{/target}">通过thymeleaf导航</a>

3.@RequestMapping

如果RequestMapping注解添加到方法上,指的是请求的最终地址
如果RequestMapping注解添加到controller类上，则是请求地址的公共前缀。

经常用于表示当前不同的模块
RequesMapping不用管默认上下文的接收。

1.不同的属性

value string[]是个数组，可能接收处理多个地址。 404资源找不到

value={"",""};

- **method属性**:请求方式，**数组**   **报错报400**

  ```java
  RequestMethod.POST

RequestMethod.GET

RequestMethod.HEAD

RequestMethod.PUT

同时存在派生注解

GetMapping
PostMapping

知识点1 form表单的请求方式

form表单只有两种请求方式:post和get,如果不是则这两种请求方式，则默认是get方式。

params 根据请求参数去匹配请求 字符窜数组 报错405 ，@RequestMapping的参数。
- params = {"username"} 必须携带username参数,也可以有其他的参数
- params={"!username"} 不能携带username参数。
- params={"username=a"} 必须携带参数并且参数值固定
- params={"username!=a"} 必须携带参数并且参数值不为

知识点2 thymeleaf路径传参

<a href="/test/testParams?username=123">testParams测试</a>
<a th:href="@{/test/testParams(username='123',password=123)}">thymeleaf新的get传递参数的方法</a>

headers属性(了解)，头信息也是键值对，和param的用法一模一样，有四种方式

2.请求路径中的占位符

?相当于任意的字符，处理特殊符号？和/
*表示0个或者多个 相似的字符 字符的内容任意
**任意的一层或者多层目录 /**/代表任意层任意目录,没有也可以

@RequestMapping("/tes?/zhanweifu")
public String success{
    return "success";
}

3.springmvc支持的路径中的占位符

路径上的参数/{}/{}，来指定路径中参数对应的id，然后通过@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";
}

四、SpringMVC获取请求参数

1.通过serletAPI获取

request.getParameter();

通过HttpServletRequest对象获取。

因为响应方法是框架调用的，他会根据我们的形参传入响应的参数。

所以我们可以直接获取HttpServletRequest参数。

没必要用原生的Servlet获取请求参数.

    @RequestMapping("/test")
    public String testParams(HttpServletRequest request) {
        String username = request.getParameter("next");
        return username;
    }

2.通过控制器方法的形参获取参数

方法：getParameter(),getParameterValues()

只要形参名字和请求方式一致就自动注入实参。
如果多个同名的请求参数，在原生的中，使用getParameterValues获取请求参数数组,
- 控制器方法如果参数是一个字符窜，则将请求参数的内容通过逗号拼接成一个字符窜
- 如果形参是个数组，则赋值就是个数组。
如果形参名和需要被注入的实参不同，使用注解@RequestParam(value="")
- value（name）实参名
- require是否必需注入，自动装配装配不了就是null，但如果开启必须注入没有则报错。
- defaultValue:默认值，当没有对应的实参，或者实参为空

3.@RequestHeader

将请求头信息和参数进行映射。

4.@CookieValue

5.通过POJO获取请求参数

可以写个java类接收一些列参数，会自动封装到对应的属性上。

本质就是，控制器去分析参数，然后根据现有的参数往里面注入实参。

6.解决实参的字符出现乱码问题

以前的解决方法是用request.setCharacterEncoding("utf-8")；将原有的编码方式转变成新的编码方式，一般使用baseServle处理。

乱码按请求方式分为。

需要在request第一次被读取数据之前写成转陈utf-8编码

get，是由tomcat造成的，所以设置tomcat的配置文件即可。
post 只有post会获取到乱码

小知识三大组件的声明周期

监听器
过滤器
servlet
我们要在servlet获取到参数前设置编码数据的编码方式，所以创建一个过滤器实现重置数据的编码，该过滤器要求在此之前没有获取过任何请求参数，否则失效，与后文为了使用put的delete新增的过滤器形成矛盾，因为新增过滤器会获取请求参数，所以需要先配置下述过滤器。

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

五、域对象中共享数据

如果我们要数据在视图中显示，就需要在域对象中共享。

域对象：

request：一次请求，一次request
application(servletContext)，只与服务器有关，整个服务器开启的时候只会运行一次。可以共享数据
session：浏览器开始，浏览器关闭。session中的数据会自动序列话写入到;cookie一致，session一致。

一般常用session和request

1.使用servletAPI向request域对象共享数据

request.setAtrribute("username","此电脑");

themeleaf中只有标签里面的属性可以被th解析，前提是属性前面要加上th:的标签。然后用${域对象中的变量名}。获取到request中对应的变量。

2.使用ModelAndView向request域对象中共享数据

springmvc为我们提供了一个对象 ModelAndView,所有的请求都会被封装成ModelAndVIew对象，即使只返回一个字符窜，也会被封装成一个ModelAndView对象。

@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView(){
    ModelAndView mav = new ModelAndView();
    mav.addObject("testScope","hello,ModelAndView");
    mav.setViewName("success");
    return mav;
}

3.通过Model对象向Request域对象中共享数据

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

4.通过Map对象向Request域对象中共享数据

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

5.通过ModelMap对象向Request域对象中共享数据

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

6.Model,ModelMap和Map之间的关系

springmvc向形参中在注入实参的是同一个，对于这三个形参传入实参为BindingAwareModelMap。

![image](https://img2020.cnblogs.com/blog/1981378/202111/1981378-20211124205517894-1697621752.png)

BindingAwareModelMap实现了Model的接口和ModelMap的类，其中ModelMap类继承了map接口。

7.向session域共享数据

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

通过session.键的形式获取到共享的数据。

8.向application域共享数据

通过application.xxx获取数据

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

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

六、springmvc视图

Springmvc中的视图接口是View接口，将模型Model的数据展示给客户。

springmvc的视图的种类有很多，默认有转发视图(forward:)和重定向视图(redirect:)

jstl，是个依赖，转发视图自动转换成jstlView
如果使用的视图技术为themeleaf,在springmvc配置文件中配置了Thymeleaf视图。
没有前缀就是themeleaf视图

1.themeleaf视图

就是没有前缀的themeleaf视图。

2.转发视图forword

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

ha.handle执行的是控制器方法。转发发生在服务器内部，可以获取到request里面的内容，但是不能跨域访问外部资源。

3.重定向视图

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

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

其中，Redirect不可以获取request的对象，是一个全新的请求,可以跨域。

4.视图控制器view-controller

当不需要进行任何业务逻辑的处理的时候，我们可以直接用请求名作为视图名称。可以直接在springmvc配置文件中配置view-controller。

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

如果使用了标签的view-controller,所有的controller控制器全部失效。

开启注解驱动可以解决这个问题。themeleaf处理的优先级更高

<mvc:annotation-driven/>

view-controller的控制级别小于themeleaf和controller的组合，相同路径由controller处理。

5.jsp页面

如果想通过视图控制器访问jsp资源，则需要配置另外一个视图解析器，现在的themeleaf配置只能解析html页面。

        <context:component-scan base-package="com.demo03.control"/>
<!--        配置传统的servlet视图解析器-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/templates/"/>
            <property name="suffix" value=".jsp"/>
        </bean>

tomcat默认的首页为webapp下的index.**页面，我们也可以在web.xml中自己配置欢迎页面。

有些路径具有一定的路径前缀，例如/xxx_war/success，前缀可能会随时变化，可以通过EL表达式写一个动态的路径前缀。

<a href="${pageContext.request.contextPath}/success">Success.jsp</a>

${pageContext.request.contextPath}用于解决使用相对路径时出现的问题，它的作用是取出所部署项目的名字。

七、RESTFUL

1.简介

![image](https://img2020.cnblogs.com/blog/1981378/202111/1981378-20211124205725640-1773071380.png)

REST:全称表现层资源状态转移。

操作资源的方式四种：POST,DELETE,GET,PUT增删查改

其中，POST只能通过表单形式发送，或者ajax
get就是form和a

delet和put通过过滤器实现请求。使用到的过滤器是HiddenHttpMethodFilter,它默认的提交方式是post，然后将post请求按照参数_method的值转换请求方式，变成delete和put。

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

delete请求:如果面对超链接的情况，我们只要阻止超链接的正常行为，新加入响应事件，通过ajax或者隐藏表单实现请求的封装和转发。
put请求:

REST风格就是不在用？传递参数，而是用斜线把所有的参数写在请求路径中。

![image](https://img2020.cnblogs.com/blog/1981378/202111/1981378-20211124205749294-1928946613.png)

2.准备工作

bean类

@Data
public class Employee {
    private Integer id;
    private String lastName;

    private String email;
    //1 male, 0 female
    private Integer 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;
    }

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

    public Employee() {
    }
}

仓库

@Repository
public class EmployeeDao {

    private static Map<Integer, Employee> employees = null;

    static{
        employees = new HashMap<Integer, Employee>();

        employees.put(1001, new Employee(1001, "E-AA", "aa@163.com", 1));
        employees.put(1002, new Employee(1002, "E-BB", "bb@163.com", 1));
        employees.put(1003, new Employee(1003, "E-CC", "cc@163.com", 0));
        employees.put(1004, new Employee(1004, "E-DD", "dd@163.com", 0));
        employees.put(1005, new Employee(1005, "E-EE", "ee@163.com", 1));
    }

    private static Integer initId = 1006;

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

    public Collection<Employee> getAll(){
        return employees.values();
    }

    public Employee get(Integer id){
        return employees.get(id);
    }

    public void delete(Integer id){
        employees.remove(id);
    }
}

2.功能清单

![image](https://img2020.cnblogs.com/blog/1981378/202111/1981378-20211124205808282-496762719.png)

1.展现所有员工

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Employee Info</title>
</head>
<body>

<table id="table" border="1" cellspacing="2px" cellpadding="2px" style="text-align: center;vertical-align: center">
    <tr>
        <th colspan="5">Employee Info</th>
    </tr>
    <tr>
        <th>id</th>
        <th>lastName</th>
        <th>email</th>
        <th>gender</th>
        <th>options(<a th:href="@{'/toAdd'}">Add</a>)</th>
    </tr>
    <tr th:each="eachOne : ${employees}">
        <td th:text="${eachOne.id}"></td>
        <td th:text="${eachOne.lastName}"></td>
        <td th:text="${eachOne.email}"></td>
        <td th:text="${eachOne.gender}"></td>
        <td>
            <a @click="deleteMethod" th:href="@{'/employee/'+${eachOne.id}}">delete</a>
            <a th:href="@{'/employee/'+${eachOne.id}}">update</a>
        </td>
    </tr>
</table>
    <form method="post" id="hiddenForm">
        <input type="hidden" name="_method" value="delete">
    </form>
<script th:src="@{/static/js/vue.js}" type="text/javascript"></script>
<script type="text/javascript">

    var vue  = new Vue({
        el: '#table',
        methods: {
            deleteMethod: function (event){
                var form1 = document.getElementById('hiddenForm');
                form1.action = event.target.href;
                form1.submit();
                event.preventDefault();
            }
        }
    });
</script>
</body>
</html>

通过th:text：注入内容
需要通过a标签控制form表单，需要通过js实现，本案例中，使用了vue组件，绑定table,然后给a添加事件函数，同时取消原本的执行方式。

更新信息

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Update</title>
</head>
<body>
    <form th:action="@{'/employee'}" method="post">
        <input type="hidden" name="_method" value="put">
        <input type="hidden" name="id" th:value="${employee.id}">
        lastName: <input type="text" name="lastName" th:value="${employee.lastName}"><br>
        email: <input type="text" name="email" th:value="${employee.email}"><br>
        gender: <input type="radio" name="gender" value="0" th:field="${employee.gender}">male
        <input type="radio" name="gender" value="1" th:field="${employee.gender}">female<br>
        <input type="submit" value="update"><br>
    </form>
</body>
</html>

静态资源访问

<mvc:default-servlet-handler/>

该标签可以使服务器现有springmvc处理，然后找不到，交给默认的servlet处理，这样就可以找到静态资源了。如果还找不到，也不会是springmvc报错。

因为tomcat默认的servlet被dispatcherServlet覆盖了，所以我们需要进行特殊声明，同时一旦使用到mvc标签。我们就要开启mvc的注解驱动，否则默认是关闭的。

八、HttpMessageConverter

全称报文信息转换器，可以将请求报文转换成java对象，或者将java对象转换成响应报文。

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

1.RequestBody

作用：获得请求体

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

requestBody:username=cjmcjm&password=111111

2.获取请求实体

@PostMapping(value ="/testRequestEntity")
public String testRequestEntity(RequestEntity<String> requestEntity){
    System.out.println("请求头:"+requestEntity.getHeaders());
    System.out.println("请求体:"+requestEntity.getBody());
    return "success";
}

作用：将请求报文分装成java对象

输出：

请求头:[host:"localhost:8080", user-agent:"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:93.0) Gecko/20100101 Firefox/93.0", accept:"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,/;q=0.8", accept-language:"zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2", accept-encoding:"gzip, deflate", content-length:"31", origin:"http://localhost:8080", connection:"keep-alive", referer:"http://localhost:8080/", cookie:"Idea-9283b9b8=75e03715-35ff-4285-a180-77ea3120546f", upgrade-insecure-requests:"1", sec-fetch-dest:"document", sec-fetch-mode:"navigate", sec-fetch-site:"same-origin", sec-fetch-user:"?1", Content-Type:"application/x-www-form-urlencoded;charset=UTF-8"]
请求体:username=cjmcjm&password=111111

3.@ResponseBody

将返回值直接写回到浏览器上，以前是通过response写出的。实际上响应体是什么我们就只能看到什么，一般而言响应体是页面，所以我们能看到页面，如果响应体是其他信息那我们就只能看到其他信息。ajax就是这样的情况。

@GetMapping("/testResponse")
public void testResponse(HttpServletResponse response) throws IOException {
    response.getWriter().println("<h1>Hello,response<h1>");
}

不需要视图解析，就不用返回任何值。

通过注解实现：

@GetMapping("/testResponse1")
@ResponseBody
public String testResponse1(){
    return "<h1>Hello,response<h1>";
}

4.springmvc来处理json

直接写回一个对象

浏览器没办法解析对象，但是可以统一成json字符窜，需要导入json相关的依赖包。

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

引入依赖之后，需要开启mvc的注解驱动，依赖的jar包中自动注解了一个消息转换器MappingJackson2HttpMessageConvert，所以回写的对象会自动转换成json对象。换成其他包不一定可以。****

<mvc:annotatio-driven/>(三个用处1.view-controller,2.default-servlet-handler,3.json包引入)

然后直接写回浏览器对象，会自动转换成json字符窜。

5.springmvc处理axios请求

本质就是在springmvc中使用axios

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

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

6.RestController

=@ResponseBody+@Controller

7.ResponseEntity

用于控制器的返回值，该控制器方法返回值就是响应到浏览器的响应报文对应的java对象。需要自己封装响应头响应体，状态码。

8.文件下载

代码：自己写个响应报文,需要注意的是响应头的内容不能改。

通过servlet获取服务器对象，从而找到某个文件url的真实路径
通过fileInputStream读出文件
通过封装报文返回数据

    @GetMapping("/testDown")
    public ResponseEntity<byte[]> downloadPic(HttpSession session) throws IOException {
        ServletContext servletContext = session.getServletContext();
//        获取到请求在服务器中对应的真实地址
        String realPath = servletContext.getRealPath("/static/img/1.jpg");
//        创建输入流
        InputStream is = new FileInputStream(new File(realPath));
//        创建文件等长的字节数组
        byte[] bytes = new byte[is.available()];
        is.read(bytes);
//        设置响应头
        MultiValueMap<String, String> headers = new HttpHeaders();
        headers.add("Content-Disposition", "attachment;filename=1.jpg");
//        设置状态码
        HttpStatus ok = HttpStatus.OK;
//        创建响应体报文
        ResponseEntity<byte[]> response = new ResponseEntity<>(bytes,headers,ok);
        is.close();
        return response;
    }

9.文件上传

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

为了处理二进制的文件，我们需要添加依赖。

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

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

在SpringMVC的配置文件中添加配置。它由框架执行，将上传的二进制文件分装成MultipartFile对象。同时我们预测springmvc是通过bean的id使用bean的。

<!--配置文件上传解析器，将上传的文件封装为MultipartFile-->

<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>

传输的对象需要放到服务器上，需要先获取到服务器上的路径，然后判断路径文件夹是否存在，最后在通过tranferto转换成对应的文件。

@PostMapping("/testUp")
public String testUp(MultipartFile photo,HttpSession session) throws IOException {
    String filename = photo.getOriginalFilename();
    String photo1 = session.getServletContext().getRealPath("photo");
    File file = new File(photo1);
    if(!file.exists()){
        file.mkdir();
    }
    filename = photo1+"/"+filename;
    photo.transferTo(new File(filename));
    return "success";
}

为了避免文件重复通常的做法是将uuid作为文件名。

String filename = photo.getOriginalFilename();
String rand1 = UUID.randomUUID().toString();
filename  = rand1 + filename.substring(filename.lastIndexOf("."));

九、拦截器

![image](https://img2020.cnblogs.com/blog/1981378/202111/1981378-20211124211541097-895915088.png)

执行顺序： filter-->DispatcherServlet-->controller

拦截器就是在controller前后执行的，在之前使用preHandle方法
之后执行PostHandler方法(具体来时就是controller创建ModelAndView前后)
所有结束,渲染视图完毕之后。

1.自定义拦截器

自定义拦截器的类需要继承专门的接口HandlerInterceptor接口

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

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

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

2.在配置文件中配置对应的控制器

1.直接植入一个bean作为拦截器

特点是对所有的有控制器方法的请求进行拦截

<mvc:interceptors>
    <bean class="com.atguigu.mvc.Intercept.MyIntercept"></bean>
</mvc:interceptors>

2.ref和bean的作用相同

<bean id="intercept" class="com.atguigu.mvc.Intercept.MyIntercept"></bean>
<mvc:interceptors>
    <ref bean="intercept"></ref>
</mvc:interceptors>

3.自定义拦截规则的拦截器

拦截其中路径有自己的含义，/**拦截所有请求
/*拦截一层目录的请求
/拦截主页面的请求

特点： 只有有控制器的方法才会被对应的拦截器

<!--    配置拦截器-->
    <mvc:interceptors>
<!--        <bean class="com.atguigu.mvc.Intercept.MyIntercept"></bean>-->
<!--        <ref bean="intercept"></ref>-->
<!--        自定义拦截方式-->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <mvc:exclude-mapping path="/"/>
            <ref bean="intercept"></ref>
        </mvc:interceptor>
    </mvc:interceptors>

<!--    配置拦截器-->
    <mvc:interceptors>
<!--        <bean class="com.atguigu.mvc.Intercept.MyIntercept"></bean>-->
<!--        <ref bean="intercept"></ref>-->
<!--        自定义拦截方式-->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <mvc:exclude-mapping path="/"/>
            <ref bean="intercept"></ref>
        </mvc:interceptor>
    </mvc:interceptors>

2.多个拦截器时执行顺序

特点：与我们在拦截器中的配置顺序一致。

如下配置两个拦截器:

<!--    配置拦截器-->
    <mvc:interceptors>
<!--        <bean class="com.atguigu.mvc.Intercept.MyIntercept"></bean>-->
        <ref bean="intercept"></ref>
<!--        自定义拦截方式-->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <mvc:exclude-mapping path="/"/>
            <ref bean="myIntercept"></ref>
        </mvc:interceptor>
    </mvc:interceptors>

拦截器包裹在controller的外面，最先装配的包裹在最外层，一个拦截器可以看成包裹了两样东西，controller方法(postHandle)和controller+视图解析(afterCompletion)

源码

![image](https://img2020.cnblogs.com/blog/1981378/202111/1981378-20211124211610568-1539232483.png)

mapperHandler：执行链，包含了两部分数据，当前的控制器方法和拦截器。

倒序执行。

![image](https://img2020.cnblogs.com/blog/1981378/202111/1981378-20211124211628521-946316924.png)

afterCompition和postHandler处理的方法类似。

3.如果有拦截器返回false

preHandler方法停止执行
调用已经执行了postHandler方法拦截器的AfterCompition方法。
程序直接结束，不进行视图处理。

十一、异常处理器

1.基于配置的异常处理

SpringMVC提供了处理控制器方法执行过程中所出现的异常的接口：HandlerExceptionResoler,控制器方法在执行过程中发生异常则会被处理。

HandlerExceptionResoler接口的实现类有：DefaultHandlerExceptionResolver和SimpleMappingExceptionResolver。

SpringMVC自定义的异常处理器为SimpleMappingExceptionResolver,使用方式：

<!--   配置控制器异常处理器-->
    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver" id="exceptionResolver">
        <property name="exceptionMappings">
            <!--
                pros的键表示输入执行过程发生的异常
                值是发生异常时跳转的视图页面
            -->
            <props>
                <prop key="java.lang.ArithmeticException">error</prop>
            </props>
        </property>
<!--        exceptionAttribute属性设置一个属性名，来接收异常信息在请求域进行共享-->
        <property name="exceptionAttribute" value="ex"></property>
    </bean>

2.基于注解的异常处理@ControllerAdvice

这样标注的类可以专门用来处理controller发出的异常，

然后就是@ExceptionHander来指定每个方法要处理的异常类。

@ControllerAdvice
public class MyException {

    @ExceptionHandler(value = {ArithmeticException.class, IOException.class})
    public String test01(Exception exception, Model model){
        model.addAttribute("ex",exception);
        System.out.println(exception);
        return "error";//异常时的错误页面的视图
    }
}

十二、全注解配置

如何取代springmvc的配置文件。

1.创建初始化类，代替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
     * @return
     */
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

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

2.生成springmvc的配置文件

1.thyleaf视图解析器的配置

    //配置生成模板解引擎
    @Bean
    public ITemplateResolver templateResolver(){
        WebApplicationContext webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
        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;
    }



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

2.WebMvcConfigurer

对于不是bean的配置我们需要继承一个接口WebMvcConfigurer

3.最终的配置文件

package com.hjw.config;

import com.hjw.intercpter.MyInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.multipart.MultipartResolver;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.*;
import org.springframework.web.servlet.handler.SimpleMappingExceptionResolver;
import org.thymeleaf.spring5.SpringTemplateEngine;
import org.thymeleaf.spring5.view.ThymeleafViewResolver;
import org.thymeleaf.templatemode.TemplateMode;
import org.thymeleaf.templateresolver.ITemplateResolver;
import org.thymeleaf.templateresolver.ServletContextTemplateResolver;

import java.util.List;
import java.util.Properties;

/**
 * @Author coder
 * @Date 2021/11/4 19:53
 * @Description
 */
//用来代替springmvc的配置文件

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

    //配置生成模板解引擎
    @Bean
    public ITemplateResolver templateResolver(){
        WebApplicationContext webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
        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.setOrder(1);
        viewResolver.setTemplateEngine(templateEngine);
        return viewResolver;
    }

//    开启默认的servlet处理器default-servlet-hander
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

//   创建view-controller
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/hello").setViewName("hello");
        registry.addViewController("/").setViewName("index");
    }

//    配置视图拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**").excludePathPatterns("/","/hello");
    }

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

//    配置异常处理


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

十三、SpringMVC的执行流程

1.SpringMVC常用组件

Handler：处理器或者控制器
HandlerMapping:是找控制器的
HandlerAdapter: 是调用控制器，封装成ModelAndView
viewReSolver：对视图解析，得到相应的视图

2.DispatcherServlet初始化

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

images

a>初始化WebApplicationContext

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

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

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

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

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

    return wac;
}

b>创建WebApplicationContext

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

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

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

    return wac;
}

c>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调用组件处理请求

a>processRequest()

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

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

protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {

    long startTime = System.currentTimeMillis();
    Throwable failureCause = null;

    LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
    LocaleContext localeContext = buildLocaleContext(request);

    RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
    ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());

    initContextHolders(request, localeContext, requestAttributes);

    try {
		// 执行服务，doService()是一个抽象方法，在DispatcherServlet中进行了重写
        doService(request, response);
    }
    catch (ServletException | IOException ex) {
        failureCause = ex;
        throw ex;
    }
    catch (Throwable ex) {
        failureCause = ex;
        throw new NestedServletException("Request processing failed", ex);
    }

    finally {
        resetContextHolders(request, previousLocaleContext, previousAttributes);
        if (requestAttributes != null) {
            requestAttributes.requestCompleted();
        }
        logResult(request, response, failureCause, asyncManager);
        publishRequestHandledEvent(request, response, startTime, failureCause);
    }
}

b>doService()

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

@Override
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
    logRequest(request);

    // Keep a snapshot of the request attributes in case of an include,
    // to be able to restore the original attributes after the include.
    Map<String, Object> attributesSnapshot = null;
    if (WebUtils.isIncludeRequest(request)) {
        attributesSnapshot = new HashMap<>();
        Enumeration<?> attrNames = request.getAttributeNames();
        while (attrNames.hasMoreElements()) {
            String attrName = (String) attrNames.nextElement();
            if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
                attributesSnapshot.put(attrName, request.getAttribute(attrName));
            }
        }
    }

    // Make framework objects available to handlers and view objects.
    request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
    request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
    request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
    request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());

    if (this.flashMapManager != null) {
        FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
        if (inputFlashMap != null) {
            request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
        }
        request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
        request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
    }

    RequestPath requestPath = null;
    if (this.parseRequestPath && !ServletRequestPathUtils.hasParsedRequestPath(request)) {
        requestPath = ServletRequestPathUtils.parseAndCache(request);
    }

    try {
        // 处理请求和响应
        doDispatch(request, response);
    }
    finally {
        if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
            // Restore the original attribute snapshot, in case of an include.
            if (attributesSnapshot != null) {
                restoreAttributesAfterInclude(request, attributesSnapshot);
            }
        }
        if (requestPath != null) {
            ServletRequestPathUtils.clearParsedRequestPath(request);
        }
    }
}

c>doDispatch()

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

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    boolean multipartRequestParsed = false;

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

    try {
        ModelAndView mv = null;
        Exception dispatchException = null;

        try {
            processedRequest = checkMultipart(request);
            multipartRequestParsed = (processedRequest != request);

            // Determine handler for the current request.
            /*
            	mappedHandler：调用链
                包含handler、interceptorList、interceptorIndex
            	handler：浏览器发送的请求所匹配的控制器方法
            	interceptorList：处理控制器方法的所有拦截器集合
            	interceptorIndex：拦截器索引，控制拦截器afterCompletion()的执行
            */
            mappedHandler = getHandler(processedRequest);
            if (mappedHandler == null) {
                noHandlerFound(processedRequest, response);
                return;
            }

            // Determine handler adapter for the current request.
           	// 通过控制器方法创建相应的处理器适配器，调用所对应的控制器方法
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

            // Process last-modified header, if supported by the handler.
            String method = request.getMethod();
            boolean isGet = "GET".equals(method);
            if (isGet || "HEAD".equals(method)) {
                long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                    return;
                }
            }
			
            // 调用拦截器的preHandle()
            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;
            }

            // Actually invoke the handler.
            // 由处理器适配器调用具体的控制器方法，最终获得ModelAndView对象
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

            if (asyncManager.isConcurrentHandlingStarted()) {
                return;
            }

            applyDefaultViewName(processedRequest, mv);
            // 调用拦截器的postHandle()
            mappedHandler.applyPostHandle(processedRequest, response, mv);
        }
        catch (Exception ex) {
            dispatchException = ex;
        }
        catch (Throwable err) {
            // As of 4.3, we're processing Errors thrown from handler methods as well,
            // making them available for @ExceptionHandler methods and other scenarios.
            dispatchException = new NestedServletException("Handler dispatch failed", err);
        }
        // 后续处理：处理模型数据和渲染视图
        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    }
    catch (Exception ex) {
        triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
    }
    catch (Throwable err) {
        triggerAfterCompletion(processedRequest, response, mappedHandler,
                               new NestedServletException("Handler processing failed", err));
    }
    finally {
        if (asyncManager.isConcurrentHandlingStarted()) {
            // Instead of postHandle and afterCompletion
            if (mappedHandler != null) {
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
            }
        }
        else {
            // Clean up any resources used by a multipart request.
            if (multipartRequestParsed) {
                cleanupMultipart(processedRequest);
            }
        }
    }
}

d>processDispatchResult()

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
                                   @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
                                   @Nullable Exception exception) throws Exception {

    boolean errorView = false;

    if (exception != null) {
        if (exception instanceof ModelAndViewDefiningException) {
            logger.debug("ModelAndViewDefiningException encountered", exception);
            mv = ((ModelAndViewDefiningException) exception).getModelAndView();
        }
        else {
            Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
            mv = processHandlerException(request, response, handler, exception);
            errorView = (mv != null);
        }
    }

    // Did the handler return a view to render?
    if (mv != null && !mv.wasCleared()) {
        // 处理模型数据和渲染视图
        render(mv, request, response);
        if (errorView) {
            WebUtils.clearErrorRequestAttributes(request);
        }
    }
    else {
        if (logger.isTraceEnabled()) {
            logger.trace("No view rendering, null ModelAndView returned.");
        }
    }

    if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
        // Concurrent handling started during a forward
        return;
    }

    if (mappedHandler != null) {
        // Exception (if any) is already handled..
        // 调用拦截器的afterCompletion()
        mappedHandler.triggerAfterCompletion(request, response, null);
    }
}

4、SpringMVC的执行流程

用户向服务器发送请求，请求被SpringMVC 前端控制器 DispatcherServlet捕获。
DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI），判断请求URI对应的映射：

a) 不存在

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

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

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

b) 存在则执行下面的流程

根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain执行链对象的形式返回。
DispatcherServlet 根据获得的Handler，选择一个合适的HandlerAdapter。
如果成功获得HandlerAdapter，此时将开始执行拦截器的preHandler(…)方法【正向】
提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)方法，处理请求。在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作：

a) HttpMessageConveter：将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息

b) 数据转换：对请求消息进行数据转换。如String转换成Integer、Double等

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

d) 数据验证：验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中

Handler执行完成后，向DispatcherServlet 返回一个ModelAndView对象。
此时将开始执行拦截器的postHandle(...)方法【逆向】。
根据返回的ModelAndView（此时会判断是否存在异常：如果存在异常，则执行HandlerExceptionResolver进行异常处理）选择一个适合的ViewResolver进行视图解析，根据Model和View，来渲染视图。
渲染视图完毕执行拦截器的afterCompletion(…)方法【逆向】。
将渲染结果返回给客户端。

posted on 2021-11-24 21:17 很绝望阅读(73) 评论(0) 编辑收藏举报

1.SpringMVC简介

1.总结

1.两种视图解析器的配置

传统的servlet

2.thymeleaf视图解析器

2.控制器的配置

1. 配置驱动(优先级低于bean配置)

2.bean配置

3.web.xml

2.SpringMVC的特点

3.细碎知识点

1.script脚本

2.单选框回显

二.HelloWord

1.创建空的web的项目，并将打包方式设置为war包。

2.添加依赖。

3.配置webapp和web.xml,web.xml是用来控制web请求的配置文件。

4.创建请求控制器

5.配置视图解析器

6.其他配置

3.@RequestMapping

1.不同的属性

知识点1 form表单的请求方式

知识点2 thymeleaf路径传参

2.请求路径中的占位符

3.springmvc支持的路径中的占位符

四、SpringMVC获取请求参数

1.通过serletAPI获取

2.通过控制器方法的形参获取参数

3.@RequestHeader

4.@CookieValue

5.通过POJO获取请求参数

6.解决实参的字符出现乱码问题

乱码按请求方式分为。

小知识 三大组件的声明周期

五、域对象中共享数据

1.使用servletAPI向request域对象共享数据

2.使用ModelAndView向request域对象中共享数据

3.通过Model对象向Request域对象中共享数据

4.通过Map对象向Request域对象中共享数据

5.通过ModelMap对象向Request域对象中共享数据

6.Model,ModelMap和Map之间的关系

7.向session域共享数据

8.向application域共享数据

六、springmvc视图

1.themeleaf视图

2.转发视图forword

3.重定向视图

4.视图控制器view-controller

5.jsp页面

七、RESTFUL

1.简介

2.准备工作

2.功能清单

1.展现所有员工

更新信息

静态资源访问

八、HttpMessageConverter

1.RequestBody

2.获取请求实体

3.@ResponseBody

4.springmvc来处理json

5.springmvc处理axios请求

6.RestController

7.ResponseEntity

8.文件下载

9.文件上传

九、拦截器

1.自定义拦截器

2.在配置文件中配置对应的控制器

1.直接植入一个bean作为拦截器

2.ref和bean的作用相同

3.自定义拦截规则的拦截器

2.多个拦截器时执行顺序

源码

3.如果有拦截器返回false

十一、异常处理器

1.基于配置的异常处理

2.基于注解的异常处理@ControllerAdvice

十二、全注解配置

小知识三大组件的声明周期