maven - 构建过程在父pom中定义 Maven 插件,但是只调用子项目中的插件

  显示原文与译文双语对照的内容

我有一组项目,它们都需要在构建过程中运行相同系列的Maven 插件执行。 我想避免在每个项目中重新声明这些配置,所以我将它们从一个只包含"模板"的those项目继承。 但是我希望在 Maven 构建期间只在子项目上运行插件,而不是在父项目上运行。

我试图完成这四种不同的方法每一种都有一个副作用我不喜欢。

在pom元素的父 build/plugins 中声明插件执行,并在父项目中使用properties-maven-plugin来启用其他插件的skip 属性( 在父项目中。 因为插件目标( 。maven-dependency-plugin: 构建类路径) 没有 skip 属性,所以这不起作用。

声明在pom元素的父 build/pluginManagement 中的插件执行。 不幸的是,我需要重新声明项目中每个子pom的build/plugins 元素中的八个插件,如下所示:


<plugin>


 <artifactId>maven-assembly-plugin</artifactId>


</plugin>


...



如果我需要更改模板pom中的插件,那么这就太重复了。

在父pom激活的配置文件中声明插件执行,该配置文件由服务器激活,缺少一个文件( 它在父pom中确实存在,所以插件不会在那里执行)的:


<profiles>


 <profile>


 <activation>


 <file>


 <missing>nobuild.txt</missing>


 </file>


 </activation>


 <build>


. . ..


 </build>


 </profile>


</profiles>



虽然在 missing 元素中文件路径似乎基于当前工作目录而不是项目 basedir,但这在大部分情况下是可行的。 这将破坏我希望能够完成的一些multimodule构建。 如果你想在"模板"项目中做一个模块,那么在我试着做一个例子时,构建中断会是一个。 项目结构类似于:


+ job


|- job-core


|- job-template


|- job1 inherits from job-template


|- job2 inherits from job-template



设置定制生命周期和打包。 这似乎允许我将插件绑定到生命周期阶段,,但不指定任何配置。

所以,还有另一种方法可以指定一些 Maven 插件执行,这些执行可以跨多个项目( 在每个项目中重复的次数最少') 重用?

时间:

我最终编写了自己的插件,它利用了执行器来调用其他 mojos 。 这允许我将构建配置和 2集中到 1,最小化在每个子项目中重复的配置量。

( 如果你对所有这一切的原因感到好奇: 每个子项目都是从 命令行 中执行的作业。 构建建立一个调用程序 shell script 并将它的附加到构建中,以便它被检入到我们的工件存储库中。 部署脚本稍后将它们拉到它们将运行的机器上。

项目pom的相关部分:


<project.. .>


 <parent>.. . </parent>


 <artifactId>job-template</artifactId>


 <packaging>pom</packaging>


 <name>job project template</name>


 <build>


 <pluginManagement>


 <plugin>


 <groupId>...</groupId>


 <artifactId>job-maven-plugin</artifactId>


 <executions>


 <execution>


 <id>generate-sources-step</id>


 <goals><goal>job-generate-sources</goal></goals>


 </execution>


 <execution>


 <id>package-step</id>


 <goals><goal>job-package</goal></goals>


 </execution>


. . . (a couple more executions).. .


 </executions>


 </plugin>


 </pluginManagement>


 </build>


</project>



必须创建一个新的maven插件项目( job-maven-plugin ) 。 Pom看起来像:


<project.. .>


 <parent>.. . </parent>


 <artifactId>job-maven-plugin</artifactId>


 <packaging>maven-plugin</packaging>


 <name>job maven executor plugin</name>


 <dependencies>


 <dependency>


 <groupId>org.twdata.maven</groupId>


 <artifactId>mojo-executor</artifactId>


 <!-- version 1.5 supports Maven 2, while version 2.0 only supports Maven 3 -->


 <version>1.5</version>


 </dependency>


 </dependencies>


</project>



从模板项目中可以看到,我的插件( 每一个阶段都需要做一些事情) 中有多个 mojos 。 例如作业包mojo绑定到软件包阶段,并使用mojo执行程序库运行另外两个 mojos ( 它只是附加一些构建构件):


/**


 * @goal job-package


 * @phase package


 */


public class PackageMojo extends AbstractMojo {


/**


 * @parameter expression="${project}"


 * @required


 * @readonly


 */


 protected MavenProject project;


/**


 * @parameter expression="${session}"


 * @required


 * @readonly


 */


 protected MavenSession session;


/**


 * @component


 * @required


 */


 protected PluginManager pluginManager;



 @Override


 public void execute() throws MojoExecutionException, MojoFailureException {


 ExecutionEnvironment environment = executionEnvironment(project, session, pluginManager);



//Attach script as a build artifact


 executeMojo(


 plugin(


 groupId("org.codehaus.mojo"),


 artifactId("build-helper-maven-plugin"),


 version("1.7")


 ),


 goal("attach-artifact"),


 configuration(


 element("artifacts",


 element("artifact",


 element("file","${project.build.directory}/script.shl"),


 element("type","shl")


 )


 )


 ),


 environment


 );



//Zip up the jar and script as another build artifact


 executeMojo(


 plugin(


 groupId("org.apache.maven.plugins"),


 artifactId("maven-assembly-plugin"),


 version("2.3")


 ),


 goal("single"),


 configuration(


 element("descriptors",


 element("descriptor","${project.build.directory}/job/descriptor.xml")


 )


 ),


 environment


 );


 }


}



然后,在子项目中,我只需要引用一次插件。 在我看来,在每个子项目( 它可以提高之间的耦合) 中重新推断每个behind-the-scenes插件是最好的。 如果我想将一个a 执行添加到构建过程中,我只需修改一个位置并打开版本号。 项目的子pom看起来像:


<project.. .>


 <parent>


 <groupId>.. . </groupId>


 <artifactId>job-template</artifactId>


 <version>.. . </version>


 <relativePath>../job-template</relativePath>


 </parent>


 <artifactId>job-testjob</artifactId>


 <name>test job</name>


 <build>


 <plugins>


 <plugin>


 <groupId>.. . </groupId>


 <artifactId>job-maven-plugin</artifactId>


 </plugin>


 </plugins>


 </build>


</project>



另外,整个multimodule目录结构现在看起来像这样:


+- job


 +- job-core


 +- job-maven-plugin


 +- job-template


 +- job-testjob1 (inherits from job-template)


 +- job-testjob2 (inherits from job-template)



我认为这个解决方案并不完全优化,因为现在嵌入了一系列 mojos,但它满足了我的目标。

最后一点:我刚刚发现了 maven-aggregate-plugin插件,它似乎允许在pom中对多个插件执行进行分组。 这可以能已经解决了这个问题,但是我没有心情重复最后几个小时的工作。 可能对其他人有利。

我个人认为解决方案 2. 重复是最小的,你应该尽可以能避免配置文件,以避免开始记录哪些配置文件需要激活。

一个项目应该能够通过简单地做一个 mvn (clean) install 来构建。

...