Creando el mismo proyecto en Maven con diferentes artefactos (basado en JDK)

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, entonces necesita compilarse en JDK 1.4 así como en JDK 1.5, y finalmente obtengo dos jar del mismo proyecto (MyProjectJDK14-1.0 y MyProjectJDK15-1.0). ¿Es posible lograr esto?

Answer 1

La forma Maven de hacer esto no es cambiar el 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 será nombrado ${finalName}-${envClassifier}.jar e incluyó como una dependencia con la siguiente sintaxis:

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

Vas a tener que llamar a la Maven construir dos veces para producir dos frascos (una motor decente de CI puede hacer eso).

Answer 2

Lo que puede hacer es definir dos profiles, uno por JDK utilizado. Cada perfil se activará Con respecto a la cual se utiliza JDK:

<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, se define una específica <finalName>, que será utilizado 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 conjunto, puede simplemente cambiar el <build> dentro de los perfiles del bloque para configurar el complemento de ensamblaje (por ejemplo, <finalName>).

---

En cuanto a su comentario: De hecho, habrá que este procedimiento se basa en dos por separado Maven, ya que tienes que volver a compilar todo el proyecto cuando se cambia la versión del 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 el matrix feature de esta herramienta, que le permite ejecutar varias compilaciones con varios parámetros, en su caso el JDK.

Answer 3

Usar perfiles de Maven. Añadir esta sección dentro de la etiqueta de su projectpom.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> 

Ver this saber más acerca de los perfiles.

Answer 4

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

Answer 5

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

Decidí que necesitaban arifactIds diferentes en lugar de clasificadores.

se puede lograr esto mediante la creación de una propiedad en la configuración y luego hacer 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>