Maven常用插件

标签：maven 插件 plugin 常用 Maven plugins apache org resources

Maven常用插件

主要介绍maven工程常用插件。

1、官网查找插件

官网：https://maven.apache.org/plugins/index.html

2、maven-compiler-plugin

https://maven.apache.org/plugins/maven-compiler-plugin/

作用：该插件用于编译项目的源代码。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.10.1</version>
    <configuration>
        <source>1.8</source>
        <source>1.8</source>
        <encoding>UTF-8</encoding>  
    </configuration>
</plugin>

<!-- 或者 -->
<properties>
     <!-- 编译代码的时候，涉及到资源文件和测试资源文件的拷贝，拷贝文件的时候涉及到文件的编码，这个是设置文件的编码为UTF-8格式的-->
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <!-- 配置maven编译的时候采用的编译器版本 -->
     <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
     <!-- 指定源代码是什么版本的，如果源码和这个版本不符将报错，maven中执行编译的时候会用到这个配置，默认是1.5，这个相当于javac命令后面的-source参数 -->
     <maven.compiler.source>1.8</maven.compiler.source>
     <!-- 该命令用于指定生成的class文件将保证和哪个版本的虚拟机进行兼容，maven中执行编译的时候会用到这个配置，默认是1.5，这个相当于javac命令后面的-target参数 -->
      <maven.compiler.target>1.8</maven.compiler.target>
</properties>

<plugin>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.1</version>
    <configuration>
        <compilerVersion>1.8</compilerVersion>
        <source>1.8</source>
        <target>1.8</target>
    </configuration>
</plugin>

3、maven-shade-plugin

https://maven.apache.org/plugins/maven-shade-plugin/

作用：将自己项目的代码资源以及依赖第三方的资源一起打成一个 jar 包。

需要在 pom 文件的 plugin 元素中引入才可以使用，它可以让用户配置 Main-Class 的值，然后在打包的时候将值

填入 /META-INF/MANIFEST.MF 文件。关于项目的依赖，它很聪明地将依赖的 JAR 文件全部解压后，再将得到

的 .class 文件连同当前项目的 .class 文件一起合并到最终的 CLI 包(可以直接运行的 jar 包)中，这样，在执行 CLI

JAR 文件的时候，所有需要的类就都在 Classpath 中了。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <version>3.2.4</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>shade</goal>
            </goals>
            <configuration>
                <transformers>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                        <mainClass>org.apache.HelloWorld</mainClass>
                    </transformer>
                </transformers>
            </configuration>
        </execution>
    </executions>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <version>3.5.2</version>
    <executions>
        <execution>
            <goals>
                <goal>shade</goal>
            </goals>
            <configuration>
                <transformers>
                    <transformer
                            implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                        <manifestEntries>
                            <Main-Class>${app.main.class}</Main-Class>
                            <X-Compile-Source-JDK>${maven.compile.source}</X-Compile-Source-JDK>
                            <X-Compile-Target-JDK>${maven.compile.target}</X-Compile-Target-JDK>
                        </manifestEntries>
                    </transformer>
                </transformers>
            </configuration>
        </execution>
    </executions>
</plugin>

4、maven-antrun-plugin

https://maven.apache.org/plugins/maven-antrun-plugin/

在maven中运行Ant任务，比如在打包阶段，对文件进行复制。

该插件能让用户在Maven项目中运行Ant任务，用户可以直接在该插件的配置以Ant的方式编写Target，然后交给

该插件的run目标去执行。在一些由Ant往Maven迁移的项目中，该插件尤其有用。

此外当你发现需要编写一些自定义程度很高的任务，同时又觉得Maven不够灵活时，也可以以Ant的方式实现之。

maven-antrun-plugin的run目标通常与生命周期绑定运行。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-antrun-plugin</artifactId>
    <version>3.0.0</version>
    <executions>
        <execution>
            <!--自定义 id -->
            <id>custom clean</id>
            <!--插件目标绑定的构建阶段 -->
            <phase>clean</phase>
            <!--插件目标 -->
            <goals>
                <goal>run</goal>
            </goals>
            <!--配置 -->
            <configuration>
                <!-- 执行的任务 -->
                <target>
                    <!--自定义文本信息 -->
                    <echo message="清理阶段"/>
                </target>
            </configuration>
        </execution>
    </executions>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-antrun-plugin</artifactId>
    <version>3.0.0</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>run</goal>
            </goals>
            <configuration>
                <target name="copy">
                    <delete>
                        <fileset dir="target" includes="*.properties"></fileset>
                    </delete>
                    <copy todir="target">
                        <!-- 将files目录下的文件都拷贝到target目录下 -->
                        <fileset dir="files"></fileset>
                    </copy>
                </target>
            </configuration>
        </execution>
    </executions>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-antrun-plugin</artifactId>
    <version>3.0.0</version>
    <executions>
        <execution>
            <id>ant-validate</id>
            <phase>validate</phase>
            <goals>
                <goal>run</goal>
            </goals>
            <configuration>
                <target>
                    <echo>I'm bound to validate phase.</echo>
                </target>
            </configuration>
        </execution>
        <execution>
            <id>ant-verify</id>
            <phase>verify</phase>
            <goals>
                <goal>run</goal>
            </goals>
            <configuration>
                <target>
                    <echo>I'm bound to verify phase.</echo>
                </target>
            </configuration>
        </execution>
    </executions>
</plugin>

5、maven-resources-plugin

https://maven.apache.org/plugins/maven-resources-plugin/

为了使项目结构更为清晰，Maven区别对待Java代码文件和资源文件，maven-compiler-plugin用来编译Java代

码，maven-resources-plugin则用来处理资源文件。

默认的主资源文件目录是src/main/resources，很多用户会需要添加额外的资源文件目录，这个时候就可以通过配

置maven-resources-plugin来实现。

