首页 > Spring MVC教程

第一个Spring MVC项目

< 上一节
在对 Spring MVC 有基本的了解之后，下面我们将为您详细讲解如何使用 IntelliJ IDEA 创建一个 Spring MVC 项目。

配置开发环境

想要创建一个 Spring MVC 项目，首先我们必须先配置好开发环境。具体的开发环境配置，如下表。

Spring MVC 6.0.X
JDK 版本 17+
Maven 3.6+
IntelliJ IDEA IntelliJ IDEA 2022.x

浏览器访问 IntelliJ IDEA 官方下载页面，下载并安装 IntelliJ IDEA。

创建 Spring MVC 项目

开发环境配置完成后，接下来我们就可以通过 Intellij IDEA 创建一个 Spring MVC 项目了。

1. 创建 Maven 父工程

首先，我们先创建一个 Maven 父工程，并通过它来管理我们在本教程中所创建的所有 Spring MVC 项目，具体步骤如下。

1) 点击 IntelliJ IDEA 左上角的 File 菜单，然后依次选择 New -> Project -> New Project，并在 New Project 窗口完善 Maven 父工程的 Name（名称）、Location（位置）、Language（编程语言）、Build system（构建方式）、JDK 以及 GroupId 和 ArtifactId 等信息，如下图。

mvc 父工程
图1：创建 Maven 父工程

2) Maven 父工程 spring-mvc-parent-project 创建完成后，其目录结构如下图。

父工程目录结构
图2：父工程结构

作为 Maven 父工程，spring-parent-project 中并不会包含任何的 Java 代码，因此我们可以将该工程下的 src 目录直接删除，这样可以让项目结构更加清晰整洁。当然如果不删除，也并不会造成任何影响。

2. 创建子模块

在完成了 Maven 父工程的创建之后，接下来我们就可以在该父工程（spring-mvc-parent-project）中创建 Spring MVC 项目了，该 Spring MVC 项目是作为 spring-mvc-parent-project 中的一个子模块而存在的。

1) 右键点击 Maven 主工程 spring-mvc-parent-project，然后在弹出的菜单中依次选择 New -> Module...，如下图。

子模块创建
图3：创建 Module

2）在 New Module 窗口的右侧分别完善 Spring 项目的 Name（子模块名称）、Location（位置）、Language（编程语言）、Build system（构建方式）、JDK 以及 GroupId 和 ArtifactId 等信息，最后点击下方的“Create”完成创建，如下图。


图4：创建 Module

3) 子模块 my-first-mvc-demo 创建完成之后，整个工程的目录结构如下图。

工程结构
图5：工程目录结构

3. 引入依赖

在完成了 Maven 父工程以及第一个子模块的创建之后，接下来我们就可以将 Spring MVC 项目需要的 Maven 依赖引入到 my-first-spring-demo 中了，使之成为一个 Spring MVC 项目。

