4.1 Maven 与 Spring

文档摘要

4.1 Maven 与 Spring 4.1 Maven 与 Spring 4.1.1 Maven 在 Spring 项目中的核心作用 Maven 在 Spring 项目中扮演着至关重要的角色，其核心作用主要体现在以下几个方面：依赖管理 (Dependency Management)： Spring 框架本身及其生态系统拥有庞大且复杂的依赖关系。例如，Spring Framework 核心模块、Spring MVC、Spring Data JPA、Spring Security 等等，每个模块又可能依赖于其他第三方库。手动管理这些依赖关系将是一场噩梦，容易出现版本冲突、依赖缺失等问题。

4.1 Maven 与 Spring

4.1.1 Maven 在 Spring 项目中的核心作用

Maven 在 Spring 项目中扮演着至关重要的角色，其核心作用主要体现在以下几个方面：

依赖管理 (Dependency Management)： Spring 框架本身及其生态系统拥有庞大且复杂的依赖关系。例如，Spring Framework 核心模块、Spring MVC、Spring Data JPA、Spring Security 等等，每个模块又可能依赖于其他第三方库。手动管理这些依赖关系将是一场噩梦，容易出现版本冲突、依赖缺失等问题。Maven 通过 pom.xml 文件集中管理项目的所有依赖，开发者只需声明需要的 Spring 模块和版本，Maven 就能自动下载、解析并管理这些依赖及其传递性依赖，极大地简化了依赖管理工作。
项目构建 (Project Building)： Spring 应用的构建过程包括编译源代码、资源文件处理、单元测试、打包部署等多个环节。Maven 遵循“约定优于配置”的原则，定义了标准的项目结构和构建生命周期。开发者只需按照 Maven 的约定组织项目代码，通过简单的 Maven 命令（如 mvn compile、mvn test、mvn package），即可自动化完成项目的构建过程，无需手动编写复杂的构建脚本。
插件集成 (Plugin Integration)： Maven 拥有丰富的插件生态系统，可以扩展其构建能力。对于 Spring 项目，可以使用各种 Maven 插件来增强开发体验和构建流程，例如：
- spring-boot-maven-plugin: 用于 Spring Boot 项目的打包、运行和管理。
- maven-compiler-plugin: 用于配置 Java 编译版本。
- maven-surefire-plugin: 用于运行单元测试。
- maven-war-plugin 或 maven-jar-plugin: 用于打包 Web 应用（WAR）或普通 Java 应用（JAR）。
- 代码质量检查插件 (如 maven-checkstyle-plugin, maven-pmd-plugin, maven-spotbugs-plugin): 用于静态代码分析，提高代码质量。
项目结构规范化 (Project Structure Standardization)： Maven 强制使用标准的项目目录结构，例如 src/main/java 存放源代码，src/main/resources 存放资源文件，src/test/java 存放测试代码等。这种规范化的结构有助于团队协作开发，降低项目维护成本，并使得项目结构清晰易懂。
生命周期管理 (Lifecycle Management)： Maven 定义了清晰的构建生命周期，例如 clean、compile、test、package、install、deploy 等。开发者只需了解 Maven 的生命周期阶段，即可通过简单的命令控制整个构建过程，实现自动化构建和部署。

4.1.2 基于 Maven 构建 Spring 项目的代码实践

接下来，我们将通过几个实际的代码案例，演示如何使用 Maven 构建和管理 Spring 项目。

案例一：创建一个基础的 Spring MVC 项目

这个案例将创建一个简单的 Spring MVC Web 应用，演示 Maven 如何管理 Spring MVC 的依赖，并构建可部署的 WAR 包。

1. 创建 Maven 项目:

使用 Maven 命令或 IDE (如 IntelliJ IDEA, Eclipse) 创建一个新的 Maven Web 应用项目。假设项目名为 spring-mvc-demo，Group Id 为 com.example，Artifact Id 为 spring-mvc-demo。

2. 修改 pom.xml 文件:

打开 pom.xml 文件，添加 Spring MVC 相关的依赖、配置 Maven 编译插件和 WAR 打包插件。