此外，资源文件过滤也是Maven的一大特性，你可以在资源文件中使用${propertyName}形式的Maven属性，然

后配置maven-resources-plugin开启对资源文件的过滤，之后就可以针对不同环境通过命令行或者Profile传入属

性的值，以实现更为灵活的构建。

maven-resources-plugin的三个目标(goal):

• resources:resources：用来将目录中的资源文件src/main/resources拷贝到编译目录

  ${project.build.outputDirectory}。这个目标默认绑定到了Maven的process-resources阶段，所以process-

  resources阶段被执行，这个目标就会自动触发。

• resources:testResources：用来将目录中的资源文件src/test/resources拷贝到编译目录

  ${project.build.testOutputDirectory}。这个目标默认绑定到了Maven的process-test-resources阶段，所以

  process-test-resources阶段被执行，这个目标就会自动触发。

• resources:copy-resources：用来将指定目录中的资源文件拷贝到指定目录，注意需要自己设置资源文件

  目录和目标目录。

<resources>
    <resource>
        <directory>src/main/resources</directory>
        <filtering>true</filtering>
        <includes>
            <include>*.properties</include>
        </includes>
    </resource>
    <resource>
        <directory>src/main/resources</directory>
        <filtering>false</filtering>
        <excludes>
            <exclude>*.xml</exclude>
        </excludes>
    </resource>
    <resource>
        <directory>${basedir}/${environment.dir}</directory>
        <includes>
            <include>${environment}.properties</include>
        </includes>
    </resource>
</resources>
<testResources>
    <testResource>
        <directory>src/test/resources</directory>
        <filtering>true</filtering>
        <includes>
            <include>*.properties</include>
        </includes>
    </testResource>
</testResources>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-resources-plugin</artifactId>
    <version>3.1.0</version>
    <configuration>
        <encoding>UTF-8</encoding>
    </configuration>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-source-plugin</artifactId>
    <version>3.2.1</version>
    <executions>
        <!-- 使用插件需要执行的任务 -->
        <execution>
            <!-- 任务id -->
            <id>attach-source</id>
            <!-- 绑定的阶段 -->
            <phase>verify</phase>
            <!-- 任务中插件的目标，可以指定多个 -->
            <goals>
                <!-- jar-no-fork主要用来创建项目的源码jar包 -->
                <goal>jar-no-fork</goal>
            </goals>
        </execution>
    </executions>
</plugin>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-resources-plugin</artifactId>
            <version>3.1.0</version>
            <executions>
                <execution>
                    <id>copy-resources</id>
                    <!-- here the phase you need -->
                    <phase>validate</phase>
                    <goals>
                        <goal>copy-resources</goal>
                    </goals>
                    <configuration>
                        <outputDirectory>${basedir}/target/extra-resources</outputDirectory>
                        <resources>
                            <resource>
                                <directory>src/main/resources</directory>
                                <filtering>true</filtering>
                            </resource>
                        </resources>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-resources-plugin</artifactId>
    <version>2.1</version>
    <executions>
        <execution>
            <phase>compile</phase>
        </execution>
    </executions>
    <configuration>
        <encoding>UTF-8</encoding>
    </configuration>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-resources-plugin</artifactId>
    <version>2.6</version>
    <configuration>
        <!-- 是否使用默认的分隔符，默认分隔符是${*}和@ ,这个地方设置为false，表示不启用默认分隔符配置-->
        <useDefaultDelimiters>false</useDefaultDelimiters>
        <!-- 自定义分隔符 -->
        <delimiters>
            <delimiter>$*$</delimiter>
            <delimiter>#*#</delimiter>
        </delimiters>
    </configuration>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-resources-plugin</artifactId>
    <version>2.5</version>
    <executions>
        <execution>
            <id>copy-resources</id>
            <phase>package</phase>
            <goals>
                <goal>copy-resources</goal>
            </goals>
            <configuration>
                <encoding>${project.build.sourceEncoding}</encoding>
                <outputDirectory>${project.build.directory}</outputDirectory>
                <resources>
                    <resource>
                        <directory>src/main/resources/</directory>
                        <includes>
                            <include>*.properties</include>
                            <include>*.xml</include>
                        </includes>
                        <filtering>true</filtering>
                    </resource>
                </resources>
            </configuration>
        </execution>
    </executions>
</plugin>

6、maven-clean-plugin

https://maven.apache.org/plugins/maven-clean-plugin/

这个插件的主要作用就是清理构建目录下得全部内容，构建目录默认是target，但是有时候我们会配置：

• project.build.directory,

• project.build.outputDirectory

• project.build.testOutputDirectory

