关于java:Maven插件开发教程

Maven 是一个一个优良的项目管理开源框架，其插件机制为其性能扩大提供了十分大的便捷性。大多数状况下，咱们不须要本人开发 Maven 插件，因为 Maven 自身提供了很多便捷的官网插件。然而对于某些非凡场景和非凡需要，开发一个自定义的 Maven 插件能大大提高开发效率。本文以一个简略的例子，展现如何创立一个自定义的 Maven 插件。

本文会以一个自制的 Maven 插件为例，展现如何应用 Idea 从 0 开始构建自制的 Maven 插件。

Maven 实质是一个插件执行框架，所有的工作都是通过插件实现的。包含常见的命令如 install/clean/deploy/compiler 这些命令，其实底层都是一个一个的 Maven 插件的执行后果。

插件指标：开发一个自制的 Maven 插件，插件名称叫demo-test-maven-plugin，该插件蕴含两个 Goal：

goal1：执行命令mvn demo-test:goal1，控制台输入This is goal1.；
goal2：执行命令mvn demo-test:goal2，向控制台输入This is goal2.；

在开发 Maven 插件之前，第一件事是确定插件项目名称。Maven 插件有特定的命名标准，命名标准分为两种类型：

官网插件我的项目命名标准：maven-xxx-plugin，其中插件名为 xxx，在 Maven 中能够应用命令mvn xxx 调用插件；
自定义插件我的项目命名标准：xxx-maven-plugin，其中插件名为 xxx，在 Maven 中能够应用命令mvn xxx 调用插件；

咱们的插件是自定义插件，插件名为demo-test，所以插件的项目名称为demo-test-maven-plugin。

确定好建设的项目名称为 demo-test-maven-plug 之后，咱们就能够去理论创立一个我的项目。本节以 Idea 作为工具，介绍如何建设一个 Maven 插件我的项目。

Idea 中新建 Maven 我的项目，并抉择 org.apache.maven.archetypes:maven-archetype-mojo 作为我的项目模板；
Idea 中输出项目名称，点击确认；
最初一步，点击 Finish 按钮，实现我的项目的创立；

通过以上步骤，咱们创立了一个空的 Maven 插件我的项目，这个我的项目目前没有任何代码。

通过上述步骤，咱们创立好了一个空的 Maven 我的项目，我的项目的目录如下所示：

![创立我的项目 4]

主动生成的我的项目 POM 文件内容如下所示，其中有以下几点比拟要害：

packaging：一般 Java 我的项目的 packaging 是 jar/war/pom，然而 Maven 插件我的项目的 packaging 是 maven-plugin；
maven-plugin-api：Maven 插件我的项目依赖了 maven-plugin-api 包，这是 Maven 插件我的项目必须依赖的外围包；

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.demo.test</groupId>
  <artifactId>demo-test-maven-plug</artifactId>
  <packaging>maven-plugin</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>demo-test-maven-plug Maven Mojo</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>org.apache.maven</groupId>
      <artifactId>maven-plugin-api</artifactId>
      <version>2.0</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

主动生成的我的项目中还蕴含一个 Java 文件，内容如下所示，这个 Java 文件有几个特点：

生成的类继承了 AbstractMojo，这里是 Maven 插件的标准要求，Maven 插件必须要继承AbstractMojo 并形象的 execute 办法；
类与办法上有一些 Tag，如@goal。Tag 和注解不同，Tag会呈现在相干文档中；
Tag @goal的作用是指定插件的命名，如命令 mvn clean 中，clean就是 @goal；
Tag @phase的作用是绑定插件执行的生成周期，如 clean 周期，那么在执行 mvn clean 时会主动触发插件；
Tag @parameter用来指定插件的参数。

Tag 机制有很多问题，如没有语法报错等，Maven 为什么会应用 Tag 而不是注解呢呢？这是因为 Java 晚期不反对注解，JDK1.5 才开始增加注解性能。Maven 开发之初没有注解，所以只能应用 Tag 来代替，新版本的 Maven 中曾经能够应用注解来代替 Tag。

package org.demo.test;

import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

/**
 * Goal which touches a timestamp file.
 *
 * @goal touch
 * 
 * @phase process-sources
 */
