web-dev-qa-db-fra.com

Dans Maven, comment afficher le chemin de classe utilisé?

Pour mes besoins actuels, j'ai un projet Maven qui crée un fichier war, et je veux voir quel chemin de classe réel il utilise lors de la création du war. Existe-t-il un moyen de le faire en une seule commande - sans avoir à compiler l'intégralité du projet?

Une idée est de faire générer par Maven le target/classpath.properties fichier, puis arrêtez-vous à ce point.

mavenclasspathwarmaven-war-plugin
42
Alexander Bird

Pour obtenir le chemin de classe par lui-même dans un fichier, vous pouvez:

mvn dependency:build-classpath -Dmdep.outputFile=cp.txt

Ou ajoutez ceci au POM.XML:

<project>
  [...]
  <build>
    <plugins>
      <plugin>
        <groupId>org.Apache.maven.plugins</groupId>
        <artifactId>maven-dependency-plugin</artifactId>
        <version>2.9</version>
        <executions>
          <execution>
            <id>build-classpath</id>
            <phase>generate-sources</phase>
            <goals>
              <goal>build-classpath</goal>
            </goals>
            <configuration>
              <!-- configure the plugin here -->
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  [...]
</project>

De: http://maven.Apache.org/plugins/maven-dependency-plugin/usage.html

69
Janik Zikovsky

ou appelez "mvn -e -X ...." et vérifiez la sortie ...

14
Philip Helger

Cette commande sorties le chemin de classe sur Mac et Linux:

mvn -q exec:exec -Dexec.executable=echo -Dexec.args="%classpath"

Faire imprimer le résultat et non l'enregistrer dans un fichier peut être utile, par exemple, lors de l'affectation du résultat à une variable dans un script Bash. Cette solution fonctionne uniquement sur Mac et Linux, mais les scripts Bash Shell aussi.

Sous Windows (par exemple dans les fichiers BAT), où il n'y a pas d'exécutable echo, vous aurez besoin de quelque chose comme ceci (non testé):

mvn -q exec:exec -Dexec.executable=cmd -Dexec.args="/c echo %classpath"

Alternativement, vous pouvez simplement exécuter le programme Java avec le chemin de classe:

mvn -q exec:exec -Dexec.executable=Java -Dexec.args="-cp %classpath Main"

Ou même comme ça (il utilisera automatiquement le chemin de classe correct):

mvn -q exec:Java -Dexec.mainClass="Main"

Cependant, ces deux approches alternatives souffrent de Maven ajoutant ses messages d'erreur lorsque votre programme échoue.

8
Danila Piatov

La commande mvn dependency:list listera le chemin de classe avec tous les fichiers JAR utilisés pour la compilation, le runtime et le test au format suivant:

INFO] --- maven-dependency-plugin:2.8:list (default-cli) @ MyProject ---
[INFO]
[INFO] The following files have been resolved:
[INFO]    org.netbeans.api:org-openide-filesystems:jar:RELEASE80:compile
[INFO]    org.netbeans.api:org-netbeans-modules-queries:jar:RELEASE80:compile
[INFO]    org.netbeans.api:org-netbeans-api-progress:jar:RELEASE80:compile
[INFO]    org.netbeans.api:org-openide-dialogs:jar:RELEASE80:compile
[INFO]    org.Apache.derby:derby:jar:10.11.1.1:compile
[INFO]    org.netbeans.api:org-openide-windows:jar:RELEASE80:compile

La seule exigence est que la compilation soit terminée. Cela ne fonctionne pas si la compilation n'est pas exécutée.

Une autre commande est la commande mvn dependency:tree.

6
Paul Guralivu

Comme ecerulm l'a noté dans son commentaire à réponse de Janik , vous pouvez spécifier la portée de dependency:build-classpath, car la sortie du chemin de classe différera pour différentes portées (par défaut test est utilisé pour une raison quelconque). Je me suis retrouvé avec une commande comme celle-ci:

mvn -DincludeScope=compile dependency:build-classpath

Au sein du POM, il pourrait être utilisé comme ceci:

<project>
  [...]
  <build>
    <plugins>
      <plugin>
        <groupId>org.Apache.maven.plugins</groupId>
        <artifactId>maven-dependency-plugin</artifactId>
        <version>2.9</version>
        <executions>
          <execution>
            <id>build-classpath</id>
            <phase>generate-sources</phase>
            <goals>
              <goal>build-classpath</goal>
            </goals>
            <configuration>
              <includeScope>compile</includeScope>
              <!-- Omit to print on console: -->
              <outputFile>${project.build.directory}/compile-classpath.txt</outputFile>
            </configuration>
          </execution>
          <execution>
            <id>build-test-classpath</id>
            <phase>generate-test-sources</phase>
            <goals>
              <goal>build-classpath</goal>
            </goals>
            <configuration>
              <includeScope>test</includeScope>
              <!-- Omit to print on console: -->
              <outputFile>${project.build.directory}/test-classpath.txt</outputFile>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  [...]
</project>

Cela produira 2 versions de classpath, une pour la construction principale et l'autre pour les tests.

2
Pavel S.

Il s'agit d'une solution de commande unique mais compile le code .

mvn -e -X -Dmaven.test.skip=true clean compile | grep -o -P '\-classpath .*? ' | awk '{print $2}'

Exemple d'utilisation du script shell 

MAVEN_CLASSPATH=$(mvn -e -X -Dmaven.test.skip=true clean compile | grep -o -P '\-classpath .*? ' | awk '{print $2}')

J'en ai utilisé une variante dans un script Shell pour exécuter un principal autonome () (pour la génération de schéma Hibernate) de cette façon

#/bin/bash

MAVEN_TEST_CLASSPATH=$(mvn -e -X clean package | grep -o -P '\-classpath .*?test.*? ')

Java $MAVEN_TEST_CLASSPATH foo.bar.DBSchemaCreate

Exemple de sortie de fichier 

mvn -e -X -Dmaven.test.skip=true clean compile | grep -o -P '\-classpath .*? ' | awk '{print $2}' > maven.classpath
1
ElMesa