How to Create a Fat/Uber JAR in Three Ways?

Konrad Drozd29 November 2020

In today’s post, I’d like to show you three ways to build an executable JAR file and prove that you don’t need to be a magician to create such a file. The reason for this is that the JAR is nothing more than a ZIP file with proper structure, and the extension changed to .jar. Actually, you don’t even really need to change the extension to .jar.

The first way to create an executable JAR is to manually build the artifact in the terminal. By presenting this approach, I would like to show how much the building tools and IDE itself make our lives easier.

In the second example, we will use the support provided by the IntelliJ IDE. Generating executable JARs from the IDE is possible and very easy, but not very practical. It is mainly suitable for small projects or one-time creation because IDE settings are not usually committed to the repository. It is also not very useful in case of continuous integration/deployment processes.

The last (recommended) approach is to create an executable JAR with the build tool (e.g. Maven, Gradle). This is the best approach as the configuration is committed to the repository, the artifact generation is independent of the IDE, and it is effortless to integrate this process into continuous integration/deployment.

What Is a Fat, Uber, Executable JAR File?

‘JAR stands for Java ARchive. It’s a file format based on the popular ZIP file format and is used for aggregating many files into one. […] A JAR file is essentially a zip file that contains an optional META-INF directory.’ ~ Oracle (JAR File Specification)

From our point of view, a JAR file is just a bunch of classes that we want to use and a META-INF directory which contains a MANIFEST.MF file. The file specifies where is our public static void main(String[] args) method. Additionally, terms fat or uber mean that in addition to bytes of our application, we will also include the external libraries that are needed to run the application. In other words, this artifact will have everything you need to run the application on a Java Runtime environment using a java -jar myApp.jar command.

If you want to learn more about the different approaches to JAR packaging, I recommend this article: The Skinny on Fat, Thin, Hollow, and Uber..

About the Application

The application will provide a command-line-interface in which you can enter some data. This data will then be saved to a .json file. What the application does is irrelevant. The only important thing is that it needs a 3rd party to work (Jackson library). The code is available on GitHub.

Let’s create some simple model class:

package com.company.model;

public class Client {

    private final String name;
    private final String surname;
    private final String email;

    public Client(String name, String surname, String email) {
        this.name = name;
        this.surname = surname;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public String getSurname() {
        return surname;
    }

    public String getEmail() {
        return email;
    }
}

and our main method:

package com.company;

import com.company.model.Client;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) throws IOException {

        Client client = readClientDataFromCli();

        writeClientToJson(client, "client.json");
    }

    private static Client readClientDataFromCli() {
        Scanner sc = new Scanner(System.in);
        System.out.println("Insert client data.");

        System.out.print("Name: ");
        String name = sc.next();

        System.out.print("Surname: ");
        String surname = sc.next();

        System.out.print("Email: ");
        String email = sc.next();

        return new Client(name, surname, email);
    }

    private static void writeClientToJson(Client client, String fileName) throws IOException {
        File outputFile = new File(fileName);
        outputFile.createNewFile();

        ObjectMapper mapper = new ObjectMapper();
        mapper.writeValue(outputFile, client);
    }
}

Now, our IDE is so smart that it allows to run this code straight from the IDE, but let’s try to build executable JAR.

Variant #1 – Build the Executable JAR Manually in Terminal

In this case, we can close our IDE and do everything from the terminal. First, we need to manually download all the dependencies that we have used in our code. Things can get a little tricky as the dependencies we used may depend on other libraries and those libraries depend on others and so on…

In our case the only dependency that we have used is jackson-databind. In the mvnrepository.com we can see that it needs two other libraries to compile: jackson-annotations and jackson-core. Luckily, none of them depend on any more libraries.

jackson-databind 2.11.3 compile dependencies

Project Structure (File -> Project Structure)


`javac`	Reads Java class and interface definitions and compiles them into bytecode and class files.
`-cp` `[-classpath]`	Specifies where to find user class files, and (optionally) annotation processors and source files.
`-d` `[-directory]`	Sets the destination directory for class files. The directory must already exist because javac does not create it.

How to Create a Fat/Uber JAR in Three Ways?

What Is a Fat, Uber, Executable JAR File?

About the Application

Variant #1 – Build the Executable JAR Manually in Terminal

Variant #2 – Build the Uber JAR With Intellij IDE Support

Variant #3 – Build the Fat JAR With Maven and Gradle

Summary

Other articles: