maven常用插件详解

官网讲解：https://maven.apache.org/plugins/

Maven 实际上是一个依赖插件执行的框架，它执行的每个任务实际上都由插件完成的。Maven 的核心发布包（jar）中并不包含任何 Maven 插件，它们以独立构件的形式存在， 只有在 Maven 需要使用某个插件时，才会去仓库中下载。

在了解插件前建议先学习一下maven生命周期，不然很多地方会不理解：https://blog.csdn.net/weixin_43888891/article/details/130756192

插件使用的两种类型：

1. 一种插件是需要绑定到生命周期进行使用的，使用的时候需要引入到项目当中，然后将插件绑定到指定的生命周期，然后执行声明周期命令会自动调用该插件，例如：mvn clean、mvn install
2. 还有一部分插件可以脱离生命周期单独调用，也就是不需要引入到项目一样可以使用，直接通过如下命令可以直接调用插件。
   • 使用 Maven 命令执行插件的目标，语法如：mvn [插件名]:[目标名]
   • 例如，调用 maven-compiler-plugin 插件的 compile 目标，命令如：mvn compiler:compile（注意不能使用插件的全名，一定是缩写名，不然会报找不到插件）

插件的xml声明结构如下：

<dependencyManagement>
	<dependencies>
		
	dependencies>
dependencyManagement>

<dependencies>
		
dependencies>

<build>
	<pluginManagement>        
		<plugins>
			
      	plugins>
    pluginManagement>
     <plugins>
         
          <plugin>
          	  
              <groupId>groupId>
              <artifactId>artifactId>
              <version>version>
              
              <executions>
                  
                  <execution>
                    
                    <id>id>
                    
                    <phase>phase>
                    
                    <goals>
                    	<goal>rungoal>
                    goals>
                    
                    <configuration>
						....
                    configuration>
                  execution>
              executions>
          plugin>
      plugins>   
build>  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

一、maven-antrun-plugin

官网介绍：https://maven.apache.org/plugins/maven-antrun-plugin/

我们想要在 clean 生命周期的 clean 阶段中显示自定义文本信息，则只需要在项目的 POM 中 ，通过 build 元素的子元素 plugins，将 maven-antrun-plugin:run 目标绑定到 clean 阶段上，并使用该插件输出自定义文本信息即可。

<build>
	<plugins>
        
        <plugin>
              <groupId>org.apache.maven.pluginsgroupId>
              <artifactId>maven-antrun-pluginartifactId>
              <version>3.0.0version>
              <executions>
                  <execution>
                    
                    <id>custom cleanid>
                    
                    <phase>cleanphase>
                    
                    <goals>
                    	<goal>rungoal>
                    goals>
                    
                    <configuration>
                      	
                    	<target>
                        	
                        	<echo message="清理阶段"/>
                      target>
                    configuration>
                  execution>
              executions>
          plugin>
	plugins>
build>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

执行命令 mvn clean ，结果如下：

插件的运行顺序： 当插件目标绑定到生命周期的不同阶段时，其执行顺序由生命周期阶段的先后顺序决定。如果多个目标绑定到同一个生命周期阶段，其执行顺序与插件声明顺序一致，先声明的先执行，后声明的后执行。

以上我们只是简单使用maven-antrun-plugin:run插件在到达指定的生命周期打印了一段文字，实际我们还可以通过该插件来完成一些特殊工作，例如打包过后自动将包上传到指定位置等等…

二、Maven 生成站点

1、maven-site-plugin（构建简单的站点）

作用：将整个项目的依赖数据生成一个网站，不仅会展示当前项目的依赖，而且还会展示传递依赖、以及依赖版本的管理等等…

maven-site-plugin属于一个maven内置绑定插件，默认就绑定到了site生命周期，所以我们项目当中并不需要引入相关依赖。打开命令行窗口，跳转到 当前项目的目录中，执行如下 mvn 命令：mvn site 就可以生成了。

注意：假如项目特别大的情况下，生成的会非常慢

执行成功以后可以在当前项目target目录下会有一个site目录，这就是生成的站点！

站点生成成功后，我们也可以执行mvn site:run命令运行这个站点。运行的时候会使用 Maven 内置的 jetty 容器来启动。站点启动后，我们可以在浏览器中输入localhost:8080/来浏览该站点。

2、maven-javadoc-plugin（生成javadoc文档）

官网介绍：https://maven.apache.org/plugins/maven-javadoc-plugin/usage.html

在插件的 Usage 页面我们可以看到添加该依赖的方式有两种。

