精华内容
下载资源
问答
  • Maven自定义插件

    2019-06-15 23:03:17
    3、导入Maven依赖插件包 4、编写测试代码 注意二点:继承AbstractMojo接口和加上 @Mojo注解 5、将这个项目 install 6、找到一个其它的项目,在pom.xml文件中加入以下配置内容 7、...

    费话不多说,直接开干。

    1、创建一个新的Maven项目。

    2、将pom.xml 文件中的 packaging 属性设置为maven-plugin。

    3、导入Maven依赖插件包

    4、编写测试代码

    注意二点: 继承 AbstractMojo 接口和加上 @Mojo 注解

    5、将这个项目 install

    6、找到一个其它的项目,在pom.xml 文件中加入以下配置内容

    7、在右边的plugin 菜单就可以看到刚刚进来的的插件了

    8、双击下面的 plugin ,就会在控制台中看到刚刚编写的代码了

     

    结尾语:这只是一个简单的demo,具体还需要根据自身的业务场景实现。

     

    更多精彩技术分享请浏览本人博客:https://blog.csdn.net/wohiusdashi

     

     

     

    展开全文
  • maven自定义插件开发

    千次阅读 2017-11-28 10:47:56
    Maven 作为一个优秀的项目管理工具,其插件机制为其功能扩展提供了非常...正好,最近有一些需求可能需要对 Drools 的一个 Maven 插件进行扩展,所以学习一下 Maven插件编写Maven 插件的命名规范一般来说,我们会将

    Maven 作为一个优秀的项目管理工具,其插件机制为其功能扩展提供了非常大的便捷性。虽然说大多数情况下,我们可能不太会自己去编写 Maven 插件,但不排除在某些特殊的情况下,我们需要去完成一个自己的插件,来协助我们处理某些比较通用的事情。正好,最近有一些需求可能需要对 Drools 的一个 Maven 插件进行扩展,所以学习一下 Maven 的插件编写。

    Maven 插件的命名规范

    一般来说,我们会将自己的插件命名为 -maven-plugin,而不推荐使用 maven--plugin,因为后者是 Maven 团队维护官方插件的保留命名方式,使用这个命名方式会侵犯 Apache Maven 商标。

    什么是 Mojo?

    Mojo 就是 Maven plain Old Java Object。每一个 Mojo 就是 Maven 中的一个执行目标(executable goal),而插件则是对单个或多个相关的 Mojo 做统一分发。一个 Mojo 包含一个简单的 Java 类。插件中多个类似 Mojo 的通用之处可以使用抽象父类来封装。

    创建 Mojo 工程

    这里,我们使用 Idea 作为开发工具进行讲解,创建工程选择 Maven,然后在模板中找到 maven-archetype-mojo,点击下一步,输入对应的参数,如:com.qchery/ekjar-maven-plugin/1.0-SNAPSHOT,最后点击完成即可创建一个简单的 Mojo 工程。
    Maven 插件的命名规范

    一般来说,我们会将自己的插件命名为 -maven-plugin,而不推荐使用 maven--plugin,因为后者是 Maven 团队维护官方插件的保留命名方式,使用这个命名方式会侵犯 Apache Maven 商标。

    什么是 Mojo?

    Mojo 就是 Maven plain Old Java Object。每一个 Mojo 就是 Maven 中的一个执行目标(executable goal),而插件则是对单个或多个相关的 Mojo 做统一分发。一个 Mojo 包含一个简单的 Java 类。插件中多个类似 Mojo 的通用之处可以使用抽象父类来封装。

    创建 Mojo 工程

    这里,我们使用 Idea 作为开发工具进行讲解,创建工程选择 Maven,然后在模板中找到 maven-archetype-mojo,点击下一步,输入对应的参数,如:com.qchery/ekjar-maven-plugin/1.0-SNAPSHOT,最后点击完成即可创建一个简单的 Mojo 工程。

    这里写图片描述

    创建完成后,工程内会生成对应的 pom.xml 文件。其内容比较简单,与普通 Maven 工程的 pom.xml 基本一致,只是自动添加了对 maven-plugin-api 的依赖,这个依赖里面会包含一些 Mojo 的接口与抽象类,在后续编写具体的 Mojo 时再进行详细讲解。

    <dependency>
      <groupId>org.apache.maven</groupId>
      <artifactId>maven-plugin-api</artifactId>
      <version>2.0</version>
    </dependency>

    与普通 pom.xml 文件一个重要的不同之处是它的打包方式:

    <packaging>maven-plugin</packaging>

    简单 Mojo 的创建

    工程创建完毕后,我们开始 Mojo 创建之旅,上面提到过 Mojo 是一个简单的 Java 类,那我们创建第一个 Mojo 类用于打印一行输出。

    import org.apache.maven.plugin.AbstractMojo;
    import org.apache.maven.plugin.MojoExecutionException;
    import org.apache.maven.plugin.MojoFailureException;
    /**
     * @goal hello
     */
    public class HelloMojo extends AbstractMojo {
    
        public void execute() throws MojoExecutionException, MojoFailureException {
            System.out.println("hello world");
        }
    
    }

    观察一下这个类,我们发现它继承了 AbstractMojo 这个抽象类,并实现了 execute() 方法,该方法就是用来定义这个 Mojo 具体操作内容,我们只需要根据自己的需要来编写自己的实现即可。

    Mojo 操作的实现我们了解了,那怎么让 Maven 知道这是一个 Mojo 而不是一个普通的 Java 类呢?这里,就需要说一下 Mojo 的查找机制了,在处理源码的时候,plugin-tools 会把使用了 @Mojo 注解或 Javadoc 里包含 @goal 注释的类来当作一个 Mojo 类。在上面的例子中,我们使用了 Javadoc 的方法来声明一个 Mojo。同样我们也可以使用 @Mojo 注解来进行声明:

    @Mojo(name = "hello")
    public class HelloMojo extends AbstractMojo {
    
        public void execute() throws MojoExecutionException, MojoFailureException {
            System.out.println("hello world");
        }
    
    }

    使用 @Mojo 注解,我们需要引入一个新包:

    <dependency>
      <groupId>org.apache.maven.plugin-tools</groupId>
      <artifactId>maven-plugin-annotations</artifactId>
      <version>3.1</version>
    </dependency>

    运行自定义 Plugin

    与使用其它插件类似,我们需要在 pom.xml 文件中引入插件:

    <build>
        <plugins>
            <plugin>
                <groupId>com.qchery</groupId>
                <artifactId>ekjar-maven-plugin</artifactId>
                <version>1.0-SNAPSHOT</version>
            </plugin>
        </plugins>
    </build>

    先执行命令:

    mvn install

    然后执行:

    mvn com.qchery:ekjar-maven-plugin:1.0-SNAPSHOT:hello

    即可看到输出:

    [INFO] Scanning for projects...
    [INFO]                                                                         
    [INFO] ------------------------------------------------------------------------
    [INFO] Building ekjar-maven-plugin Maven Mojo 1.0-SNAPSHOT
    [INFO] ------------------------------------------------------------------------
    [INFO] 
    [INFO] --- ekjar-maven-plugin:1.0-SNAPSHOT:hello (default-cli) @ ekjar-maven-plugin ---
    hello world
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------
    [INFO] Total time: 0.249 s
    [INFO] Finished at: 2017-03-26T12:59:47+08:00
    [INFO] Final Memory: 6M/123M
    [INFO] ------------------------------------------------------------------------

    缩短执行命令

    在刚才运行插件的时候,我们使用全量的插件指引,但这个实在是太长太繁琐了,那我们是否可以缩短我们的执行命令呢?答案肯定是可以的,如果你想要执行的是你本地库中最新版本的插件,那么你可以删除掉版本号;如果你的命名满足前面提及的两种命令方式,你可以直接使用插件名及 goal 名来运行对应的插件,如:

    mvn ekjar:hello

    你会得到与之前完全一样的结果。

    绑定 Maven 执行周期

    你还可以将插件配置为将特定目标,从而附加到构建生命周期中的某个特定阶段。如:

    <build>
        <plugins>
            <plugin>
                <groupId>com.qchery</groupId>
                <artifactId>ekjar-maven-plugin</artifactId>
                <version>1.0-SNAPSHOT</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>hello</goal>
                        </goals>
                        <phase>package</phase>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

    继承AbstractMojo 的类中,参数可以通过命令赋值,例如:

    /**
     *
     * @goal echo
     * @phase process-sources
     */
    public class MyMojo extends AbstractMojo {
    
        /**
         * @parameter expression="${echo.message}" default-value="Hello World..."
         */
        private String message;
    
        public void execute() throws MojoExecutionException, MojoFailureException {
            System.out.println("hello world");
    
            getLog().info("hello mymojo : "+message);
        }
    
    }

    其中注释就是maven插件很重要的元数据

    /**
     * @goal CustomMavenMojo:表示该插件的服务目标
     * @phase compile:表示该插件的生效周期阶段
     * @requiresProject false:表示是否依托于一个项目才能运行该插件
     * @parameter expression="${name}":表示插件参数,使用插件的时候会用得到
     * @required:代表该参数不能省略
     */

    执行:

    mvn com.handarui.yanquan:yanquan:1.0-SNAPSHOT:echo -Decho.message="The Eagle has Landed"
    

    (MyMojo类中的message 参数的javadoc注释是 echo.message, 通过命令赋值时,需要传入
    -Decho.message=XXX 这种形式 )

    展开全文
  • maven简介 Maven 作为一个优秀的项目管理工具,其插件机制为其功能扩展提供了非常大的...正好,最近有一些需求可能需要对 Drools 的一个 Maven 插件进行扩展,所以学习一下 Maven插件编写Maven 插件的命名...

    maven简介

    Maven 作为一个优秀的项目管理工具,其插件机制为其功能扩展提供了非常大的便捷性。虽然说大多数情况下,我们可能不太会自己去编写 Maven 插件,但不排除在某些特殊的情况下,我们需要去完成一个自己的插件,来协助我们处理某些比较通用的事情。正好,最近有一些需求可能需要对 Drools 的一个 Maven 插件进行扩展,所以学习一下 Maven 的插件编写。
    

    Maven 插件的命名规范

    一般来说,我们会将自己的插件命名为 -maven-plugin,而不推荐使用 maven–plugin,因为后者是 Maven 团队维护官方插件的保留命名方式,使用这个命名方式会侵犯 Apache Maven 商标。

    什么是 Mojo?

    Mojo 就是 Maven plain Old Java Object。每一个 Mojo 就是 Maven 中的一个执行目标(executable goal),而插件则是对单个或多个相关的 Mojo 做统一分发。一个 Mojo 包含一个简单的 Java 类。插件中多个类似 Mojo 的通用之处可以使用抽象父类来封装。

    创建 Mojo 工程

    这里,我们使用 Idea 作为开发工具进行讲解,创建工程选择 Maven,然后在模板中找到 maven-archetype-mojo(其实也可以不用选择任何模板,直接下一步),点击下一步,输入对应的参数,如:com.sm/hello-maven-plugin/0.0.1,最后点击完成即可创建一个简单的 Mojo 工程。

    配置pom.xml

    创建完成后,工程内会生成对应的 pom.xml 文件。其内容比较简单,与普通 Maven 工程的 pom.xml 基本一致,只是自动添加了对 maven-plugin-api 的依赖,这个依赖里面会包含一些 Mojo 的接口与抽象类,在后续编写具体的 Mojo 时再进行详细讲解。

    <!-- maven插件api接口 -->
    <dependency>
        <groupId>org.apache.maven</groupId>
        <artifactId>maven-plugin-api</artifactId>
        <version>2.0</version>
    </dependency>
    <!-- maven注解 -->
    <dependency>
        <groupId>org.apache.maven.plugin-tools</groupId>
        <artifactId>maven-plugin-annotations</artifactId>
        <version>3.1</version>
    </dependency>
    

    与普通 pom.xml 文件一个重要的不同之处是它的打包方式:

    <packaging>maven-plugin</packaging>
    

    简单 Mojo 的创建

    工程创建完毕后,我们开始 Mojo 创建之旅,上面提到过 Mojo 是一个简单的 Java 类,那我们创建第一个 Mojo 类用于打印一行输出。

    import org.apache.maven.plugin.AbstractMojo;
    import org.apache.maven.plugin.MojoExecutionException;
    import org.apache.maven.plugin.MojoFailureException;
    /**
     * @goal hello
     */
    public class HelloMojo extends AbstractMojo {
    
        public void execute() throws MojoExecutionException, MojoFailureException {
            System.out.println("hello world");
        }
    
    }
    

    观察一下这个类,我们发现它继承了 AbstractMojo 这个抽象类,并实现了 execute() 方法,该方法就是用来定义这个 Mojo 具体操作内容,我们只需要根据自己的需要来编写自己的实现即可。

    Mojo 操作的实现我们了解了,那怎么让 Maven 知道这是一个 Mojo 而不是一个普通的 Java 类呢?这里,就需要说一下 Mojo 的查找机制了,在处理源码的时候,plugin-tools 会把使用了 @Mojo 注解或 Javadoc 里包含 @goal 注释的类来当作一个 Mojo 类。在上面的例子中,我们使用了 Javadoc 的方法来声明一个 Mojo。同样我们也可以使用 @Mojo 注解来进行声明:

    @Mojo(name = "hello")
    public class HelloMojo extends AbstractMojo {
    
        public void execute() throws MojoExecutionException, MojoFailureException {
            System.out.println("hello world");
        }
    }
    

    运行自定义 Plugin

    与使用其它插件类似,我们需要在 pom.xml 文件中引入插件。正常情况应该是先将编写的maven插件上传到nexus私服,然后再配置,这样就会从nexus私服上下载
    nexus私服 教程请参考:

    1. nexus的linux安装包: https://download.csdn.net/download/miracle_8/12056904
    2. 安装: https://blog.csdn.net/BuFanQi_Info/article/details/81317844
    3. 上传jar:  https://blog.csdn.net/u013887008/article/details/79429973
    4. 删除jar: https://blog.csdn.net/u013958151/article/details/80311462
    

    当然考虑到maven的加载机制是先从本地的repository加载的,可以直接在本地repository按照maven的目录配置对应的数据目录并上传自定义插件包即可

    之后就可以在本地的项目中添加自定义插件的引用了

    <build>
        <plugins>
            <plugin>
                <groupId>com.sm</groupId>
                <artifactId>hello-maven-plugin</artifactId>
                <version>0.0.1</version>
            </plugin>
        </plugins>
    </build>
    

    验证

    先执行命令:

    mvn install
    

    然后执行:

    mvn com.sm:hello-maven-plugin:0.0.1:hello
    

    即可看到输出:

    [INFO] Scanning for projects...
    [INFO]                                                                         
    [INFO] ------------------------------------------------------------------------
    [INFO] Building hello-maven-plugin Maven Mojo 0.0.1
    [INFO] ------------------------------------------------------------------------
    [INFO] 
    [INFO] --- hello-maven-plugin:0.0.1:hello (default-cli) @ hello-maven-plugin ---
    hello world
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------
    [INFO] Total time: 0.249 s
    [INFO] Finished at: 2017-03-26T12:59:47+08:00
    [INFO] Final Memory: 6M/123M
    [INFO] ------------------------------------------------------------------------
    

    缩短执行命令
    在刚才运行插件的时候,我们使用全量的插件指引,但这个实在是太长太繁琐了,那我们是否可以缩短我们的执行命令呢?答案肯定是可以的,如果你想要执行的是你本地库中最新版本的插件,那么你可以删除掉版本号;如果你的命名满足前面提及的两种命令方式,你可以直接使用插件名及 goal 名来运行对应的插件,如:

    mvn sm:hello
    

    你会得到与之前完全一样的结果。

    绑定 Maven 执行周期

    你还可以将插件配置为将特定目标,从而附加到构建生命周期中的某个特定阶段。如:

    <build>
        <plugins>
            <plugin>
                <groupId>com.sm</groupId>
                <artifactId>hello-maven-plugin</artifactId>
                <version>0.0.1</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>hello</goal>
                        </goals>
                        <phase>package</phase>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
    

    继承AbstractMojo 的类中,参数可以通过命令赋值,例如:

    /**
     *
     * @goal echo
     * @phase process-sources
     */
    public class Hello extends AbstractMojo {
    
        /**
         * @parameter property="echo.message" default-value="Hello World..."
         */
         //@Parameter(defaultValue="${project}", readonly=true)
        private String message;
    
        public void execute() throws MojoExecutionException, MojoFailureException {
            System.out.println("hello world");
    
            getLog().info("hello mymojo : "+message);
        }
    
    }
    

    其中注释就是maven插件很重要的元数据

    /**
     * @goal CustomMavenMojo:表示该插件的服务目标
     * @phase compile:表示该插件的生效周期阶段
     * @requiresProject false:表示是否依托于一个项目才能运行该插件
     * @parameter expression="${name}":表示插件参数,使用插件的时候会用得到 express在最新的maven中已经被替代了
     * @required:代表该参数不能省略
     */
    

    执行:

    mvn com.sm:hello-maven-plugin:0.0.1:hello -Decho.message="Fuck shit "
    

    (MyMojo类中的message 参数的javadoc注释是 echo.message, 通过命令赋值时,需要传入
    -Decho.message=XXX 这种形式 )

    完整代码及验证命令如下

    项目结构

    在这里插入图片描述

    项目代码
    // hello-maven-plugin:pom.xml
    <?xml version="1.0" encoding="UTF-8"?>
    <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/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>1ScalaStudy</artifactId>
            <groupId>org.example</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.sm</groupId>
        <artifactId>hello-maven-plugin</artifactId>
        <packaging>maven-plugin</packaging>
    
    
        <dependencies>
            <!-- maven插件api接口 -->
            <dependency>
                <groupId>org.apache.maven</groupId>
                <artifactId>maven-plugin-api</artifactId>
                <version>2.0</version>
            </dependency>
            <!-- maven注解 -->
            <dependency>
                <groupId>org.apache.maven.plugin-tools</groupId>
                <artifactId>maven-plugin-annotations</artifactId>
                <version>3.1</version>
            </dependency>
            <!--<dependency>-->
                <!--<groupId>org.apache.maven.plugins</groupId>-->
                <!--<artifactId>maven-site-plugin</artifactId>-->
                <!--<version>3.6</version>-->
            <!--</dependency>-->
    
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>2.5.1</version>
                    <configuration>
                        <encoding>UTF-8</encoding>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-plugin-plugin</artifactId>
                    <version>3.2</version>
                    <configuration>
                        <skipErrorNoDescriptorsFound>true</skipErrorNoDescriptorsFound>
                    </configuration>
                </plugin>
            </plugins>
        </build>
        <!--<reporting>-->
            <!--<plugins>-->
                <!--<plugin>-->
                    <!--<groupId>org.apache.maven.plugins</groupId>-->
                    <!--<artifactId>maven-javadoc-plugin</artifactId>-->
                    <!--<version>3.2.0</version>-->
                <!--</plugin>-->
                <!--<plugin>-->
                    <!--<groupId>org.apache.maven.plugins</groupId>-->
                    <!--<artifactId>maven-project-info-reports-plugin</artifactId>-->
                    <!--<version>3.1.0</version>-->
                <!--</plugin>-->
            <!--</plugins>-->
        <!--</reporting>-->
    
    </project>
    
    // hello-maven-plugin:AbstractHelloMojo.java
    package com.sm;
    
    import org.apache.maven.plugin.AbstractMojo;
    import org.apache.maven.plugin.MojoExecutionException;
    import org.apache.maven.plugin.MojoFailureException;
    
    public abstract class AbstractHelloMojo extends AbstractMojo {
    
    
        @Override
        public void execute() throws MojoExecutionException, MojoFailureException {
            System.out.println("AbstractHelloMojo");
        }
    }
    
    // hello-maven-plugin:HelloMojo.java
    package com.sm;
    
    import org.apache.maven.plugin.MojoExecutionException;
    import org.apache.maven.plugin.MojoFailureException;
    import org.apache.maven.plugins.annotations.LifecyclePhase;
    import org.apache.maven.plugins.annotations.Mojo;
    import org.apache.maven.plugins.annotations.Parameter;
    
    @Mojo(name = "hello", defaultPhase = LifecyclePhase.COMPILE)
    public class HelloMojo extends AbstractHelloMojo {
    
        @Parameter(property = "msg")
        private String msg;
    
        @Override
        public void execute() throws MojoExecutionException, MojoFailureException {
            System.out.println("HelloMojo:" + msg);
        }
    }
    
    //  hello-maven-plugin:HiMojo.java
    package com.sm;
    
    import org.apache.maven.plugin.MojoExecutionException;
    import org.apache.maven.plugin.MojoFailureException;
    import org.apache.maven.plugins.annotations.LifecyclePhase;
    import org.apache.maven.plugins.annotations.Mojo;
    import org.apache.maven.plugins.annotations.Parameter;
    
    import java.util.List;
    
    @Mojo(name = "hi", defaultPhase = LifecyclePhase.COMPILE)
    // defaultPhase: 表示默认的执行阶段, 在引入插件并配置好executions的goal之后, 程序会首先根据
    // defaultPhase来执行, 也可以通过显示的配置<phase>来改变执行的阶段
    // defaultPhase和<phase>必须配置其中一个, 否则无法执行
    public class HiMojo extends AbstractHelloMojo {
    
        @Parameter
        private List<String> options;
    
        @Override
        public void execute() throws MojoExecutionException, MojoFailureException {
            System.out.println("HiMojo:" + options);
        }
    }
    
    // 插件使用: maven-plugin-test:pom.xml
    <?xml version="1.0" encoding="UTF-8"?>
    <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/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>1ScalaStudy</artifactId>
            <groupId>org.example</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.sn</groupId>
        <artifactId>maven-plugin-test</artifactId>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>com.sm</groupId>
                    <artifactId>hello-maven-plugin</artifactId>
                    <version>1.0-SNAPSHOT</version>
                    <!-- 默认的goal里面的参数配置, 可以被execution里面的配置覆盖 -->
                    <!--<configuration>-->
                        <!--<options>-->
                            <!--<option>1</option>-->
                            <!--<option>2</option>-->
                        <!--</options>-->
                        <!--<msg>1</msg>-->
                    <!--</configuration>-->
                    <executions>
                        <execution>
                            <id>hello1</id>
                            <phase>clean</phase>
                            <configuration>
                                <msg>hahaha</msg>
                            </configuration>
                            <goals>
                                <goal>hello</goal>
                            </goals>
                        </execution>
                        <execution>
                            <id>hello2</id>
                            <!-- 采用默认的phase -->
                            <!--<phase>compile</phase>-->
                            <configuration>
                                <msg>hahaha2</msg>
                            </configuration>
                            <goals>
                                <goal>hello</goal>
                            </goals>
                        </execution>
                        <execution>
                            <!--<phase>clean</phase>-->
                            <id>hi</id>
                            <goals>
                                <goal>hi</goal>
                            </goals>
                            <configuration>
                                <options>
                                    <option>1</option>
                                    <option>2</option>
                                </options>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>2.3.2</version>
                    <configuration>
                        <source>1.7</source>
                        <target>1.7</target>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </project>
    
    

    源码附件: https://download.csdn.net/download/miracle_8/12901610

    验证命令总结
    maven常用命令:
    名词: lifecycle phase goal => lifecycle包含多个phase, phase包含多个goal, 
    mvn [一个或多个phase|一个或多个goal], 多个phase|goal可以混合, maven按照顺序执行
    a. 内置的lifecycle:default, clean and site. The default lifecycle handles your project deployment, the clean lifecycle handles project cleaning, while the site lifecycle handles the creation of your project's site documentation.
    
    1. 安装到本地仓库: maven clean install
    2. 部署到远程仓库: maven clean deploy
    
    3. 查看插件拥有的goals: 
    mvn help:describe -Dplugin=groupId:artifactId:version
    例子: mvn help:describe -Dplugin=com.sm:hello-maven-plugin:1.0-SNAPSHOT
    
    4. 单独执行插件的某个goal:
    mvn groupId:artifactId:goal
    例子: mvn com.sm:hello-maven-plugin:hello
    
    5. 简化执行插件的某个goal: (参数最好设置的长一点, 比如下面的 msg改为test.test.msg)
    mvn globalPrefix:goal -Dparam=value
    例子: mvn hello:hello -Dmsg=123
    
    6. 执行插件中指定的execution:
    mvn globalPrefix:goal@executionID =>  maven版本必须是3.3.1以上
    例子: mvn hello:hello@hello1
    
    
    展开全文
  • 前面实现了简单自定义 Maven 插件编写和测试,在代码中用到了 @goal 和 @parameter,分别用来标记插件的目标和参数。接下来详细介绍编写 Maven 插件要用到的标记。Mojo 标记自定义 Maven 插件的常用标记如下所示。...

    前面实现了简单自定义 Maven 插件的编写和测试,在代码中用到了 @goal 和 @parameter,分别用来标记插件的目标和参数。接下来详细介绍编写 Maven 插件要用到的标记。

    Mojo 标记

    自定义 Maven 插件的常用标记如下所示。

    1)@goal

    这是自定义 Maven 插件 Mojo 代码中唯一必须声明的标记,用来声明该 Mojo 的目标名称。

    2)@phase

    声明默认将该目标绑定到 default 生命周期的某个阶段。这样在配置使用该插件目标时就可以不声明 phase。

    3)@requiresDependecyResolution

    声明运行该 Mojo 之前必须解析哪些范围的依赖。比如 maven-surefire-plugin 的 test 目标中,就用 @requireDependecyResolution test 标注必须解析完测试访问的所有依赖(compile、test 和 runtime)。该标记的默认值是 runtime。

    4)@requiresProject

    声明该目标是不是必须在一个 Maven 项目中运行,默认值是true。

    大部分 Maven 插件的目标都需要依赖一个项目才能执行。但有例外,比如 maven-help-plugin 插件中的 system 目标,是用来显示系统属性和环境变量属性信息的,就不必要强制依赖一个项目才能运行,所以就用 @requiresProject false 声明。

    5)@requiresDirectInvoction

    声明该目标是否只能使用命令行调用,默认值是 false,既可以在命令行中调用,也可以在 pom 中配置绑定生命周期阶段。如果是 true 的话,就只支持在命令行中执行;如果在 pom 中进行配置绑定生命周期阶段的话,Maven 就会异常。

    6)@requiresOnline

    声明 Maven 是不是必须是在线状态,默认值是 false。

    7)@requiresReport

    声明是否要求项目报告已经生成,默认值是 false。

    8)@aggregator

    在多模块的 Maven 项目中,声明该目标是否只在顶层模块构建的时候执行。如 maven-javadoc-plugin 的 aggregator-jar 就使用 @aggregator 标记,它只会在顶层项目生成一个已经聚合的 JavaDoc 文档。

    9)@execute goal=""

    声明执行该目标之前,先执行指定的目标。

    如果该目标是自己插件的另外一个目标,直接 goal="目标名"。

    如果该目标是另外一个插件的目标,就需要写成 goal="目标前缀:目标名"。

    10)@execute phase=""

    声明在执行该目标之前,Maven 先运行到当前生命周期的指定阶段。

    11)@execute lifecycle=""phase=""

    声明在执行该目标之前,Maven 运行到指定生命周期的指定阶段。

    Mojo 参数

    在 Mojo 中,一般都会有一个或多个 Mojo 参数需要配置,会用 @parameter 标记。

    Maven 执行 Boolean、Int、Float、String、Date、File 和 URL 等单值类型的参数,多值类型的参数包括数组、Collection、Map、Properties 等。下面分别介绍它们的配置。

    1. Boolean(boolean、Boolean)

    标记形式:

    /**

    *@parameter

    */

    private boolean testBoolean;

    pom 中的配置:

    value

    2. Int(Integer、long、Long、short、Short、byte、Byte)

    标记形式:

    /**

    *@parameter

    */

    private int testInt;

    pom 中的配置:

    value

    3. Float(Float、double、Double)

    标记形式:

    /**

    *@parameter

    */

    private double testDouble;

    pom 中的配置:

    value

    4. String(StringBuffer、char、Character)

    标记形式:

    /**

    *@parameter

    */

    private String testString;

    pom 中的配置:

    value

    5. Date(yyyy-MM-dd hh:mm:ssa)

    标记形式:

    /**

    *@parameter

    */

    private Date testDate;

    pom 中的配置:

    value

    6. File

    标记形式:

    /**

    *@parameter

    */

    private File testFile;

    pom 中的配置:

    value

    7. URL

    标记形式:

    /**

    *@parameter

    */

    private URL testUrl;

    Pom 中的配置

    value

    8. 数组

    标记形式:

    /**

    *@parameter

    */

    Private String[] test

    pom 中的配置

    abc

    efg

    9. Collection

    标记形式:

    /**

    *@parameter

    */

    Private String[] tests

    pom 中的配置

    abc

    efg

    10. Map

    标记形式:

    /**

    *@parameter

    */

    Private Map test

    pom 中的配置

    value1

    value2

    11. Properties

    标记形式:

    /**

    *@parameter

    */

    Private Properties tests;

    Pom 中的配置:

    name1

    value1

    name2

    value2

    除了直接使用 @parameter 标记配置的 Mojo 属性外,我们还可以使用 @parameter 的其它属性,进行进一步的详细声明:

    @parameter alias=""

    通过 alias 指定 Mojo 参数的别名。

    /**

    *@parameter alias="username"

    */

    Private String testUserName;

    Pom 中的配置:

    value

    @parameter expression="${attributeName}"

    读取属性的值给参数赋值。如:

    /**

    *@parameter expression="${userName}"

    */

    Private String testUserName

    我们可以通过在 pom 中配置 userName 参数赋值,也可以在命令行中使用 -DuserName=value 进行赋值。

    @parameter default-value="value/${attributeName}"

    支持对 Mojo 属性赋予初始值

    除了 @parameter 标记外,我们还可以使用 @required 和 @readonly 配合标记属性

    1)@required 表示 Mojo 参数是必须的,如果使用了该标记,则必须配置 Mojo 值,否则会报错

    2)@readonly 表示 Mojo 参数是只读的,用户不能通过配置修改。

    Maven插件中的错误处理和日志

    在 Mojo 的执行方法后面,支持 MojoExecutationException 和 MojoFailureException 两种异常。

    如果运行抛出 MojoFailureException 异常,会显示“Build Failure”错误信息,表示可以预期的错误。

    如果运行抛出 MojoExecutationException 异常,会显示“Build Error”错误信息,表示未预期的错误。

    除了前面的两个异常定义外,Mojo 中还提供了相关方法可以输出不同等级的日志。用户可以通过这些日志输出,更详细地把握执行状况。

    这里可以调用父类 AbstractMojo 的 getLog() 方法获取 Log 对象,输入四个等级的日志信息。从低到高分别是:

    Debug:调试日志。

    Info:消息日志。

    Warn:警告日志。

    Error:错误日志。

    为了输出上面各个级别的信息,分别提供了三种方法。

    Void debug(CharSequence ch)。

    Void debug(CharSequence ch,Throwable error)。

    Void debug(Throwable error)。

    展开全文
  • Gradle自定义插件编写

    千次阅读 2019-12-11 17:53:13
    Gradle 简介 Gradle是一个基于JVM的构建工具,它提供了: 像Ant一样,通用灵活的构建工具 可以切换的,基于约定的构建框架 强大的多工程构建支持 基于Apache Ivy的强大的...基于Groovy,build脚本使用Groovy编写...
  • Maven3 自定义插件开发

    2014-08-21 10:29:41
    Maven3实战笔记15编写Maven插件 [url]...[color=red]Maven3 自定义插件开发[/color] [url]http://lvjun106.iteye.com/blog/1767441[/url] 问题: 1. No mojo definitions were...
  • 编写自定义Maven2插件

    2016-10-31 14:42:17
    from:... 一、创建一个插件项目   > mvn archetype:create -DgroupId=org.sonatype.mavenbook.plugins -DartifactId=first-maven-plugin -DarchetypeGroupId=org.apache.maven.archetypes -
  • 我已经编写了自己的自定义Maven插件并将其上传到我的Archiva服务器.它与指定的全名一起工作正常:mvn com.mjolnirr:maven-plugin:manifest但是当我想通过前缀来做它时,它会失败:mvn mjolnirr:manifest[ERROR] No ...
  • 编写自定义Maven2插件

    2010-01-07 11:29:37
    一、创建一个插件项目 > mvn archetype:create -DgroupId=org.sonatype.mavenbook.plugins -DartifactId=first-maven-plugin -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-...
  • Maven自定义plugin

    2011-07-19 23:10:58
    尽管如此众多的插件为我们提供了几乎所需要的所有功能,但我还是想进一步了解如何编写一个自定义插件呢。那么按照下面的步骤我们就可以完成一个自定义的插件了。  先来看看我的环境吧。      如果你熟悉...
  • Maven插件编写

    2011-09-06 17:24:00
    最近一直在学习Maven,今天看到了Maven插件方面的知识了,具体插件是什么,怎么编写自定义插件等等,这一系列的问题的理解了,不是专门来编写插件的,只是为了了解插件的编写的基本流程,至于深入理解,这里还不到那...
  • 伴随着日常开发的需要,我们可能需要用到的maven插件,这些插件一部分可以去网上下载,一部分可以去问下公司里面的前辈们,可是还有第三种情况的时候,比如我们需要特殊服务的时候,就需要自定义编写maven插件了来...
  • 前言:公司业务需要开发Kettle的自定义Step插件,在查找资料的过程中发现网上关于Kettle的资料比较少,有的资料比较简洁,因此记录一下自己demo插件的详细开发过程。 插件功能:用户输入需要替换的字符和替换后的...
  • 1. 自定义插件介绍 在一些情况下,Maven现有的一些插件可能满足不了我们的一些“特殊服务”。这个时候有三种选择,第一,问问有经验的Maven开发者,是否有相应的。第二,从网上找找搜搜,看看有没有别的组织开发的...
  • maven 自定义插件插件快速入门新建一个maven项目更改package类型引入依赖我的pom.xml(参考使用,请忽略)编写goal实现将插件打包安装到本地仓库测试插件新增另外一个maven工程配置自定义的插件运行命令 插件快速...
  • maven插件的demo

    2018-08-25 22:48:41
    maven插件demo,包含了与maven声明周期的绑定,自定义参数等,但是这就是一个demo,只是演示了maven插件编写方式
  • 前言 虽然,平时工作基本用不到自定义插件,但手动...简单来说,实现自定义插件,只需要继承maven-plugin-api工程中的AbastractMojo并实现无参抽象方法execute即可. 不过这还不够,因为还需要考虑goal,phase和入参等操作...
  • maven常见插件和命令

    2018-05-26 20:42:51
    maven-antrun-pluginhttp://maven.apache.org/plugins/maven-antrun-plugin/maven-antrun-plugin能让用户在Maven项目中运行Ant任务。用户可以直接在该插件的配置以Ant的方式编写...此外当你发现需要编写一些自定义...
  • Archetype 任务 步骤 第一步 根据需要生成的项目框架搭建...第三步 编写archetype-metadata.xml文件 第四步 将需要自定义的变量参数化 方法二 第一步 采用archetype插件,根据项目逆向生成对应的archetype项目 ...
  • 基本思想取决于为测试框架编写自定义的选项,这使得完成工作非常容易。 因此,总的来说,整个集成测试框架的核心(itf-jupiter-extension)是,它为测试框架提供补充支持,特别是对于使用集成测试。 当然,其中集成...
  • 我有一个类似的问题:this previous question...例如-javaagent:lib/eclipselink.jar我试图让Netbeans启动开发应用程序(我们将编写自定义的启动脚本进行最终部署)由于我使用Maven管理Eclipselink依赖项,我可能不知道...
  • Maven学习笔记之如何编写Maven项目的Plugins插件前言新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中...
  • 编写一个maven插件,install到本地仓库,其他项目通过引用这个插件来统计文件的数量 ...--自定义插件所需依赖--> <dependency> <groupId>org.apache.maven</groupId> <artifact...
  • 参考:自定义maven插件的实现_朱培(知浅_ZLH)-CSDN博客maven(从零实现一个自定义插件)不得不说,网上的博客有点捞,看着看着都不知道这是啥玩意了。这里先严防几个问题,idea缓存!打包后最好检查一下仓库!然后开始...
  • 参考:自定义maven插件的实现_朱培(知浅_ZLH)-CSDN博客maven(从零实现一个自定义插件)不得不说,网上的博客有点捞,看着看着都不知道这是啥玩意了。这里先严防几个问题,idea缓存!打包后最好检查一下仓库!然后开始...
  • maven使用Okta的身份管理平台轻松部署您的应用程序使用Okta的API在几分钟之内即可对任何应用程序中的用户进行身份验证,管理和保护。 今天尝试Okta。 由于其插件生态系统的普及,... 有时,您需要编写一个自定义...
  • maven插件maven-assembly-plugin的使用

    千次阅读 2019-10-13 12:11:35
    maven-assembly-plugin可用于打自定义的分发包,可以使用内置的预指定的descriptors,或自己编写descriptors的xml文件,将依赖,文档信息,以及单个文件或文件夹,自由的组合在一起。 在pom文件中的插件中定义,maven...

空空如也

空空如也

1 2 3 4 5
收藏数 95
精华内容 38
关键字:

maven自定义插件编写