Maven 插件详解

plugin作用

plugin元素用于配置maven构建使用的插件

plugin结构

结构示例：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.8.1</version>
    <configuration>
        <source>1.8</source>
        <target>1.8</target>
    </configuration>
    <executions>
        <execution>
            <id>compile</id>
            <phase>compile</phase>
            <goals>
                <goal>compile</goal>
            </goals>
        </execution>
        <execution>
            <id>test-compile</id>
            <phase>test-compile</phase>
            <goals>
                <goal>testCompile</goal>
            </goals>
        </execution>
    </executions>
</plugin>

• groupId是org.apache.maven.plugins
• artifactId是maven-compiler-plugin
• version是3.8.1
• configuration元素配置了source和target参数
• execution元素配置了compile和test-compile两个执行目标

常见插件

Maven内置插件

内置插件整理

- maven-clean-plugin

maven-clean-plugin的主要功能是清理项目构建过程中生成的目录和文件。默认情况下，它会删除 target 目录及其内容，这是 Maven 默认的输出目录。

主要功能：

• 清理输出目录：默认情况下，maven-clean-plugin 会删除 target 目录，这是 Maven 构建过程中产生的输出目录。
• 自定义删除目录和文件：你可以通过配置来删除项目中的其他目录或文件。
• 自动执行清理操作：通常，clean 阶段会自动触发这个插件，但你也可以显式运行 mvn clean 来执行清理操作。

常见配置项：

• filesets：指定需要删除的文件集，可以包括目录、文件等。
• directory：指定要删除的目录，默认为 target。
• excludeDefaults：是否排除默认清理的文件和目录。

配置示例：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-clean-plugin</artifactId>
    <version>3.1.0</version>
    <executions>  
        <execution>
            <configuration>
            	<excludeDefaults>true</excludeDefaults>
                <filesets>
                    <fileset>
                        <directory>${project.basedir}/target1</directory>
                    </fileset>
                    <fileset>
                        <directory>${project.basedir}/test-output</directory> 
                        <includes>
                            <include>**/*.tmp</include>
                        </includes>
                    </fileset>
                </filesets>
            </configuration>
        </execution>
    </executions>
</plugin>

• 禁用默认删除的target目录
• 清理整个target1目录
• 清理test-output目录中的所有.tmp后缀的文件

- maven-resources-plugin

maven-resources-plugin 插件是 Maven 中用于处理项目中的资源文件（如 .properties、.xml、.txt 等）的工具。它负责将项目中的资源文件（如配置文件、属性文件、图片、XML 文件等）复制到最终的构建目录中，通常是 target/classes 或 target/test-classes，并支持对文件的过滤、编码设置、包括和排除特定文件等功能。以供编译和打包使用。

Maven Resources Plugin 通常与其他 Maven 插件一起使用。例如，在处理资源文件后，你可能需要使用 Maven Compiler Plugin 来编译项目。

Maven Resources Plugin 默认绑定到 Maven 构建生命周期的 process-resources 阶段。这意味着在执行 mvn compile、mvn package等命令时，将自动执行该插件。

主要功能：

• 资源复制：将资源文件从源目录复制到目标目录。
• 资源过滤：对资源文件内容进行过滤（例如，替换占位符），在构建过程中根据 Maven 属性替换文件中的动态值。
• 编码配置：设置资源文件的编码格式。
• 包含/排除资源文件：通过包含和排除模式指定哪些资源文件应该被处理。

配置示例：

方式1：直接在 标签下写 <resources>：

这种方式是 Maven 的一种约定俗成的简化配置方式，Maven 会默认使用 maven-resources-plugin 插件来处理资源。这种简化方式适用于大多数情况下的基本需求，比如指定资源目录、开启过滤等，但缺乏对插件更详细配置的灵活性。

<build>
    <resources>
        <resource>
            <directory>src/main/config</directory>
            <filtering>true</filtering>
        </resource>
        <resource>
            <directory>src/main/images</directory>
            <includes>
                <include>*.png</include>
                <include>*.jpg</include>
            </includes>
        </resource>
    </resources>
</build>

上述配置示例中，指定了两个资源目录：src/main/config 和 src/main/images。

• src/main/config 目录下的资源文件将进行过滤处理
• src/main/images 目录下的 .png 和 .jpg 文件将被包含。

方式2：在 maven-resources-plugin 插件中写 <resources>：
这种方式更为显式，您可以在插件配置中直接指定需要的资源处理规则，并且可以更细致地控制资源的处理方式，包括过滤规则、排除规则等。这种方式适用于需要更复杂资源处理需求的场景。

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-resources-plugin</artifactId>
            <version>...</version>
            <configuration>
                <resources>
		        	<resource>
		            	<directory>src/main/config</directory>
			            <filtering>true</filtering>
			        </resource>
			        <resource>
			            <directory>src/main/images</directory>
			            <includes>
			                <include>*.png</include>
			                <include>*.jpg</include>
			            </includes>
			        </resource>
			    </resources>
            </configuration>
        </plugin>
    </plugins>
</build>

各功能示例明细：

1. 资源复制
   默认的源目录是 src/main/resources，目标目录是 target/classes。

   <plugin>
       <groupId>org.apache.maven.plugins</groupId>
       <artifactId>maven-resources-plugin</artifactId>
       <version>3.2.0</version>
       <executions>
           <execution>
               <phase>process-resources</phase>
               <goals>
                   <goal>resources</goal>
               </goals>
               <configuration>
                   <basedir>src/custom/resources</basedir> <!-- 自定义源目录 -->
                   <outputDirectory>${project.build.directory}/custom-resources</outputDirectory> <!-- 自定义目标目录 -->
               </configuration>
           </execution>
       </executions>
   </plugin>
   

   • 上面示例自定义源目录是src/custom/resources，自定义目标目录是/custom-resources

2. 资源过滤
   资源过滤允许你在复制资源文件时，动态替换文件内容中的占位符。例如，可以将 ${version} 替换为实际的版本号。

   <plugin>
       <groupId>org.apache.maven.plugins</groupId>
       <artifactId>maven-resources-plugin</artifactId>
       <version>3.2.0</version>
       <executions>
           <execution>
               <phase>process-resources</phase>
               <goals>
                   <goal>resources</goal>
               </goals>
               <configuration>
                   <filters>
                       <filter>src/main/resources/filter.properties</filter> <!-- 指定过滤文件 -->
                   </filters>
               </configuration>
           </execution>
       </executions>
   </plugin>
   

   • 指定过滤文件为filter.properties，filter.properties 文件中可以定义各占位符的值，Maven 在构建过程中会将资源文件中的占位符替换成过滤文件中配置的实际值。
   • 例如：filter.properties中的配置

     version=1.0.0
     project.name=My Project
     

     Maven 在构建过程中会将资源文件，如application.yml、application.properties中的占位符${version}、${project.name}替换为filter.properties中配置实际值

3. 编码配置
   可以通过 encoding 配置项指定资源文件的编码格式，默认是 UTF-8。

   <plugin>
       <groupId>org.apache.maven.plugins</groupId>
       <artifactId>maven-resources-plugin</artifactId>
       <version>3.2.0</version>
       <executions>
           <execution>
               <phase>process-resources</phase>
               <goals>
                   <goal>resources</goal>
               </goals>
               <configuration>
                   <encoding>UTF-8</encoding> <!-- 设置资源文件的编码为UTF-8 -->
               </configuration>
           </execution>
       </executions>
   </plugin>
   

4. 包含/排除资源文件
   可以通过 includes 和 excludes 元素指定需要复制的文件，以及排除不需要复制的文件。

   <plugin>
       <groupId>org.apache.maven.plugins</groupId>
       <artifactId>maven-resources-plugin</artifactId>
       <version>3.2.0</version>
       <executions>
           <execution>
               <phase>process-resources</phase>
               <goals>
                   <goal>resources</goal>
               </goals>
               <configuration>
                   <overwrite>true</overwrite> <!-- 允许覆盖目标目录中的文件 -->
                   <includes>
                       <include>**/*.properties</include> <!-- 只包括所有的.properties文件 -->
                   </includes>
                   <excludes>
                       <exclude>**/test/**</exclude> <!-- 排除test目录下的所有文件 -->
                   </excludes>
               </configuration>
           </execution>
       </executions>
   </plugin>
   

- maven-compiler-plugin

maven-compiler-plugin 是 Maven 中用于编译项目源代码的插件。它的主要功能是将项目的 Java 源代码编译为字节码（.class 文件）。该插件可以在 Maven 构建生命周期中的多个阶段执行，通常在 compile 和 test-compile 阶段执行。

默认情况下，Maven Compiler Plugin 会编译 src/main/java 目录下的 Java 源文件，并将编译结果输出到 target/classes 目录中。这使得编译后的类文件可以被包含在最终的构建结果中。

Maven Compiler Plugin 通常与其他 Maven 插件一起使用。例如，在编译完成后，你可能需要使用 Maven Surefire Plugin 来运行单元测试。

Maven Compiler Plugin 默认绑定到 Maven 构建生命周期的 compile 阶段。这意味着在执行 mvn compile、mvn package等命令时，将自动执行该插件。

基本功能：

• 编译 Java 源文件：将项目的源代码（位于 src/main/java 和 src/test/java）编译成字节码。
• 设置编译选项：例如，选择 Java 编译器版本、设置编译选项、是否启用调试信息等。
• 编译阶段：通常，maven-compiler-plugin 会在 compile 和 test-compile 阶段自动运行，分别处理主代码和测试代码。

常见配置项：

• source：指定 Java 源代码的版本（例如 1.8，11）。
• target：指定生成的字节码的版本（例如 1.8，11）。
• encoding：指定源代码文件的字符编码。
• compilerVersion：指定要使用的 Java 编译器版本（例如 javac）。
• debug：启用或禁用调试信息的生成。
• fork：是否在独立的进程中执行编译。

配置示例：
如果需要编译时包含调试信息（比如源文件行号），可以使用 debug 配置项。启用 debug 选项后，编译过程中会生成包含调试信息的 .class 文件。这对于调试和使用调试器非常有帮助。

maven-compiler-plugin 默认在当前的 JVM 中运行。如果希望在独立的 JVM 进程中运行编译过程，可以使用 fork 配置项。启用 fork 后，编译过程会在单独的进程中运行，这对于避免与其他进程的冲突、提高编译速度或调试时有所帮助。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.10.1</version> <!-- 插件版本 -->
    <configuration>
        <source>1.8</source>  <!-- 设置 Java 源代码的版本 -->
        <target>1.8</target>  <!-- 设置生成字节码的版本 -->
        <encoding>UTF-8</encoding>  <!-- 设置源代码文件的编码 -->
        <debug>true</debug>  <!-- 启用调试信息 -->
        <fork>true</fork>  <!-- 启用独立进程执行编译 -->
    </configuration>
</plugin>

上述配置示例中，指定了要使用的 Java 版本为 1.8，并设置了编码方式为 UTF-8。

- maven-surefire-plugin

maven-surefire-plugin 是 Maven 中用于执行单元测试的插件。它主要用于在构建过程中执行项目中的单元测试（通常是位于 src/test/java 目录中的测试类），并生成测试报告。它支持多种测试框架，如 JUnit、TestNG 等。

默认情况下，Maven Surefire Plugin 会执行 src/test/java 目录下以 Test 结尾的测试类，并在 target/surefire-reports 目录下生成测试报告。

Maven Surefire Plugin 通常与其他 Maven 插件一起使用。例如，在测试完成后，你可能需要使用 Maven Failsafe Plugin 来运行集成测试。

Maven Surefire Plugin 默认绑定到 Maven 构建生命周期的 test 阶段。这意味着在执行 mvn test、mvn package等命令时，将自动执行该插件。

主要功能：

• 执行单元测试：运行项目中编写的单元测试。
• 生成测试报告：生成 HTML 或 XML 格式的测试报告。
• 并行执行：支持多线程并行执行测试，提高构建速度。
• 测试过滤：可以指定哪些测试类或测试方法需要执行，哪些不需要。
• 跳过测试：可以选择跳过测试的执行，通常用于快速构建或调试。

常见配置项：

• test：指定测试类的模式，通常是 **/*Test.java 或其他符合 Maven 测试命名规则的模式。
• includes 和 excludes：分别用于包含和排除特定的测试类。
• parallel：配置并行执行的策略，以提高测试执行效率。
• forkCount：设置同时运行的 JVM 数量。
• skipTests：跳过测试的执行（常用于构建阶段中跳过测试，或者在调试时跳过）。
• failIfNoTests：如果没有测试类，是否让构建失败。
• testFailureIgnore：当测试失败时，是否忽略失败。