在这里我们使用reporting的方式，将javadoc集成到站点。

<reporting>
	<plugins>
		<plugin>
			<groupId>org.apache.maven.pluginsgroupId>
			<artifactId>maven-javadoc-pluginartifactId>
			<version>3.4.1version>
			<configuration>
				<aggregate>trueaggregate>
			configuration>
		plugin>
	plugins>
reporting>
1
2
3
4
5
6
7
8
9
10
11
12

此时我们在项目目录下执行 mvn clean site 命令。生成之后会发现站点文档多了一个Project Reports

生成javadoc的时候需要注意，有的测试类可能没有public，需要加上public，不然可能会异常！

点击进来可以看到一共是两个javadoc，一个是test的。

点进来就是这样的，一般实际开发当中很少使用，但是对于开源框架来说javadoc文档是必不可缺的。

3、maven-checkstyle-plugin（检查代码）

checkstyle 插件可以帮助团队中的各个成员来检查编码规范，并生成检查后的报告。我们首先在 pom.xml 文件中加入 checkstyle 插件的依赖：

<reporting>
	<plugins>
		<plugin>
			<groupId>org.apache.maven.pluginsgroupId>
			<artifactId>maven-checkstyle-pluginartifactId>
			<version>3.2.2version>
		plugin>
	plugins>
<reporting>	
1
2
3
4
5
6
7
8
9

他跟maven-javadoc-plugin一样，都是可以将报告集成到站点文档当中。待 Maven 下载该插件完成后，执行命令mvn clean site来重新生成站点。执行mvn site:run命令来重新启动站点。启动后，同样是在 Project Reports 目录下，可以看到新生成的 checkStyle 结果。

4、maven-jxr-plugin（查看源码）

Maven 的 jxr 插件是一个很强大的插件，可以随时查看项目的源代码。相同步骤，首先在 pom.xml 文件中加入 jxr 插件的依赖：

<plugin>
	<groupId>org.apache.maven.pluginsgroupId>
	<artifactId>maven-jxr-pluginartifactId>
	<version>3.3.0version>
	<configuration>
		<aggregate>trueaggregate>
		<encoding>UTF-8encoding>
	configuration>
plugin>
1
2
3
4
5
6
7
8
9

他跟maven-javadoc-plugin一样，同样也是可以集成到站点文档当中。待 Maven 下载该插件完成后，重新生成站点，并重启站点，即可在左边的目录中看到新生成的源码目录，点击后即阅读其中的源码。

5、自定义站点外观

默认情况下，如果用户想要自定义站点的外观，需要在src/site目录下创建 site.xml 文件，在该文件中定义其中的参数和配置。

<project name="ximi-mall">
    
    <bannerLeft>
        <name>Sonatypename>
        <src>https://pic.7y7.com/Uploads/Picture/2020-11-05/5fa3aefd70710_600_0.jpgsrc>
        <href>http://maven.apache.org/href>
    bannerLeft>
    
    <body>
    <menu ref="reports"/>
    body>
    
    <skin>
        <groupId>org.apache.maven.skinsgroupId>
        <artifactId>maven-fluido-skinartifactId>
        <version>1.11.2version>
    skin>
project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

这里，我们简单配置了 site.xml 文件，重新定义了站点的 logo，以及站点的皮肤（skin）。重新打开站点后，样式已经发生了很大的变化。

这里面的皮肤可以直接在 Maven 的官网中找到皮肤列表。在这其中选择自己喜欢的皮肤类型。

三、maven-invoker-plugin

官网介绍：https://maven.apache.org/plugins/maven-invoker-plugin/run-mojo.html

Maven 自动化构建是一种方案，即当某个项目构建完成后（特别是有代码更新的情况下），所有依赖它的相关项目也应该开始构建过程，以确保这些项目的稳定运行。

Maven 的自动化构建主要通过如下两种方案实现：

• 使用 maven-invoker-plugin 插件。
• 使用持续集成（CI）服务器自动管理构建自动化，例如 Jenkins （了解即可）。

假如有A、B、C三个项目，其中B和C都引用了A，现在有个需求，在本地构建A的时候，要求连B和C也一块同步构建。

