Création du même projet dans Maven avec différents artifactid (basé sur JDK utilisé)

Question

J'ai un scénario dans lequel mon projet doit être compilé dans différents JDK et le nom d'artefact résultant doit être différent en fonction du JDK utilisé. Par exemple, si le nom du projet est MyProject et que j'appelle mvn install, alors il doit être compilé dans JDK 1.4 et JDK 1.5, et finalement j'obtiens deux jars du même projet (MyProjectJDK14-1.0 et MyProjectJDK15-1.0). Est-il possible d'y parvenir?

Answer 1

La méthode Maven pour ce faire n'est pas de changer le finalName de l'artefact mais d'utiliser un classificateur . Par exemple:

<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> 

L'artefact JAR sera nommé ${finalName}-${envClassifier}.jar et inclus une dépendance à l'aide de la syntaxe suivante:

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

Vous devez appeler le build Maven deux fois pour produire à la fois des pots (un moteur CI décent peut le faire).

Answer 2

Ce que vous pouvez faire est de définir deux profiles, un par JDK utilisé. Chaque profil sera activé au sujet de laquelle est utilisé 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> 

Ensuite, dans chaque profil, vous définissez un <finalName> spécifique, qui sera utilisé pour nommer le fichier JAR généré. Par conséquent, si vous générez votre application à l'aide de JDK 1.4, le fichier JAR généré sera appelé myBuild-jdk1.4.jar.

Si votre package final est créé à l'aide d'un assembly, vous pouvez simplement modifier le bloc <build> dans les profils pour configurer le plugin d'assembly (par exemple, <finalName>).

---

En ce qui concerne votre commentaire: En effet, cette procédure aura besoin de deux builds séparés sur Maven, comme vous devez recompiler l'ensemble du projet lors du changement de la version JDK. Une des conventions de Maven2 est qu'un projet = un artefact. Ce que vous voulez, c'est avoir un projet avec deux artefacts.

Finalement, une solution est d'utiliser Hudson pour construire votre application, et en particulier le matrix feature de cet outil, qui vous permet d'exécuter plusieurs builds avec divers paramètres, dans votre cas le JDK.

Answer 3

Utiliser les profils Maven. Ajouter cette section dans la balise project de votre 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> 

Voir this en savoir plus sur les profils.

Answer 4

Il existe en fait un moyen de produire plusieurs WAR avec une seule construction (je suppose que cela fonctionne également pour les JAR): vous pouvez utiliser le plugin d'assembly avec plusieurs exécutions pour des descripteurs différents.

Answer 5

Un problème similaire est les différentes variantes de l'API JDBC utilisées dans différentes versions du JDK. J'ai décidé que ceux-ci avaient besoin de différents arifactIds plutôt que de classificateurs.

Vous pouvez y parvenir en définissant une propriété dans les paramètres, puis faisant référence à cette dans la balise 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>