配置示例：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>3.0.0-M5</version>
    <configuration>
        <includes>
            <include>**/MyTest*.java</include>
        </includes>
        <excludes>
            <exclude>**/AnotherTest.java</exclude>
        </excludes>
        <reportsDirectory>${project.build.directory}/surefire-reports/custom-reports</reportsDirectory>
    </configuration>
</plugin>

• 上述配置示例中，指定了要包含的测试类为 MyTest*.java，排除的测试类为 AnotherTest.java，并将测试报告输出到自定义目录 target/surefire-reports/custom-reports。

- maven-surefire-report-plugin

maven-surefire-report-plugin 是一个用于生成 Maven 构建过程中执行测试后的报告的插件。它与 maven-surefire-plugin 配合使用，maven-surefire-plugin 执行单元测试，而 maven-surefire-report-plugin 负责基于这些测试结果生成报告。

通常，这个插件会在 site 阶段生成测试报告，可以生成 HTML 格式的详细报告，帮助开发者查看和分析测试结果。

主要功能：

• 生成测试报告：根据 maven-surefire-plugin 执行的测试结果，生成 HTML 或其他格式的报告。
• 报告内容：包括每个测试类的执行情况、失败的测试、成功的测试、跳过的测试、每个测试的执行时间等信息。
• 支持格式：可以生成 HTML、XML 等格式的报告。
• 集成 Maven Site：maven-surefire-report-plugin 通常与 maven-site-plugin 一起使用，生成站点文档并集成测试报告。

常见配置选项：

• 输出格式：
  • html：生成 HTML 格式的报告，适合浏览查看。
  • xml：生成 XML 格式的报告，适合机器读取或集成其他工具。
• 报告文件名：
  • outputName：指定生成报告的文件名。
  • summaryFileName：指定报告的汇总文件名。
• 报告标题：
  • documentTitle：自定义报告页面的标题，便于在生成的站点中区分不同的报告。
• 报告目录：
  • reportOutputDirectory：指定生成报告的输出目录，默认情况下报告会保存在 target/site 目录下。

配置示例：
以下是一个标准的配置示例，用于在 Maven 的 site 阶段生成 HTML 格式的测试报告。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-report-plugin</artifactId>
    <version>3.0.0-M5</version>
    <executions>
        <execution>
            <goals>
                <goal>report</goal>  <!-- 生成报告 -->
            </goals>
            <phase>site</phase>  <!-- 在 site 阶段生成报告 -->
        </execution>
    </executions>
    <configuration>
        <outputName>unit-test-report</outputName>  <!-- 输出文件名 -->
        <reportFormat>html</reportFormat>  <!-- 设置报告格式为 HTML -->
        <documentTitle>Unit Test Report</documentTitle>  <!-- 设置报告标题 -->
        <summaryFileName>summary</summaryFileName>  <!-- 汇总文件名 -->
    </configuration>
</plugin>

- maven-jar-plugin

maven-jar-plugin 是一个用于将项目编译后的文件打包成 JAR 文件的 Maven 插件。它是 Maven 构建生命周期的一部分，负责将编译好的 .class 文件及其他资源文件（如配置文件、图片等）打包成一个 JAR 文件。该插件非常适合用于 Java 项目的打包和发布。

默认情况下，Maven Jar Plugin 将项目的编译输出目录（默认为 target/classes）中的类文件打包成一个 JAR 文件。这样，在构建过程中，就会生成一个包含项目所有类的 JAR 文件。

Maven Jar Plugin 通常与其他 Maven 插件一起使用。例如，在创建 JAR 文件后，你可能需要使用 Maven Assembly Plugin 将其与其他资源文件打包成一个完整的可执行 JAR 文件。

Maven Jar Plugin 默认绑定到 Maven 构建生命周期的 package 阶段。这意味着在执行 mvn package 命令时，将自动创建项目的 JAR 文件。

主要功能：

• 创建 JAR 文件：将编译后的 .class 文件、资源文件（如 properties、xml 等）打包成一个 JAR 文件。
• 设置 Manifest 文件：可以在 JAR 包中嵌入自定义的 MANIFEST.MF 文件，设置主类、版本、依赖等信息。
• 自定义输出：可以指定 JAR 文件的输出目录、文件名等。
• 附加 JAR 文件：支持生成附加的 JAR 文件（例如测试 JAR、源代码 JAR、Javadoc JAR 等）。

主要配置选项：

• outputDirectory：指定生成 JAR 文件的输出目录，默认为 target 目录。
• finalName：指定生成的 JAR 文件的名称，不带扩展名（默认为项目名称和版本号）。
• archive：自定义 JAR 文件的打包配置，通常包括 manifest（指定 MANIFEST.MF 文件的内容）、addMavenDescriptor 等。
• includeDependencies：指定是否将项目的依赖项打包到 JAR 文件中（通常用于创建 “uber JAR” 或 “fat JAR”）。
• manifestEntries：为 MANIFEST.MF 文件添加自定义条目。
• attach：如果设置为 true，插件会生成附加的 JAR 文件，如源代码 JAR 或 Javadoc JAR。

