Dockerizing a Java Application

Last updated: January 16, 2024

Written by: Sumit Pal Singh

Docker

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.

1. Overview

In this article, we’ll show how to Dockerize a Java runnable jar-based application. Do read about the benefits of using Docker.

2. Building the Runnable Jar

We’ll be using Maven to build a runnable jar.

So, our application has a simple class, HelloWorld.java, with a main method:

public class HelloWorld {
    public static void main(String[] args){
        System.out.println("Welcome to our application");
    }
}

And we’re using the maven-jar-plugin to generate a runnable jar:

<plugin>
   <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
     <version>${maven-jar-plugin.version}</version>             
      <configuration>
          <archive>
             <manifest>
              <mainClass>com.baeldung.HelloWorld</mainClass>
              </manifest>
           </archive>
       </configuration>
</plugin>

3. Writing the Dockerfile

Let’s write the steps to Dockerize our runnable jar in a Dockerfile. The Dockerfile resides in the root directory of the build context:

FROM openjdk:17-jdk-alpine
MAINTAINER baeldung.com
COPY target/docker-java-jar-0.0.1-SNAPSHOT.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

Here, in the first line, we’re importing the OpenJDK Java version 17 image as our base image from their official repository. Subsequent lines will create additional layers over this base image as we advance.

In the second line, we specify the maintainer for our image, which is baeldung.com in this case. This step doesn’t create any additional layers.

In the third line, we create a new layer by copying the generated jar, docker-java-jar-0.0.1-SNAPSHOT.jar, from the target folder of the build context into the root folder of our container with the name app.jar.

And in the final line, we specify the main application with the unified command that gets executed for this image. In this case, we tell the container to run the app.jar using the java -jar command. Also, this line does not introduce any additional layer.

4. Building and Testing the Image

Now that we have our Dockerfile, let’s use Maven to build and package our runnable jar:

mvn package

After that, let’s build our Docker image:

docker image build -t docker-java-jar:latest .

Here, we use the -t flag to specify a name and tag in <name>:<tag> format. In this case, docker-java-jar is our image name, and the tag is latest. The “.” signifies the path where our Dockerfile resides. In this example, it’s simply the current directory.

Note: We can build different Docker images with the same name and different tags.

Finally, let’s run our Docker image from the command line: