zoukankan      html  css  js  c++  java
  • maven之自定义插件

      Maven 是一个系统管理框架或体系,专注管理构建的生命周期和各个阶段。真正工作的是绑定到各个阶段的 Maven 插件。每个插件具有一个或一个以上的目标,可以将这些插件的目标绑定到 Maven 生命周期的各个阶段中,或直接从命令行运行这些插件的目标。用户可以从 Apache 和其他的参考 Maven 中心仓库获取。当然,这些插件基本上能满足大部分程序员的需求,但是在特殊情况下,可能我们自己有特殊的需求,就要求我们自己去实现一个定制的插件;其实编写插件也并不是很难很复杂的事情,接下来我们开始研究一下,怎么样编写看似高深的、能绑定到 Maven 生命周期的阶段中自动被调用执行的 Maven 插件。

      为了方便大家对编写 Maven 插件的方向和过程有个总体的了解,先介绍一下编写 Maven 插件的基本步骤。

    • 创建 Maven 项目。插件的功能肯定需要编写 Java 类的,所以插件本身就是一个 Maven 项目。当然,相对于以前研究的 Maven 项目,插件项目有它的特殊点:packaging 必须是 maven-plugin 类型,可以通过 maven-archetype-plugin 快速创建一个 Maven 插件项目。
    • 编写插件目标。每个插件都至少包含一个目标,每个目标对应一个独立的 Java 类。这里把这种类叫 Mojo 类(对象)。Mojo 类必须继承 AbstractMojo 父类。
    • 设置目标的配置点。大部分 Maven 件和它的目标都是可以配置的。根据需要,可以在编写 Mojo 的时候给它设置好可以配置的参数。
    • 编写逻辑代码,实现目标功能。用 Java 代码实现插件的功能。
    • 处理错误和日志。当 Mojo 运行的时候发生异常时,需要根据情况控制 Maven 的运行状况,并且用代码实现必要的日志输出,为用户提供必要的提示信息。
    • 测试插件。编写测试案例,绑定(或命令行)执行插件。

    自定义插件实现:

      自定义Mojo需要继承 AbstractMojo 这个抽象类,并实现了 execute() 方法,该方法就是用来定义这个 Mojo 具体操作内容,我们只需要根据自己的需要来编写自己的实现即可。那么Maven 如何知道这是一个 Mojo 而不是一个普通的 Java 类呢? Mojo 的查找机制:在处理源码的时候,plugin-tools 会把使用了 @Mojo 注解或 Javadoc 里包含 @goal 注释的类来当作一个 Mojo 类。我们这里使用 @Mojo 注解来进行声明。

    1.导入依赖:

    <?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">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.wuzz.demo</groupId>
        <artifactId>wuzz-maven-plugin</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <!--打包方式-->
        <packaging>maven-plugin</packaging>
        <dependencies>
            <!--使用doc的方式-->
            <dependency>
                <groupId>org.apache.maven</groupId>
                <artifactId>maven-plugin-api</artifactId>
                <version>3.5.2</version>
            </dependency>
            <dependency><!--使用注解的方式-->
                <groupId>org.apache.maven.plugin-tools</groupId>
                <artifactId>maven-plugin-annotations</artifactId>
                <version>3.5.2</version>
                <scope>provided</scope>
            </dependency>
        </dependencies>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-plugin-plugin</artifactId>
                    <version>3.5.2</version>
                    <!-- 插件执行命令前缀 -->
                    <configuration>
                        <goalPrefix>wuzz</goalPrefix>
                        <skipErrorNoDescriptorsFound>true</skipErrorNoDescriptorsFound>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
                <!-- 编码和编译和JDK版本 -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </project>

    2.Mojo实现类:

    import org.apache.maven.plugin.AbstractMojo;
    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;
    
    /**
     * @description: 类功能描述
     * @author: wuzhenzhao
     * @time 2020/7/15 14:45
     * @since 1.0
     **/
    // mojo注解就是maven插件的注解
    // 后面配置的是生命周期,我这里配置了PACKAGE,即默认是打包时候执行本插件(这个可以在pom文件指定)
    @Mojo(name = "wuzzMojo", defaultPhase = LifecyclePhase.PACKAGE)
    public class WuzzMojo extends AbstractMojo {
        // 配置的是本maven插件的配置,在pom使用configration标签进行配置 property就是名字,
        // 在配置里面的标签名字。在调用该插件的时候会看到
        @Parameter(property = "application")
        private String application;
    
        @Parameter(property = "sourceFolderPath")
        private String sourceFolderPath;
    
        @Override
        public void execute() throws MojoExecutionException, MojoFailureException {
            System.out.println(
                    String.format("Hello World WuzzMojo: 应用名称: %s | 当前应用根目录: %s",
                            application,
                            sourceFolderPath)
            );
        }
    }

    3. 执行 mvn  install 。成功即可在maven仓库下看到该jar

    4.创建一个新的 maven 工程,依赖如下:

    <?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">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.wuzz.demo</groupId>
        <artifactId>maven-plugin-test</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <build>
            <plugins>
                <plugin>
                    <!--引入刚刚的插件依赖-->
                    <groupId>com.wuzz.demo</groupId>
                    <artifactId>wuzz-maven-plugin</artifactId>
                    <version>1.0-SNAPSHOT</version>
                    <executions>
                        <execution>
                            <goals>
                                <goal>wuzzMojo</goal>
                            </goals>
                            <phase>package</phase>
                        </execution>
                    </executions>
                    <!-- 这里加入的是相关参数,这些参数必须跟插件实现里面的属性保持一致 -->
                    <configuration>
                        <application>api</application><!-- 当前应用名称 -->
                        <sourceFolderPath>${basedir}</sourceFolderPath><!-- 当前应用根目录 -->
                    </configuration>
                </plugin>
            </plugins>
        </build>
    
    </project>

      打开Maven 界面可以看到 :

      双击 wuzzMojo :

       也可以执行  mvn  package 也会执行自定义插件的方法。这里是以pom文件里 phase 定义的值决定,我这里定义成 package,所以只有在打包的时候才会执行。这样就完成了一个简单的  maven 自定义插件

     Mojo 参数:

    /**
     * This annotation will mark your class as a Mojo (ie. goal in a Maven plugin).
     *
     * @author Olivier Lamy
     * @since 3.0
     */
    @Documented
    @Retention( RetentionPolicy.CLASS )
    @Target( ElementType.TYPE )
    @Inherited
    public @interface Mojo
    {
        /**
         * goal name (required).唯一必须声明的标注,当用户命令行调用或在pom中配置插件是,需使用该目标名称
         * @return the goal name
         */
        String name();
    
        /**默认将该目标绑定至default声明周期的某个阶段,这样在配置使用插件目标时,就无需声明phase,如maven-surefire-plugin的test目标带有@phase tes标注
         * default phase to bind your mojo.
         * @return the default phase
         */
        LifecyclePhase defaultPhase() default LifecyclePhase.NONE;
    
        /**在运行mojo之前必须解析所有指定范围的依赖,如maven-surefire-plugin的test目标带有requiresDependencyResolution test标注,表示执行测试前,所有测试范围的依赖必须得到解析
         * the required dependency resolution scope.
         * @return the required dependency resolution scope
         */
        ResolutionScope requiresDependencyResolution() default ResolutionScope.NONE;
    
        /**
         * the required dependency collection scope.
         * @return the required dependency collection scope 
         */
        ResolutionScope requiresDependencyCollection() default ResolutionScope.NONE;
    
        /**
         * your Mojo instantiation strategy. (Only <code>per-lookup</code> and <code>singleton</code> are supported)
         * @return the instantiation strategy
         */
        InstantiationStrategy instantiationStrategy() default InstantiationStrategy.PER_LOOKUP;
    
        /**
         * execution strategy: <code>once-per-session</code> or <code>always</code>.
         * @return <code>once-per-session</code> or <code>always</code>
         */
        String executionStrategy() default "once-per-session";
    
        /**该目标是否必须在一个maven项目中运行(如测试插件用于测试其他项目),默认为true。大部分插件目标需依赖一个项目才能运行,但是,maven-help-plugin的system目标例外,它用来显示系统属性和环境变量信息,无需实际项目。
         * does your mojo requires a project to be executed?
         * @return requires a project
         */
        boolean requiresProject() default true;
    
        /**是否要求项目报告已经生成,默认为false
         * does your mojo requires a reporting context to be executed?
         * @return requires a reporting context
         */
        boolean requiresReports() default false;
    
        /**当mojo在多模块项目上运行时,该标注表示目标只会在顶层模块运行。
         * if the Mojo uses the Maven project and its child modules.
         * @return uses the Maven project and its child modules
         */
        boolean aggregator() default false;
    
        /**为true时,该目标就只能通过命令行直接调用。默认为false
         * can this Mojo be invoked directly only?
         * @return invoked directly only
         */
        boolean requiresDirectInvocation() default false;
    
        /**是否要求maven必须是在线状态,默认值为false
         * does this Mojo need to be online to be executed?
         * @return need to be online
         */
        boolean requiresOnline() default false;
    
        boolean inheritByDefault() default true;
    
        /**
         * own configurator class.
         * @return own configurator class
         */
        String configurator() default "";
    
        /**
         * is your mojo thread safe (since Maven 3.x)?
         * @return is thread safe
         */
        boolean threadSafe() default false;
    }

     

  • 相关阅读:
    Binary Tree Inorder Traversal
    Populating Next Right Pointers in Each Node
    Minimum Depth of Binary Tree
    Majority Element
    Excel Sheet Column Number
    Reverse Bits
    Happy Number
    House Robber
    Remove Linked List Elements
    Contains Duplicate
  • 原文地址:https://www.cnblogs.com/wuzhenzhao/p/13307429.html
Copyright © 2011-2022 走看看