<?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.example</groupId>
    <artifactId>spring-mvc-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.version>5.3.20</spring.version> <!- - Spring 版本 -->
    </properties>
    <dependencies>
        <!-- Spring MVC 依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Servlet API 依赖 (provided scope，运行时由 Web 服务器提供) -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
        <!-- JSTL 标签库 (用于 JSP 页面) -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <!-- Maven 编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>${maven.compiler.source}</source>
                    <target>${maven.compiler.target}</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <!-- Maven WAR 打包插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.3.2</version>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml> <!- - 允许没有 web.xml 文件 -->
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

pom.xml 文件详解:

<packaging>war</packaging>: 指定项目打包类型为 WAR (Web Application Archive)。
<properties>: 定义属性，例如 spring.version 用于统一管理 Spring 版本，方便后续升级。
<dependencies>: 声明项目依赖：
- spring-webmvc: Spring MVC 核心模块。
- javax.servlet-api: Servlet API，scope 设置为 provided，表示运行时由 Web 服务器 (如 Tomcat) 提供，Maven 构建时需要。
- jstl: JSTL 标签库，用于 JSP 页面。
<build> -> <plugins>: 配置 Maven 插件：
- maven-compiler-plugin: 配置 Java 编译版本和字符编码。
- maven-war-plugin: 配置 WAR 打包插件，failOnMissingWebXml 设置为 false，允许项目没有 web.xml 文件 (可以使用注解配置 Servlet)。

3. 创建 Spring MVC 配置:

在 src/main/java 目录下创建 Spring MVC 的配置类 (例如 WebAppConfig.java) 和 Controller 类 (例如 HelloController.java)。

WebAppConfig.java (Spring 配置类):


package com.example.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
@EnableWebMvc // 启用 Spring MVC
@ComponentScan(basePackages = "com.example.controller") // 扫描 Controller 组件
public class WebAppConfig implements WebMvcConfigurer {
    // 可以添加视图解析器、拦截器等配置
}

HelloController.java (Controller 类):


package com.example.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class HelloController {
    @RequestMapping("/hello")
    @ResponseBody
    public String hello() {
        return "Hello, Spring MVC with Maven!";
    }
}

4. 创建 web.xml (可选，如果使用 Servlet 3.0+ 可以省略):

在 src/main/webapp/WEB-INF 目录下创建 web.xml 文件，配置 DispatcherServlet。如果使用 Servlet 3.0+，并且在 Spring 配置类中启用了 @EnableWebMvc，可以省略 web.xml，Servlet 容器会自动扫描 Spring 配置。

web.xml (可选):


<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
  <display-name>Spring MVC Demo</display-name>
  <!-- 配置 Spring MVC DispatcherServlet -->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>com.example.config.WebAppConfig</param-value> <!- - Spring 配置类路径 -->
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

5. 构建和部署:

在项目根目录下运行 Maven 命令 mvn clean package。Maven 将会编译代码、处理资源文件、打包成 spring-mvc-demo.war 文件，存放在 target 目录下。

将 spring-mvc-demo.war 文件部署到 Web 服务器 (如 Tomcat) 中。启动 Tomcat 后，访问 http://localhost:8080/spring-mvc-demo/hello，即可看到 "Hello, Spring MVC with Maven!" 的输出。

案例二：使用 Spring Boot 简化 Spring 项目构建

Spring Boot 旨在简化 Spring 应用的开发和部署。Spring Boot Maven 插件 (spring-boot-maven-plugin) 提供了更便捷的方式来构建和运行 Spring Boot 应用。

1. 创建 Spring Boot Maven 项目:

可以使用 Spring Initializr (start.spring.io) 在线生成 Spring Boot Maven 项目，或者使用 IDE 创建 Spring Boot 项目。选择 Web 依赖 (Spring Web MVC)。

2. 查看 pom.xml 文件:

Spring Boot 项目的 pom.xml 文件通常会继承 spring-boot-starter-parent，并使用 Spring Boot Starter 依赖。


<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.1</version> <!- - Spring Boot 版本 -->
        <relativePath/> <!- - lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>spring-boot-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-boot-demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId> <!- - Spring Boot Web Starter -->
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId> <!- - Spring Boot Maven 插件 -->
            </plugin>
        </plugins>
    </build>
