代码管理
依赖管理 - Maven

Maven 生命周期与插件

# Maven 生命周期与插件

Maven 生命周期
Maven 插件概述
Maven 插件的用途
插件的目标 (Plugin Goals)
Maven 插件配置
Maven 插件标签详解
常用 Maven 插件汇总

# Maven 生命周期

Maven 项目构建生命周期描述的是一次构建过程经历了多少个事件，配合插件使用（到了某个生命周期触发插件）。

Maven 对项目构建的生命周期划分为 3 套：

clean：清理工作
default：核心工作，例如编译、测试、打包、部署等
site：产生报告，发布站点等

clean 生命周期：

pre-clean：执行一些需要在 clean 之前完成的工作
clean：移除所有上一次构建生成的文件
post-clean：执行一些需要在 clean 之后立刻完成的工作

default 生命周期：

validate（校验） 校验项目是否正确并且所有必要的信息可以完成项目的构建过程。
initialize（初始化） 初始化构建状态，比如设置属性值。
generate-sources（生成源代码） 生成包含在编译阶段中的任何源代码。
process-sources（处理源代码） 处理源代码，比如说，过滤任意值。
generate-resources（生成资源文件） 生成将会包含在项目包中的资源文件。
process-resources （处理资源文件） 复制和处理资源到目标目录，为打包阶段最好准备。
compile（编译） 编译项目的源代码。
process-classes（处理类文件） 处理编译生成的文件，比如说对Java class文件做字节码改善优化。
generate-test-sources（生成测试源代码） 生成包含在编译阶段中的任何测试源代码。
process-test-sources（处理测试源代码） 处理测试源代码，比如说，过滤任意值。
generate-test-resources（生成测试资源文件） 为测试创建资源文件。
process-test-resources（处理测试资源文件） 复制和处理测试资源到目标目录。
test-compile（编译测试源码） 编译测试源代码到测试目标目录.
process-test-classes（处理测试类文件） 处理测试源码编译生成的文件。
test（测试） 使用合适的单元测试框架运行测试（Juint是其中之一）。
prepare-package（准备打包） 在实际打包之前，执行任何的必要的操作为打包做准备。
package（打包） 将编译后的代码打包成可分发格式的文件，比如JAR、WAR或者EAR文件。
pre-integration-test（集成测试前） 在执行集成测试前进行必要的动作。比如说，搭建需要的环境。
integration-test（集成测试） 处理和部署项目到可以运行集成测试环境中。
post-integration-test（集成测试后） 在执行集成测试完成后进行必要的动作。比如说，清理集成测试环境。
verify （验证） 运行任意的检查来验证项目包有效且达到质量标准。
install（安装） 安装项目包到本地仓库，这样项目包可以用作其他本地项目的依赖。
deploy（部署） 将最终的项目包复制到远程仓库中与其他开发者和项目共享。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

并不是都会执行所有的步骤，而是执行选择步骤的上方步骤，如选择了 generate-test-resources，则 generate-test-resources 上面的步骤都会执行，但是下面的并不会执行。

site 生命周期：

pre-site：执行一些需要在生成站点文档之前完成的工作
site：生成项目的站点文档
post-site：执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
site-deploy：将生成的站点文档部署到特定的服务器上

# Maven 插件概述

Maven 是一个强大的项目构建工具，但其核心仅仅定义了抽象的生命周期，具体的构建任务都由插件来实现。每个插件可以包含多个功能，每个功能称为一个 "插件目标"（goal）。

Maven 生命周期与插件的关系

Maven 有三套标准的生命周期，每个生命周期都包含多个阶段：

clean：用于清理项目。
default（或 build）：项目的核心构建流程，包括编译、测试、打包、部署等。
site：生成项目站点文档（一般较少使用）。

这些生命周期中的每个阶段都可以绑定到一个或多个插件目标。比如 mvn compile 绑定的是 maven-compiler-plugin 插件的 compile 目标。

