Spring Boot With Docker Example

In this tutorial you’ll see how to build a Docker image for running a Spring Boot application. We’ll create a basic DockerFile to dockerize a Spring Boot MVC application where view is created using Thymeleaf.

Maven Dependencies

Since we are creating a web application so we need a spring-boot-starter-web, for Thymeleaf we need spring-boot-starter-thymeleaf, spring-boot-maven-plugin is also added to our pom.xml. This plugin provides many convenient features-

  • It helps to create an executable jar (über-jar), which makes it more convenient to execute and transport your service.
  • It also searches for the public static void main() method to flag the class having this method as a runnable class.
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

Classes for Spring Boot Web Application

We’ll add a simple controller for our web application.

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

public class MessageController {
  public String showMessage(Model model) { 
    model.addAttribute("msg", "Welome to Docker");
    return "message";

View class (Thymeleaf template)

In src/main/resources added a new folder Templates and in that created a message.html file.

<!DOCTYPE html>
<meta charset="UTF-8">
<title>Spring Boot With Docker</title>
    <p th:text="${msg}"></p>

Application Class

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

public class SpringBootProjectApp {
  public static void main(String[] args) {
    SpringApplication.run(SpringBootProjectApp.class, args);

Running the application

You can run this Spring Boot web application as a stand alone Java application but we’ll run it by creating an executable jar.

For creating a completely self-contained executable jar file run mvn package from the command line. Note that you should be in your Spring Boot project directory.

knpcode:SprinBootProject$ mvn package

To run application using the created jar, you can use the java -jar command, as follows-

java -jar target/SprinBootProject-0.0.1-SNAPSHOT.jar

But we’ll do the samething by creating a DockerFile.


For running in your application in Docker container you need to create an image which is a read-only template with instructions for creating a Docker container.

For creating Docker image you create a Dockerfile which is a text file with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image.

Create a text file with in your project directory named DockerFile and copy the following text in it.

FROM openjdk:8-jdk-alpine

ARG JAR_FILE=target/SprinBootProject-0.0.1-SNAPSHOT.jar

COPY ${JAR_FILE} app.jar

ENTRYPOINT ["java","-jar","/app.jar"]
  1. Often, an image is based on another image, with some additional customization. This is true in our case too and the base image used here is openjdk:8-jdk-alpine
    This image is based on the popular Alpine Linux project which is much smaller than most distribution base images (~5MB), and thus leads to much slimmer images in general.
  2. Then assign a name to the jar path.
  3. Copy jar file.
  4. Execute jar using the ENTRYPOINT instruction by providing arguments in the following form-
    ENTRYPOINT [“executable”, “param1”, “param2”]
    Which makes it equivalent to java -jar target/SprinBootProject-0.0.1-SNAPSHOT.jar

Create a docker image

You can create a Docker image by running command in the following form-

sudo docker build -t name:tag .

For our project command to create a docker image-

sudo docker build -t sbexample:1.0 .

. means using the current directory as context
tag the image as sbexample:1.0

To create a container (run an image)

The docker run command must specify an image to derive the container from.

sudo docker run -d -p 8080:8080 sbexample:1.0

Here options are-

-d To start a container in detached mode (to run the container in the background )
-p Publish all exposed ports to the host interfaces

If every thing works fine then you will have a dockerized Spring Boot application at this point which you can access by typing URL http://localhost:8080/ in a browser

Spring Boot With Docker

If you want to see the running containers use following command

sudo docker ps

To stop a running container use following command

sudo docker stop container_id

Related Posts

  • Spring Boot Microservices Eureka + Ribbon
  • Spring Boot Microservices + Hystrix Circuit Breaker
  • Spring Boot + Spring Data JPA + MySQL + Spring RESTful
  • Spring Boot + Data JPA + Oracle One to Many Example
  • Spring Boot MVC Form Validation Example
  • Spring Boot Example Using Spring Tool Suite (STS)
  • spring-boot-starter-parent in Spring Boot
  • Spring Expression Language (SpEL) Tutorial
  • That’s all for the topic Spring Boot With Docker Example. If something is missing or you have something to share about the topic please write a comment.

    You may also like

  • Injecting Prototype Bean into a Singleton Bean in Spring
  • Spring Bean Definition Inheritance
  • Java Callable And Future With Examples
  • Serialization Proxy Pattern -readResolve() and writeReplace()
  • Compare Two Strings in Java – equals, compareTo() methods
  • Combiner in Hadoop MapReduce
  • Share this post:

    Leave a Reply

    Your email address will not be published.

    This site uses Akismet to reduce spam. Learn how your comment data is processed.