</project>

pom.xml 文件详解 (Spring Boot):

<parent>: 继承 spring-boot-starter-parent，提供了 Spring Boot 的默认配置和依赖管理。
<dependencies>:
- spring-boot-starter-web: Spring Boot Web Starter，包含了 Spring MVC、Tomcat 等 Web 开发常用依赖。
- spring-boot-starter-test: Spring Boot 测试 Starter，用于单元测试和集成测试。
<build> -> <plugins>:
- spring-boot-maven-plugin: Spring Boot Maven 插件，用于打包可执行 JAR 或 WAR 文件，并提供 spring-boot:run 命令直接运行 Spring Boot 应用。

3. 创建 Spring Boot 应用类和 Controller:

在 src/main/java 目录下创建 Spring Boot 应用启动类 (例如 SpringBootDemoApplication.java) 和 Controller 类 (例如 HelloController.java)。

SpringBootDemoApplication.java (Spring Boot 应用启动类):


package com.example.springbootdemo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication // Spring Boot 应用注解，包含 @Configuration, @EnableAutoConfiguration, @ComponentScan
public class SpringBootDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootDemoApplication.class, args);
    }
}

HelloController.java (Controller 类):


package com.example.springbootdemo.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController // @Controller + @ResponseBody
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot with Maven!";
    }
}

4. 构建和运行:

在项目根目录下运行 Maven 命令 mvn clean package。Maven 将会打包成可执行 JAR 文件 spring-boot-demo-0.0.1-SNAPSHOT.jar，存放在 target 目录下。

可以使用命令 java -jar target/spring-boot-demo-0.0.1-SNAPSHOT.jar 运行 Spring Boot 应用，或者使用 Maven 插件命令 mvn spring-boot:run 直接运行。

访问 http://localhost:8080/hello，即可看到 "Hello, Spring Boot with Maven!" 的输出。

案例三：Maven 依赖管理详解

Maven 的依赖管理是其核心功能之一。理解 Maven 的依赖管理机制对于构建复杂的 Spring 项目至关重要。

1. 依赖范围 (Scope):

<scope> 元素用于定义依赖的作用范围，不同的作用范围影响依赖在不同构建阶段 (编译、测试、运行时) 的可用性。常用的 scope 包括：

compile (默认): 编译范围。在编译、测试、运行时都有效。大部分 Spring 依赖都使用 compile 范围。
test: 测试范围。只在测试阶段有效，例如 JUnit, Mockito 等测试框架。
runtime: 运行时范围。编译时不需要，但在运行时需要，例如 JDBC 驱动。
provided: 已提供范围。编译和测试时需要，但在运行时由容器 (如 Web 服务器) 提供，例如 Servlet API。
system: 系统范围。类似于 provided，但需要显式指定依赖的本地路径，不推荐使用。
import: 导入范围。只能用于 <dependencyManagement> 中，用于导入其他 POM 文件的 <dependencyManagement> 配置，实现依赖版本统一管理。

2. 传递性依赖 (Transitive Dependencies):

Maven 能够自动解析和下载传递性依赖。例如，如果项目依赖 spring-webmvc，而 spring-webmvc 又依赖 spring-context、spring-beans 等，Maven 会自动将这些传递性依赖也引入到项目中。

3. 依赖冲突解决 (Dependency Conflict Resolution):

当项目中存在多个版本的同一个依赖时，Maven 会根据一定的规则解决冲突，保证构建的稳定性。Maven 默认使用 “最近原则 (Nearest Wins)” 和 “第一声明原则 (First Declaration Wins)” 来解决冲突。

最近原则: 选择依赖路径最短的那个版本。
第一声明原则: 如果依赖路径长度相同，选择在 pom.xml 文件中先声明的那个版本。

开发者也可以通过 <dependencyManagement> 和 <dependencies> 中的 <exclusions> 和 <optional> 元素来更精细地控制依赖版本和排除不需要的传递性依赖。

4. <dependencyManagement> 依赖版本管理:

