动态maven人工关节

Question

POM是否可以声明（或至少发布）包含系统属性的artifactId？我指的是实际项目的工件，而不是依赖项。

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

然而，马文3.3。抱怨

[警告]“artifactId”包含表达式，但应为常量

既然我希望这个项目能够与sbt互操作，那么发布带有scala二进制版本后缀的工件的最佳方式是什么？




Answer 1

我们遵循以下建议的基于属性（通过配置文件）的方法：scala-maven-plugin FAQ

<artifactId>something_${scala.compat.version}</artifactId>

<properties>
 <scala.compat.version>2.12</scala.compat.version>
</properties>

maven仍然会发出警告（有充分的理由），但在FlatteMaven插件的帮助下，我们构建/安装了替换了变量的POM。

Answer 2

如果您使用maven，我将使用multi-pom和maven helper插件，这样每个模块中的artifactId都是常量。

Answer 3

专业的方法是使用分类器。从官方文档中可以看到一个与您的情况完全匹配的示例（对于不同的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，一个正常的Jar，另一个带有指定（动态）分类器的Jar。

然后Maven将自动发布分类jar和普通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>

如果您想只构建分类的一个而不是标准的（未使用的）罐，您可以跳过正常罐的创建，如下所示：

<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插件的默认html" target="_blank">执行，并将其绑定到一个不存在的阶段。因此，Maven将只生成已分类的Jar。安装插件将只安装分类插件。

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

如果不同的动态版本需要不同的传递依赖项，那么分类器确实不合适
但是，可以实现具有动态依赖关系（以及动态传递依赖关系）的动态工件。以下是我使用（并成功测试）的方法：

作为首选，我隔离了概要文件中的动态行为，但您显然可以将其移回默认构建（或在默认情况下激活概要文件）。

首先，让我们在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>

注意，配置文件正在定制并提供以下内容：

• 根据运行时（aka dynamic）值，使用动态名称将最终Jar名称更改为${project.artifactId}{scalaBinaryVersion}-${project.version}
• 通过Maven Resources插件过滤现有pom文件，并将其复制到目录target\${scalaBinaryVersion}。复制的pom将与动态版本具有依赖关系，因为资源插件将替换它们。但是，它还没有动态artifactId
• 完成动态pom文件。Replacer插件将用动态值替换artifactIdXML元素（处理target文件夹，因此临时文件中的所有内容）
• 跳过默认安装的生成
• 使用动态pom文件（过滤、复制和替换的pom文件，提供动态依赖项（以及动态可传递依赖项）和动态artifactId）执行自定义安装文件

因此，执行以下maven调用：

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

Maven将在本地缓存中为动态工件ID、动态依赖版本和动态pom有效地安装一个新工件
注意：如果相关的依赖项版本和动态scala版本相同，则可以保存一个参数，使调用更短、更一致。