# Maven 插件的用途

插件和依赖的区别

插件是工具，偏向于开发环境.和项目功能、源码、打包好的 jar 包没有任何关系.插件和依赖的关系，类似于 IDEA 工具和上线的 jar 包。
Maven 的核心文件很小,主要的任务都是由插件来完成.定位到：%本地仓库%\org\apache\maven\plugins ，可以看到一些下载好的插件。

Maven 插件主要用于：

编译代码文件
创建 JAR/WAR 文件
运行单元测试
创建项目文档
生成项目报告

Maven 插件分为以下两类：

核心插件（Core Plugins）：由 Maven 官方提供，完成核心构建任务。
第三方插件（Third-party Plugins）：由社区或第三方提供，扩展了 Maven 的功能。

注意事项

Maven 默认会自动使用内置插件完成生命周期中的各个阶段。如果你显式配置了某个插件，它将覆盖默认的行为。

# 插件的目标 (Plugin Goals)

Maven 的构建过程通过插件来完成各种任务，每个任务称为插件的 "目标"（Goal）。每个目标在执行时，Maven 会在控制台中输出详细的执行日志，帮助开发者了解每个阶段执行的具体情况。

# 1. `mvn clean` 阶段

执行 mvn clean 命令，用于清理项目中的构建文件（通常是 target/ 目录中的内容）。

[INFO] --- maven-clean-plugin:3.1.0:clean (default-clean) @ my-app ---
# 说明：执行 maven-clean-plugin 插件的 clean 目标，版本是 3.1.0，默认目标名称是 default-clean
# @ 后面是项目名称 "my-app"

[INFO] Deleting /path/to/project/target
# 说明：正在删除构建目录 "target/"，这个目录包含上次构建生成的文件

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
# 说明：清理阶段执行成功

[INFO] ------------------------------------------------------------------------
[INFO] Total time:  0.456 s
# 说明：清理总耗时为 0.456 秒

[INFO] Finished at: 2024-08-21T14:23:01+00:00
# 说明：清理阶段完成的时间

[INFO] ------------------------------------------------------------------------

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

maven-clean-plugin:3.1.0:clean：表示执行的是 maven-clean-plugin 插件的 clean 目标，插件版本为 3.1.0。
Deleting /path/to/project/target：表示正在删除构建目录中的内容，通常是 target/ 目录。
BUILD SUCCESS：表示清理成功。

# 2. `mvn compile` 阶段

执行 mvn compile 命令，用于编译项目源代码。

[INFO] --- maven-compiler-plugin:3.8.1:compile (default-compile) @ my-app ---
# 说明：执行 maven-compiler-plugin 插件的 compile 目标，版本是 3.8.1，默认目标名称是 default-compile

[INFO] Compiling 10 source files to /path/to/project/target/classes
# 说明：编译 10 个源文件，输出到 "/path/to/project/target/classes" 目录

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
# 说明：编译成功

[INFO] ------------------------------------------------------------------------
[INFO] Total time:  1.234 s
# 说明：编译总耗时为 1.234 秒

[INFO] Finished at: 2024-08-21T14:24:56+00:00
# 说明：编译阶段完成的时间

[INFO] ------------------------------------------------------------------------

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

maven-compiler-plugin:3.8.1:compile：表示使用的是 maven-compiler-plugin 插件，目标是 compile，用于编译源代码。
Compiling 10 source files to /path/to/project/target/classes：表示编译了 10 个源文件，输出目录为 target/classes。
BUILD SUCCESS：表示编译成功。

# 3. `mvn test` 阶段

执行 mvn test 命令，用于运行单元测试。

[INFO] --- maven-surefire-plugin:3.0.0-M5:test (default-test) @ my-app ---
# 说明：执行 maven-surefire-plugin 插件的 test 目标，版本是 3.0.0-M5，默认目标名称是 default-test