<dependencyManagement> 元素用于统一管理依赖的版本，但不引入实际依赖。在 <dependencyManagement> 中声明的依赖，只有在 <dependencies> 中显式声明时才会被引入。


<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- ... 其他 Spring 模块版本 ... -->
    </dependencies>
</dependencyManagement>

在 <dependencies> 中使用时，可以省略版本号，Maven 会自动使用 <dependencyManagement> 中定义的版本。


<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId> <!- - 省略版本号，使用 dependencyManagement 中定义的版本 -->
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId> <!- - 省略版本号，使用 dependencyManagement 中定义的版本 -->
    </dependency>
    <!-- ... 其他依赖 ... -->
</dependencies>

5. Mermaid 图表 - Maven 依赖关系图:

可以使用 Mermaid graph TD 图表来可视化 Maven 依赖关系。例如，以下图表展示了一个简单的 Spring MVC 项目的依赖关系：

图表解释:

spring-mvc-demo 项目 (A) 直接依赖 spring-webmvc (B), javax.servlet-api (H), 和 jstl (I)。
spring-webmvc (B) 又传递性依赖 spring-context (C) 和 spring-web (D)。
spring-context (C) 又传递性依赖 spring-aop (E) 和 spring-beans (F)。
spring-beans (F) 又传递性依赖 spring-core (G)。

通过 Mermaid 图表，可以更直观地理解 Maven 项目的依赖关系，有助于排查依赖问题和优化项目依赖结构。

4.1.3 Maven 插件在 Spring 项目中的应用

Maven 插件可以扩展 Maven 的构建能力，在 Spring 项目中，常用的 Maven 插件包括：

spring-boot-maven-plugin: (前面案例已介绍) Spring Boot 官方提供的 Maven 插件，用于 Spring Boot 应用的打包、运行、热部署和 Docker 镜像构建等。
maven-compiler-plugin: (前面案例已介绍) 用于配置 Java 编译版本、字符编码等。
maven-surefire-plugin: 用于运行单元测试。可以配置测试报告格式、包含/排除测试类等。


<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.22.2</version>
    <configuration>
        <includes>
            <include>**/*Test.java</include> <!- - 包含所有以 Test.java 结尾的测试类 -->
        </includes>
        <excludes>
            <exclude>**/*IT.java</exclude> <!- - 排除所有以 IT.java 结尾的集成测试类 -->
        </excludes>
        <reportFormat>plain</reportFormat> <!- - 测试报告格式 -->
        <useFile>false</useFile>
    </configuration>
</plugin>

maven-war-plugin / maven-jar-plugin: (前面案例已介绍) 用于打包 Web 应用 (WAR) 或普通 Java 应用 (JAR)。

代码质量检查插件: 例如 maven-checkstyle-plugin, maven-pmd-plugin, maven-spotbugs-plugin。这些插件可以集成代码静态分析工具，在 Maven 构建过程中自动检查代码风格、潜在 Bug 和安全漏洞，提高代码质量。

maven-checkstyle-plugin 配置示例:


<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-checkstyle-plugin</artifactId>
    <version>3.1.2</version>
    <executions>
        <execution>
            <id>checkstyle</id>
            <phase>validate</phase> <!- - 在 validate 阶段执行检查 -->
            <goals>
                <goal>check</goal>
            </goals>
            <configuration>
                <configLocation>checkstyle.xml</configLocation> <!- - Checkstyle 配置文件路径 -->
                <encoding>UTF-8</encoding>
                <consoleOutput>true</consoleOutput>
                <failsOnError>true</failsOnError> <!- - 检查失败是否导致构建失败 -->
                <linkXRef>false</linkXRef>
            </configuration>
        </execution>
    </executions>
</plugin>

需要在项目根目录下创建 checkstyle.xml 文件，配置 Checkstyle 检查规则。

资源处理插件 maven-resources-plugin: 用于处理项目资源文件，例如配置文件、静态资源文件等。可以配置资源文件的过滤、复制等操作。
版本管理插件 versions-maven-plugin: 用于管理项目依赖版本，可以自动升级依赖版本、检查过期的依赖等。