<build>
    <plugins>
        
        <plugin>
            <groupId>org.apache.maven.pluginsgroupId>
            <artifactId>maven-invoker-pluginartifactId>
            <version>3.2.2version>
            <configuration>
                <debug>truedebug>
                
                <projectsDirectory>D:\mavenprojectsDirectory>
                
                <pomIncludes>
                    <pomInclude>B\pom.xmlpomInclude>
                    <pomInclude>C\pom.xmlpomInclude>
                pomIncludes>
            configuration>
            <executions>
                <execution>
                    <id>id-integration-testid>
                    
                    <goals>
                        <goal>rungoal>
                    goals>
                execution>
            executions>
        plugin>
    plugins>
build>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

• projectsDirectory：需要构建项目的目录，该元素可单独使用，表示该目录下的所有 Maven项目都会在当前项目构建完成后开始构建；
• pomIncludes：该元素内可以声明一个或多个 pomInclude 元素，需与 projectDirectory 元素配合使用，共同指定需要构建项目的 pom.xml。

通过mvn help:describe -Dplugin=invoker命令可以查看该插件是在哪个声明周期开始执行的以及这个插件有多少个目标。

mvn help:describe -Dplugin=插件标识
1

maven-invoker-plugin 插件绑定的 Maven 生命周期阶段为 integration-test 及其以后，所以执行 integration-test 阶段及其以后的都可以触发该插件。

四、maven-surefire-plugin

官网介绍：https://maven.apache.org/surefire/maven-surefire-plugin/test-mojo.html

在default生命周期当中有一个test阶段，也就是只要我们执行mvn package或者mvn install都会经过test阶段，该阶段内置绑定了maven-surefire-plugin插件。

该插件主要起到的作用是我们在package或者install的时候，他会执行test目录下带有@Test注解的方法。

我们可以通过声明该插件让他跳过单元测试。就算失败了也不让他影响主流程代码的打包。

<plugin>
	 <groupId>org.apache.maven.pluginsgroupId>
     <artifactId>maven-surefire-pluginartifactId>
     
     <configuration>
     	
         <skipTests>trueskipTests>
         
         <testFailureIgnore>truetestFailureIgnore>
     configuration>
 plugin>
1
2
3
4
5
6
7
8
9
10
11

除了使用插件我们还可以在idea上手动跳过测试

或者是直接使用命令跳过测试：mvn package -DskipTests

五、maven-compiler-plugin

官网介绍：https://maven.apache.org/plugins/maven-compiler-plugin/compile-mojo.html

这个插件也是maven内置绑定插件，编译的时候自动使用该插件，也就是这个插件决定了我们使用的Java版本。

<plugin>
    <groupId>org.apache.maven.pluginsgroupId>
    <artifactId>maven-compiler-pluginartifactId>
    <configuration>
        <source>1.8source>
        <target>1.8target>
        <encoding>utf-8encoding>
        <parameters>trueparameters>
    configuration>
plugin>
1
2
3
4
5
6
7
8
9
10

关于configuration属性讲解

• source：源代码使用的JRE版本，假如我们什么都不设置他就是根据插件的版本而使用默认的jdk版本，如下图所示。当然也可以通过标签进行设置JRE版本，目前插件最新版就是3.11。

• target：需要生成的目标class文件的JRE版本，跟上面的一样，他可以通过标签指定
• encoding：字符集编码，可以通过标签指定
• parameters：默认为false，设置为true将生成元数据以对方法参数进行反射（这是 官网的介绍）。通过此参数设置true可以获取方法的真实参数名，否则获取到的就是arg0、arg1。springboot的父工程spring-boot-starter-parent就是将parameters设置为了true。

User findUser(String arg0, String arg1);
1

在实际开发使用当中我们往往不会声明该插件，因为maven自动就绑定了该插件，我只需要指定对应的配置即可。

<properties>
    <maven.compiler.source>8maven.compiler.source>
    <maven.compiler.target>8maven.compiler.target>
    <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    <maven.compiler.parameters>truemaven.compiler.parameters>
properties>
1
2
3
4
5
6

假如使用的是springboot项目，并且继承了spring-boot-starter-parent那我们properties当中什么都可以不配置。spring-boot-starter-parent已经为我们配置好了。

六、spring-boot-maven-plugin

注意上面的插件都是org.apache.maven.plugins，也就是maven所提供的，而spring-boot-maven-plugin是springboot给我们提供的。

如果不使用该插件我们maven install打出来的jar包是不包含项目所依赖的包的，也就意味着项目根本没法运行。这个插件的版本是随着springboot的版本的。