[INFO] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.678 s - in com.example.MyAppTests
# 说明：测试结果汇总，总共运行 5 个测试，0 个失败，0 个错误，0 个跳过，耗时 0.678 秒

[INFO] 
[INFO] Results:
[INFO] 
[INFO] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0
# 说明：再次展示测试结果汇总

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
# 说明：测试成功

[INFO] ------------------------------------------------------------------------
[INFO] Total time:  2.345 s
# 说明：测试总耗时为 2.345 秒

[INFO] Finished at: 2024-08-21T14:26:15+00:00
# 说明：测试阶段完成的时间

[INFO] ------------------------------------------------------------------------

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

maven-surefire-plugin:3.0.0-M5:test：表示执行的是 maven-surefire-plugin 插件，目标是 test，用于运行单元测试。
Tests run: 5, Failures: 0, Errors: 0, Skipped: 0：表示测试结果，5 个测试全部通过。

# 4. `mvn package` 阶段

执行 mvn package 命令，用于打包项目（通常生成 JAR 或 WAR 文件）。

[INFO] --- maven-jar-plugin:3.2.0:jar (default-jar) @ my-app ---
# 说明：执行 maven-jar-plugin 插件的 jar 目标，版本是 3.2.0，默认目标名称是 default-jar

[INFO] Building jar: /path/to/project/target/my-app-1.0-SNAPSHOT.jar
# 说明：生成 JAR 文件，路径为 "/path/to/project/target/my-app-1.0-SNAPSHOT.jar"

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
# 说明：打包成功

[INFO] ------------------------------------------------------------------------
[INFO] Total time:  0.789 s
# 说明：打包总耗时为 0.789 秒

[INFO] Finished at: 2024-08-21T14:27:45+00:00
# 说明：打包阶段完成的时间

[INFO] ------------------------------------------------------------------------

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

maven-jar-plugin:3.2.0:jar：表示使用的是 maven-jar-plugin 插件，目标是 jar，用于打包项目。
Building jar: /path/to/project/target/my-app-1.0-SNAPSHOT.jar：表示生成了 JAR 文件，输出路径为 target/my-app-1.0-SNAPSHOT.jar。

# 5. `mvn install` 阶段

执行 mvn install 命令，用于将项目打包后的文件安装到本地仓库。

[INFO] --- maven-install-plugin:2.5.2:install (default-install) @ my-app ---
# 说明：执行 maven-install-plugin 插件的 install 目标，版本是 2.5.2，默认目标名称是 default-install

[INFO] Installing /path/to/project/pom.xml to /path/to/.m2/repository/com/example/my-app/1.0-SNAPSHOT/my-app-1.0-SNAPSHOT.pom
# 说明：将项目的 pom.xml 文件安装到本地仓库

[INFO] Installing /path/to/project/target/my-app-1.0-SNAPSHOT.jar to /path/to/.m2/repository/com/example/my-app/1.0-SNAPSHOT/my-app-1.0-SNAPSHOT.jar
# 说明：将生成的 JAR 文件安装到本地仓库

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
# 说明：安装成功

[INFO] ------------------------------------------------------------------------
[INFO] Total time:  0.890 s
# 说明：安装总耗时为 0.890 秒

[INFO] Finished at: 2024-08-21T14:28:55+00:00
# 说明：安装阶段完成的时间

[INFO] ------------------------------------------------------------------------

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

maven-install-plugin:2.5.2:install：表示执行的是 maven-install-plugin 插件，目标是 install，用于将构建产物安装到本地仓库。
Installing /path/to/project/pom.xml 和 Installing /path/to/project/target/my-app-1.0-SNAPSHOT.jar：表示安装了 pom.xml 和 JAR 文件到本地 Maven 仓库。

# Maven 插件配置

Maven 插件的配置在 pom.xml 文件的 <build> 部分进行。以下是一个典型的插件配置结构：

