In Maven, how output the classpath being used?

Question

For my current purposes I have a Maven project which creates a war file, and I want to see what actual classpath it is using when creating the war. Is there a way to do that in a single command -- without having to compile the entire project?

One idea is to have Maven generate the target/classpath.properties file and then stop at that point.

Answer 1

To get the classpath all by itself in a file, you can:

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

Or add this to the 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>

From: http://maven.apache.org/plugins/maven-dependency-plugin/usage.html

Answer 2

or call "mvn -e -X ...." and check the output...

Answer 3

This command outputs the classpath on Mac and Linux:

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

Having the result printed and not saved into a file might be useful, for instance, when assigning the result to a variable in a Bash script. This solution runs on Mac and Linux only, but so do Bash shell scripts.

In Windows (e.g. in BAT files), where there is no echo executable, you will need something like this (untested):

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

---

Alternatively, you can just execute java program with the classpath:

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

Or even like that (it will use the correct classpath automatically):

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

However, both these alternative approaches suffer from Maven adding its error messages when your program fails.

Answer 4

The command mvn dependency:list will list the classpath with all the jars used for compilation, runtime and test in the following format:

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

The only requirement is that the compilation is finished. It doesn't work if the compilation isn't ran.

An other command is The command mvn dependency:tree.

Answer 5

As ecerulm noted in his comment to Janik's answer, you may want to specify the scope to dependency:build-classpath, as classpath output will differ for different scopes (by default test is used for some reason). I've ended up with a command like this:

mvn -DincludeScope=compile dependency:build-classpath

Within the POM, it could be used like this:

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

This will output 2 versions of classpath, one for main build and the other for tests.

Answer 6

This is a single command solution but does compile the code.

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

• It's based in Philip Helger's previous answer (Thanks by the way)

Shell script example usage

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

I used a variation of it in a shell script to run a standalone main() (for Hibernate schema generation) this way

#/bin/bash

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

java $MAVEN_TEST_CLASSPATH foo.bar.DBSchemaCreate

File output example

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