<build>
    
    <finalName>consumer-consulfinalName>
    <plugins>
        <plugin>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-maven-pluginartifactId>
            <version>2.7.10version>
            <configuration>
            	
                <mainClass>
                    com.gzl.cn.OrderConsulMain80
                mainClass>
            configuration>
            <executions>
                
                <id>repackageid>
                <execution>
                	
                    <goals>
                        <goal>repackagegoal>
                    goals>
                execution>
            executions>
        plugin>
    plugins>
build>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

spring-boot-starter-parent已经给我们做了插件管理，也就是我们项目当中假如需要使用该插件，直接通过如下就可以直接使用：

<plugin>
	<groupId>org.springframework.bootgroupId>
	<artifactId>spring-boot-maven-pluginartifactId>
plugin>
1
2
3
4

七、versions-maven-plugin

官网介绍：https://www.mojohaus.org/versions/versions-maven-plugin/index.html

versions-maven-plugin插件可以管理项目版本，特别是当Maven工程项目中有大量子模块时，可以批量修改pom版本号，插件会把父模块更新到指定版本号，然后更新子模块版本号与父模块相同，可以避免手工大量修改和遗漏的问题。

<plugin>
    <groupId>org.codehaus.mojogroupId>
    <artifactId>versions-maven-pluginartifactId>
    <version>2.15.0version>
    <configuration>
		  <generateBackupPoms>falsegenerateBackupPoms>-->
	 configuration>
plugin>
1
2
3
4
5
6
7
8

注意：这个插件我们项目当中可以不引用他，直接使用命令就可以。假如项目当中引用了插件并且指定了一些配置，那么使用命令运行会遵循项目当中的配置。

（1）使用插件升级版本,比如这里想升级为0.0.4-SNAPSHOT在顶级目录执行命令

mvn versions:set -DnewVersion=0.0.4-SNAPSHOT
1

设置generateBackupPoms为false，则直接修改pom，不会生成备份文件，也就不需要使用commit再次确认，但是也无法使用revert命令回退版本号。

假如项目当中引用了上面的插件依赖并且设置了generateBackupPoms为false，那么命令中不需要携带generateBackupPoms=false，也不会生成备份文件。

mvn versions:set -DnewVersion=0.0.4-SNAPSHOT -DgenerateBackupPoms=false
1

（2）如果想回退可以使用以下命令回退 到备份的pom.xml：

mvn versions:revert
1

（3）没有问题执行以下命令会删除备份文件 就不能根据备份文件回退了

mvn versions:commit
1

关于参数：

为了更好的使用插件修改版本号，减少不必要的版本号修改，推荐Maven工程遵循如下规范：

1. 同一项目中所有模块版本保持一致
2. 子模块统一继承父模块的版本
3. 统一在顶层模块Pom的节中定义所有子模块的依赖版本号，子模块中添加依赖时不要添加版本号
4. 开发测试阶段使用SNAPSHOT
5. 生产发布使用RELEASE
6. 新版本迭代只修改父POM中的版本和子模块依赖的父POM版本

八、build-helper-maven-plugin

官网介绍：https://www.mojohaus.org/build-helper-maven-plugin/index.html

这个插件包含各种独立的小目标来帮助Maven的构建生命周期。这里就简单说一下timestamp-property插件目标吧。假如我们要实现打出来的jar包要求加上时间戳，这时候可以通过该插件来完成。

如下是默认jar包命名规则：

<build>
  <finalName>${project.artifactId}-${project.version}finalName>
build>
1
2
3

添加如下：

<build>
    <finalName>ProjectName-${build.time}finalName>
	<plugins>
	
	   <plugin>
	       <groupId>org.codehaus.mojogroupId>
	       <artifactId>build-helper-maven-pluginartifactId>
	       <version>3.4.0version>
	       <configuration>
	           <timeZone>GMT+8timeZone>
	       configuration>
	       <executions>
	           <execution>
	               <id>timestamp-propertyid>
	               <goals>
	                   <goal>timestamp-propertygoal>
	               goals>
	               <configuration>
	                   
	                   <name>build.timename>
	                   <pattern>yyyyMMdd-HHmmsspattern>
	                   <timeZone>GMT+8timeZone>
	               configuration>
	           execution>
	       executions>
	   plugin>
	plugins>
build>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

打出来的包如下：

九、maven-resources-plugin

详细讲解：https://blog.csdn.net/weixin_43888891/article/details/130755755

十、maven-archetype-plugin

官网介绍：https://maven.apache.org/archetype/maven-archetype-plugin/

maven-archetype-plugin插件可以帮我们创建maven项目，插件提供了不同类型的项目模板，其中最简单的模板就是 maven-archetype-quickstart，只需要用户提供项目最基本的信息，就能生成项目的基本结构及 POM 文件，在cmd执行如下命令即可创建项目：