<build>
  <plugins>
    <!-- 配置具体的插件 -->
    <plugin>
      <groupId>org.apache.maven.plugins</groupId> <!-- 插件所属的组 ID -->
      <artifactId>maven-compiler-plugin</artifactId> <!-- 插件的唯一标识，用于指定具体的插件 -->
      <version>3.8.1</version> <!-- 插件的版本号 -->
      <configuration>
        <source>1.8</source> <!-- 指定 Java 源代码的版本 -->
        <target>1.8</target> <!-- 指定编译后的字节码目标版本 -->
        <encoding>UTF-8</encoding> <!-- 设置源代码文件的编码格式 -->
      </configuration>
    </plugin>
    <!-- 其他插件配置 -->
    ...
  </plugins>
</build>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# Maven 插件标签详解

# 1. `<plugin>`：定义一个插件

<plugin>
  <groupId>org.apache.maven.plugins</groupId> <!-- 插件所属的组织或团队，如 Apache Maven 官方插件 -->
  <artifactId>maven-compiler-plugin</artifactId> <!-- 插件的唯一标识，如编译插件 -->
  <version>3.8.1</version> <!-- 指定插件的版本 -->
  <configuration>
    <!-- 插件的具体配置，如设置编译的 Java 版本 -->
  </configuration>
  <executions>
    <!-- 定义插件的执行目标和阶段绑定 -->
  </executions>
</plugin>

1
2
3
4
5
6
7
8
9
10
11

标签	作用
`<groupId>`	插件所属的组织或团队，例如 `org.apache.maven.plugins` 表示 Apache Maven 官方插件。
`<artifactId>`	插件的唯一标识，例如 `maven-compiler-plugin` 是 Maven 的编译插件。
`<version>`	指定插件的版本，例如 `3.8.1`。
`<configuration>`	配置插件的具体行为，例如设置编译的 Java 版本。
`<executions>`	定义插件的执行目标和生命周期阶段绑定。

# 2. `<configuration>`：插件的配置项

用于指定插件的具体行为，例如编译插件的 source 和 target 版本。

<configuration>
  <source>1.8</source> <!-- 设置 Java 源代码版本 -->
  <target>1.8</target> <!-- 设置编译后的字节码版本 -->
  <encoding>UTF-8</encoding> <!-- 设置源代码文件的编码 -->
</configuration>

1
2
3
4
5

标签	作用
`<source>`	设置 Java 源代码版本，例如 `1.8`。
`<target>`	设置编译后的字节码版本，例如 `1.8`。
`<encoding>`	设置源代码文件的编码，例如 `UTF-8`。

# 3. `<executions>` 和 `<execution>`：定义插件的执行

可以通过 <executions> 配置多个执行目标，每个 <execution> 可以绑定到不同的生命周期阶段。

<executions>
  <execution>
    <id>compile-source</id> <!-- 执行的标识符，可以任意命名 -->
    <phase>compile</phase> <!-- 绑定的生命周期阶段，如 compile -->
    <goals>
      <goal>compile</goal> <!-- 执行的目标，如编译源代码 -->
    </goals>
  </execution>
  <!-- 可以定义更多的执行目标 -->
</executions>

1
2
3
4
5
6
7
8
9
10

标签	作用
`<id>`	执行的标识符，可以任意命名，例如 `compile-source`。
`<phase>`	绑定的生命周期阶段，例如 `compile`。
`<goals>`	定义插件的目标，例如 `compile`。
`<goal>`	插件的具体目标，例如编译源代码。

# 4. `<pluginManagement>`：插件版本管理

pluginManagement 用于集中管理插件的版本和默认配置，但不会直接激活插件，实际使用时仍需在 <plugins> 中声明。

<build>
  <pluginManagement>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-source-plugin</artifactId>
        <version>3.2</version>
        <configuration>
          <attach>true</attach> <!-- 设置是否附加源代码到构建的工件 -->
        </configuration>
      </plugin>
    </plugins>
  </pluginManagement>
