动态maven artifactId

Question

POM是否可以声明(或至少发布)artifactId包含系统属性？我的意思是实际项目的artifactId,而不是依赖项.

我正在使用maven来构建一个scala项目,因此,为了允许在pom.xml中发布不同scala版本的项目,我想声明:

<artifactId>myproject_${scalaBinaryVersion}</artifactId>

然而maven 3.3.抱怨

[警告]'artifactId'包含一个表达式,但应该是一个常量

既然我希望这个项目可以与sbt互操作,那么发布一个后缀为scala二进制版本的工件的最佳方法是什么？

Answer 1

在Maven的方式这样做的是使用分类.从官方文档中,一个示例完全符合您的情况(对于不同的Java版本,但您可以使用Scala替换Java):

分类器允许区分从相同POM构建但其内容不同的工件.它是一些可选的任意字符串 - 如果存在 - 将附加到版本号之后的工件名称.作为此元素的动机,请考虑一个项目,该项目提供针对JRE 1.5的工件,但同时也是一个仍支持JRE 1.4的工件.第一个工件可以配备分类器jdk15,第二个工件配备jdk14,以便客户端可以选择使用哪个.

您可以按如下方式配置POM:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>2.5</version>
            <executions>
                <execution>
                    <goals>
                        <goal>jar</goal>
                    </goals>
                    <configuration>
                        <classifier>${scalaBinaryVersion}</classifier>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

注意:我们正在添加Maven Jar插件的额外执行,因此该项目将创建两个jar,正常的一个+另一个具有指定的(动态)分类器.

然后Maven将自动发布分类罐和普通jar(因为它将自动附加到构建).然后,您可以将其作为另一个Maven依赖项导入另一个项目,将其分类器指定为Maven GAV的一部分(在本例中为GAVC):

<dependency>
    <groupId>your.group.id</groupId>
    <artifactId>your.constant.artifact.id</artifactId>
    <version>your.version</version>
    <classifier>your.dynamic.classifier</classifier>
</dependency>

如果您只想构建已分类的jar且没有标准(未使用)jar,则可以跳过正常jar的创建,如下所示:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>2.5</version>
            <executions>
                <execution>
                    <id>default-jar</id>
                    <phase>none</phase>
                    <goals>
                        <goal>jar</goal>
                    </goals>
                </execution>
                <execution>
                    <id>scala-version-jar</id>
                    <goals>
                        <goal>jar</goal>
                    </goals>
                    <configuration>
                        <classifier>${scalaBinaryVersion}</classifier>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

注意:我们只是覆盖Jar插件的默认执行并将其绑定到非现有阶段.因此,Maven只生成分类Jar.然后,安装插件将仅安装已分类的插件.

更新:如何使用动态依赖项安装动态artifactId

如果不同的动态版本需要不同的传递依赖性,那么确实分类器是不合适的.
然而,可以实现具有动态依赖性(并且因此动态传递依赖性)的动态artifactIds.以下是我使用的方法(并成功测试):

作为首选项,我在配置文件中隔离了动态行为,但您显然可以将其移回默认构建(或默认情况下配置文件处于活动状态).

首先,让我们在我们的pom中定义需要动态版本的依赖项,因此通过以下属性:

<properties>
    <scalaBinaryVersion>scalaversion</scalaBinaryVersion>
    <dependency.version>4.11</dependency.version>
</properties>

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>${dependency.version}</version>
    </dependency>
</dependencies>

注意:为了一个例子,我在这种情况下使用Junit作为依赖,而不是在test范围内,因为我希望它作为compile依赖(再次,仅适用于此示例).

然后让我们为动态行为定义一个配置文件:

<profiles>
    <profile>
        <id>build-scala-version</id>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-jar-plugin</artifactId>
                    <version>2.5</version>
                    <configuration>
                        <finalName>${project.artifactId}_${scalaBinaryVersion}-${project.version}</finalName>
                    </configuration>
                </plugin>

                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>2.7</version>
                    <executions>
                        <execution>
                            <id>copy-pom</id>
                            <phase>generate-resources</phase>
                            <goals>
                                <goal>copy-resources</goal>
                            </goals>
                            <configuration>
                                <outputDirectory>${project.build.directory}/${scalaBinaryVersion}</outputDirectory>
                                <resources>
                                    <resource>
                                        <directory>${basedir}</directory>
                                        <includes>
                                            <include>pom.xml</include>
                                        </includes>
                                        <filtering>true</filtering>
                                    </resource>
                                </resources>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>

                <plugin>
                    <groupId>com.google.code.maven-replacer-plugin</groupId>
                    <artifactId>replacer</artifactId>
                    <version>1.5.1</version>
                    <executions>
                        <execution>
                            <id>replace-artifactid</id>
                            <phase>prepare-package</phase>
                            <goals>
                                <goal>replace</goal>
                            </goals>
                            <configuration>
                                <file>target/${scalaBinaryVersion}/pom.xml</file>
                                <token>&lt;artifactId&gt;${project.artifactId}&lt;/artifactId&gt;</token>
                                <!-- Replace to -->
                                <value>&lt;artifactId&gt;${project.artifactId}_${scalaBinaryVersion}&lt;/artifactId&gt;</value>
                                <outputDir>target\${scalaBinaryVersion}\replacer</outputDir>
                                <outputFile>pom.xml</outputFile>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>

                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                    <executions>
                        <execution>
                            <id>default-install</id>
                            <configuration>
                                <skip>true</skip>
                            </configuration>
                        </execution>
                        <execution>
                            <id>install-scala-version</id>
                            <phase>install</phase>
                            <goals>
                                <goal>install-file</goal>
                            </goals>
                            <configuration>
                                <groupId>${project.groupId}</groupId>
                                <artifactId>${project.artifactId}_${scalaBinaryVersion}</artifactId>
                                <version>${project.version}</version>
                                <packaging>${project.packaging}</packaging>
                                <file>${project.build.directory}/${project.artifactId}_${scalaBinaryVersion}-${project.version}.jar</file>
                                <pomFile>${project.build.directory}/${scalaBinaryVersion}/replacer/pom.xml</pomFile>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>

请注意,配置文件正在自定义并提供以下内容:

• 使用动态名称更改最终Jar名称,具体取决于运行时(也称为动态)值 ${project.artifactId}_{scalaBinaryVersion}-${project.version}
• 通过Maven Resources Plugin过滤现有的pom文件并将其复制到目录中target\${scalaBinaryVersion}.复制的pom将具有动态版本的依赖项,因为Resources Plugin将替换它们.但是,它不会有动态artifactId(尚未).
• 完成动态pom文件.Replacer插件将用artifactId动态值替换XML元素(处理target文件夹,因此临时文件上的所有内容)
• 跳过默认安装的生成
• 使用动态pom文件执行自定义install-file 安装(已过滤,复制和替换的文件,提供动态依赖关系(以及动态传递依赖关系)和动态artifactId

因此,执行以下maven调用:

mvn clean install -Pbuild-scala-version -DscalaBinaryVersion=hello -Ddependency.version=4.4

Maven将在本地缓存中有效地为动态artifactId,动态依赖版本和动态pom安装新工件.
注意:如果相关的依赖版本和动态scala版本相同,那么您可以保存参数并使调用更短且更一致.