mvn archetype:generate -DgroupId=com.gzl.cn -DartifactId=helloMaven -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
1

经常使用ide来创建项目，一般很少有人知道其实通过命令也是可以创建项目的。

参数说明：

• -DgroupId: 项目组 ID，通常为组织名或公司网址的反写。
• -DartifactId: 项目名。
• -DarchetypeArtifactId: 指定 ArchetypeId，maven-archetype-quickstart 用于快速创建一个简单的 Maven 项目。
• -DinteractiveMode: 是否使用交互模式。

使用命令创建好的项目如下：

十一、flatten-maven-plugin

springcloud都在使用该插件：https://github.com/alibaba/spring-cloud-alibaba/blob/2021.x/pom.xml

自 Maven 3.5.0-beta-1 开始，可以使用 ${revision}, ${sha1} and/or ${changelist} 这样的变量作为版本占位符。
像这样：

<project>
  <modelVersion>4.0.0modelVersion>
  <groupId>org.apache.maven.cigroupId>
  <artifactId>ci-parentartifactId>
  <name>First CI Friendlyname>
  <version>${revision}version>

  <properties>
	<revision>1.0revision>
  properties>
  ...
project>
1
2
3
4
5
6
7
8
9
10
11
12

或者像这样：

<project>
  <modelVersion>4.0.0modelVersion>
  <groupId>org.apache.maven.cigroupId>
  <artifactId>ci-parentartifactId>
  <name>First CI Friendlyname>
  <version>${revision}${sha1}${changelist}version>
  ...
  <properties>
    <revision>1.0revision>
    <changelist>-SNAPSHOTchangelist>
    <sha1/>
  properties>
project>
1
2
3
4
5
6
7
8
9
10
11
12
13

可以使用这样的命令：

mvn -Drevision=2.7.8 -Dchangelist=-RELEASE -Dsha1=ssbd clean package
1

由于properties标签是可以被继承的，所以在子工程当中也可以使用该标签${revision}，这样就做到了一处修改处处修改。

但是现在存在一个问题：Install / Deploy 时，子工程当中的版本占位符将不能被替换。这将导致 Install / Deploy 后， maven 不能识别。无法识别的话那他都不知道继承哪个版本的父pom，自然肯定会存在问题！

这个时候就需要通过flatten-maven-plugin来解决这个问题！将如下依赖直接引入到父工程。

<build>
	<plugins>
		<plugin>
		     <groupId>org.codehaus.mojogroupId>
		     <artifactId>flatten-maven-pluginartifactId>
		     <version>1.2.7version>
		     <configuration>
		         <updatePomFile>trueupdatePomFile>
		         <flattenMode>resolveCiFriendliesOnlyflattenMode>
		     configuration>
		     <executions>
		         <execution>
		             <id>flattenid>
		             <phase>process-resourcesphase>
		             <goals>
		                 <goal>flattengoal>
		             goals>
		         execution>
		         <execution>
		             <id>flatten.cleanid>
		             <phase>cleanphase>
		             <goals>
		                 <goal>cleangoal>
		             goals>
		         execution>
		     executions>
		 plugin>
	plugins>	 
build>	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

引入依赖后，install的时候会发现会有如下几个文件。实际上这个插件就是在pom的基础上生成一个新的pom，新的pom会把变量给替换成真的值，这样就可以避免上面所说的问题，然后install的时候插件会让maven直接编译他新生成的pom。

这时候再去仓库看看安装好的，会发现已经成功替换了

十二、maven-help-plugin

关于maven-help-plugin我们不需要引用到项目，直接可以调用命令即可，提供的有如下：

• mvn help:system：用于查看系统属性和环境变量等系统信息
• mvn help:active-profiles：查看当前激活的profiles
• mvn help:all-profiles：查看所有profiles
• mvn help:effective-pom：查看完整的pom信息，详解：https://blog.csdn.net/weixin_43888891/article/details/130483451
• mvn help:effective-settings：查看构建的时候使用的镜像相关信息

十三、maven-dependency-plugin

关于maven-dependency-plugin我们也不需要引用到项目，直接可以调用命令即可，提供的有如下：

• mvn dependency:list：查看已解析依赖，也就是项目当中可以使用的
• mvn dependency:tree：看到依赖树
• mvn dependency:analyze ：查看项目当中引用的依赖哪些使用到了，哪些没有使用到