1) 在 my-first-mvc-demo 的 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>
    <parent>
        <groupId>net.biancheng.c</groupId>
        <artifactId>spring-mvc-parent-project</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>my-first-mvc-demo</artifactId>
    <!--Web 项目打包类型为 war-->
    <packaging>war</packaging>

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

    <dependencies>
        <!--Spring MVC 相关依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>6.0.6</version>
        </dependency>

        <!--将 Thymeleaf 模板引擎集成到 Spring 中-->
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring6</artifactId>
            <version>3.1.1.RELEASE</version>
        </dependency>

        <!--Servlet 依赖，其作用域 scope 为 provided，含义为项目打包时不会将此依赖打入到 包中-->
        <!--原因是 tomcat 服务器中已经提供了该依赖-->
        <dependency>
            <groupId>jakarta.servlet</groupId>
            <artifactId>jakarta.servlet-api</artifactId>
            <version>6.0.0</version>
            <scope>provided</scope>
        </dependency>

        <!-- commons-logging 日志依赖-->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.3.2</version>
                <configuration>
                    <webXml>src/main/webapp/WEB-INF/web.xml/</webXml>
                    <webResources>
                        <resource>
                            <directory>src/main/resources</directory>
                            <targetPath>WEB-INF/classes</targetPath>
                            <includes>
                                <include>**/*.properties</include>
                            </includes>
                        </resource>
                    </webResources>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2)  如果我们第一次将上面的依赖引入到工程模块中时，Maven 会自动联网去下载依赖包。下载完成后，点击  IntelliJ IDEA 最右侧的 Maven 选项，此时会弹出一个 Maven 窗口，这里我们可以看到子模块 my-first-mvc-demo 的依赖（Dependencies），如下图。

Maven 工具
图6：Maven 依赖

温馨提示，当我们在项目的 POM 文件中引入了新的依赖后，若 IDEA 并未自动将下载，则可以手动点击一下图 6 右上角的 Reload All Maven Projects 按钮，重新加载所有的 Maven 工程，此时 IDEA 会重新下载并引入所有依赖。

4. 添加 webapp 目录

1) 在 my-first-mvc-demo 的 src/main/ 目录下新建一个名为 webapp 的目录，如下图。

添加 webapp
图7：添加 webapp 

2) 点击 IDEA 左上角的 File 菜单，然后选择 Project Structure 对项目结构进行配置，如下图。


图8：项目结构

3) 在 Project Structure 窗口中，点击 Project Settings 下的 Modules 选项对 my-first-mvc-demo 下 web 模块进行配置，然后点击 Deployment Descriptors 下的“+”按钮，添加 web.xml 配置文件，如下图。 

+web
图9：添加 web.xml

4) 在弹出的 Deployment Descriptor Location 窗口，对 web.xml 的位置以及版本进行配置，然后点击下方的“OK”按钮，配置完成后点击最下方的 Apply 按钮应用配置。。


图10：配置 web.xml 

6)  点击 Project Structure 下方的 OK 按钮，返回 IDEA 主工作窗口，我们会看到刚刚在 src/main/webapp 目录下多了一个名为 WEB-INF 的子目录，且 IDEA 还在该子目录下自动生成了一个 web.xml 文件，如下图。


图12：生成 web.xml

5. 配置 DispatcherServlet（前端控制器）

我们知道，Spring MVC 是基于 Servlet 的实现， 其核心是一个名为 DispatcherServlet 的前端控制器，该控制器主要负责截获请求并将其分派给相应的处理器（例如 Controller 控制器）处理。

与所有的 Servlet 一样，DispatcherServlet 也需要在 web.xml 中进行配置后才能够正常工作，示例代码如下：
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_0.xsd"
         version="6.0">

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

Spring MVC 初始化时，会自动从应用程序的 WEB-INF 目录下查找 Spring MVC 的配置文件。该配置文件的默认命名规则为{servlet-name}-servlet.xml。例如，在上面的 web.xml 配置中 servelt-name 的值为 dispatcher，因此 Spring MVC 初始化时会自动从 webapp 下查找 /WEB-INF/dispatcher-servlet.xml 作为 Spring MVC 的配置文件。

此外，我们还可以在 <servlet> 中通过 <init-param> 元素对 contextConfigLocation 参数进行设置，手动指定 Spring MVC 配置文件的位置，这样我们就可以将 Spring MVC 的配置文件存放在应用程序中的其他位置了，示例代码如下。 
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_0.xsd"
         version="6.0">

    <!-- 配置 SpringMVC 的前端控制器，对浏览器发送的请求统一进行处理 -->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--配置 DispatcherServlet 的一个初始化参数：spring mvc 配置文件按的位置和名称-->
        <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>dispatcherServlet</servlet-name>
        <!--设置springMVC的核心控制器所能处理的请求的请求路径
        /所匹配的请求可以是/login或.html或.js或.css方式的请求路径
        但是/不能匹配.jsp请求路径的请求-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

默认情况下，所有的 Servlet（包括 DispatcherServlet）都是在第一次调用时才会被加载。这种机制虽然能一定程度上降低项目启动的时间，但却增加了用户第一次访问所需的时间，给用户带来的体验不佳。因此在上面的 web.xml 中，我们还通过 <load-on-startup> 元素对 Spring MVC 前端控制器 DispatcherServlet 的初始化时间进行了设置，让它在项目启动时就完成了加载。

load-on-startup 元素取值规则如下：
  • 它的取值必须是一个整数；
  • 当值小于 0 或者没有指定时，则表示容器在该 Servlet 被首次请求时才会被加载；
  • 当值大于 0 或等于 0 时，表示容器在启动时就加载并初始化该 Servlet，取值越小，优先级越高；
  • 当取值相同时，容器就会自行选择顺序进行加载。

此外，我们还通过 <servlet-mapping> 将 DispatcherServlet 映射到“/”，表示 DispatcherServlet 需要截获并处理该项目的所有 URL 请求（以 .jsp 为后缀的请求除外）。

6. 创建 Spring MVC 配置

在 my-first-mvc-demo 的 src/main/resources 目录下，创建一个名为 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
       https://www.springframework.org/schema/context/spring-context.xsd ">

    <!--开启组件扫描-->
    <context:component-scan base-package="net.biancheng.c"></context:component-scan>

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

在上面的配置中，我们定义一个名为 viewResolver，类型为 ThymeleafViewResolver 的 Bean，这其实是 Thymeleaf 的视图解析器。通过它，我们可以对 Thymeleaf 视图的编码、视图前缀、视图后缀等进行配置。

7. 创建 Controller（控制器）

我们知道，DispatcherServlet 会拦截用户发送来的所有请求进行统一处理，但不同的请求有着不同的处理过程，例如登陆请求和注册请求就分别对应着登陆过程和注册过程，因此我们需要 Controller 来对不同的请求进行不同的处理。

在 Spring MVC 中，一个普通的 Java 类只要标注了 @Controller 注解，就会被 Spring MVC 识别成 Controller（控制器）。Controller 类中的每一个处理请求的方法被称为“控制器方法”。

控制器方法在处理完请求后，通常会返回一个字符串类型的逻辑视图名（ViewName），Spring MVC 需要借助 ViewResolver（视图解析器）将这个逻辑视图名解析为真正的 View 视图，最终响应给客户端展示。

例如，在 my-first-mvc-demo 的 src/main/java 目录下创建一个 net.biancheng.c.controller 包，并在该包下创建一个名为 HelloController 的控制器类，代码如下。
package net.biancheng.c.controller;

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

@Controller
public class HelloController {

    @RequestMapping("/")
    public String sayHello() {
        //视图名，视图为：视图前缀+index+视图后缀，即 /WEB-INF/template/index.html
        return "index";
    }

    @RequestMapping("/login")
    public String welcome() {
        //视图名，视图为：视图前缀+login+视图后缀，即 /WEB-INF/template/login.html
        return "login";
    }

    @RequestMapping("/register")
    public String success() {
        //视图名，视图为：视图前缀+register+视图后缀，即 /WEB-INF/template/register.html
        return "register";
    }
}

在以上代码中，除了 @Controller 注解外，我们还在方法上使用了 @RequestMapping 注解，它的作用就是将请求和处理请求的控制器方法关联映射起来，建立映射关系。Spring MVC 的 DispatcherServelt 在拦截到指定的请求后，就会根据这个映射关系将请求分发给指定的控制器方法进行处理。

8. 创建 View（视图）

根据 Spring MVC 配置文件中关于 Thymeleaf 视图解析器的配置可知，如下图，所有的 Thymeleaf 视图文件都应该存放在 /WEB-INFO/temlpates 目录下且文件名必须以 .html 结尾。


图13：视图解析器配置

1) 我们需要在 my-first-mvc-demo 中的 src/main/webapp /WEB-INFO 目录下创建一个 templates 的目录，并在该目录下创建 index.html，代码如下。 
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
<h1 th:text="欢迎您"></h1>

未注册用户，请<a th:href="@{/register}">注册</a><br/>
已注册用于，去<a th:href="@{/login}">登陆</a>
</body>
</html>

2) 在 src/main/webapp/WEB-INFO/templates 下创建 login.html，代码如下。 
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>C语言中文网</title>
</head>
<body>
<h1 th:text="欢迎来登陆页面"></h1>
<a th:href="@{/}">跳转首页</a><br/>
<a th:href="@{/register}">跳转到注册页面</a>
</body>
</html>

3) 在 src/main/webapp/WEB-INFO/templates 下创建 register.html，代码如下。 
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>C语言中文网</title>
</head>
<body>
<h1 th:text="欢迎来到注册页面"></h1>
<a th:href="@{/}">跳转首页</a><br/>
<a th:href="@{/login}">跳转到登陆页面</a>
</body>
</html>

部署运行

在完成了上面所有的步骤之后，我们就已经完成了 Spring MVC 项目的创建和编码工作。接下来，我们就可以将这个 Spring MVC 项目部署到 Tomcat 服务器中运行了，具体步骤如下。

1. 点击 IDEA 顶部菜单中 Run，然后选择 Edit Configurations...，如下图。

修改配置
图14：修改配置

2. 在 Run/Debug Configurations 窗口中，点击左上角的“+”按钮，
添加 tomcat 服务器
图15：添加本地 Tomcat 服务器

3. 在 Run/Debug Configurations 右侧的 Server 选项卡中，对 Tomcat 服务器的本地安装路径、名称、端口等内容进行配置，如下图。

配置 Tomcat 本地安装路径
图16：配置 Tomcat 本地安装路径、名称、端口号

4. 切换到 Deployment 选项卡，点击下方的“+”按钮选择 Artifact，将 my-first-mvc-demo:war 部署到 Tomcat 中，然后将应用的上下文路径（Application Context）修改为“/my-first-mvc-demo”，如下图。

部署并设置根路径
图17：部署 war

5.  返回 IDEA 主工作区，点击顶部菜单的 Run，然后下拉菜单中选择“Run Tomcat 10.1.4”启动 Tomcat 服务器，如下图。

运行 Tomcat
图18：启动 Tomcat

6. Tomcat 启动完成后，通过浏览器访问“http://localhost:8080/my-first-mvc-demo/”，结果如下图 。

访问
图19：访问

声明：《Spring系列教程》为本站“54笨鸟”官方原创，由国家机构和地方版权局所签发的权威证书所保护。
< 上一节