3 votes

Anand Sunderraman avatar

projet maven multi-modules, compiler un des modules avec une version différente de java

Demandé el 26 de Mai, 2016
Quand la question a-t-elle été
1870 affichage
Nombre de visites la question a
3 Réponses
Nombre de réponses aux questions
Résolu
Situation réelle de la question

J'essaie de construire un projet multimodule maven, dans lequel je veux que deux des modules soient construits en java 8 et l'autre en java 7.

EDIT : J'ai aussi regardé cette question SO

J'ai donc essayé les solutions proposées à l'adresse suivante Modules Maven et Java multi-version

Donc mon pom parent ressemble à

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>parent</artifactId>
    <name>parent</name>
    <version>1.0.0-SNAPSHOT</version>
    <description>Parent pom </description>
    <packaging>pom</packaging>

    <properties>
        <aspectj.version>1.8.5</aspectj.version>
        <jackson.version>2.4.0</jackson.version>
        <java.version>1.8</java.version>
        <java.source.version>${java.version}</java.source.version>
        <java.target.version>${java.version}</java.target.version>
        <jdk.version>8</jdk.version>
        <jdk>${env.JAVA_HOME_8}</jdk>
        <jersey.version>2.9</jersey.version>
        <groovy.version>2.4.3</groovy.version>
        <slf4j.version>1.7.9</slf4j.version>
        <spock.version>1.0-groovy-2.4</spock.version>
        <spring.boot.version>1.3.5.RELEASE</spring.boot.version>
        <spring.version>4.2.6.RELEASE</spring.version>
        <spring.security.version>3.1.7.RELEASE</spring.security.version>
        <spring.data.version>1.7.0.RELEASE</spring.data.version>
    </properties>

    <dependencyManagement>

    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.18.1</version>
                <executions>
                    <execution>
                        <id>unit-tests</id>
                        <goals>
                            <goal>test</goal>
                        </goals>
                        <phase>test</phase>
                        <configuration>
                            <includes>
                                <include>**/*Test.*</include>
                                <include>**/*Spec.*</include>
                            </includes>
                            <excludes>
                                <exclude>**/*IntegrationTest.*</exclude>
                            </excludes>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-release-plugin</artifactId>
                <version>2.5</version>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>build-helper-maven-plugin</artifactId>
                <version>1.7</version>
                <executions>
                    <execution>
                        <id>add-source</id>
                        <phase>generate-sources</phase>
                        <goals>
                            <goal>add-source</goal>
                        </goals>
                        <configuration>
                            <sources>
                                <source>src/main/groovy</source>
                            </sources>
                        </configuration>
                    </execution>
                    <execution>
                        <id>add-test-source</id>
                        <phase>generate-test-sources</phase>
                        <goals>
                            <goal>add-test-source</goal>
                        </goals>
                        <configuration>
                            <sources>
                                <source>src/test/groovy</source>
                                <source>src/test/java</source>
                            </sources>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.3</version>
                <configuration>
                    <compilerId>groovy-eclipse-compiler</compilerId>
                    <source>${java.source.version}</source>
                    <target>${java.target.version}</target>
                    <showDeprecation>true</showDeprecation>
                    <showWarnings>true</showWarnings>
                    <verbose>true</verbose>
                    <executable>${jdk}/bin/javac</executable>
                    <fork>true</fork>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>org.codehaus.groovy</groupId>
                        <artifactId>groovy-eclipse-compiler</artifactId>
                        <version>2.9.2-01</version>
                    </dependency>
                    <dependency>
                        <groupId>org.codehaus.groovy</groupId>
                        <artifactId>groovy-eclipse-batch</artifactId>
                        <version>2.4.3-01</version>
                    </dependency>
                    <dependency>
                        <groupId>junit</groupId>
                        <artifactId>junit</artifactId>
                        <version>4.11</version>
                    </dependency>
                </dependencies>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>cobertura-maven-plugin</artifactId>
                <version>2.7</version>
                <configuration>
                    <formats>
                        <format>html</format>
                        <format>xml</format>
                    </formats>
                    <outputDirectory>${project.build.directory}/surefire-reports/cobertura</outputDirectory>
                    <instrumentation>
                        <ignoreTrivial>true</ignoreTrivial>
                        <ignores>
                            <ignore>org.slf4j.Logger.*</ignore>
                        </ignores>
                        <excludes>
                            <exclude>**/Application.class</exclude>
                            <exclude>**/ApplicationConfig.class</exclude>
                            <exclude>**/JerseyConfig.class</exclude>
                        </excludes>
                    </instrumentation>
                    <check />
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>cobertura</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

    <modules>
        <module>model</module>
        <module>persistence</module>
        <module>service</module>
    </modules>
</project>