</build>

1
2
3
4
5
6
7
8
9
10
11
12
13
14

标签	作用
`<pluginManagement>`	集中管理插件的版本和默认配置，不会直接激活插件。
`<plugins>`	包含所有要管理的插件配置。
`<plugin>`	定义每个插件的配置，如 `<groupId>`、`<artifactId>` 和 `<version>`。
`<configuration>`	配置插件的默认行为，例如 `attach=true`。

在子项目中，只需引入插件即可继承父项目中定义的版本和配置：

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-source-plugin</artifactId>
      <!-- 版本和配置继承自父项目 -->
    </plugin>
  </plugins>
</build>

1
2
3
4
5
6
7
8
9

# 常用 Maven 插件汇总

在 Spring Boot 项目开发中，Maven 插件至关重要。它们不仅用于项目构建、依赖管理、打包和测试，还帮助我们更好地自动化项目的部署和资源处理。以下是基于 Spring Boot 项目常用的 Maven 插件总结，并包含详细的代码示例、使用说明和插件适用范围。

# 1. Spring Boot Maven 插件：`spring-boot-maven-plugin`

适用范围：仅限 Spring Boot 项目

实际开发场景：用于将 Spring Boot 项目打包为可执行的 JAR 或 WAR 文件，并支持直接运行 Spring Boot 应用。这个插件还可以在开发时直接启动 Spring Boot 项目，方便调试和开发。

<build>
  <plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId> <!-- Spring Boot 插件的组ID -->
      <artifactId>spring-boot-maven-plugin</artifactId> <!-- Spring Boot Maven 插件 -->
      <version>3.0.0</version> <!-- 插件版本，根据你使用的 Spring Boot 版本进行替换 -->
      <executions>
        <execution>
          <goals>
            <goal>repackage</goal> <!-- 将项目重新打包为可执行 JAR 文件 -->
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

代码解析：

<goal>repackage</goal>：这个目标用于将项目打包为可执行的 JAR 或 WAR 文件，并将所有依赖打包在一起。

# 2. 编译插件：`maven-compiler-plugin`

适用范围：所有 Maven 项目

实际开发场景：设置项目的 JDK 编译版本，确保项目在指定的 JDK 版本下进行编译。适用于任何基于 Java 的项目，尤其是需要保证 JDK 版本一致性的团队开发环境。

<build>
  <plugins>
    <!-- 编译插件 -->
    <plugin>
      <groupId>org.apache.maven.plugins</groupId> <!-- 插件的组ID，Apache Maven 官方插件 -->
      <artifactId>maven-compiler-plugin</artifactId> <!-- 插件的Artifact ID，指定为 Maven 的编译插件 -->
      <version>3.8.1</version> <!-- 插件版本号 -->
      <configuration>
        <source>1.8</source> <!-- 指定 Java 源代码的版本为 1.8，确保使用符合 Java 8 的语法特性 -->
        <target>1.8</target> <!-- 指定编译后生成的字节码版本为 Java 1.8，确保在 Java 8 环境下运行 -->
        <encoding>UTF-8</encoding> <!-- 指定源代码文件的编码格式，避免编译时出现乱码问题 -->
      </configuration>
    </plugin>
  </plugins>
</build>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

代码解析：

<source> 和 <target>：指定编译的 JDK 版本，确保项目的源码和字节码版本一致。
<encoding>：设置源码文件的编码格式，常用 UTF-8，避免因编码不一致导致的编译错误。

# 3. 资源处理插件：`maven-resources-plugin`

适用范围：所有 Maven 项目

实际开发场景：在项目构建时自动处理资源文件（如配置文件、静态资源等），将其从源码目录复制到目标目录，并支持过滤操作。适用于任何需要资源文件复制和处理的项目。

