(1) Este conjunto de temas de aprendizaje de SpringMVC proviene del video del nodo de energía de la estación B : https://www.bilibili.com/video/BV1sk4y167pD?p=1

(2) Una descripción general del contenido del tema es la siguiente:

1. Capítulo 1: Descripción general de SpringMVC

1.1 Introducción a SpringMVC

SpringMVC, también llamado Spring web mvc, es parte del marco de Spring y fue lanzado después de Spring3.0.

1.2 Ventajas de SpringMVC

(1) Basado en la arquitectura MVC: Basado en la arquitectura MVC, las funciones están claramente divididas y desacopladas.

(2) Fácil de entender, rápido de comenzar, simple de usar: después de aprender Spring, puede desarrollar un proyecto SpringMVC anotado. SpringMVC también es liviano y tiene un frasco pequeño. No confíe en interfaces y clases específicas.

(3) Como parte del marco Spring, se pueden usar IoC y Aop de Spring: es conveniente integrar Strtus, MyBatis, Hiberate, JPA y otros marcos.

(4) SpringMVC refuerza el uso de anotaciones, que se pueden usar en controladores, servicios y Dao, que es conveniente y flexible.

Utilice @Controller para crear un objeto de procesador, @Service para crear un objeto de negocio, @Autowired o @Resource para inyectar Service en la clase de controlador y Dao en la clase de servicio.

1.3 Crear un proyecto web SpringMVC: los pasos detallados son los siguientes

1.3.1 Crear un proyecto vacío

1.3.2 Agregar un módulo web SpringMVC a este proyecto vacío

1.3.3 Diagrama esquemático del proyecto web inicial después de agregar el módulo web SpringMVC

1.4 Implementar la función en SpringMVC Web recién creada: pasar por el front y el back end

1.4.0 Requisitos y pasos de implementación

1.4.1 Cree un directorio de recursos de recursos y un directorio de código fuente de Java en el directorio principal

1.4.2 Configurar las dependencias SpringMVC y Servlet en el archivo 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.wind</groupId>
    <artifactId>springmvc-web</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <!--注册站点用，默认生成的，暂时用不到-->
    <name>springmvc-web Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <!--添加servlet依赖-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

        <!--添加SpringMVC依赖，会自动把里面整合的Spring依赖添加进来-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>

    </dependencies>

    <build>
        <finalName>springmvc-web</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>

                <!-- 编码和编译和JDK版本 -->
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.1</version>
                    <configuration>
                        <source>${maven.compiler.source}</source>
                        <target>${maven.compiler.target}</target>
                    </configuration>
                </plugin>

                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

1.4.3 Registre el procesador central DispatchServlet en el archivo web.xml

(1) La versión de restricción de la dependencia web en el archivo web.xml es demasiado baja, reemplácela con una versión potente:

(2) archivo de configuración 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">

    <!--
    注册SpringMVC的核心对象DispatcherServlet，需要在Tomcat服务器启动的时候创建一个DispatcherServlet实例对象。
    为什么要创建DispatcherServlet对象实例呢？
    因为在创建DispatcherServlet对象实例的时候，会创建SpringMVC容器对象，也即会读取SpringMVC的配置文件，把这个配置文件
    中声名的bean对象都创建好，这样的话，当用户发起请求时就可以直接这些对象来处理ajax请求了。
    servlet的初始化方法init()，DispatcherServlet对象的创建在这个init方法中：
    {
    //读取配置文件，创建SpringMVC的Web容器
    WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
    //把容器对象放到ServletContext对象中
    getServletContext().setAttribute("key", ctx);
    }
    测试：启动Tomcat的时候报了一个错：Could not open ServletContext resource [/WEB-INF/springMVC-servlet.xml]
    -->
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--自定义SpringMVC读取的配置文件：
        （1）contextConfigLocation：SpringMVC配置文件位置的属性
        （2）classpath：指定SpringMVC配置文件的位置
        -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <!--Tomcat服务器启动后，就开始创建该SpringMVC容器对象。值是一个大于等于的0的整数，值越小，说明被创建的时间越早。-->
        <load-on-startup>1</load-on-startup>
    </servlet>


    <!--解释url-pattern：
    在使用框架的时候，url-pattern可以有两种取值：
    （1）使用扩展名的方式，语法：*.xxx，其中的xxx是自定义的扩展名，比如：*.action，*.do，*.mvc
        此时针对它们有效：
        http://localhost:8008/springmvc-web/*.do
        http://localhost:8008/springmvc-web/*.action
        http://localhost:8008/springmvc-web/*.mvc
    （2）使用斜杠 / ：代表所有类型的路由类型
    -->
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

1.4.4 Escriba un controlador específico en el paquete java: MyController (doSome procesador solicitado por some.do y doOther procesador solicitado por other.do)

package com.wind.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

/**
 * @Controller 用来创建一个控制器对象，并且存储在SpringMVC容器中，通过这个控制器对象来处理前端请求。
 * 位置：在类的上面
 * 功能：能够处理前端发起的HTTP请求。能够处理请求的都是控制器（处理器），MyController能够处理请求，叫做后端控制器。
 */
@Controller
public class MyController {