• project.reporting.outputDirectory

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-clean-plugin</artifactId>
    <version>3.0.0</version>
    <configuration>
        <skip>true</skip>
    </configuration>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-clean-plugin</artifactId>
    <version>2.5</version>
    <executions>
        <!-- 使用插件需要执行的任务 -->
        <execution>
            <!-- 任务中插件的目标，可以指定多个 -->
            <id>clean-target</id>
            <goals>
                <goal>clean</goal>
            </goals>
            <!-- 绑定的阶段 -->
            <phase>validate</phase>
        </execution>
    </executions>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-clean-plugin</artifactId>
    <version>3.0.0</version>
    <configuration>
        <!--<skip>true</skip>-->
        <!--<failOnError>false</failOnError>-->
        <!--当配置true时,只清理filesets里的文件,构建目录中得文件不被清理.默认是flase.-->
        <excludeDefaultDirectories>false</excludeDefaultDirectories>
        <filesets>
            <fileset>
                <!--要清理的目录位置-->
                <directory>${basedir}/logs</directory>
                <!--是否跟随符号链接 (symbolic links)-->
                <followSymlinks>false</followSymlinks>
                <!--默认有些文件是不会被清理的,比如.svn文件,如果设置成false,则全部按照自定义的来处理-->
                <useDefaultExcludes>true</useDefaultExcludes>
                <!--对这些文件进行清理-->
                <includes>
                    <include>**/*</include>
                </includes>
                <!--对这些文件不清理-->
                <excludes>
                    <exclude>nc*</exclude>
                </excludes>
            </fileset>
        </filesets>
    </configuration>
</plugin>

7、maven-surefire-plugin

http://maven.apache.org/plugins/maven-surefire-plugin/

可能是由于历史的原因，Maven 2/3中用于执行测试的插件不是maven-test-plugin，而是maven-surefire-

plugin。

其实大部分时间内，只要你的测试类遵循通用的命令约定(以Test结尾、以TestCase结尾、或者以Test开头)，就几

乎不用知晓该插件的存在。

然而在当你想要跳过测试、排除某些测试类、或者使用一些TestNG特性的时候，了解maven-surefire-plugin的一

些配置选项就很有用了。

例如 mvn test -Dtest=FooTest 这样一条命令的效果是仅运行FooTest测试类，这是通过控制maven-surefire-

plugin的test参数实现的。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.22.2</version>
    <configuration>
        <skipTests>true</skipTests>
    </configuration>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.22.2</version>
    <configuration>
        <includes>
            <include>**/*Tests.java</include>
        </includes>
    </configuration>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.22.2</version>
    <configuration>
        <excludes>
            <exclude>**/*WorldTest.java</exclude>
        </excludes>
    </configuration>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.22.2</version>
    <configuration>
        <suiteXmlFiles>testng.xml</suiteXmlFiles>
    </configuration>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.22.2</version>
    <configuration>
        <groups>util</groups>
    </configuration>
</plugin>

<plugin>
    <!-- 通过配置 maven-jar-plugin 将测试类打包 -->
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>3.2.2</version>
    <executions>
        <execution>
            <goals>
                <goal>test-jar</goal>
            </goals>
        </execution>
    </executions>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>3.2.2</version>
    <configuration>
        <!-- 测试报告目录 -->
        <reportsDirectory>${project.build.directory}/test-reports</reportsDirectory>
    </configuration>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.9</version>
    <configuration>
        <skip>true</skip>
        <testFailureIgnore>true</testFailureIgnore>
    </configuration>
</plugin>

8、maven-war-plugin

war 项目默认的打包工具，默认情况下会打包项目编译生成的 .class 文件、资源文件以及项目依赖的所有 jar 包。

<!-- war插件(将项目打成war包) -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.1</version>
    <configuration>
        <!-- war包名字 -->
        <warName>WebMavenDemo1</warName>
    </configuration>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>3.3.1</version>
    <configuration>
        <webResources>
            <resource>
                <filtering>true</filtering>
                <directory>src/main/webapp</directory>
                <includes>
                    <include>**/*.css</include>
                    <include>**/*.js</include>
                </includes>
            </resource>
        </webResources>
    </configuration>
</plugin>

9、maven-jar-plugin

https://maven.apache.org/plugins/maven-jar-plugin/

jar 项目默认的打包工具，默认情况下只会将项目源码编译生成的class文件和资源文件打包进来，不会打包进项目

依赖的jar包。打成jar时，设定manifest的参数，比如指定运行的Main class，还有依赖的jar包，加入classpath

中。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>2.6</version>
    <configuration>
        <archive>
            <manifest>
                <addClasspath>true</addClasspath>
                <classpathPrefix>lib/</classpathPrefix>
                <mainClass>org.apache.HelloWorld</mainClass>
            </manifest>
        </archive>
    </configuration>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>2.4</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>jar</goal>
            </goals>
            <configuration>
                <classifier>without-configs</classifier>
                <excludes>
                    <exclude>*.properties</exclude>
                    <exclude>*.xml</exclude>
                </excludes>
            </configuration>
        </execution>
    </executions>
</plugin>

10、maven-dependency-plugin

https://maven.apache.org/plugins/maven-dependency-plugin/

用于复制依赖的jar包到指定的文件夹里。

最大的用途是帮助分析项目依赖。

• dependency:list 能够列出项目最终解析到的依赖列表。

• dependency:tree：能进一步的描绘项目依赖树。

• dependency:analyze：可以告诉你项目依赖潜在的问题。

如果你有直接使用到的却未声明的依赖，该目标就会发出警告。

maven-dependency-plugin 还有很多目标帮助你操作依赖文件，例如dependency:copy-dependencies能将项目

依赖从本地Maven仓库复制到某个特定的文件夹下面。

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

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>2.8</version>
    <executions>
        <execution>
            <id>copy-dependencies</id>
            <phase>package</phase>
            <goals>
                <goal>copy-dependencies</goal>
            </goals>
            <configuration>
                <outputDirectory>${project.build.directory}/lib</outputDirectory>
                <overWriteReleases>false</overWriteReleases>
                <overWriteSnapshots>false</overWriteSnapshots>
                <overWriteIfNewer>true</overWriteIfNewer>
            </configuration>
        </execution>
    </executions>
</plugin>

11、maven-assembly-plugin

https://maven.apache.org/plugins/maven-assembly-plugin/

该插件的用途是制作项目分发包，该分发包可能包含了项目的可执行文件、源代码、readme、平台脚本等等。

maven-assembly-plugin支持各种主流的格式如zip、tar.gz、jar和war等，具体打包哪些文件是高度可控的。

例如用户可以按文件级别的粒度、文件集级别的粒度、模块级别的粒度、以及依赖级别的粒度控制打包，此外，包

含和排除配置也是支持的。

maven-assembly-plugin要求用户使用一个名为assembly.xml的元数据文件来表述打包，它的single目标可以直

接在命令行调用，也可以被绑定至生命周期。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.4</version>
    <configuration>
        <archive>
            <manifest>
                <mainClass>org.apache.HelloWorld</mainClass>
            </manifest>
        </archive>
        <descriptorRefs>
            <!--指定描述符 -->
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
    </configuration>
    <executions>
        <execution>
            <!--该execution的标记，可以自己取任意名称 -->
            <id>make-assembly</id>
            <!--绑定到package生命周期阶段上，如果省略，目标将绑定到其元数据中指定的默认值 -->
            <phase>package</phase>
            <goals>
                <!-- maven-assembly-plugin插件只有一个goal就是single -->
                <!-- 该打包任务只运行一次 -->
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>

maven的Assembly Plugin依赖于提供的程序集描述符来指示其执行。虽然已经有现成的可供使用的描述符，但是

它们只能满足一些常见的程序集要求。所以为了让你自定义程序集插件创建程序集，你需要知道如何使用程序集描

述符。

Maven的Assembly Plugin使开发人员能够将项目输出组合到一个可分发的归档文件中，该归档文件还包含依赖

项、模块、站点文档和其他文件。

示例：此描述符指定要创建的程序集存档的类型、程序集的内容以及依赖项或其模块与程序集绑定的方式。

<!-- 程序集定义从项目生成的文件集合，通常以zip、tar或tar.gz等归档格式分发。例如，项目可以生成一个ZIP程序集，其中根目录中包含项目的JAR工件，lib/目录中包含运行时依赖项，以及启动独立应用程序的shell脚本。 -->
<assembly xmlns="http://maven.apache.org/ASSEMBLY/2.1.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.1.1 https://maven.apache.org/xsd/assembly-2.1.1.xsd">
  <!-- 设置程序集的id，项目的特定文件程序集的符号名称。此外，除了通过将其值附加到生成的归档文件来明确地命名组装的包之外，该id在部署时还用作工件的分类器。 -->  
  <id/>
  <!-- 指定程序集的格式。通过goal参数指定格式通常比在这里指定格式更好。可以提供多种格式，Assembly Plugin将为每一种所需格式生成一个存档。格式通过添加<format>子元素指定值来完成。例如zip创建一个zip文件格式，tar创建一个tar格式，tar.gz创建一个gzip的tar格式，jar创建一个jar格式，dir创建一个分离的目录格式，war创建一个war格式等。 -->  
  <formats>
      <format>tar.gz</format>
      <format>dir</format>
  </formats>
  <!-- 在最终存档中包含一个基本目录。默认值是true。如果你正在创建一个名为“your-app”的程序集，将includeBaseDirectory设置为true将创建一个包含这个基本目录的归档文件。如果此选项设置为false，则创建的归档文件将解压缩其内容到当前目录。 -->  
  <includeBaseDirectory>false</includeBaseDirectory>
  <!-- 设置生成程序集存档的基本目录。如果没有设置并且includeBaseDirectory为true，${project.build.finalName}会被替代。 -->
  <baseDirectory/>
  <!-- 在最终存档中包含一个站点目录。项目的站点目录位置由程序集插件的siteDirectory参数确定。 -->
  <includeSiteDirectory/>
  <!-- 从常规归档流中过滤各种容器描述符的组件集，这样它们就可以聚合然后添加。 -->  
  <containerDescriptorHandlers>   
    <!-- 为进入程序集存档的文件配置一个过滤器，以允许聚合各种类型的描述符片段，例如components.xml、web.xml等。 -->  
    <containerDescriptorHandler>
      <!-- 处理程序的丛角色提示，用于从容器中查找。 -->  
      <handlerName/>
      <!-- 处理器的配置选项。 -->    
      <configuration/>
    </containerDescriptorHandler>
  </containerDescriptorHandlers>
  <!-- 指定包含在程序集中的模块文件。 -->    
  <moduleSets>
    <!-- 代表项目的pom.xml中的<module>元素。当从命令行使用<moduleSets>时，需要先通过执行:"mvn package assembly:assembly"来传递包阶段。这个错误/问题计划由Maven 2.1解决。 -->  
    <moduleSet>
      <!-- 如果设置为true，插件将包括当前反应堆中的所有项目，以便在此ModuleSet中处理。这些将受包含/排除规则的约束。默认值是false。 -->  
      <useAllReactorProjects/>
      <!-- 如果设置为false，插件将排除这个模块集中的子模块。否则，它将处理所有子模块，每个主题包含/排除规则。 -->    
      <includeSubModules/>
      <!-- 当<include>子元素出现时，它们定义了一组要包含的项目坐标。如果没有，则<includes>表示所有有效值。工件坐标可以以简单的groupId:artifactId形式给出，也可以以groupId:artifactId:type[:classifier]:version形式完全限定。此外还可以使用通配符。 -->    
      <includes/>
      <!-- 类似includes。 -->    
      <excludes/>
      <!-- 包含用于在程序集中包含项目模块的源文件的配置选项。 -->  
      <sources>
        <!-- 在计算受此集影响的文件时,是否应该使用标准排除模式,如匹配CVS和Subversion元数据文件。对于向后兼容性,默认值是正确的。 -->  
        <useDefaultExcludes/>
        <!-- 将输出目录设置为组件根目录的根。例如,“日志”将指定文件放在日志目录中。 --> 
        <outputDirectory/>  
        <includes/>
        <excludes/>
        <!-- 类似unix权限，设置包含的文件模式，是一个8进制值。(User)(Group)(other) -->    
        <fileMode/>
        <directoryMode/>
        <fileSets>
          <fileSet>
            <useDefaultExcludes/>
            <outputDirectory/>
            <includes/>
            <excludes/>
            <fileMode/>
            <directoryMode/>
            <directory/>
            <lineEnding/>
            <filtered/>
            <nonFilteredFileExtensions/>
          </fileSet>
        </fileSets>
        <includeModuleDirectory/>
        <excludeSubModuleDirectories/>
        <outputDirectoryMapping/>
      </sources>
      <binaries>
        <outputDirectory/>
        <includes/>
        <excludes/>
        <fileMode/>
        <directoryMode/>
        <attachmentClassifier/>
        <includeDependencies/>
        <dependencySets>
          <dependencySet>
            <outputDirectory/>
            <includes/>
            <excludes/>
            <fileMode/>
            <directoryMode/>
            <useStrictFiltering/>
            <outputFileNameMapping/>
            <unpack/>
            <unpackOptions>
              <includes/>
              <excludes/>
              <filtered/>
              <nonFilteredFileExtensions/>
              <lineEnding/>
              <useDefaultExcludes/>
              <encoding/>
            </unpackOptions>
            <scope/>
            <useProjectArtifact/>
            <useProjectAttachments/>
            <useTransitiveDependencies/>
            <useTransitiveFiltering/>
          </dependencySet>
        </dependencySets>
        <unpack/>
        <unpackOptions>
          <includes/>
          <excludes/>
          <filtered/>
          <nonFilteredFileExtensions/>
          <lineEnding/>
          <useDefaultExcludes/>
          <encoding/>
        </unpackOptions>
        <outputFileNameMapping/>
      </binaries>
    </moduleSet>
  </moduleSets>
  <!-- 指定包含在程序集中的文件组。 -->  
  <fileSets>
    <!-- fileSet允许将文件组包含到程序集中。 -->  
    <fileSet>
      <useDefaultExcludes/>
      <!-- 设置输出目录相对于程序集根目录的根目录。 -->  
      <outputDirectory/>
      <includes/>
      <excludes/>
      <fileMode/>
      <directoryMode/>
      <!-- 设置模块目录中的绝对或相对位置。 -->  
      <directory/>
      <lineEnding/>
      <filtered/>
      <nonFilteredFileExtensions/>
    </fileSet>
  </fileSets>
  <!-- 指定包含在程序集中的单个文件。 -->    
  <files>
    <file>
      <source/>
      <sources/>
      <outputDirectory/>
      <destName/>
      <fileMode/>
      <lineEnding/>
      <filtered/>
    </file>
  </files>
  <!-- 指定在程序集中包含的依赖。 -->    
  <dependencySets>
    <dependencySet>
      <outputDirectory/>
      <includes/>
      <excludes/>
      <fileMode/>
      <directoryMode/>
      <useStrictFiltering/>
      <outputFileNameMapping/>
      <unpack/>
      <unpackOptions>
        <includes/>
        <excludes/>
        <filtered/>
        <nonFilteredFileExtensions/>
        <lineEnding/>
        <useDefaultExcludes/>
        <encoding/>
      </unpackOptions>
      <scope/>
      <useProjectArtifact/>
      <useProjectAttachments/>
      <useTransitiveDependencies/>
      <useTransitiveFiltering/>
    </dependencySet>
  </dependencySets>
  <!-- 自2.1.1版本后废弃了，指定在程序集中包含的存储库文件。 -->    
  <repositories>
    <repository>
      <outputDirectory/>
      <includes/>
      <excludes/>
      <fileMode/>
      <directoryMode/>
      <includeMetadata/>
      <groupVersionAlignments>
        <groupVersionAlignment>
          <id/>
          <version/>
          <excludes/>
        </groupVersionAlignment>
      </groupVersionAlignments>
      <scope/>
    </repository>
  </repositories>
  <!-- 指定要包含在程序集中的共享组件xml文件位置。 -->    
  <componentDescriptors/>
</assembly>

有四种预定义的描述符格式可供重用，打包在Assembly Plugin中。它们的描述id是：

• bin：引入maven-assembly-plugin时，在中配置为bin以创建项目的二进制发行存档。

<assembly xmlns="http://maven.apache.org/ASSEMBLY/2.1.1"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.1.1 https://maven.apache.org/xsd/assembly-2.1.1.xsd">
  <id>bin</id>
  <formats>
    <format>tar.gz</format>
    <format>tar.bz2</format>
    <format>zip</format>
  </formats>
  <fileSets>
    <fileSet>
      <directory>${project.basedir}</directory>
      <outputDirectory></outputDirectory>
      <includes>
        <include>README*</include>
        <include>LICENSE*</include>
        <include>NOTICE*</include>
      </includes>
    </fileSet>
    <fileSet>
      <directory>${project.build.directory}</directory>
      <outputDirectory></outputDirectory>
      <includes>
        <include>*.jar</include>
      </includes>
    </fileSet>
    <fileSet>
      <directory>${project.build.directory}/site</directory>
      <outputDirectory>docs</outputDirectory>
    </fileSet>
  </fileSets>
</assembly>

• jar-with-dependencies

<assembly xmlns="http://maven.apache.org/ASSEMBLY/2.1.1"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.1.1 https://maven.apache.org/xsd/assembly-2.1.1.xsd">
  <!-- TODO: a jarjar format would be better -->
  <id>jar-with-dependencies</id>
  <formats>
    <format>jar</format>
  </formats>
  <includeBaseDirectory>false</includeBaseDirectory>
  <dependencySets>
    <dependencySet>
      <outputDirectory>/</outputDirectory>
      <useProjectArtifact>true</useProjectArtifact>
      <unpack>true</unpack>
      <scope>runtime</scope>
    </dependencySet>
  </dependencySets>
</assembly>

• src

<assembly xmlns="http://maven.apache.org/ASSEMBLY/2.1.1"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.1.1 https://maven.apache.org/xsd/assembly-2.1.1.xsd">
  <id>src</id>
  <formats>
    <format>tar.gz</format>
    <format>tar.bz2</format>
    <format>zip</format>
  </formats>
  <fileSets>
    <fileSet>
      <directory>${project.basedir}</directory>
      <includes>
        <include>README*</include>
        <include>LICENSE*</include>
        <include>NOTICE*</include>
        <include>pom.xml</include>
      </includes>
      <useDefaultExcludes>true</useDefaultExcludes>
    </fileSet>
    <fileSet>
      <directory>${project.basedir}/src</directory>
      <useDefaultExcludes>true</useDefaultExcludes>
    </fileSet>
  </fileSets>
</assembly>

• project

<assembly xmlns="http://maven.apache.org/ASSEMBLY/2.1.1"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.1.1 https://maven.apache.org/xsd/assembly-2.1.1.xsd">
  <id>project</id>
  <formats>
    <format>tar.gz</format>
    <format>tar.bz2</format>
    <format>zip</format>
  </formats>
  <fileSets>
    <fileSet>
      <directory>${project.basedir}</directory>
      <outputDirectory></outputDirectory>
      <useDefaultExcludes>true</useDefaultExcludes>
      <excludes>
        <exclude>**/*.log</exclude>
        <exclude>**/${project.build.directory}/**</exclude>
      </excludes>
    </fileSet>
  </fileSets>
</assembly>

在pom.xml中指定自定义的配置：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.4</version>
    <configuration>
        <finalName>data</finalName>
        <descriptors>
            <!-- 自定义配置 -->
            <descriptor>package.xml</descriptor>
        </descriptors>
    </configuration>
    <executions>
        <execution>
            <id>make-assembly</id>
            <phase>package</phase>
        </execution>
    </executions>
</plugin>

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-assembly-plugin</artifactId>
	<version>2.4</version>
	<configuration>
		<appendAssemblyId>false</appendAssemblyId>
		<descriptors>
			<descriptor>${basedir}/assembly.xml</descriptor> <!-- Assembly 描述符文件 -->
			<!-- <descriptor>src/main/assembly/assembly.xml</descriptor> -->
		</descriptors>
	</configuration>
	<executions>
		<execution>
			<id>make-assembly</id>
			<phase>package</phase>
			<goals>
				<goal>single</goal>
			</goals>
		</execution>
	</executions>
</plugin>

12、maven-archetype-plugin

https://maven.apache.org/archetype/maven-archetype-plugin/

Archtype指项目的骨架，Maven初学者最开始执行的Maven命令可能就是mvn archetype:generate，这实际上就

是让maven-archetype-plugin生成一个很简单的项目骨架，帮助开发者快速上手。

可能也有人看到一些文档写了mvn archetype:create，但实际上create目标已经被弃用了，取而代之的是

generate目标，该目标使用交互式的方式提示用户输入必要的信息以创建项目，体验更好。

maven-archetype-plugin还有一些其他目标帮助用户自己定义项目原型，例如你由一个产品需要交付给很多客户

进行二次开发，你就可以为他们提供一个Archtype，帮助他们快速上手。

$ mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=myapp -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

13、appassembler-maven-plugin

作用：实现自动打包成可运行的脚本，还可以跨平台(Windows/linux)。

<build>
    <plugins>
        <!-- 支持java1.8 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>
        <!-- -使用UTF-8编码处理资源文件 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-resources-plugin</artifactId>
            <configuration>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>appassembler-maven-plugin</artifactId>
            <version>2.0.0</version>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <goals>
                        <goal>assemble</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <repositoryLayout>flat</repositoryLayout>
                <configurationDirectory>conf</configurationDirectory>
                <configurationSourceDirectory>src/main/resources</configurationSourceDirectory>
                <copyConfigurationDirectory>true</copyConfigurationDirectory>
                <includeConfigurationDirectoryInClasspath>true</includeConfigurationDirectoryInClasspath>
                <assembleDirectory>${project.build.directory}/${project.name}</assembleDirectory>
                <extraJvmArguments>-Xms256m -Xmx1024m -Xss1024k -XX:PermSize=128M
                    -XX:MaxNewSize=256m -XX:MaxPermSize=128m
                </extraJvmArguments>
                <binFileExtensions>
                    <unix>.sh</unix>
                </binFileExtensions>
                <platforms>
                    <platform>windows</platform>
                    <platform>unix</platform>
                </platforms>
                <repositoryName>lib</repositoryName>
                <programs>
                    <program>
                        <mainClass>org.apache.HelloWorld</mainClass>
                        <name>startup</name>
                    </program>
                </programs>
            </configuration>
        </plugin>
    </plugins>
</build>

14、maven-help-plugin

https://maven.apache.org/plugins/maven-help-plugin/

maven-help-plugin是一个小巧的辅助工具。

最简单的help:system可以打印所有可用的环境变量和Java系统属性。

help:effective-pom和help:effective-settings最为有用，它们分别打印项目的有效POM和有效settings，有效

POM是指合并了所有父POM(包括Super POM)后的XML，当你不确定POM的某些信息从何而来时，就可以查

看有效POM。

有效settings同理，特别是当你发现自己配置的settings.xml没有生效时，就可以用help:effective-settings来验

证。

此外，maven-help-plugin的describe目标可以帮助你描述任何一个Maven插件的信息，还有all-profiles目标和

active-profiles目标帮助查看项目的Profile。

15、spring-boot-maven-plugin

针对springboot和maven集成的项目，打成jar包，则需要使用springboot和maven集成好的打包插件：spring-

boot-maven-plugin，例如特别是含有@SpringBootApplication注解的入口启动程序。

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <version>1.3.5.RELEASE</version>
    <configuration>
        <mainClass>org.apache.HelloWorld</mainClass>
    </configuration>
    <executions>
        <execution>
            <goals>
                <goal>repackage</goal>
            </goals>
        </execution>
    </executions>
</plugin>

16、wagon-maven-plugin

用于一键部署，把本地打包的jar文件，上传到远程服务器上，并执行服务器上的shell命令。

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>wagon-maven-plugin</artifactId>
    <version>1.0</version>
    <configuration>
        <serverId>crawler</serverId>
        <fromDir>target</fromDir>
        <includes>*.jar,*.properties,*.sh</includes>
        <url>sftp://服务器ip地址/home/dream</url>
        <commands>
            <command>chmod 755 /home/dream/update.sh</command>
            <command>/home/dream/update.sh</command>
        </commands>
        <displayCommandOutputs>true</displayCommandOutputs>
    </configuration>
</plugin>

<build>
    <extensions>
        <extension>
            <groupId>org.apache.maven.wagon</groupId>
            <artifactId>wagon-ssh</artifactId>
            <version>2.8</version>
        </extension>
    </extensions>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>wagon-maven-plugin</artifactId>
            <version>1.0</version>
            <executions>
                <execution>
                    <id>upload-deploy</id>
                    <!-- 运行package打包的同时运行upload-single和sshexec -->
                    <phase>package</phase>
                    <goals>
                        <goal>upload-single</goal>
                        <goal>sshexec</goal>
                    </goals>
                    <configuration>
                        <serverId>linux-server-dev</serverId>
                        <fromFile>target/project_name.war</fromFile>
                        <url>scp://192.168.20.128/home/tomcat/apache-tomcat-7.0.55/webapps</url>
                        <commands>
                            <command>sh /home/tomcat/apache-tomcat-7.0.55/bin/shutdown.sh</command>
                            <command>rm -rf /home/tomcat/apache-tomcat-7.0.55/webapps/javawebdeploy</command>
                            <command>sh /home/tomcat/apache-tomcat-7.0.55/bin/startup.sh</command>
                        </commands>
                        <displayCommandOutputs>true</displayCommandOutputs>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

17、maven-enforcer-plugin

https://maven.apache.org/enforcer/maven-enforcer-plugin/

在一个稍大一点的组织或团队中，你无法保证所有成员都熟悉Maven，那他们做一些比较愚蠢的事情就会变得很

正常。

例如给项目引入了外部的SNAPSHOT依赖而导致构建不稳定，使用了一个与大家不一致的Maven版本而经常抱怨

构建出现诡异问题。

maven-enforcer-plugin能够帮助你避免之类问题，它允许你创建一系列规则强制大家遵守，包括设定Java版本、

设定Maven版本、禁止某些依赖、禁止SNAPSHOT依赖。

只要在一个父POM配置规则，然后让大家继承，当规则遭到破坏的时候，Maven就会报错。

除了标准的规则之外，你还可以扩展该插件，编写自己的规则。maven-enforcer-plugin的enforce目标负责检查

规则，它默认绑定到生命周期的validate阶段。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-enforcer-plugin</artifactId>
    <version>1.4.1</version>
    <executions>
        <execution>
            <id>enforce</id>
            <configuration>
                <rules>
                    <dependencyConvergence/>
                </rules>
            </configuration>
            <goals>
                <goal>enforce</goal>
            </goals>
        </execution>
    </executions>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-enforcer-plugin</artifactId>
    <version>3.0.0-M3</version>
    <executions>
        <execution>
            <id>enforce-versions</id>
            <goals>
                <goal>enforce</goal>
            </goals>
            <configuration>
                <rules>
                    <bannedPlugins>
                        <!-- will only display a warning but does not fail the build. -->
                        <level>WARN</level>
                        <excludes>
                            <exclude>org.apache.maven.plugins:maven-verifier-plugin</exclude>
                        </excludes>
                        <message>Please consider using the maven-invoker-plugin (http://maven.apache.org/plugins/maven-invoker-plugin/)!</message>
                    </bannedPlugins>
                    <banDuplicateClasses>
                        <ignoreClasses>
                            <!-- example of ignoring one specific class -->
                            <ignoreClass>com.xyz.i18n.Messages</ignoreClass>
 
                            <!-- example of ignoring with wildcards -->
                            <ignoreClass>org.apache.commons.logging.*</ignoreClass>
                        </ignoreClasses>
                        <scopes>
                            <scope>compile</scope>
                            <scope>provided</scope>
                        </scopes>
                        <findAllDuplicates>true</findAllDuplicates>
                        <ignoreWhenIdentical>true</ignoreWhenIdentical>
                    </banDuplicateClasses>
                    <requireMavenVersion>
                        <version>3.2.0</version>
                    </requireMavenVersion>
                    <requireJavaVersion>
                        <version>1.8</version>
                    </requireJavaVersion>
                </rules>
                <fail>false</fail>
            </configuration>
        </execution>
    </executions>
    <dependencies>
        <dependency>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>extra-enforcer-rules</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>
</plugin>

18、maven-release-plugin

http://maven.apache.org/plugins/maven-release-plugin/

该插件的用途是帮助自动化项目版本发布，它依赖于POM中的SCM信息。

• release:prepare：用来准备版本发布，具体的工作包括检查是否有未提交代码、检查是否有SNAPSHOT依

  赖、升级项目的SNAPSHOT版本至RELEASE版本、为项目打标签等等。

• release:perform：则是签出标签中的RELEASE源码，构建并发布。版本发布是非常琐碎的工作，它涉及了

  各种检查，而且由于该工作仅仅是偶尔需要，因此手动操作很容易遗漏一些细节。

• maven-release-plugin：让该工作变得非常快速简便，不易出错。maven-release-plugin的各种目标通常

  直接在命令行调用，因为版本发布显然不是日常构建生命周期的一部分。

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-release-plugin</artifactId>
            <version>3.0.0</version>
            <configuration>
                <!--  prepare发布之前执行的mvn命令   -->
                <preparationGoals>clean verify</preparationGoals>
                <!--  生成的tag格式  这里 @{} 而不是 ${} 可以防止project.version被其他方式覆盖 -->
                <tagNameFormat>release-@{project.version}</tagNameFormat>
                <!--   手动push -->
                <pushChanges>false</pushChanges>
            </configuration>
        </plugin>
    </plugins>
</build>
<scm>
    <!--      git https  -->
    <connection>scm:git:https://github.com/Code-Agitator/maven-release-plugin-demo.git</connection>
    <!--      git https  -->
    <developerConnection>scm:git:https://github.com/Code-Agitator/maven-release-plugin-demo.git
        </developerConnection>
    <!--      git url  -->
    <url>https://github.com/Code-Agitator/maven-release-plugin-demo</url>
</scm>

19、build-helper-maven-plugin

https://www.mojohaus.org/build-helper-maven-plugin/index.html

Maven默认只允许指定一个主Java代码目录和一个测试Java代码目录，虽然这其实是个应当尽量遵守的约定，

但偶尔你还是会希望能够指定多个源码目录（例如为了应对遗留项目），build-helper-maven-plugin的add-

source目标就是服务于这个目的，通常它被绑定到默认生命周期的generate-sources阶段以添加额外的源码目

录。需要强调的是，这种做法还是不推荐的，因为它破坏了 Maven的约定，而且可能会遇到其他严格遵守约定的

插件工具无法正确识别额外的源码目录。

build-helper-maven-plugin的另一个非常有用的目标是attach-artifact，使用该目标你可以以classifier的形式选取

部分项目文件生成附属构件，并同时install到本地仓库，也可以deploy到远程仓库。

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>build-helper-maven-plugin</artifactId>
    <version>1.8</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>attach-artifact</goal>
            </goals>
        </execution>
    </executions>
</plugin>

20、exec-maven-plugin

http://mojo.codehaus.org/exec-maven-plugin/

exec-maven-plugin很好理解，顾名思义，它能让你运行任何本地的系统程序，在某些特定情况下，运行一个

Maven外部的程序可能就是最简单的问题解决方案，这就是exec:exec的用途，当然，该插件还允许你配置相关的

程序运行参数。

除了exec目标之外，exec-maven-plugin还提供了一个java目标，该目标要求你提供一个mainClass参数，然后它

能够利用当前项目的依赖作为classpath，在同一个JVM中运行该mainClass。

有时候，为了简单的演示一个命令行Java程序，你可以在POM中配置好exec-maven-plugin的相关运行参数，然后

直接在命令运行 mvn exec:java 以查看运行效果。

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>exec-maven-plugin</artifactId>
    <version>3.1.1</version>
    <executions>
        <execution>
            <goals>
                <goal>java</goal>
            </goals>
            <phase>test</phase>
        </execution>
    </executions>
    <configuration>
        <includeProjectDependencies>true</includeProjectDependencies>
        <includePluginDependencies>true</includePluginDependencies>
        <executableDependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
        </executableDependency>
        <mainClass>com.example.testmvnpkgexespringboot.TestMvnPkgExeSpringbootApplication</mainClass>
        <arguments>
            <argument>1</argument>
            <argument>2</argument>
        </arguments>
        <systemProperties>
            <systemProperty>
                <key>password</key>
                <value>123456</value>
            </systemProperty>
        </systemProperties>
    </configuration>
    <dependencies>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
            <type>jar</type>
        </dependency>
    </dependencies>

</plugin>

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>exec-maven-plugin</artifactId>
    <version>3.1.1</version>
    <executions>
        <execution>
            <id>exec-npm-run-build</id>
            <phase>test</phase>
            <goals>
                <goal>exec</goal>
            </goals>
            <configuration>
                <executable>ls</executable>
                <arguments>
                    <argument>-alh</argument>
                </arguments>
                <workingDirectory>${basedir}</workingDirectory>
            </configuration>
        </execution>
    </executions>
</plugin>

22、versions-maven-plugin

https://www.mojohaus.org/versions/versions-maven-plugin/index.html

很多 Maven 用户遇到过这样一个问题，当项目包含大量模块的时候，为他们集体更新版本就变成一件烦人的事

情，到底有没有自动化工具能帮助完成这件事情呢？

（当然你可以使用sed之类的文本操作工具，不过不在本文讨论范围）答案是肯定的，versions-maven- plugin 提

供了很多目标帮助你管理 Maven 项目的各种版本信息。

例如最常用的，命令 mvn versions:set -DnewVersion=1.1-SNAPSHOT 就能帮助你把所有模块的版本更新到1.1-

SNAPSHOT。

该插件还提供了其他一些很有用的目标，display-dependency- updates 能告诉你项目依赖有哪些可用的更新；

类似的 display-plugin-updates 能告诉你可用的插件更新；然后 use- latest-versions 能自动帮你将所有依赖升级

到最新版本。

最后，如果你对所做的更改满意，则可以使用 mvn versions:commit 提交，不满意的话也可以使用 mvn

versions:revert 进行撤销。

<plugin>
	<groupId>org.codehaus.mojo</groupId>
	<artifactId>versions-maven-plugin</artifactId>
	<version>2.7</version>
</plugin>

了解几个重要的命令：

# 显示所有的依赖更新
mvn versions:display-dependency-updates

# 显示项目的插件更新
mvn versions:display-plugin-updates

# 显示项目的属性更新
mvn versions:display-property-updates

# 设置项目版本号
mvn versions:set -DnewVersion=1.0.1-SNAPSHOT -DgenerateBackupPoms=true

# 设置属性版本号
mvn versions:set-property -Dproperty=tsollu.version -DnewVersion=1.0.1-SNAPSHOT -DgenerateBackupPoms=true

# 移除 pom.xml.versionsBackup 备份文件
mvn versions:commit

# 基于 pom.xml.versionsBackup 备份文件回滚
mvn versions:revert

标签：maven,插件,plugin,常用,Maven,plugins,apache,org,resources
From： https://blog.csdn.net/qq_30614345/article/details/136971821