<build>
  <plugins>
    <!-- 资源处理插件 -->
    <plugin>
      <groupId>org.apache.maven.plugins</groupId> <!-- Apache Maven 官方插件 -->
      <artifactId>maven-resources-plugin</artifactId> <!-- 资源文件处理插件 -->
      <version>3.2.0</version> <!-- 插件版本号 -->
      <configuration>
        <encoding>UTF-8</encoding> <!-- 指定资源文件的编码格式，确保处理时不会乱码 -->
        <resources>
          <resource>
            <directory>src/main/resources</directory> <!-- 指定资源文件的源目录 -->
            <includes>
              <include>**/*.properties</include> <!-- 包含所有 .properties 文件 -->
              <include>**/*.xml</include> <!-- 包含所有 .xml 文件 -->
            </includes>
            <excludes>
              <exclude>**/test/**</exclude> <!-- 排除 test 目录中的所有文件 -->
            </excludes>
            <filtering>true</filtering> <!-- 启用占位符替换，如配置文件中的 ${...} 动态注入 -->
          </resource>
        </resources>
      </configuration>
    </plugin>
  </plugins>
</build>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

代码解析：

<directory>：指定资源文件的源目录。该目录中的文件将被处理并复制到目标目录中，通常是 src/main/resources。
<includes>：指定需要包含在处理中的文件模式，例如 **/*.properties 表示所有 .properties 文件。
<excludes>：指定需要排除在处理之外的文件模式，例如排除测试目录中的文件 **/test/**。
<filtering>：启用资源文件的占位符替换功能，如在 .properties 文件中动态注入 Maven 配置的 ${...} 变量。

# 4. 依赖打包插件：`maven-assembly-plugin`

适用范围：所有 Maven 项目

实际开发场景：在项目打包时，需要将所有依赖打包到一个可执行的 JAR 文件中。例如在微服务或工具类项目中，常常需要生成一个包含所有依赖的“fat jar”。

<build>
  <plugins>
    <!-- 依赖打包插件 -->
    <plugin>
      <artifactId>maven-assembly-plugin</artifactId> <!-- 插件的唯一标识，指定为 maven-assembly-plugin -->
      <configuration>
        <descriptorRefs>
          <descriptorRef>jar-with-dependencies</descriptorRef> <!-- 引用预定义的描述符，用于生成包含所有依赖的 JAR 文件 -->
        </descriptorRefs>
        <archive>
          <manifest>
            <mainClass>com.example.MainClass</mainClass> <!-- 替换为你的主程序类的完整路径 -->
          </manifest>
        </archive>
      </configuration>
      <executions>
        <execution>
          <id>make-assembly</id> <!-- 执行的标识符 -->
          <phase>package</phase> <!-- 在 package 阶段执行 -->
          <goals>
            <goal>single</goal> <!-- 生成单个包含所有依赖的 JAR 文件 -->
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

代码解析：

<descriptorRef>：选择预定义的打包方式，如 jar-with-dependencies，用于生成“fat jar”。
<mainClass>：指定 JAR 文件的主类入口，运行时找到程序的启动点。

# 5. 源代码打包插件：`maven-source-plugin`

适用范围：所有 Maven 项目

实际开发场景：当需要将源代码附加到 JAR 文件中进行发布，或将源代码打包供其他开发者参考时使用。常用于发布到 Maven 仓库或为公共库提供源代码。

<build>
  <plugins>
    <!-- 源代码打包插件 -->
    <plugin>
      <groupId>org.apache.maven.plugins</groupId> <!-- 插件所属的组织ID -->
      <artifactId>maven-source-plugin</artifactId> <!-- 插件的唯一标识 -->
      <executions>
        <execution>
          <id>attach-sources</id> <!-- 执行的标识符 -->
          <goals>
            <goal>jar</goal> <!-- 生成包含源代码的 JAR 文件 -->
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

代码解析：

<goal>jar</goal>：生成包含源代码的 JAR 包，便于调试或发布到 Maven 仓库。

# 6. 依赖管理插件：`maven-dependency-plugin`

适用范围：所有 Maven 项目

实际开发场景：在某些项目中，需要将项目的依赖复制到指定目录中，方便后续部署或分发。这个插件可以自动管理和复制项目的依赖。

<build>
  <plugins>
    <!-- 依赖管理插件 -->
    <plugin>
      <groupId>org.apache.maven.plugins</groupId> <!-- Apache Maven 官方插件 -->
      <artifactId>maven-dependency-plugin</artifactId> <!-- 依赖管理插件 -->
      <version>3.1.2</version> <!-- 插件版本 -->
      <executions>
        <execution>
          <id>copy-dependencies</id> <!-- 执行的标识符 -->
          <phase>package</phase> <!-- 在 package 阶段执行 -->
          <goals>
            <goal>copy-dependencies</goal> <!-- 复制所有依赖到指定目录 -->
          </goals>
          <configuration>
            <outputDirectory>${project.build.directory}/lib</outputDirectory> <!-- 指定依赖复制到的目标目录 -->
            <excludeTransitive>false</excludeTransitive> <!-- 包含所有传递依赖 -->
            <stripVersion>true</stripVersion> <!-- 是否去除依赖的版本信息 -->
          </configuration>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

代码解析：

<outputDirectory>：指定依赖库复制到的目标目录，通常是 target/lib 目录。
<excludeTransitive>：是否包含所有传递依赖，设置

为 false 包括所有依赖。

<stripVersion>：设置为 true 表示去除复制的依赖文件名中的版本号。

# 7. Web 服务器插件：`maven-jetty-plugin`

适用范围：所有 Maven 项目（特别适用于 Web 项目）

实际开发场景：在开发 Web 项目时，使用 maven-jetty-plugin 启动一个内嵌的 Jetty 服务器，可以快速测试 Web 应用，而无需额外配置外部服务器。

<plugin>
  <groupId>org.mortbay.jetty</groupId> <!-- 插件的组织ID，表示插件的提供者 -->
  <artifactId>jetty-maven-plugin</artifactId> <!-- 插件的Artifact ID，明确使用 jetty-maven-plugin -->
  <version>8.1.16.v20140903</version> <!-- 插件版本 -->
  <configuration>
    <connectors>
      <connector implementation="org.eclipse.jetty.server.nio.SelectChannelConnector">
        <port>8080</port> <!-- 指定 Jetty 服务器监听的端口号 -->
      </connector>
    </connectors>
    <scanIntervalSeconds>10</scanIntervalSeconds> <!-- 设置扫描间隔时间，自动重载文件变化 -->
  </configuration>
</plugin>

1
2
3
4
5
6
7
8
9
10
11
12
13

代码解析：

<port>：指定 Jetty 服务器监听的端口，默认是 8080。
<scanIntervalSeconds>：设置文件变化的扫描间隔，开发时自动重新加载资源。

# 8. Web 服务器插件：`tomcat7-maven-plugin`

适用范围：所有 Maven 项目（特别适用于 Web 项目）

实际开发场景：在开发基于 Tomcat 的 Web 应用时，使用 tomcat7-maven-plugin 可以直接启动一个内嵌的 Tomcat 服务器进行快速测试，尤其适用于 Servlet 和 JSP 开发。

<plugin>
  <groupId>org.apache.tomcat.maven</groupId> <!-- 插件的组织ID，表示插件的提供者 -->
  <artifactId>tomcat7-maven-plugin</artifactId> <!-- 插件的Artifact ID，明确使用 tomcat7-maven-plugin -->
  <version>2.2</version> <!-- 插件版本 -->
  <configuration>
    <path>/</path> <!-- 应用部署的上下文路径，设置为根路径表示可直接通过 http://localhost:8080/ 访问 -->
    <port>8080</port> <!-- 指定 Tomcat 服务器监听的端口号 -->
    <uriEncoding>UTF-8</uriEncoding> <!-- 设置 URI 编码格式，确保请求参数和响应内容的编码一致 -->
  </configuration>
</plugin>

1
2
3
4
5
6
7
8
9
10

代码解析：

<path>：指定应用的上下文路径，设置为 / 表示在根路径下部署应用。
<port>：指定 Tomcat 服务器的监听端口，通常设置为 8080。
<uriEncoding>：指定 URI 编码格式，设置为 UTF-8 以避免请求参数和响应内容出现乱码问题。

插件适用范围总结

插件名称	适用范围	备注说明
spring-boot-maven-plugin	仅限 Spring Boot	主要用于 Spring Boot 项目的打包和运行
maven-compiler-plugin	所有 Maven 项目	设置 JDK 编译版本，适用于任何基于 Java 的项目
maven-resources-plugin	所有 Maven 项目	处理资源文件的复制和过滤操作，常用于配置文件管理
maven-assembly-plugin	所有 Maven 项目	用于生成“fat jar”，适合需要将所有依赖打包的项目
maven-source-plugin	所有 Maven 项目	打包源代码用于发布或调试
maven-dependency-plugin	所有 Maven 项目	管理依赖并复制到指定目录，适合复杂项目的依赖管理
maven-jetty-plugin	所有 Maven 项目	启动内嵌 Jetty 服务器，特别适用于快速测试 Web 项目
tomcat7-maven-plugin	所有 Maven 项目	启动内嵌 Tomcat 服务器，适合 Servlet 和 JSP 项目测试

编辑此页

上次更新: 2024/12/28, 18:32:08

← Maven 资源与多环境配置本地搭建Maven私服→

Maven 生命周期与插件

# Maven 生命周期与插件

# Maven 生命周期

# Maven 插件概述

# Maven 插件的用途

# 插件的目标 (Plugin Goals)

# 1. mvn clean 阶段

# 2. mvn compile 阶段

# 3. mvn test 阶段

# 4. mvn package 阶段

# 5. mvn install 阶段

# Maven 插件配置

# Maven 插件标签详解

# 1. <plugin>：定义一个插件

# 2. <configuration>：插件的配置项

# 3. <executions> 和 <execution>：定义插件的执行

# 4. <pluginManagement>：插件版本管理

# 常用 Maven 插件汇总

# 1. Spring Boot Maven 插件：spring-boot-maven-plugin

# 2. 编译插件：maven-compiler-plugin

# 3. 资源处理插件：maven-resources-plugin

# 4. 依赖打包插件：maven-assembly-plugin

# 5. 源代码打包插件：maven-source-plugin

# 6. 依赖管理插件：maven-dependency-plugin

# 7. Web 服务器插件：maven-jetty-plugin

# 8. Web 服务器插件：tomcat7-maven-plugin

# 1. `mvn clean` 阶段

# 2. `mvn compile` 阶段

# 3. `mvn test` 阶段

# 4. `mvn package` 阶段

# 5. `mvn install` 阶段

# 1. `<plugin>`：定义一个插件

# 2. `<configuration>`：插件的配置项

# 3. `<executions>` 和 `<execution>`：定义插件的执行

# 4. `<pluginManagement>`：插件版本管理

# 1. Spring Boot Maven 插件：`spring-boot-maven-plugin`

# 2. 编译插件：`maven-compiler-plugin`

# 3. 资源处理插件：`maven-resources-plugin`

# 4. 依赖打包插件：`maven-assembly-plugin`

# 5. 源代码打包插件：`maven-source-plugin`

# 6. 依赖管理插件：`maven-dependency-plugin`

# 7. Web 服务器插件：`maven-jetty-plugin`

# 8. Web 服务器插件：`tomcat7-maven-plugin`