    /**
     * 在SpringMVC中，使用方法来处理前端请求。方法是自定义的，可以有多种参数，多种返回值。
     * ModelAndView：使用SpringMVC框架中自带的视图类。
     * (1)在类中添加数据，以便在视图中展示：
     * 比如：modelAndView.addObject("fun", "doSome处理器");
     * (2)在类中添加视图，读取之前在类中添加好的数据：
     * 比如：modelAndView.setViewName("show");
     */
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome() {
        System.out.println("处理some.do这个请求了");
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("msg", "使用注解的SpringMVC应用项目");
        modelAndView.addObject("fun", "doSome处理器");
        modelAndView.setViewName("show");
        return modelAndView;
    }

    @RequestMapping(value = "/other.do")
    public ModelAndView doOther() {
        System.out.println("处理other.do这个请求了");
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("msg", "使用注解的SpringMVC应用项目");
        modelAndView.addObject("fun", "doOther处理器");
        modelAndView.setViewName("other");
        return modelAndView;
    }

}

1.4.5 Configurar el escáner de componentes y ver el solucionador en el archivo springmvc.xml

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

    <!--声名组件扫描器-->
    <context:component-scan base-package="com.wind"/>

    <!--视图解析器：添加前缀和后缀。
    SpringMVC框架为了避免对于请求资源路径与扩展名上的冗余，在视图解析器 InternalResouceViewResolver
    中引入了请求的前辍与后辍。而 ModelAndView 中只需给出要跳转页面的文件名即可，对于具体的文件路径与文件扩展名，
    视图解析器会自动完成拼接。-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--视图文件的路径-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--视图文件的扩展名-->
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

1.4.6 Cree vistas jsp en el directorio del proyecto WEB-INF: show.jsp y other.jsp

<%--
  Created by IntelliJ IDEA.
  Date: 2021/1/1
  Time: 12:22
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h3>/WEB-INF/jsp/show.jsp从request作用域中myController控制器获取的处理结果</h3>
<h3>msg数据是：${msg}</h3>
<h3>fun数据是：${fun}</h3>
</body>
</html>

<%--
  Created by IntelliJ IDEA.
  Date: 2021/1/1
  Time: 12:22
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h3>/WEB-INF/jsp/other.jsp从request作用域中myController控制器获取的处理结果</h3>
<h3>msg数据是：${msg}</h3>
<h3>fun数据是：${fun}</h3>
</body>
</html>

1.4.7 El diagrama de estructura final del proyecto una vez completadas las operaciones anteriores

1.4.8 Pruebas de front-end y back-end

1.5 El flujo de procesamiento de solicitudes web utilizando el marco Spring MVC

1.5.1 Flujo de procesamiento de SpringMVC para análisis de código fuente de solicitudes de front-end

[IntelliJ IDEA para macOS muestra rápidamente todos los métodos abreviados de una clase: comando + 7]

1.5.2 Explicación del directorio WEB-INF

(1) Los recursos del directorio WEB-INF no están abiertos a los usuarios, es decir, los usuarios no pueden acceder directamente a ellos.

(2) Por lo tanto, en circunstancias normales, los recursos de la página a los que accede el usuario, como show.jsp, se colocan en el directorio WEB-INF / jsp.

(3) Al mismo tiempo, durante el desarrollo, configure un analizador de vista en el archivo sppringmvc.xml para agregar un prefijo y un sufijo a la vista para reducir la escritura de código redundante.

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

    <!--声名组件扫描器-->
    <context:component-scan base-package="com.wind"/>

    <!--视图解析器：添加前缀和后缀。
    SpringMVC框架为了避免对于请求资源路径与扩展名上的冗余，在视图解析器 InternalResouceViewResolver
    中引入了请求的前辍与后辍。而 ModelAndView 中只需给出要跳转页面的文件名即可，对于具体的文件路径与文件扩展名，
    视图解析器会自动完成拼接。-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--视图文件的路径-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--视图文件的扩展名-->
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

1.6 componentes MVC de SpringMVC

1.6.1 Diagrama de flujo del proceso de ejecución de SpringMVC

1.6.2 Análisis simple del proceso de ejecución de SpringMVC

(1) El navegador envía la solicitud al despachador central.

(2) El programador central envía directamente la solicitud al asignador del procesador.

(3) El mapeador de procesadores encontrará el procesador procesando la solicitud de acuerdo con la solicitud, la encapsulará como una cadena de ejecución del procesador y la devolverá al planificador central.

(4) El programador central encuentra el adaptador de procesador que puede ejecutar el procesador de acuerdo con los procesadores en la cadena de ejecución del procesador.

(5) El adaptador de procesador llama al procesador de ejecución.

(6) El procesador encapsula el resultado del procesamiento y la vista que se va a saltar a un objeto ModelAndView y lo devuelve al adaptador del procesador.

(7) El adaptador de procesador devuelve directamente el resultado al programador central.

(8) El programador central llama al solucionador de vistas para encapsular el nombre de la vista en ModelAndView como un objeto de vista.

(9) El solucionador de vistas devuelve el objeto de vista encapsulado al planificador central.

(10) El programador central llama al objeto de vista y lo deja representar por sí mismo, es decir, completa los datos para formar un objeto de respuesta.

(11) El despachador central responde al navegador.

Descripción general de SpringMVC-1-