Spring MVC 项目构建流程

1、软件版本

• IDEA -- 2020.3.3
• JDK -- 1.8
• Maven -- 3.6.1
• Spring 5.3.6
• Apache Tomcat 9.0.62

2、本文目标

通过 Spring MVC 实现一个 Hello World，将项目发布到 Tomcat 中，然后在首页中发起一个请求，请求交给 Spring MVC 处理，由 Spring MVC 向客户端输出一个 Hello World，通过这个案例让大家熟悉下 Spring MVC 的使用步骤。

3、Hello World 案例

Step1：创建一个 Maven 项目

使用 IDEA 创建父工程，打开 IDEA -> File -> New -> Project

注意：是创建常规 Maven 项目

按照下图输入对应的信息。

点击 Finish，项目创建成功，如下图所示。

按照下图中的说明，将红框的部分删除。（本步骤为可选操作）。

pom.xml 文件内容如下所示，不是的话，用下面的内容替换即可。

<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.javacode2018</groupId>
    <artifactId>springmvc-series</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

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

</project>

此时项目结构如下图所示。

如下图，File -> Settings 中指定项目 Maven 的版本。（以前以配置过的，这步可忽略）

Step2：项目中创建一个 Java Enterprise 模块

选中项目 -> 点击鼠标右键 -> New -> Module，创建一个 maven 模块。

如下图，选择 Java Enterprise 类型创建 web 模块，注意图中红框的选项，不要选错了。

点击上图中的 Next，进入下面页面，输入模块的信息，然后点击 Next。

如下图，点击 Finish，完成模块的创建。

项目结构如下图所示。

Step3：Maven 中添加 Spring MVC 相关依赖

在 chat01-helloworld/pom.xml 中，添加了 Spring MVC 的依赖配置信息。

添加后，完整的内容为：

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.javacode2018</groupId>
    <artifactId>chat01-helloworld</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>chat01-helloworld</name>
    <packaging>war</packaging>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.6</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.3.1</version>
            </plugin>
        </plugins>
    </build>
</project>

同时，我们会看到，Spring MVC 的其它一些依赖被自动添加进来了，如下图所示。

Step4：web.xml 中配置 Spring MVC

这种方式创建的模块，它的 web.xml 版本符合要求，为 4.0 版本，无需升级。

为了保证 Spring 能找到控制器，需要做如下配置：

• 配置 Spring MVC 前端控制器 DispatcherServlet；
• 配置初始化时，加载 springmvc.xml 文件;
• 配置应用启动时就实例化前端控制器(可选)。
• 配置解析请求路径。

在 web.xml 中添加 Spring MVC 的配置，可以直接将下面代码直接替换到 web.xml 中，主要就是配置了 DispatcherServlet 这个 servlet，这个是 Spring MVC 的核心配置。

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

        <load-on-startup>0</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

Step5：添加 Spring MVC 配置文件

• 配置扫描 Controller 包下所下的所有 java 文件。
• 配置视图解析器，设置前后缀。视图解析器会根据配置路径将逻辑视图解析出物理视图。
• 配置处理器映射器和处理器适配器(此两项配置可选),当没有配置时，Spring 会使用默认的处理器映射器和处理器适配器来处理请求。在实际开发基本上不用配置。

chat01-helloworld->resource->鼠标右键->New->XXML Configuration File->Spring Config

输入文件名称：springmvc.xml 。

文件添加成功，如下图所示。

在其中添加 <context:component-scan> 标签，具体如下所示。

<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 https://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.javacode2018.chat01helloworld"/>

</beans>

Step6：写一个 HelloController

这个类中创建了一个 hello 方法，方法上面添加了一个 @RequestMapping 注解，是 Spring MVC 中的一个注解，value 属性用来指定一个 url 列表，Spring MVC 会将这些指定的 url 请求转发给当前方法处理。

我们希望访问 /hello.do 的时候，跳转到 /WEB-INF/view/hello.jsp 这个页面，这个页面中输出一段内容。

package com.javacode2018.springmvcseries.chat01;

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

@Controller
public class HelloController {
    /**
     * @RequestMapping：用来表示url和方法的映射
     * value属性用来指定一个url列表，springmvc会将这些指定的url请求转发给当前方法处理
     * @return
     */
    @RequestMapping("/hello.do")
    public ModelAndView hello() {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("/WEB-INF/view/hello.jsp");
        //也可用下面一句代替上面两句
        //ModelAndView modelAndView = new ModelAndView("WEB-INF/view/hello.jsp");
        //稍后将这个信息显示在hello.jsp中，modelAndView.addObject相当于request.setAttribute(name,value)
        modelAndView.addObject("msg","这是第一个 Spring MVC 程序!");
        return modelAndView;
    }
}

/WEB-INF/view/中添加 hello.jsp 内容如下

修改后的 hello.jsp 的内容如下。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<div style="text-align: center">
    <h1>Hello Spring MVC</h1>
    <h1>msg:${msg}</h1>
</div>

接着修改 index.jsp 的内容，添加一个超链接，当点击这个超链接的时候，请求会发给 Spring MVC，然后 Spring MVC 会将请求转发给 HelloController 的 hello 方法，然后通过这个方法最后将 hello.jsp 内容输出。

<a href="hello.do">hello Spring MVC</a>

Step7：将项目部署到 tomcat 中

这里我们将项目部署到 tomcat9 中，过程如下：

如下图，启动 tomcat。

Step8：验证效果

访问：http://localhost:8080/chat01/

点击页面中的连接，会跳转到 http://localhost:8080/chat01/hello.do，输出

4、Spring MVC 处理请的过程

4.1 详细的过程

1. tomcat 启动的时候，会初始化 DispatcherServlet，DispatcherServlet 中会创建一个 Spring MVC 容器，其实就是我们熟悉的 Spring 容器（ApplicationContext），只不过这个容器的类型是（WebApplicationContext），此容器会加载 web.xml 中 contextConfigLocation 指定的 Spring MVC 配置文件

1. 由于 springmvc.xml 中指定了扫描包的规则，而 HelloController 符合这个扫描规则，所以会被注册到 Spring MVC 容器中

1. 当发起 *.do 请求的时候，请求会到达 DispatcherServlet 中央处理器，中央处理器会根据请求路径，去 Spring MVC 容器中找到能够处理这个请求的方法，具体由哪个方法来处理这个请求呢？

这里就是通过 @RequestMapping 来匹配的，这个注解可以将请求和方法进行映射，匹配的请求会被 @RequestMapping 标注的方法处理，所以在这个步骤中 springmvc 容器会发现 HelloController 这个 bean 的 hello 方法方法可以处理 /hello.do 请求

1. DispatcherServlet 中通过反射来调用 helloController 这个 bean 的 hello 方法
2. DispatcherServlet 接收到了 hello 方法的返回值
3. DispatcherServlet 根据 hello 方法的返回值，做跳转操作，相当于

request.getRequestDispatcher("/WEB-INF/view/hello.jsp").forward(request,response);

4.2 简化过程

客户端发送请求 ---> 到达 tomcat ---> tomcat 发现是请求是 *.do 的请求 ---> tomcat 将请求转发给中央调度器 DispatcherServlet ---> 中央调度器根据 url 将转发给我们自定义的 controller ---> DispacherServlet 根据 controller 的返回结果做跳转操作 ---> 将结果输出到客户端