Differences Between Classpath and Sourcepath

Last updated: January 16, 2024

Written by: Deboshree Banerjee

Reviewed by: Eric Martin

Core Java

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Introduction

In Java, we often come across the terms sourcepath and classpath. Although these terms may seem similar at first, they have different functions in the compilation and execution of a program. While both of them help locate files, they have some distinct differences.

In this tutorial, we’ll explore the nuances of sourcepath and classpath and understand the distinction in their usage.

2. sourcepath

sourcepath is used by the compiler to locate the source code files that are needed to compile the Java program. It specifies the directories where the compiler should look for source files when compiling the program.

If the source files are located in a directory or multiple directories, they are specified using the -sourcepath option during compilation.

3. Specifying sourcepath Through Command-Line

Suppose we have a project with the following directory structure:

my-project/
|-- src/
|   |-- Main.java
|   |-- Utils.java
|-- test/
|   |-- TestMain.java

The source files are in the src directory, and the test files are in the test directory. To compile the project, we need to specify the location of the source files using the -sourcepath option:

$ javac -sourcepath ./src/ ./src/Main.java ./src/Utils.java

This command tells the Java compiler to look for source files in the “src” directory. However, we still need to specify the path to each individual source file we want to compile relative to the source directory. This is necessary for the compiler to know the exact location of each source file within the source directory.

4. classpath

classpath is used by the JVM (Java Virtual Machine) to locate compiled classes and other resources that are needed to run the Java program. It specifies the directories where the JVM should look for class files when executing the program.

During the execution process, the Java interpreter uses the classpath to locate the compiled Java class files needed to run the program. The interpreter reads the bytecode from the class files and executes the program accordingly.

If the compiled classes are located in a directory or multiple directories, they are specified using the –classpath option during execution.

5. Specifying classpath Through Command-Line

Suppose we have a project with the following directory structure:

my-project/
|-- src/
|   |-- Main.java
|   |-- Utils.java

Here, the source files are in the src directory. To compile and run the project, we need to specify the classpath:

$ javac -classpath ./src/ ./src/Main.java ./src/Utils.java

This command tells the compiler to use the src directory for any external dependencies.

Once the code is compiled, we can run the program using the same classpath:

$ java -classpath src Main

This command tells the interpreter to use the compiled Main class file located in the src directory.

6. Using classpath With the javac and java Commands

The javac command uses the –classpath option to specify the location of compiled .class files and external libraries (such as JAR files) needed by the Java compiler.

Similarly, the java command uses the -classpath option to specify the location of files and external libraries that the Java program needs to access during runtime.

7. Omitting sourcepath and Only Using classpath

If the -sourcepath option isn’t specified, the Java compiler searches for source files in the directories specified in the user classpath (specified with the -classpath option), as well as in the current working directory.

The -sourcepath option could be omitted if the source files are located in a directory that’s already included in the classpath. In this case, the compiler will still be able to find and compile the source files.