maven 2 - tutorial - Construyendo el mismo proyecto en Maven con diferentes artefactos(basado en JDK utilizado)

maven-archetype-webapp

Question

Tengo un escenario en el que mi proyecto debe compilarse en diferentes JDK y el nombre del artefacto resultante debe ser diferente según el JDK utilizado. Por ejemplo, si el nombre del proyecto es MyProject y llamo a mvn install, debe compilarse en JDK 1.4 y JDK 1.5, y finalmente obtengo dos archivos jar del mismo proyecto (MyProjectJDK14-1.0 y MyProjectJDK15-1.0). ¿Es posible lograr esto?

Answer 1

En realidad, hay una forma de producir más de un WAR con una compilación (supongo que esto también funciona para los JAR): puede usar el complemento de ensamblaje con varias ejecuciones para diferentes descriptores.

Answer 2

Lo que puede hacer es definir dos profiles , uno por JDK utilizado. Cada perfil se activará con respecto a qué JDK se utiliza:

<profiles>
<profile>
<id>profile-for-jdk1.4</id>
<activation>
<activeByDefault>false</activeByDefault>
<jdk>1.4</jdk>
</activation>
<build>
<finalName>myBuild-jdk1.4</finalName>
</build>
</profile>
<profile>
<id>profile-for-jdk1.5</id>
<activation>
<activeByDefault>false</activeByDefault>
<jdk>1.5</jdk>
</activation>
<build>
<finalName>myBuild-jdk1.5</finalName>
</build>
</profile>
</profiles>

Luego, en cada perfil, define un <finalName> específico, que se usará para nombrar el archivo JAR generado.

Por lo tanto, si construye su aplicación utilizando JDK 1.4, el JAR generado se llamará myBuild-jdk1.4.jar .

Si su paquete final se construye utilizando un ensamblaje, simplemente puede cambiar el bloque <build> dentro de los perfiles para configurar el complemento del ensamblaje (por ejemplo, a <finalName> ).

Con respecto a su comentario: De hecho, este procedimiento necesitará dos compilaciones separadas en Maven, ya que tendrá que volver a compilar todo el proyecto al cambiar la versión JDK. Una de las convenciones de Maven2 es que un proyecto = un artefacto. Lo que quieres es tener un proyecto con dos artefactos.

Finalmente, una solución es usar Hudson para compilar su aplicación, y especialmente la función de matriz de esta herramienta, que le permite ejecutar múltiples compilaciones con varios parámetros, en su caso, el JDK.

Answer 3

Un problema similar son las diferentes variantes de la API JDBC utilizadas en diferentes versiones del JDK.

Decidí que estos necesitaban diferentes arreglos en lugar de clasificadores.

Puede lograr esto estableciendo una propiedad en la configuración y luego haciendo referencia a esto en la etiqueta artifactId:

<project>
<modelVersion>4.0.0</modelVersion>
<artifactId>throwing-jdbc-${jdbc.version}</artifactId>
<name>Throwing JDBC</name>
<profiles>
<profile>
<id>jdbc3</id>
<activation>
<activeByDefault>false</activeByDefault>
<jdk>[1.3,1.4,1.5]</jdk>
</activation>
<properties>
<jdbc.version>3.0</jdbc.version>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>build-helper-maven-plugin</artifactId>
<version>1.7</version>
<configuration>
<sources>
<source>src/jdbc3-variants/java</source>
</sources>
</configuration>
<executions>
<execution>
<goals>
<goal>add-source</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
<profile>
<id>jdbc4</id>
<activation>
<activeByDefault>false</activeByDefault>
<jdk>1.6</jdk>
</activation>
<properties>
<jdbc.version>4.0</jdbc.version>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.6</source>
<target>1.6</target>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>build-helper-maven-plugin</artifactId>
<configuration>
<sources>
<source>src/jdbc4/java</source>
<source>src/jdbc4-variants/java</source>
</sources>
</configuration>
<executions>
<execution>
<goals>
<goal>add-source</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
<profile>
<id>jdbc41</id>
<activation>
<activeByDefault>false</activeByDefault>
<jdk>1.7</jdk>
</activation>
<properties>
<jdbc.version>4.1</jdbc.version>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>build-helper-maven-plugin</artifactId>
<configuration>
<sources>
<source>src/jdbc4/java</source>
<source>src/jdbc4.1/java</source>
<source>src/jdbc4.1-variants/java</source>
</sources>
</configuration>
<executions>
<execution>
<goals>
<goal>add-source</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
</profiles>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<sourceDirectory>src/main/java</sourceDirectory>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-source-plugin</artifactId>
<version>2.2.1</version>
<executions>
<execution>
<phase>verify</phase>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

Answer 4

Utilice los perfiles de Maven. Agregue esta sección dentro de la etiqueta del project de su pom.xml :

<profiles>
<profile>
<activation>
<jdk>1.4</jdk>
</activation>
<build>
<finalName>${project.artifactId}-${project.version}-JDK1.4</finalName>
</build>
</profile>
<profile>
<activation>
<jdk>1.5</jdk>
</activation>
<build>
<finalName>${project.artifactId}-${project.version}-JDK1.5</finalName>
</build>
</profile>
</profiles>

Vea profiles para saber más sobre los perfiles.

Answer 5

La mejor manera de hacer esto es no cambiar el nombre finalName del artefacto, sino usar un clasificador . Por ejemplo:

<project>
...
<build>
<plugins>
<plugin>
<artifactId>maven-jar-plugin</artifactId>
<configuration>
<classifier>${envClassifier}</classifier>
</configuration>
</plugin>
</plugins>
</build>
...
<profiles>
<profile>
<id>jdk16</id>
<activation>
<jdk>1.6</jdk>
</activation>
<properties>
<envClassifier>jdk16</envClassifier>
</properties>
</profile>
<profile>
<id>jdk15</id>
<activation>
<jdk>1.5</jdk>
</activation>
<properties>
<envClassifier>jdk15</envClassifier>
</properties>
</profile>
</profiles>
</project>

El artefacto JAR se llamará ${finalName}-${envClassifier}.jar y se incluirá como una dependencia utilizando la siguiente sintaxis:

<dependency>
<groupId>com.mycompany</groupId>
<artifactId>my-project</artifactId>
<version>1.0</version>
<classifier>jdk16</classifier>
</dependency>

Tendrá que llamar a la compilación Maven dos veces para producir ambos tarros (un motor CI decente puede hacer eso).