How to Package Java Apps with One-JAR Distributing Java applications can be challenging. Standard JAR files contain your compiled code but leave out the third-party libraries your application relies on. This forces users to manage a complex classpath. One-JAR solves this problem by nesting all dependency JARs inside a single, executable archive. Here is how to package your Java application using One-JAR. What is One-JAR?
One-JAR is an open-source packaging tool. Unlike “fat JAR” solutions that unpack and merge all dependency classes into one giant folder, One-JAR keeps dependency JARs intact. It uses a custom class loader to read the nested JAR files directly at runtime. This prevents resource overwrites and filename conflicts. Step 1: Set Up the Directory Structure
To build a One-JAR manually, you must organize your project files into a specific hierarchy. Create a working directory with the following structure: my-app-one-jar.jar (The root folder/archive) main/: Contains your application’s primary code JAR. lib/: Contains all third-party dependency JARs.
com/simontuffs/onejar/: Contains the One-JAR boot class files. META-INF/: Contains the MANIFEST.MF file. Step 2: Download the One-JAR Bootstrapping Classes
One-JAR requires its own launcher classes to handle the custom class loading. Download the latest One-JAR binary distribution. Extract the com/simontuffs/onejar/ class framework.
Place this folder directly into the root of your packaging directory. Step 3: Configure the Manifest File
The MANIFEST.MF file tells the Java Virtual Machine (JVM) how to launch the application. Create a text file named MANIFEST.MF inside the META-INF folder. It must include the following attributes:
Manifest-Version: 1.0 Main-Class: com.simontuffs.onejar.Boot One-Jar-Main-Class: com.yourcompany.project.MainClassName Use code with caution.
Main-Class: Always points to the One-JAR boot loader (com.simontuffs.onejar.Boot).
One-Jar-Main-Class: Points to your actual application entry point containing the public static void main method. Step 4: Package the Application
Once your files are organized, use the standard Java Archive tool to bundle everything together. Navigate to your root working directory in your terminal and execute the following command:
jar -cmf META-INF/MANIFEST.MF my-application.jar com/ lib/ main/ Use code with caution.
This command fuses the manifest, the One-JAR launcher, the dependencies, and your application code into a single executable called my-application.jar. Step 5: Run the Executable
Your application is now fully self-contained. Users only need a Java Runtime Environment (JRE) installed to run your app with a simple terminal command: java -jar my-application.jar Use code with caution. Automation with Build Tools
While manual packaging helps you understand the underlying mechanism, packaging by hand becomes tedious. You can automate this workflow using build tools:
Ant: One-JAR provides a dedicated Ant task (com.simontuffs.onejar.ant.OneJarTask) to integrate packaging directly into your build scripts.
Maven: The onejar-maven-plugin can be attached to your build lifecycle to automatically generate the One-JAR artifact during the package phase.
By utilizing One-JAR, you streamline deployment, eliminate classpath configuration errors, and provide a clean, single-file software delivery experience for your users. If you want to automate this process, let me know: Which build tool you use (Maven, Gradle, or Ant)? Your Java version?
I can provide the exact configuration script for your project.
Leave a Reply