Ways to Add JARs to Classpath in Java

1. Introduction

While working on Java projects, we often rely on external libraries to write our applications.

In this article, we’ll examine different methods for adding these libraries as JARs on the classpath.

2. Using -cp or -classpath on the Command Line

First, if we’re launching our program from the command line, it can make sense to specify our JAR dependencies as part of the command:

java -cp /path/to/jar/file.jar com.example.MyClass

Here, /path/to/jar/file.jar is the path to the JAR file and com.example.MyClass is the class to be executed.

We can also add multiple jars:

java -cp “lib/jar1.jar:lib/jar2.jar" com.example.MyClass

3. Using CLASSPATH on the Command Line

There might be scenarios where the same JAR is needed to run multiple Java programs on the same machine.

In this case, instead of specifying the classpath in every command, we can set the CLASSPATH environment variable in macOS/Linux:

export CLASSPATH=/path/to/jar/file.jar

Here’s how we can do the same in Windows:

set CLASSPATH=C:\path\to\jar\file.jar

Once we set the CLASSPATH, we can run our Java programs without specifying the –classpath option.

It’s important to note that if we set the CLASSPATH like this, it remains valid only for that terminal session. Once the terminal is closed, the setting is lost. We can add the classpath as an environment variable to make it permanent.

4. Specifying the Classpath in a MANIFEST.MF File

When we create a self-contained application, it’s helpful to bundle all the dependent JARs into one application JAR.

To do this, we need to include the classpath in the JAR file’s MANIFEST.MF file:

Manifest-Version: 1.0
Class-Path: lib/jar1.jar lib/jar2.jar
Main-Class: com.example.MainClass

Then we add this manifest when creating our application JAR:

jar cvfm app.jar MANIFEST.MF -C /path/to/classes .

We can then run it:

java -jar app.jar

This includes lib/jar1.jar and lib/jar2.jar on the classpath.

It’s important to note that the Class-Path option takes precedence over the CLASSPATH environment variable as well as the –classpath command-line option.

5. Adding JARs to the lib/ext Directory

Adding JARs in the lib/ext directory of the Java installation is a legacy mechanism, where JAR files placed in it are automatically added to the classpath. However, this isn’t a recommended approach for most use cases.

Since these JARs are loaded by the external classloader, they take priority over JARs specified in the CLASSPATH environment variable or directories specified in –classpath or –cp option.

6. Adding JARs in Eclipse/Intellij IDE

We can easily add JAR files to our project’s classpath using popular IDEs like Eclipse or IntelliJ. Both IDEs provide user-friendly interfaces to include external libraries in our project.

For detailed instructions, we can refer to the IDE-specific documentation for the most accurate and up-to-date guidance.

7. Using a Build Tool

While the above methods work well for small projects, projects both large and small can take advantage of a build tool. Maven and Gradle are the popular build tools used for this purpose.

Assuming that our project follows a standard Maven project structure, we can include a dependency and its transitive dependencies in our project:

<dependencies>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>example-library</artifactId>
        <version>1.0.0</version>
    </dependency>
</dependencies>

Let’s run the command:

mvn package

Maven includes these JARs in the classpath for us.

We can also use the idea of a build tool in combination with an IDE to further simplify adding JARs to our classpath.

8. Conclusion

Using external libraries is a fundamental task in Java development.

The way we add JARs depends on the project’s complexity and requirements. For quick tests or scripts, a simple command line option may suffice. For large-scale projects, we likely need to use a robust tool like Maven or Gradle to manage project dependencies.