Et le pom dans le module ressemble à :

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>model</artifactId>
    <name>model</name>
    <description>Model forservices</description>
    <packaging>jar</packaging>

    <parent>
        <artifactId>parent</artifactId>
        <groupId>com.example</groupId>
        <version>1.0.0-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>

    <properties>
        <java.version>1.7</java.version>
        <java.source.version>${java.version}</java.source.version>
        <java.target.version>${java.version}</java.target.version>
        <jdk.version>7</jdk.version>
        <jdk>${env.JAVA_HOME_7}</jdk>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.raml.plugins</groupId>
                <artifactId>raml-jaxrs-maven-plugin</artifactId>
                <version>1.3.3</version>
                <configuration>
                    <jaxrsVersion>2.0</jaxrsVersion>
                    <jsonMapper>jackson2</jsonMapper>
                    <jsonMapperConfiguration>
                        <generateBuilders>true</generateBuilders>
                        <includeHashcodeAndEquals>true</includeHashcodeAndEquals>
                        <includeToStringuseLongIntegers>true</includeToStringuseLongIntegers>
                    </jsonMapperConfiguration>
                </configuration>
                <executions>
                    <execution>
                        <id>generate-model</id>
                        <goals>
                            <goal>generate</goal>
                        </goals>
                        <phase>generate-sources</phase>
                        <configuration>
                            <sourcePaths>
                                <sourcePath>${basedir}/src/main/raml/services.raml</sourcePath>
                            </sourcePaths>
                            <basePackageName>com.example.app</basePackageName>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Cependant, lors de la compilation, j'obtiens l'erreur suivante :

[INFO] Found location </Users/someuser/.m2/repository/org/codehaus/groovy/groovy-eclipse-batch/2.4.3-01/groovy-eclipse-batch-2.4.3-01.jar> for className <org.eclipse.jdt.internal.compiler.batch.Main>
[INFO] no javaAgentClass seems to be set
[INFO] Compiling in a forked process using /Users/someuser/.m2/repository/org/codehaus/groovy/groovy-eclipse-batch/2.4.3-01/groovy-eclipse-batch-2.4.3-01.jar
[INFO] -------------------------------------------------------------
[ERROR] COMPILATION ERROR : 
[INFO] -------------------------------------------------------------
[ERROR] Failure executing groovy-eclipse compiler:
javac: invalid flag: -jar
Usage: javac <options> <source files>
use -help for a list of possible options

[INFO] 1 error
[INFO] -------------------------------------------------------------
[INFO] ------------------------------------------------------------------------
[INFO] BUILD FAILURE
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2.687s
[INFO] Finished at: Thu May 26 10:04:15 EDT 2016
[INFO] Final Memory: 21M/320M
[INFO] ------------------------------------------------------------------------
[ERROR] Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.3:compile (default-compile) on project model: Compilation failure
[ERROR] Failure executing groovy-eclipse compiler:
[ERROR] javac: invalid flag: -jar
[ERROR] Usage: javac <options> <source files>
[ERROR] use -help for a list of possible options

EDIT: :

Donc, en me basant sur la réponse de A. Di Matteo, j'ai essayé

  1. suppression des options fork et executable de la section config du maven-compiler-plugin
  2. Réglage de la version source et cible à 1.7 sur mon module qui nécessitait une version différente de java

Il se construit avec succès. Mais lorsque je lis le manifeste de compilation, il est indiqué Build-Jdk : 1.8.0_40. Qu'est-ce que cela signifie ?

Manifest-Version: 1.0
Implementation-Title: model
Build-Date: 2016-05-26 10:44:16
Implementation-Version: 1.0.0-SNAPSHOT
Archiver-Version: Plexus Archiver
Built-By: 
Specification-Vendor: my org
Repo-Name: model
Specification-Title: model
Implementation-Vendor-Id: com.org
Git-Hash: xxx
Implementation-Vendor: my org
App-Name: model
Version-Number: 1.0.0-SNAPSHOT
Created-By: Apache Maven 3.0.5
Build-Jdk: 1.8.0_40
Specification-Version: 1.0.0-SNAPSHOT
Demandé el 26 de Mai, 2016 par Anand Sunderraman

0 votes

Avatar de Tunaki

Quelle est la relation entre "invalid flag : -jar" et l'impossibilité de changer de version de javac ? Cela ressemble à une autre erreur. Comment savez-vous que Java 8 est toujours utilisé ?

Commenté el 26 de Mai, 2016 par Tunaki

0 votes

Avatar de Anand Sunderraman

@Tunaki Je ne fais que rapporter l'erreur que j'obtiens, je ne suis pas sûr de la relation.

Commenté el 26 de Mai, 2016 par Anand Sunderraman

0 votes

Avatar de A. Di Matteo