配置示例：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>3.1.2</version>
    <configuration>
		<outputDirectory>${project.build.directory}</outputDirectory> <!-- 自定义输出目录 -->
		<finalName>my-custom-name</finalName> <!-- 自定义文件名 -->
        <archive>
        	<!-- 配置 JAR 文件的 manifest 文件 -->
            <manifest>
                <mainClass>com.xxok.boot.XxokBootApplication</mainClass><!-- 指定 JAR 文件的主类（启动类），即 Java 应用程序的入口点 -->
                <addClasspath>true</addClasspath><!-- 是否将类路径（Class-Path）条目添加到 manifest 文件中 -->
                <classpathPrefix>lib/</classpathPrefix><!-- 设置类路径前缀，通常用于嵌套 JAR 或依赖的 JAR 文件 -->
                <useUniqueVersions>false</useUniqueVersions><!-- 是否使用唯一版本号，默认为 true，设置为 false 后可以避免版本号影响 -->
            </manifest>
            <!-- 自定义的 manifestEntries 配置，将额外的条目添加到 JAR 的 MANIFEST.MF 文件 -->
            <manifestEntries>
                <Class-Path>./</Class-Path><!-- 添加 Class-Path 条目，指定依赖的 JAR 文件位置 -->
            </manifestEntries>
        </archive>
        <!-- 排除不需要打包到 JAR 文件中的文件和目录 -->
        <excludes>
            <exclude>**/test/**</exclude>
            <exclude>application*.yml</exclude>
        </excludes>
    </configuration>
</plugin>

- maven-dependency-plugin

maven-dependency-plugin用于处理项目中的依赖关系，它可以复制项目的依赖包到指定的目录或解压缩依赖包。

Maven Dependency Plugin 的执行时机取决于你在项目的 pom.xml 文件中如何配置它。由于 Maven Dependency Plugin 并没有默认绑定到特定的构建生命周期阶段，因此你需要显式地配置它来执行特定的任务。

通常，你可以将 Maven Dependency Plugin 配置到以下几个阶段中：

• validate 验证阶段：
  在 Maven 构建生命周期的 validate 阶段执行 Maven Dependency Plugin 可能是有意义的，特别是当你需要在构建之前验证项目依赖是否正确时。

• compile 编译阶段：
  在 compile 阶段执行 Maven Dependency Plugin 可能会用到，尤其是在需要在编译代码之前处理依赖的情况下。

• test 测试阶段：
  如果你希望在运行单元测试之前或之后执行 Maven Dependency Plugin 的任务，可以将其配置到 test 阶段。

• package 打包阶段：
  Maven Dependency Plugin 也可以在打包阶段执行，这样可以确保在生成最终构件之前处理依赖。

• install 安装阶段：
  在执行 install 阶段时，你可能希望 Maven Dependency Plugin 处理依赖，以确保安装到本地仓库的构件包含正确的依赖信息。

• deploy 部署阶段：
  类似于 install 阶段，你也可以在执行 deploy 阶段时配置 Maven Dependency Plugin 来处理依赖。

主要功能：

• 查看项目的依赖树：可以查看当前项目的所有依赖关系。
• 复制依赖：将依赖的 JAR 文件复制到指定目录。
• 分析依赖冲突：检查项目中可能存在的版本冲突。
• 解析依赖：输出依赖的详细信息，帮助分析依赖的版本等。

常见目标（Goals）：

• dependency:tree：查看项目的依赖树。
• dependency:copy：复制指定的依赖到目标目录。
• dependency:copy-dependencies：将所有的依赖复制到目标目录。
• dependency:list：列出当前项目的所有依赖。
• dependency:analyze：分析项目中的依赖，检查不再使用的依赖和缺失的依赖。
• dependency:purge-local-repository：清除本地仓库中的依赖。

配置示例：
可以通过在 pom.xml 文件中配置 元素来指定 Maven Dependency Plugin 的执行阶段，例如：

1. 查看项目的依赖树

   <plugin>
       <groupId>org.apache.maven.plugins</groupId>
       <artifactId>maven-dependency-plugin</artifactId>
       <version>3.2.0</version>
       <executions>
           <execution>
               <id>analyze-dependencies</id>
               <phase>validate</phase>
               <goals>
                   <goal>analyze</goal>
               </goals>
           </execution>
       </executions>
   </plugin>
   

   • 配置了一个执行阶段为 validate，目标为 analyze 的 Maven Dependency Plugin 执行任务。这意味着在执行 Maven 构建生命周期的 validate 阶段时，将执行 Maven Dependency Plugin 的 analyze 目标。

2. 复制依赖

           <plugin>
   			<groupId>org.apache.maven.plugins</groupId>
   			<artifactId>maven-dependency-plugin</artifactId>
   			<executions>
   				<execution>
   					<phase>package</phase>
   					<goals>
   						<goal>copy-dependencies</goal>
   					</goals>
   					<configuration>
   						<outputDirectory>${project.build.directory}/lib</outputDirectory>
   					</configuration>
   				</execution>
   			</executions>
   		</plugin>
   

   • 将 Maven Dependency Plugin 绑定到 Maven 构建生命周期的 package 阶段，并指定了 copy-dependencies 目标。在这个配置中，指定了将项目依赖复制到 ${project.build.directory}/lib 目录下。

3. 分析依赖冲突

   <plugin>
       <groupId>org.apache.maven.plugins</groupId>
       <artifactId>maven-dependency-plugin</artifactId>
       <version>3.3.0</version>
       <executions>
           <execution>
               <goals>
                   <!-- 分析项目的依赖 -->
                   <goal>analyze</goal>
               </goals>
           </execution>
       </executions>
   </plugin>
   

   • goal: analyze：这个目标用于分析项目的依赖，检查哪些依赖已经不再使用，哪些依赖是缺失的。

- maven-war-plugin

maven-war-plugin 是 Maven 构建工具中的一个插件，用于将 Web 应用程序的源码打包成 WAR (Web ARchive) 文件。WAR 文件是用于 Java Web 应用部署的标准格式，通常包含 JSP、Servlet、静态资源、WEB-INF 目录以及相关配置文件等。

默认情况下，Maven War Plugin 将项目的编译输出目录（默认为 target/classes）中的类文件以及 src/main/webapp 目录中的 Web 资源文件（如 HTML、JSP、CSS、JavaScript 等）打包成一个 WAR 文件。这样，在构建过程中，就会生成一个包含项目所有 Web 资源的 WAR 文件。

Maven War Plugin 通常与其他 Maven 插件一起使用。例如，在创建 WAR 文件后，你可能需要使用 Maven Tomcat Plugin 将 WAR 文件部署到 Tomcat 服务器上进行测试。

Maven War Plugin 默认绑定到 Maven 构建生命周期的 package 阶段。这意味着在执行 mvn package 命令时，将自动创建项目的 WAR 文件。

在 Maven 项目的 pom.xml 文件中，你可以配置 Maven War Plugin 的行为。你可以指定 WAR 文件的名称、包含哪些类文件和 Web 资源文件、以及是否包含其他依赖等。

主要功能：

• 构建 WAR 包：将项目中的 Web 应用程序打包成一个标准的 WAR 文件，适用于部署到 Servlet 容器（如 Tomcat、Jetty 等）。
• 定制化 WAR 包结构：可以定制 WAR 文件中包含的文件和目录结构。
• 处理 Web 资源：如静态文件、JSP 文件、Web 配置文件等。
• 多模块支持：支持多模块项目中打包多个 WAR 文件。

主要目标（Goals）：

• war:war：将项目打包为 WAR 文件。
• war:exploded：构建一个解压后的 WAR 包，通常用于开发和调试阶段。
• war:run：直接在本地启动一个嵌入式的容器（例如 Jetty）来运行 WAR 包。

配置示例：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>3.3.2</version>
    <configuration>
        <!-- 设置 WAR 文件的输出目录 -->
        <outputDirectory>${project.build.directory}/custom-webapp</outputDirectory>
        
        <!-- 设置 Web 应用的根目录 -->
        <webappDirectory>${project.basedir}/src/main/webapp</webappDirectory>
        
        <!-- 配置打包时包含哪些文件 -->
        <includes>
            <!-- 包含所有的 .jsp 和 .html 文件 -->
            <include>**/*.jsp</include>
            <include>**/*.html</include>
        </includes>
        
        <!-- 配置排除哪些文件 -->
        <excludes>
            <!-- 排除 test 目录下的 Java 文件 -->
            <exclude>**/test/**/*.java</exclude>
        </excludes>

        <!-- 设置上下文路径，这在某些部署环境中可能有用 -->
        <contextPath>/myapp</contextPath>

        <!-- 配置覆盖的模块（如共享资源） -->
        <overlays>
            <overlay>
                <!-- 这里的 `my-library` 是其他项目的 Web 模块 -->
                <groupId>com.example</groupId>
                <artifactId>my-library</artifactId>
                <version>1.0.0</version>
            </overlay>
        </overlays>

        <!-- 排除某些文件或目录，这对于 WEB-INF/classes 中的资源有用 -->
        <packagingExcludes>WEB-INF/classes/com/example/**</packagingExcludes>

        <!-- 设置是否支持开发阶段的爆炸型 WAR 输出 -->
        <exploded>true</exploded>
    </configuration>

    <!-- 插件执行阶段配置 -->
    <executions>
        <execution>
            <goals>
                <!-- 执行默认的 war:war 目标来打包 WAR 文件 -->
                <goal>war</goal>
            </goals>
            <!-- 配置插件执行的生命周期阶段 -->
            <phase>package</phase>
        </execution>

        <execution>
            <goals>
                <!-- 在开发阶段生成爆炸型 WAR 文件，适合快速调试 -->
                <goal>exploded</goal>
            </goals>
            <phase>prepare-package</phase>
        </execution>
    </executions>
</plugin>

- maven-install-plugin

maven-install-plugin 是 Maven 中用于将构建生成的 artifact（如 JAR、WAR、EAR 等）安装到本地 Maven 仓库的插件。该插件通常在开发过程中使用，将本地构建的 artifact 安装到本地仓库，供其他项目使用。这个插件可以在构建生命周期中的 install 阶段执行，以保证本地仓库中有最新版本的构建产物。

主要功能：

• 将构建产物安装到本地仓库：这个插件会将项目构建生成的 artifact（如 JAR、WAR、EAR 文件等）安装到本地 Maven 仓库，供其他项目作为依赖使用。
• 部署功能：通过此插件，可以将 artifact 发布到远程仓库。
• 支持自定义安装路径：可以配置本地仓库的路径，而不仅仅使用默认的 ~/.m2/repository。
• 支持验证功能：在安装 artifact 之前，插件会进行验证，确保文件的完整性。

主要配置选项：

• localRepository：指定本地仓库路径。如果没有设置，默认路径为 ~/.m2/repository。
• verify：是否在安装时验证 artifact 的完整性，默认为 true。如果设置为 false，则跳过验证。
• artifactId：构建生成 artifact 的 ID，通常从 POM 文件自动获取。
• groupId：构建生成 artifact 的 groupId，通常从 POM 文件自动获取。
• version：构建生成 artifact 的版本，通常从 POM 文件自动获取。
• packaging：构建生成 artifact 的打包类型（如 jar、war、ear）。
• generatePom：是否生成 POM 文件并将其与 artifact 一同安装到本地仓库。

配置示例：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-install-plugin</artifactId>
    <version>3.1.0</version>
    <executions>
        <!-- 在 install 阶段执行 install 目标 -->
        <execution>
            <goals>
                <goal>install</goal>
            </goals>
            <phase>install</phase> <!-- 绑定到 install 阶段 -->
        </execution>
    </executions>
    <configuration>
        <!-- 指定本地仓库的路径 -->
        <localRepository>/path/to/your/local/repo</localRepository>
        
        <!-- 控制是否验证 artifact 的完整性 -->
        <verify>false</verify>
        
        <!-- 使用项目的 GAV 信息 -->
        <artifactId>${project.artifactId}</artifactId>
        <groupId>${project.groupId}</groupId>
        <version>${project.version}</version>
        <packaging>${project.packaging}</packaging>
        
        <!-- 可选：生成 POM 文件并一起安装 -->
        <generatePom>true</generatePom>
    </configuration>
</plugin>

- maven-deploy-plugin

maven-deploy-plugin 是 Maven 中用于将构建生成的 artifact（如 JAR、WAR、EAR 等）部署到远程 Maven 仓库的插件。它通常在构建的最后阶段使用，将构建产物推送到中央仓库或私有仓库，供其他项目或团队使用。

该插件的关键功能是将项目的构建产物发布到 Maven 仓库（通常是远程仓库），以便其他项目能够通过 Maven 依赖它。maven-deploy-plugin 经常与 maven-install-plugin 一起使用，前者将 artifact 安装到本地仓库，后者则将它们发布到远程仓库。

主要功能：

• 部署构建产物：将项目构建生成的 artifact 推送到远程 Maven 仓库。
• 支持多种远程仓库：支持将 artifact 发布到不同的远程仓库（如 Nexus、Artifactory、Central Repository 等）。
• 发布 POM 文件：可以选择是否将与 artifact 一同发布的 POM 文件发布到远程仓库。
• 支持版本控制：可以发布不同版本的 artifact，并支持 SNAPSHOT 版本和发布版本的区分。

主要配置选项：

• repository：远程仓库的配置，包括 URL、认证信息等。
• url：远程仓库的 URL 地址，通常以 http:// 或 https:// 开头。
• uniqueVersion：是否为 SNAPSHOT 版本生成唯一版本号。默认为 true，会在发布 SNAPSHOT 版本时添加时间戳。
• goals：插件的目标。常见的目标是 deploy，它会在 Maven 的 deploy 阶段执行。
• updateReleaseInfo：在发布 artifact 后，是否更新远程仓库中的版本信息。
• repositoryId：指定仓库的 ID，用于从 settings.xml 中查找认证信息。

配置示例：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-deploy-plugin</artifactId>
    <version>3.1.0</version>
    <executions>
        <execution>
            <goals>
                <goal>deploy</goal>
            </goals>
            <phase>deploy</phase>
        </execution>
    </executions>
    <configuration>
        <!-- 发布到私有仓库 -->
        <repositoryId>my-repo</repositoryId>
        <url>https://nexus.example.com/repository/maven-releases/</url>
        <uniqueVersion>false</uniqueVersion>
        <updateReleaseInfo>true</updateReleaseInfo>
    </configuration>
</plugin>

- maven-assembly-plugin

提供了一种将项目构建结果打包成特定格式的归档文件的能力。相比于一般的 JAR 或 WAR 文件，使用 Maven Assembly Plugin 可以创建更为复杂、自定义的归档文件，例如包含依赖库、配置文件等的可执行 JAR 文件，或者包含特定结构的目录布局的归档文件。此插件特别适用于需要将多个文件（如编译后的类文件、配置文件、库依赖、资源文件等）合并为一个分发包的场景，方便分发和部署。

通常会通过定义打包规则的.xml文件，来配合使用。

Maven Assembly Plugin 通常与其他 Maven 插件一起使用。例如，在创建归档文件后，你可能需要使用 Maven Install Plugin 将其安装到本地 Maven 仓库中。

Maven Assembly Plugin 提供了一个强大的工具来创建各种类型的归档文件，方便项目的打包和分发。通过灵活的配置，可以满足不同项目的需求，是 Maven 构建过程中的重要组成部分。

主要功能：

• 创建压缩包：可以将项目的构建产物与所有依赖库、资源文件打包为一个压缩文件（如 JAR、ZIP、TAR）。
• 包括/排除文件：支持灵活配置哪些文件和资源应被包含在内，哪些应排除。
• 自定义文件结构：可以自定义文件在打包后的结构，决定哪些文件放在包的哪一层目录。
• 多个输出格式：支持输出多种格式，如 ZIP、TAR、JAR 等。
• 自动包含依赖：支持将项目的所有依赖库自动包含到分发包中，确保包的完整性。

主要配置选项：

• finalName：指定最终打包文件的名字。
• archive：用于配置打包文件的格式（如 ZIP、TAR）。
• dependencySets：指定哪些依赖需要包含到输出包中。
• appendAssemblyId：指定是否将构建 ID 添加到输出文件名中。
• outputDirectory：指定打包的输出目录。
• formats：指定打包格式，通常是 zip 或 tar。
• includeBaseDirectory：指定是否将项目的根目录包含在输出包的结构中。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>3.2.0</version>
    <configuration>
        <appendAssemblyId>false</appendAssemblyId>
        <outputDirectory>${project.build.directory}</outputDirectory>
        <descriptors>
            <descriptor>src/main/resources/package.xml</descriptor>
        </descriptors>
    </configuration>
    <executions>
        <execution>
            <id>package</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>

package.xml：

<?xml version="1.0" encoding="UTF-8"?>
<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3 http://maven.apache.org/xsd/assembly-1.1.3.xsd">
    <id>package</id>
    <formats>
        <format>tar.gz</format>
    </formats>
    <includeBaseDirectory>true</includeBaseDirectory>
    <fileSets>
        <fileSet>
            <directory>src/main/bin</directory>
            <outputDirectory>bin</outputDirectory>
            <fileMode>0755</fileMode>
        </fileSet>

        <fileSet>
            <directory>src/main/resources</directory>
            <outputDirectory>config</outputDirectory>
            <includes>
                <include>application.yml</include>
                <include>application-${env}.yml</include>
            </includes>
            <filtered>true</filtered>
            <fileMode>0644</fileMode>
        </fileSet>

        <fileSet>
            <directory>${project.build.directory}</directory>
            <outputDirectory></outputDirectory>
            <includes>
                <include>*.jar</include>
            </includes>
            <fileMode>0755</fileMode>
        </fileSet>

        <fileSet>
            <directory>${project.build.directory}/lib</directory>
            <outputDirectory>lib</outputDirectory>
            <includes>
                <include>*.jar</include>
            </includes>
            <fileMode>0755</fileMode>
        </fileSet>
    </fileSets>
</assembly>

• appendAssemblyId：这个设置为 false，意味着打包后的文件名不会包含 assemblyId（即 package）。默认情况下，插件会将 assemblyId（这里是 package）追加到输出文件名中。如果设置为 false，则输出文件名将不包含这个标识。

• outputDirectory：打包的文件会输出到 $project.build.directory目录。${project.build.directory} 是 Maven 的标准构建输出目录，通常为 target/。

• descriptors：指定了使用 src/main/resources/package.xml 作为自定义的描述符文件。这意味着插件会根据该文件中的定义来执行打包任务。

• execution：

  • id：执行的 ID 为 package，这个 ID 用于标识该执行。
  • phase：这个插件执行在 package 阶段，即在 mvn package 命令运行时执行。
  • goal：目标是 single，表示生成一个单一的打包文件，而不是多个文件。

• formats：设置输出包的格式为 tar.gz，表示打包为一个压缩的 .tar.gz 文件。常见的格式还有 zip 和 tar。

• includeBaseDirectory：设置为 true，表示将基础目录（项目根目录）包含在压缩包中。如果设置为 false，则不会包含基础目录，文件会直接被放到压缩包的根目录下。

• fileSets：这是一个包含多个文件集的配置，每个 fileSet 定义了从项目中选取的文件或目录，并指定它们在压缩包中的目标路径。可以通过 指定源目录， 指定目标路径， 设置文件权限。

  • 从 src/main/bin 目录中选取文件，放入压缩包中的 bin 目录。设置文件权限为 0755（可执行文件）。
  • 从 src/main/resources 目录中选取 application.yml 和 application-${env}.yml 文件，放入压缩包中的 config 目录。启用了 true，这意味着在打包时会进行文件过滤（例如将 application-${env}.yml 中的 ${env} 替换为实际的环境变量）。文件权限设置为 0644（普通文件）。
  • 从 ${project.build.directory}（通常是 target/）中选取所有 .jar 文件，并将它们直接放入压缩包的根目录。文件权限设置为 0755，通常是为了确保 .jar 文件是可执行的。
  • 从 ${project.build.directory}/lib 目录中选取所有 .jar 文件，放入压缩包中的 lib 目录。

- maven-shade-plugin

maven-shade-plugin 是一个用于在 Maven 构建过程中创建一个包含所有依赖的可执行 JAR 包的插件。它的主要用途是将所有的项目依赖（包括第三方依赖）打包到一个 JAR 文件中，形成一个 “fat JAR” 或者 “uber JAR”。这个 JAR 文件包含了项目的代码和所有的依赖，不需要外部的依赖库文件就能独立运行，通常用于生成可以直接执行的 JAR 包，适用于分发和部署。

当多个依赖项中存在相同的类时，Maven Shade Plugin 可以通过合并或重命名策略来解决这些冲突。这确保了打包后的 JAR 文件在运行时不会因为类路径问题导致错误。

Maven Shade Plugin 支持过滤不必要的文件和资源，以减小最终 JAR 文件的大小。你可以配置插件以排除特定的文件或目录。

虽然 Maven Shade Plugin 主要用于创建包含依赖项的 JAR 文件，但它也可以与其他 Maven 插件配合使用，以实现更复杂的构建和部署任务。

Maven Shade Plugin 为 Java 应用的打包和分发提供了强大的支持，通过将所有必要的依赖项打包到一个 JAR 文件中，它简化了部署过程，并有助于避免依赖冲突。

在 Maven 项目的 pom.xml 文件中，你可以通过配置 Maven Shade Plugin 来指定特定的行为，如依赖项的合并策略、文件过滤等。

主要功能：

• 创建包含所有依赖的可执行 JAR：将项目代码和所有的依赖打包到一个 JAR 文件中，使得不需要在外部安装依赖即可直接运行。
• 资源合并：自动合并依赖包中的 META-INF 资源文件，避免冲突，尤其是在多个 JAR 中存在相同资源时。
• 类重定位：可以通过重定位（Relocation）来避免不同依赖库中类路径的冲突。
• 自定义清单文件：通过修改 MANIFEST.MF 文件来设置应用程序的启动类，确保生成的 JAR 文件可以直接执行。
• 生成无缩减的 POM：可以配置生成包含所有依赖的 POM 文件，便于在其他项目中复用。

主要配置选项：
以下是 maven-shade-plugin 的一些常用配置选项：

• 基本配置选项
  • createDependencyReducedPom: 是否生成一个包含仅有直接依赖的简化版 POM 文件。默认为 false，即不生成。
  • filters: 配置文件过滤规则，可以排除某些资源文件或依赖。
  • transformers: 配置如何修改 JAR 文件中的资源，如修改 MANIFEST.MF 或合并服务文件等。
  • relocations: 用于重定位类路径，避免不同依赖之间的类冲突。
  • shadedArtifactAttached: 是否将生成的 shaded JAR 附加到构建产物中。
• 资源合并
  • transformer: 用于定义资源合并策略，常见的有 ManifestResourceTransformer（合并 MANIFEST.MF）和 ServicesResourceTransformer（合并 META-INF/services 文件）。
• 类重定位（Relocation）
  • pattern: 定义需要重定位的原始包路径。
  • shadedPattern: 定义重定位后的包路径。
• 自定义 MANIFEST.MF
  • mainClass: 指定应用的主类，使得生成的 JAR 文件可以直接运行。
  • addDefaultImplementationEntries: 是否自动将默认的实现条目加入 MANIFEST.MF 中。

配置示例：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <version>3.2.1</version>
    <executions>
        <execution>
            <phase>package</phase> <!-- 在 package 阶段执行 -->
            <goals>
                <goal>shade</goal> <!-- 执行 shade 目标 -->
            </goals>
        </execution>
    </executions>
    <configuration>
        <createDependencyReducedPom>false</createDependencyReducedPom> <!-- 不创建缩减后的 POM -->
        <transformers>
            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                <mainClass>com.example.Main</mainClass> <!-- 设置主类 -->
            </transformer>
        </transformers>
    </configuration>
</plugin>

- maven-site-plugin

maven-site-plugin 用于为项目生成静态的 HTML 网站。它的目标是将项目的构建和发布过程与文档生成和项目展示相结合。通过该插件，开发者可以生成包括项目概要、构建信息、测试报告、依赖关系、插件信息等在内的完整网站，帮助项目团队更好地展示和共享项目相关的文档。

默认情况下，Maven Site Plugin 会在项目的 target 目录下生成一个静态网站，包括 HTML 文件、CSS 样式表、JavaScript 脚本等。生成的网站文档通常位于 target/site 目录下。

Maven Site Plugin 可以与其他 Maven 插件配合使用，例如，你可以在生成网站文档后使用 Maven Deploy Plugin 将文档部署到服务器上。

Maven Site Plugin 提供了一个方便的方式来生成项目的网站文档，使得开发者可以轻松地创建、发布和分享项目文档，提高了项目的可维护性和可用性。

主要功能：

• 生成项目文档：自动生成包含项目描述、构建信息、依赖信息等的 HTML 页面。
• 集成报告生成：可以集成其他 Maven 插件生成的报告，如 Javadoc、测试报告、代码覆盖率等，并将这些报告以网页的形式展示。
• 自定义网站布局：支持通过自定义模板和布局文件来改变生成的网站外观。
• 发布网站：通过配置，可以将生成的项目网站发布到指定的 Web 服务器上。

主要配置选项：

• reportPlugins：配置哪些插件的报告需要包括在网站中。例如，你可以配置 maven-javadoc-plugin、maven-surefire-report-plugin 等插件生成的报告。
• generateReports：指定是否生成报告。默认情况下，它会生成一组标准报告，如 Javadoc、测试报告等。
• outputDirectory：指定生成网站的输出目录。默认值为 target/site。

配置示例：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-site-plugin</artifactId>
    <version>3.9.1</version>
    <executions>
        <execution>
            <phase>site</phase> <!-- 在 site 阶段生成网站 -->
            <goals>
                <goal>site</goal> <!-- 执行 site 目标 -->
            </goals>
        </execution>
    </executions>
    <configuration>
        <outputDirectory>target/site</outputDirectory> <!-- 设置输出目录 -->
        <generateReports>true</generateReports> <!-- 生成报告 -->
    </configuration>
</plugin>

• 在 site 阶段执行 maven-site-plugin 插件，生成项目网站。
• 网站会默认生成在 target/site 目录下。
• generateReports 配置为 true，启用报告生成功能。

- maven-antrun-plugin

aven-antrun-plugin 用来在 Maven 构建过程中执行 Ant 任务。这个插件结合了 Maven 的构建生命周期和 Ant 的任务执行，支持在 Maven 的不同阶段（如编译、测试、打包等）运行 Ant 任务。由于 Maven 本身没有内置对某些复杂或特殊任务的支持，maven-antrun-plugin 允许开发者在构建过程中使用 Ant 的任务和功能。

主要功能：

• 执行 Ant 任务：在 Maven 构建过程中，可以执行任何 Ant 任务，例如文件复制、删除、编译、压缩、解压、执行脚本等。
• 集成 Ant 脚本：可以在 Maven 构建过程中嵌入自定义的 Ant 脚本，实现 Maven 与 Ant 任务的融合。
• 灵活的构建流程：使用 maven-antrun-plugin，可以将 Ant 的灵活性与 Maven 的构建生命周期结合在一起，实现更复杂的构建流程。

主要配置选项：

• tasks：定义要执行的 Ant 任务。
• target：指定要执行的 Ant 任务目标。
• inheritAll：是否继承 Maven 构建中的所有属性（默认值为 true）。

执行阶段：

• phase：指定插件执行的生命周期阶段。例如，compile、test、install 等。
• goal：定义在指定生命周期阶段执行的目标，通常为 run。

配置示例：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-antrun-plugin</artifactId>
    <version>3.1.0</version>
    <executions>
        <execution>
            <phase>compile</phase> <!-- 在 compile 阶段执行 -->
            <goals>
                <goal>run</goal> <!-- 执行目标是 run -->
            </goals>
            <configuration>
                <tasks>
                    <copy file="src/main/resources/input.txt" 
                          tofile="target/output.txt"/> <!-- 文件复制任务 -->
                </tasks>
            </configuration>
        </execution>
    </executions>
</plugin>

• 在 compile 阶段执行 maven-antrun-plugin，其目标为 run，执行文件复制操作，将 src/main/resources/input.txt 文件复制到 target/output.txt。

- maven-checkstyle-plugin

maven-checkstyle-plugin 是一个用于在 Maven 构建过程中进行 代码检查 的插件，它通过运行 Checkstyle 工具来分析 Java 源代码，确保代码符合一定的编码规范。Checkstyle 提供了一个广泛的规则集，允许开发团队根据项目的需要定制化代码标准，并在每次构建时检查代码质量。

主要功能：

• 代码质量检查：通过 Checkstyle 执行静态代码分析，检查代码风格、命名约定、代码复杂度等。
• 报告生成：生成详细的检查报告，可以输出为 HTML、XML 或文本格式。
• 集成到 Maven 构建生命周期：插件可以在不同的构建阶段执行，例如 validate、compile、test、install 等。
• 配置灵活：可以自定义规则集，选择不同的规则进行代码检查。

主要配置选项：

• Checkstyle 规则文件
  • configLocation：指定 Checkstyle 配置文件的位置，可以使用自定义的 Checkstyle 配置文件，也可以使用官方提供的规则文件（例如 sun_checks.xml）。
  • configProperties：传递给 Checkstyle 配置文件的属性，用于进一步定制规则。
• 输出格式
  • outputFile：指定输出报告的文件位置，支持 xml、html 和 plain 等格式。
  • encoding：指定输出文件的字符编码。
• 激活阶段
  • execution：可以在不同的构建阶段执行 Checkstyle，如 validate、compile、test 等。
  • failOnViolation：设置为 true 时，如果检测到违规，构建会失败；如果为 false，构建会继续进行，但会输出违规信息。

配置示例：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-checkstyle-plugin</artifactId>
    <version>3.1.0</version>
    <executions>
        <execution>
            <phase>validate</phase> <!-- 在 validate 阶段执行 -->
            <goals>
                <goal>check</goal> <!-- 执行 check 目标 -->
            </goals>
            <configuration>
                <configLocation>google_checks.xml</configLocation> <!-- 使用 Google 风格规则 -->
                <outputFile>target/checkstyle-result.xml</outputFile> <!-- 输出到 XML 文件 -->
                <failOnViolation>true</failOnViolation> <!-- 违规时构建失败 -->
            </configuration>
        </execution>
    </executions>
</plugin>

• 在 validate 阶段执行 check 目标，使用 google_checks.xml 作为 Checkstyle 规则文件。
• 输出结果会保存到 target/checkstyle-result.xml。
• 设置 failOnViolation 为 true，意味着如果有代码违反规则，构建会失败。

- maven-enforcer-plugin

maven-enforcer-plugin 是一个用于确保 Maven 构建过程中遵循一系列规则的插件。它主要用于在构建过程中应用一些 强制性规则，这些规则可以帮助确保构建的一致性、规范性以及避免潜在的构建问题。通过配置该插件，开发团队可以强制要求特定的构建环境、依赖版本、JDK 版本等条件，保证每次构建都符合特定的标准。

主要功能：

• 环境验证：强制执行特定的环境要求，比如确保使用正确的 JDK 版本。
• 依赖管理：确保使用特定版本的依赖库，并防止冲突。
• 构建标准化：强制执行标准化的构建规范，避免不同开发者或 CI 环境中的差异。
• 报告生成：输出违规的详细信息，帮助开发人员快速定位问题。

主要规则（Goals）：

• enforce：执行所有启用的规则。
• banDuplicates：防止依赖出现重复项。
• requireMavenVersion：强制要求指定的 Maven 版本。
• requireJavaVersion：强制要求指定的 JDK 版本。
• banDependency：禁止使用特定的依赖。
• dependencyConvergence：检查项目中是否存在版本冲突的依赖。
• enforcePluginVersions：检查插件版本的一致性。

主要配置选项：

• requireJavaVersion（要求特定的 JDK 版本）
• requireMavenVersion（要求特定的 Maven 版本）
• dependencyConvergence（检查依赖版本冲突）
• banDuplicates（禁止重复依赖）
• banDependency（禁止特定依赖）
• requireProperty（要求某个系统属性）

配置示例：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-enforcer-plugin</artifactId>
    <version>3.0.0-M3</version>
    <executions>
        <execution>
            <goals>
                <goal>enforce</goal> <!-- 执行所有规则 -->
            </goals>
            <configuration>
                <rules>
                    <requireJavaVersion>
                        <version>1.8</version> <!-- 强制 JDK 1.8 -->
                    </requireJavaVersion>
                    <requireMavenVersion>
                        <version>[3.6.0,)</version> <!-- 强制 Maven 版本 >= 3.6.0 -->
                    </requireMavenVersion>
                    <dependencyConvergence /> <!-- 确保依赖版本一致 -->
                    <banDuplicates /> <!-- 禁止重复依赖 -->
                    <banDependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-core</artifactId> <!-- 禁止使用 spring-core 依赖 -->
                    </banDependency>
                    <requireProperty>
                        <property>maven.test.skip</property> <!-- 确保定义了 maven.test.skip 属性 -->
                        <message>Property 'maven.test.skip' is required</message> <!-- 错误信息 -->
                    </requireProperty>
                </rules>
            </configuration>
        </execution>
    </executions>
</plugin>

• equireJavaVersion：强制要求 JDK 版本为 1.8。
• requireMavenVersion：强制要求 Maven 版本大于或等于 3.6.0。
• dependencyConvergence：确保项目中所有依赖的版本一致。
• banDuplicates：禁止项目中出现重复的依赖项。
• banDependency：禁止使用 org.springframework:spring-core 这个依赖。
• requireProperty：确保构建过程中定义了 maven.test.skip 属性。

如果在构建过程中，任何一个规则不满足要求，构建将会失败并抛出相应的错误信息。这样有助于确保构建的标准化和一致性，避免由于环境差异或版本不一致导致的构建问题

- maven-pmd-plugin

maven-pmd-plugin 用于集成 PMD（Programming Mistake Detector）静态代码分析工具，以检测 Java 代码中的潜在问题、坏味道（code smells）以及不符合编程最佳实践的代码片段。PMD 会分析 Java 源代码，并根据预定义的规则集（rule sets）报告潜在问题，帮助开发人员编写更加清晰、可靠和高效的代码。

- maven-release-plugin

maven-release-plugin 用于管理和执行 Maven 项目的发布过程。它提供了一组命令，可以帮助开发人员自动化发布版本，包括更新版本号、创建标签、发布到远程仓库等操作。它简化了发布过程，使得发布的步骤更加可靠、可重现。

主要功能：

• 自动化版本更新：更新项目的版本号，从开发版本（如 1.0-SNAPSHOT）切换到正式版本（如 1.0）。
• 创建 Git 标签（如果使用 Git 作为版本控制系统）或其他版本控制工具的标签。
• 发布构建到远程仓库。
• 提交和推送变更（如更新的 pom.xml 文件）。
• 自动化构建和发布流程，确保发布的一致性和可靠性。

- maven-scm-plugin

Maven SCM 插件（maven-scm-plugin）是一个用于与源代码管理（SCM）系统集成的插件。它支持多种版本控制系统（VCS），如 Git、Subversion（SVN）、Mercurial 等，可以在构建过程中自动处理 SCM 操作，例检出（checkout）代码、更新（update）代码、提交（commit）更改、标签（tag）创建等。

你可以在命令行中使用 Maven SCM Plugin，具体命令格式为 mvn scm:goal，其中 goal 是指插件的具体目标，如 checkout、update 等。

Maven SCM Plugin 可以与其他 Maven 插件配合使用，例如，在检出代码后，你可能需要使用 Maven Compiler Plugin 编译代码。

Maven SCM Plugin 为 Maven 项目与版本控制系统的集成提供了便利，使得开发者能够通过 Maven 构建系统进行统一的版本控制操作，提高了项目的管理效率和可维护性。

在 Maven 项目的 pom.xml 文件中，你可以配置 Maven SCM Plugin 的行为。你需要指定版本控制系统的 URL、用户名、密码等信息，以及具体要执行的操作。

主要功能：

• 检出代码（checkout）：从 SCM 仓库中检出源代码。
• 更新代码（update）：更新本地代码库，使其与远程仓库保持同步。
• 提交更改（commit）：将本地更改提交到远程 SCM 仓库。
• 创建标签（tag）：为当前代码创建一个标签，通常用于发布版本。
• 获取 SCM 信息（info）：获取当前代码仓库的状态和版本信息。
• 查看状态（status）：查看当前工作目录的文件状态，是否有修改、冲突或新增文件。

主要配置选项：

• connection：指定 SCM 连接的 URL，通常是你源代码仓库的 URL。
• developerConnection：开发者连接的 URL，通常是用于提交代码的连接。
• url：远程仓库的 URL，通常是与 SCM 相关的基本路径。
• scmProvider：指定 SCM 提供者（如 git、svn）。
• tag：创建标签时使用的标签名称。
• branch：指定操作的分支。
• message：提交代码时的提交信息。
• update：指定更新操作的范围（是否更新所有文件，默认是所有）。
• add：指定在提交之前要添加的新文件。

配置示例：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-scm-plugin</artifactId>
    <version>1.11.2</version>
    <executions>
        <execution>
            <goals>
                <goal>checkout</goal>
            </goals>
            <configuration>
                <connection>scm:git:https://github.com/your-repository/project.git</connection>
                <developerConnection>scm:git:git@github.com:your-repository/project.git</developerConnection>
                <url>https://github.com/your-repository/project</url>
            </configuration>
        </execution>
    </executions>
</plugin>

• 此配置用于检出 Git 仓库中的代码。你需要指定 connection 和 developerConnection 的 URL，以及仓库的 url。

- maven-failsafe-plugin

maven-failsafe-plugin 是 Maven 中用于运行集成测试的插件。与 maven-surefire-plugin 插件（用于运行单元测试）不同，maven-failsafe-plugin 主要用于运行集成测试，并且它的设计目的是确保即使集成测试失败，也不会影响构建的最终结果。

主要功能：

• 运行集成测试：在 Maven 的 integration-test 和 verify 阶段运行集成测试。
• 失败处理：即使集成测试失败，也不会导致构建失败，便于进行进一步的调查或处理。
• 自动化报告生成：失败的测试会生成报告，供开发者查看和分析。
• 支持并行执行：可以并行运行多个测试，以加速集成测试的执行。
• 与 Surefire 插件兼容：可以与 maven-surefire-plugin 一起使用，以便分别运行单元测试和集成测试。

主要配置选项：

• includes：指定测试类的包含模式，默认为 **/*IT.java（即所有以 IT 结尾的类）。可以根据需要更改为其他模式。
• excludes：指定测试类的排除模式。
• skip：是否跳过集成测试的执行。如果设置为 true，将跳过集成测试。
• forkCount：指定测试运行时启动的进程数，支持并行执行。
• reuseForks：是否在多个测试间复用测试进程。
• parallel：指定并行执行测试的方法（如按类或按方法）。
• testFailureIgnore：如果设置为 true，即使测试失败，也会继续执行后续步骤。
• debugForkedProcess：是否为每个子进程启用调试模式。

