Das gleiche Projekt in Maven mit verschiedenen Artefakten erstellen (basierend auf JDK verwendet)

Question

Ich habe ein Szenario, in dem mein Projekt in verschiedenen JDKs kompiliert werden muss und der resultierende Artefaktname basierend auf dem verwendeten JDK unterschiedlich sein sollte. Wenn der Projektname beispielsweise MyProject lautet und ich mvn install anrufe, muss er in JDK 1.4 und JDK 1.5 kompiliert werden, und schließlich bekomme ich zwei JAR des gleichen Projekts (MyProjectJDK14-1.0 und MyProjectJDK15-1.0). Ist das möglich?

Answer 1

Der Maven-Weg, dies zu tun, ist nicht die finalName des Artefakts zu ändern, sondern einen Klassifikator zu verwenden. Zum Beispiel:

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

Der JAR-Artefakt wird ${finalName}-${envClassifier}.jar genannt werden und enthielt als Abhängigkeit der folgende Syntax:

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

Du musst die Maven zweimal beiden Gläser zu produzieren, bauen nennen (a anständiger CI-Motor tun kann).

Answer 2

Was Sie tun können, ist zwei profiles zu definieren, eine pro JDK verwendet. Jedes Profil wird aktiviert darüber, welche JDK verwendet wird:

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

Dann in jedem Profil definieren Sie eine bestimmte <finalName>, die verwendet wird, um die erzeugte JAR-Datei zu benennen.

Wenn Sie also Ihre Anwendung mit JDK 1.4 erstellen, erhält das generierte JAR den Namen myBuild-jdk1.4.jar.

Wenn das endgültige Paket mit einer Baugruppe erstellt wird, können Sie einfach die <build> Block-Innenprofile ändern, um das Baugruppen-Plugin zu konfigurieren (z. B. zu <finalName>).

---

In Bezug auf Ihre Bemerkung: der Tat dieses Verfahren müssen zwei getrennte auf Maven baut, wie Sie das gesamte Projekt neu kompilieren, wenn die JDK-Version zu ändern. Eine der Maven2-Konventionen ist, dass ein Projekt = ein Artefakt ist. Was Sie wollen, ist ein Projekt mit zwei Artefakten.

Schließlich ist eine Lösung, Hudson zu verwenden, um Ihre Anwendung und speziell die matrix feature dieses Tools zu erstellen, das Ihnen ermöglicht, mehrere Builds mit verschiedenen Parametern auszuführen, in Ihrem Fall das JDK.

Answer 3

Verwenden Sie Maven-Profile. Fügen Sie diesen Abschnitt im Inneren des project-Tag Ihrer 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> 

this Sehen Sie mehr über Profile kennen.

Answer 4

Es gibt tatsächlich eine Möglichkeit, mehr als eine WAR mit einem Build zu erstellen (ich denke, das funktioniert auch für JARs): Sie können das Assembly-Plugin mit mehreren Ausführungen für verschiedene Deskriptoren verwenden.

Answer 5

Ein ähnliches Problem ist die unterschiedlichen Varianten des JDBC-API in verschiedenen Versionen des JDK verwendet.

entschied ich, dass diese etwas andere arifactIds benötigt als Klassifizierer.

Sie können dies erreichen, indem eine Eigenschaft in Einstellungen speichern und Referenzierung diese dann im artifactId tag:

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