"Build-JDK" est le JDK utilisé pour compiler, pas la version cible par rapport à laquelle il a été compilé, donc vous ne devriez pas vous inquiéter à ce sujet, c'est cohérent avec ce que vous avez utilisé. Vérifiez en utilisant l'option javap comme expliqué dans les commentaires ci-dessous.

Commenté el 26 de Mai, 2016 par A. Di Matteo

Réponses

Trop de publicités?

2voto

A. Di Matteo avatar
A. Di Matteo Points 6655

En regardant ceci ancien fil concernant le compilateur groovy :

Est-ce que par hasard vous spécifiez explicitement 'javac' en tant qu'exécutable quelque part dans votre pom ? La seule façon de reproduire votre problème est d'utiliser une configuration comme celle-ci :

<configuration>
  <compilerId>groovy-eclipse-compiler</compilerId>
  <executable>javac</executable>
  <fork>true</fork>
</configuration>

Lorsque je supprime l'option {{javac}}, tout se passe bien.

Il s'agit d'un petit bug dans le compilateur groovy-eclipse puisque nous ne devrions jamais regarder l'option exécutable (et je vais corriger cela), mais la solution est facile.

Et cette ancienne

La situation est maintenant corrigée localement. Veuillez rouvrir si ce n'est pas le problème que vous aviez.

Lors de l'utilisation du compilateur Groovy Eclipse dans une compilation Maven, l'option maven-compiler-plugin forked = true provoque l'erreur "invalid flag : -jar".

Il semble que le problème soit lié à l'utilisation de fork et executable et bien qu'il s'agisse d'une ancienne version du compilateur groovy, il est toujours (partiellement ?) présent.

En utilisant le POM minimal ci-dessous :

<project>
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.sample</groupId>
    <artifactId>sample-project</artifactId>
    <version>0.0.2-SNAPSHOT</version>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.3</version>
                <configuration>
                    <compilerId>groovy-eclipse-compiler</compilerId>
                    <source>1.7</source>
                    <target>1.7</target>
                    <showDeprecation>true</showDeprecation>
                    <showWarnings>true</showWarnings>
                    <verbose>true</verbose>
                    <executable>path_to_java8\bin\javac.exe</executable>
                    <fork>true</fork>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>org.codehaus.groovy</groupId>
                        <artifactId>groovy-eclipse-compiler</artifactId>
                        <version>2.9.2-01</version>
                    </dependency>
                    <dependency>
                        <groupId>org.codehaus.groovy</groupId>
                        <artifactId>groovy-eclipse-batch</artifactId>
                        <version>2.4.3-01</version>
                    </dependency>
                    <dependency>
                        <groupId>junit</groupId>
                        <artifactId>junit</artifactId>
                        <version>4.11</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>

</project>

Nous pouvons déjà reproduire le problème et le trompeur erreur de drapeau non valide.

Retrait de la <fork>true</fork> l'entrée de la configuration, la construction serait alors SUCCESSFUL mais il ne tiendrait pas compte non plus de la executable qui, d'après la documentation officielle, est utilisé pour

Définit l'exécutable du compilateur à utiliser lorsque fork es true .

Une suggestion pour résoudre ce problème serait la suivante :

  • Retirer le fork et executable option
  • Utilisez la version majeure de Java, dans ce cas 8 comme JDK par défaut pour tous les modules
  • Régler le source / target à la version mineure si nécessaire, en l'occurrence 7 dans certains modules
  • Configurer le animal-maven-sniffer en conséquence dans les modules concernés pour vous assurer que vous adhérez à la compilation croisée Java 7.

En ce qui concerne la compilation croisée, je vous recommande vivement de lire ce qui suit Article de StackOverflow .

Répondu el 26 de Mai, 2016 par A. Di Matteo (6655 Points )

0voto

Alex K avatar
Alex K Points 56

Le problème "javac : invalid flag : -jar" est que groovy-eclipse-compiler attendait le chemin vers java et non vers javac dans la balise "executable".

  <configuration>
      <compilerId>groovy-eclipse-compiler</compilerId>
      <source>${java.source.version}</source>
      <target>${java.target.version}</target>
      <showDeprecation>true</showDeprecation>
      <showWarnings>true</showWarnings>
      <verbose>true</verbose>
      <executable>${jdk}/bin/javac</executable>
      <fork>true</fork>
  </configuration>

Vous pouvez remplacer <executable>${jdk}/bin/javac</executable> avec <executable>${jdk}/bin/java</executable>

J'espère que cela vous aidera

Répondu el 26 de Mai, 2016 par Alex K (56 Points )

0voto

khmarbaise avatar
khmarbaise Points 28405

La meilleure solution est d'utiliser Chaîne d'outils .

Répondu el 27 de Mai, 2016 par khmarbaise (28405 Points )

Questions en vedette

Top Tags

Dans notre réseau

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

Yandex
X