配置示例：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-failsafe-plugin</artifactId>
            <version>3.1.0</version>
            <executions>
                <execution>
                    <phase>integration-test</phase>
                    <goals>
                        <goal>integration-test</goal>
                        <goal>verify</goal>
                    </goals>
                    <configuration>
                        <includes>
                            <include>**/*IntegrationTest.java</include>
                        </includes>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

• 在 integration-test 和 verify 阶段运行集成测试。
• 只会运行文件名以 IntegrationTest 结尾的测试类。

- maven-sonar-plugin

maven-sonar-plugin 是 Maven 中用于与 SonarQube 集成的插件。SonarQube 是一个开源的代码质量管理平台，提供代码分析和质量报告。maven-sonar-plugin 插件允许开发者在 Maven 构建过程中自动执行 SonarQube 的代码质量检查，帮助识别潜在的代码问题、漏洞、安全风险等。

主要功能：

• 与 SonarQube 集成：通过 SonarQube 的分析引擎，对代码进行质量检查。
• 自动化上传分析结果：在 Maven 构建过程中，自动生成 SonarQube 质量分析报告并上传到 SonarQube 服务器。
• 支持多种分析类型：支持 Java、JavaScript、TypeScript、C#、Python 等多种语言的静态分析。
• 增量分析：可以设置只分析自上次提交以来的增量代码，提高分析效率。
• 报告生成：生成包含代码质量、漏洞、安全风险等信息的详细报告。

主要配置选项：

• sonar.host.url：SonarQube 服务器的 URL，指定 SonarQube 的地址。
• sonar.login：SonarQube 用户的认证令牌或用户名，用于身份验证。
• sonar.projectKey：项目在 SonarQube 中的唯一标识符。每个 SonarQube 项目都有一个唯一的 projectKey。
• sonar.projectName：项目的名称，在 SonarQube 中显示的名称。
• sonar.projectVersion：项目的版本信息。
• sonar.sources：源代码的路径，默认是 src/main/java。
• sonar.tests：测试代码的路径，通常是 src/test/java。
• sonar.language：分析的语言，指定代码的主要语言。通常情况下，这个选项可以不设置，SonarQube 会自动检测。
• sonar.exclusions：排除某些文件或目录不参与分析。
• sonar.inclusions：指定要包括的文件或目录。
• sonar.coverage.exclusions：排除代码覆盖率分析中的某些文件或方法。
• sonar.java.binaries：编译后的字节码目录，通常是 target/classes。

配置示例：

<build>
    <plugins>
        <plugin>
            <groupId>org.sonarsource.maven</groupId>
            <artifactId>sonar-maven-plugin</artifactId>
            <version>3.9.1.2184</version>
            <executions>
                <execution>
                    <phase>verify</phase>
                    <goals>
                        <goal>sonar</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <sonar.host.url>http://localhost:9000</sonar.host.url>
                <sonar.login>your-sonar-token</sonar.login>
                <sonar.projectKey>my_project_key</sonar.projectKey>
                <sonar.projectName>My Project</sonar.projectName>
                <sonar.projectVersion>1.0</sonar.projectVersion>
            </configuration>
        </plugin>
    </plugins>
</build>

• sonar.host.url：SonarQube 服务器的地址。
• sonar.login：用于认证的 SonarQube 令牌。
• sonar.projectKey、sonar.projectName 和 sonar.projectVersion：分别指定项目在 SonarQube 中的唯一标识符、项目名称和版本。

三方提供插件

三方插件整理

- spring-boot-maven-plugin

用于将 Spring Boot 应用打包为可执行 JAR 或 WAR 文件，并支持 Spring Boot 特有的功能，如运行 Spring Boot 应用、构建可执行 JAR 包等。

常用场景：

• 打包和部署 Spring Boot 应用，特别适用于 Spring Boot 项目中自动化构建和部署。

常见目标：

• repackage：将应用打包成一个可执行的 JAR 或 WAR 文件。
• run：直接运行 Spring Boot 应用。

配置示例：

<plugin>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-maven-plugin</artifactId>
  <version>3.1.0</version>
  <executions>
    <execution>
      <goals>
        <goal>repackage</goal> <!-- 打包为可执行JAR -->
      </goals>
    </execution>
  </executions>
</plugin>

• 该配置会自动将 Spring Boot 项目打包为一个可执行的 JAR 文件。使用 mvn spring-boot:run 可以启动 Spring Boot 应用程序。

- git-commit-id-plugin

提取 Git 仓库的提交信息（如 Git 提交 ID、分支信息等），并将其作为构建的属性嵌入到项目中。

常用场景：

• 将 Git 提交 ID 或分支信息嵌入到构建输出，方便跟踪构建版本。

常见目标：

• generate：生成 Git 提交信息并将其绑定到构建过程中。

配置示例：

<plugin>
  <groupId>pl.project13.maven</groupId>
  <artifactId>git-commit-id-plugin</artifactId>
  <version>4.0.0</version>
  <executions>
    <execution>
      <goals>
        <goal>generate</goal>
      </goals>
    </execution>
  </executions>
  <configuration>
    <timestampFormat>yyyy-MM-dd HH:mm:ss</timestampFormat>
  </configuration>
</plugin>

• 该插件会自动提取 Git 提交 ID，生成 git.commit.id 和 git.commit.time 等信息并将其嵌入到项目的构建中。通常用于记录构建版本号。

- properties-maven-plugin

在构建过程中替换文件中的占位符，并将 Maven 属性注入到项目文件中。

常用场景：

• 自动替换配置文件中的占位符，如版本号、Git 提交 ID 等信息。

常见目标：

• process：处理资源文件，替换文件中的属性。

配置示例：

<plugin>
  <groupId>org.codehaus.mojo</groupId>
  <artifactId>properties-maven-plugin</artifactId>
  <version>1.0.0</version>
  <executions>
    <execution>
      <goals>
        <goal>process</goal>
      </goals>
    </execution>
  </executions>
  <configuration>
    <files>
      <file>${project.basedir}/src/main/resources/config.properties</file>
    </files>
  </configuration>
</plugin>

• 配置了该插件后，它会在构建过程中将 config.properties 文件中的占位符（如 ${project.version}）替换为当前的 Maven 项目属性。通常用于将版本号、Git 提交 ID 等信息注入到配置文件中。

- liquibase-maven-plugin

用于数据库迁移和版本控制，支持在 Maven 构建过程中执行 Liquibase 的数据库变更脚本。

常用场景：

• 据库迁移管理，特别是在多环境（开发、测试、生产）中保持数据库一致性。

常见目标：

• update：执行数据库迁移脚本。
• rollback：回滚数据库到指定的变更点。

配置示例：

<plugin>
  <groupId>org.liquibase</groupId>
  <artifactId>liquibase-maven-plugin</artifactId>
  <version>4.0.0</version>
  <executions>
    <execution>
      <goals>
        <goal>update</goal> <!-- 执行数据库迁移 -->
      </goals>
    </execution>
  </executions>
  <configuration>
    <changeLogFile>src/main/resources/db/changelog/db.changelog-master.xml</changeLogFile>
    <url>jdbc:mysql://localhost:3306/mydb</url>
    <username>root</username>
    <password>password</password>
  </configuration>
</plugin>

• 这个配置会在构建过程中使用 Liquibase 执行数据库迁移，自动应用 db.changelog-master.xml 中定义的迁移脚本。

- docker-maven-plugin

用于在 Maven 构建过程中构建和推送 Docker 镜像，适用于微服务和容器化应用。

常用场景：

• 构建 Docker 镜像，自动化部署应用程序。

常见目标：

• build：构建 Docker 镜像。
• push：将镜像推送到 Docker 仓库。

配置示例：

<plugin>
  <groupId>com.spotify</groupId>
  <artifactId>docker-maven-plugin</artifactId>
  <version>1.0.0</version>
  <executions>
    <execution>
      <goals>
        <goal>build</goal> <!-- 构建 Docker 镜像 -->
      </goals>
    </execution>
  </executions>
  <configuration>
    <imageName>myapp:latest</imageName>
    <dockerFile>Dockerfile</dockerFile>
  </configuration>
</plugin>

• 该插件可以用来根据 Dockerfile 文件构建 Docker 镜像，并将镜像推送到 Docker 仓库。配置中指定了镜像名称和 Dockerfile 的路径。

- cobertura-maven-plugin

用于生成代码覆盖率报告，帮助分析测试覆盖的代码比例。

常用场景：

• 查看和分析代码的测试覆盖率。

常见目标：

• cobertura：生成覆盖率报告。

配置示例：

<plugin>
  <groupId>net.revelc</groupId>
  <artifactId>maven-cobertura-plugin</artifactId>
  <version>2.7</version>
  <executions>
    <execution>
      <goals>
        <goal>cobertura</goal>
      </goals>
    </execution>
  </executions>
</plugin>

• 配置该插件后，它会在构建过程中生成代码覆盖率报告，帮助开发者了解测试覆盖情况。

- exec-maven-plugin

允许在 Maven 构建过程中执行外部程序或脚本。

常用场景：

• 执行外部命令，如启动应用、执行脚本等。

常见目标：

• exec：执行外部命令。

配置示例：

<plugin>
  <groupId>org.codehaus.mojo</groupId>
  <artifactId>exec-maven-plugin</artifactId>
  <version>3.1.0</version>
  <executions>
    <execution>
      <goals>
        <goal>exec</goal>
      </goals>
      <configuration>
        <executable>echo</executable>
        <arguments>
          <argument>Hello, Maven!</argument>
        </arguments>
      </configuration>
    </execution>
  </executions>
</plugin>

• 该插件可以执行外部命令或脚本，例子中执行了 echo 命令打印“Hello, Maven!”。

- jdepend-maven-plugin

用于生成 Java 项目的依赖性分析报告，帮助开发者检查项目中的类之间的依赖关系，以提高代码的可维护性和可扩展性。

常用场景：

• 分析项目中的包和类之间的依赖关系，发现潜在的循环依赖问题、过度耦合等。

常见目标：

• check：分析并检查代码中的依赖性规则。
• jdepend：生成依赖性报告。

配置示例：

<plugin>
  <groupId>org.jdepend</groupId>
  <artifactId>jdepend-maven-plugin</artifactId>
  <version>2.0.0</version>
  <executions>
    <execution>
      <goals>
        <goal>jdepend</goal>
      </goals>
    </execution>
  </executions>
  <configuration>
    <outputDirectory>${project.build.directory}/jdepend</outputDirectory>
    <xmlOutput>true</xmlOutput>
    <jdependFile>target/jdepend-report.xml</jdependFile>
  </configuration>
</plugin>

• 该插件会分析项目的类和包之间的依赖关系，并生成 XML 格式的报告，帮助开发者发现潜在的设计问题（如过度依赖、循环依赖等）。

- findbugs-maven-plugin

用于在构建过程中运行 FindBugs 分析工具，检测 Java 代码中的潜在问题（如空指针、资源泄露、线程安全问题等）。

常用场景：

• 静态代码分析，检测代码中的潜在问题，特别是在持续集成过程中。

常见目标：

• findbugs：执行 FindBugs 检查。
• check：执行 FindBugs 检查并生成报告。

配置示例：

<plugin>
  <groupId>org.codehaus.mojo</groupId>
  <artifactId>findbugs-maven-plugin</artifactId>
  <version>3.0.5</version>
  <executions>
    <execution>
      <goals>
        <goal>findbugs</goal> <!-- 执行 FindBugs 分析 -->
      </goals>
    </execution>
  </executions>
  <configuration>
    <outputDirectory>${project.build.directory}/findbugs</outputDirectory>
    <xmlOutput>true</xmlOutput>
  </configuration>
</plugin>

• 该插件会在构建过程中执行 FindBugs 分析，生成 FindBugs 的 XML 格式报告。报告文件会存储在 target/findbugs 目录下。

- flyway-maven-plugin

用于管理和执行数据库迁移，帮助开发者管理数据库版本、执行数据库结构的变更。

常用场景：

• 数据库迁移和版本控制，特别是在团队协作和多环境部署中，保证数据库结构的一致性。

常见目标：

• migrate：执行数据库迁移。
• clean：清除数据库中所有的表（慎用！）。
• info：查看当前数据库迁移的状态。

配置示例：

<plugin>
  <groupId>org.flywaydb</groupId>
  <artifactId>flyway-maven-plugin</artifactId>
  <version>9.16.0</version>
  <executions>
    <execution>
      <goals>
        <goal>migrate</goal> <!-- 执行数据库迁移 -->
      </goals>
    </execution>
  </executions>
  <configuration>
    <url>jdbc:mysql://localhost:3306/mydb</url>
    <user>root</user>
    <password>password</password>
    <locations>
      <location>classpath:db/migration</location> <!-- 迁移脚本路径 -->
    </locations>
  </configuration>
</plugin>

• 该插件会根据 src/main/resources/db/migration 目录下的 SQL 文件执行数据库迁移。配置中指定了数据库的连接信息，包括 URL、用户名和密码。

springboot项目默认maven插件

springboot项目中的默认maven插件貌似只是在sprinng-boot-dependencies和spring-boot-starter-parent中声明了，但没看到哪里真正配置它们，但为什么springboot项目默认就有这几个插件？

事实上，这些默认插件的配置本身并不是在Spring Boot中进行的。相反，这些插件的配置只是在Maven的默认设置中。

Maven配置的默认插件：

在Maven中，这些插件是默认包含在一个名为super POM（或者super parent）中的，这个POM是所有Maven项目的一个父POM。每当创建一个新的Maven项目时，Maven都会自动继承这个super POM，从而使用其中的默认设置。这就是为什么即使在没有声明这些默认插件的情况下，Spring Boot项目中依然使用了这些默认插件。

Spring Boot只是利用了Maven的默认设置，提供了一个定义了所有默认依赖和插件版本的BOM（Bill of Materials），使得子工程在继承spring-boot-starter-parent或引入sprinng-boot-dependencies这个BOM后可以自动继承这些默认依赖和插件的版本号和配置。

总之，这些默认插件之所以会被自动使用，是因为它们已经是Maven中默认的插件之一，而Spring Boot只是利用了这个特性，并提供了一个定义了默认依赖和插件的BOM让开发者可以更方便地使用这些默认插件。