public class MyMojo
    extends AbstractMojo
{
    /**
     * Location of the file.
     * @parameter expression="${project.build.directory}"
     * @required
     */
    private File outputDirectory;

    public void execute()
        throws MojoExecutionException
    {
        File f = outputDirectory;

        if (!f.exists() )
        {f.mkdirs();
        }

        File touch = new File(f, "touch.txt");

        FileWriter w = null;
        try
        {w = new FileWriter( touch);

            w.write("touch.txt");
        }
        catch (IOException e)
        {throw new MojoExecutionException( "Error creating file" + touch, e);
        }
        finally
        {if ( w != null)
            {
                try
                {w.close();
                }
                catch (IOException e)
                {// ignore}
            }
        }
    }
}

默认的 POM 版本比拟老，性能缺失，所以在开发之前须要批改主动生成我的项目中的 POM：

降级 maven-plugin-api 包版本到 3.8.3。主动生成 POM 的版本是低版本的 2.0；
增加 maven-plugin-annotations 依赖，这个包内蕴含了 Maven 相干的注解，能够取代 Tag；
增加 maven-plugin-plugin 插件依赖，这个包能够使插件反对 JDK1.8 以上的版本；

批改之后的 POM 如下所示：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.demo.test</groupId>
    <artifactId>demo-test-maven-plugin</artifactId>
    <packaging>maven-plugin</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>demo-test-maven-plug Maven Mojo</name>
    <url>http://maven.apache.org</url>

    <dependencies>
        <dependency>
            <groupId>org.apache.maven</groupId>
            <artifactId>maven-plugin-api</artifactId>
            <version>3.8.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.maven.plugin-tools</groupId>
            <artifactId>maven-plugin-annotations</artifactId>
            <version>3.6.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-plugin-plugin</artifactId>
                <version>3.6.1</version>
            </plugin>
        </plugins>
    </build>
</project>

开篇说过，本文我的项目中的插件须要两个 goal：

goal1：执行命令mvn demo-test:goal1，控制台输入This is goal1.；
goal2：执行命令mvn demo-test:goal2，向控制台输入This is goal2.；

在 Maven 插件开发中，goal 和 Mojo 类对应，所以咱们也须要实现两个 Mojo 类，如下所示，和默认生成的 Mojo 类不同：

@Mojo注解：定义插件相干的信息，如 name 示意 goal 的名称；
@Parameter注解：指定插件运行时应用的参数，name是参数名，defaultValue是默认值；

@Mojo(name = "goal1")
public class Goal1Mojo extends AbstractMojo {@Parameter(name = "name", defaultValue = "test")
    private String name;

    public void execute() {getLog().info("This is goal1.");
    }
}

@Mojo(name = "goal2")
public class Goal2Mojo extends AbstractMojo {@Parameter(name = "name", defaultValue = "test")
    private String name;

    public void execute() {getLog().info("This is goal2.");
    }
}

通过下面的步骤，咱们简略实现了一个 Maven 插件，插件的名称是 demo-test，插件蕴含两个 Goal：goal1 和goal2，接下来，咱们把插件我的项目编译并公布，编译和公布的步骤此处不做具体介绍。

我的项目编译公布好之后，咱们在另外一个我的项目的 POM 中引入该插件：

    <build>
        <plugins>
            <plugin>
                <groupId>org.demo.test</groupId>
                <artifactId>demo-test-maven-plugin</artifactId>
                <version>1.0-SNAPSHOT</version>
            </plugin>
        </plugins>
    </build>

在我的项目的命令行执行mvn demo-test:goal1，能够看到以下输入：

[INFO] Scanning for projects...
[INFO] 
[INFO] ---------------------< com.example:javafx-spring >----------------------
[INFO] Building javafx-spring 0.0.1-SNAPSHOT
[INFO] --------------------------------[jar]---------------------------------
[INFO] 
[INFO] --- demo-test-maven-plugin:1.0-SNAPSHOT:goal1 (default-cli) @ javafx-spring ---
[INFO] This is goal1.
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  0.470 s
[INFO] Finished at: 2021-11-18T17:55:11+08:00
[INFO] ------------------------------------------------------------------------

在我的项目的命令行执行mvn demo-test:goal2，能够看到以下输入：

[INFO] Scanning for projects...
[INFO] 
[INFO] ---------------------< com.example:javafx-spring >----------------------
[INFO] Building javafx-spring 0.0.1-SNAPSHOT
[INFO] --------------------------------[jar]---------------------------------
[INFO] 
[INFO] --- demo-test-maven-plugin:1.0-SNAPSHOT:goal2 (default-cli) @ javafx-spring ---
[INFO] This is goal2.
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  0.540 s
[INFO] Finished at: 2021-11-18T17:57:46+08:00
[INFO] ------------------------------------------------------------------------

至此，咱们的 Maven 插件曾经开发实现，达到最开始设定的目标。

import org.apache.maven.execution.MavenSession;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecution;
import org.apache.maven.plugin.descriptor.PluginDescriptor;
import org.apache.maven.plugins.annotations.Component;
import org.apache.maven.plugins.annotations.Execute;
import org.apache.maven.plugins.annotations.InstantiationStrategy;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.plugins.annotations.ResolutionScope;
import org.apache.maven.project.MavenProject;
import org.apache.maven.settings.Settings;
 
       // 此 Mojo 对应的指标的名称
@Mojo( name = "<goal-name>",
       aggregator = <false|true>, 
       configurator = "<role hint>",
       // 执行策略
       executionStrategy = "<once-per-session|always>",
       inheritByDefault = <true|false>,
       // 实例化策略
       instantiationStrategy = InstantiationStrategy.<strategy>,
       // 如果用户没有在 POM 中明确设置此 Mojo 绑定到的 phase，那么绑定一个 MojoExecution 到那个 phase
       defaultPhase = LifecyclePhase.<phase>,
       requiresDependencyResolution = ResolutionScope.<scope>,
       requiresDependencyCollection = ResolutionScope.<scope>,
       // 提醒此 Mojo 须要被间接调用（而非绑定到生命周期阶段）requiresDirectInvocation = <false|true>,
       // 提醒此 Mojo 不能在离线模式下运行
       requiresOnline = <false|true>,
       // 提醒此 Mojo 必须在一个 Maven 我的项目内运行
       requiresProject = <true|false>,
       // 提醒此 Mojo 是否线程平安，线程平安的 Mojo 反对在并行构建中被并发的调用
       threadSafe = <false|true> ) // (since Maven 3.0)
 
// 何时执行此 Mojo
@Execute( goal = "<goal-name>",           // 如果提供 goal，则隔离执行此 Mojo
          phase = LifecyclePhase.<phase>, // 在此生命周期阶段主动执行此 Mojo
          lifecycle = "<lifecycle-id>" )  // 在此生命周期中执行此 Mojo
public class MyMojo
    extends AbstractMojo
{
    
    @Parameter( name = "parameter",
                // 在 POM 中可应用别名来配置参数
                alias = "myAlias",
                property = "a.property",
                defaultValue = "an expression, possibly with ${variables}",
                readonly = <false|true>,
                required = <false|true> )
    private String parameter;
 
    @Component( role = MyComponentExtension.class,
                hint = "..." )
    private MyComponent component;
 
 
    @Parameter(defaultValue = "${session}", readonly = true )
    private MavenSession session;
 
    @Parameter(defaultValue = "${project}", readonly = true )
    private MavenProject project;
 
    @Parameter(defaultValue = "${mojoExecution}", readonly = true )
    private MojoExecution mojo;
 
    @Parameter(defaultValue = "${plugin}", readonly = true )
    private PluginDescriptor plugin;
 
    @Parameter(defaultValue = "${settings}", readonly = true )
    private Settings settings;
 
    @Parameter(defaultValue = "${project.basedir}", readonly = true )
    private File basedir;
 
    @Parameter(defaultValue = "${project.build.directory}", readonly = true )
    private File target;
 
    public void execute()
    {}}

【Maven】maven 插件开发实战

本文最先公布至微信公众号，版权所有，禁止转载！

关于java:Maven插件开发教程

Maven 插件开发

Maven 插件指标

插件我的项目命名

建设插件我的项目

插件项目分析

批改我的项目 POM

增加自定义 Mojo

插件的应用

附录 1：Maven 注解详解

参考文章