Building and Deploying Your First Java App with Docker in Just 5 Minutes

Published at

1/13/2025

Dependencies Setup

Step 1: Prerequisites

Install Java 8
Install Maven
Install Docker
Install VS Code + Extensions

Mac Installation

# Install Homebrew if not present
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install Java 8
brew tap homebrew/cask-versions
brew install --cask temurin8

# Install Maven
brew install maven

# Install Docker Desktop
brew install --cask docker

# Install VS Code
brew install --cask visual-studio-code

# Install VS Code Extensions
code --install-extension vscjava.vscode-java-pack
code --install-extension ms-azuretools.vscode-docker

Windows Installation

# Install Chocolatey if not present
Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))

# Install Java 8
choco install temurin8

# Install Maven
choco install maven

# Install Docker Desktop
choco install docker-desktop

# Install VS Code
choco install vscode

# Install VS Code Extensions
code --install-extension vscjava.vscode-java-pack
code --install-extension ms-azuretools.vscode-docker

Project Setup (Both Platforms)

# Create project structure
mkdir -p simple-service
cd simple-service

VS Code Settings

{
    "java.configuration.runtimes": [
        {
            "name": "JavaSE-1.8",
            "path": "/Library/Java/JavaVirtualMachines/temurin-8.jdk/Contents/Home",
            "default": true
        }
    ],
    "java.configuration.updateBuildConfiguration": "automatic",
    "java.compile.nullAnalysis.mode": "automatic",
    "maven.executable.path": "/usr/local/bin/mvn"
}

Verify Installation

# Verify Java
java -version

# Verify Maven
mvn -version

# Verify Docker
docker --version

Project Setup

# Create Maven project
mvn archetype:generate \
  -DgroupId=com.example \
  -DartifactId=simple-service \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DarchetypeVersion=1.4 \
  -DinteractiveMode=false

Creating the test app

After the last step you should have simple-service directory with the pre-builded structure.

Step 1

Update pom.xml file

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>simple-service</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>simple-service</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.httpcomponents.client5</groupId>
        <artifactId>httpclient5</artifactId>
        <version>5.4</version>
    </dependency>
</dependencies>
<properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>com.example.App</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Step 2

Add logic to App.java

package com.example;

import com.sun.net.httpserver.HttpServer;
import java.net.InetSocketAddress;
import java.io.IOException;
import java.io.OutputStream;

public class App {
    public static void main(String[] args) throws IOException {
        HttpServer server = HttpServer.create(new InetSocketAddress(1800), 0);
        server.createContext("/", (exchange -> {
            String response = "Hello from Java!";
            exchange.sendResponseHeaders(200, response.length());
            try (OutputStream os = exchange.getResponseBody()) {
                os.write(response.getBytes());
            }
        }));
        server.setExecutor(null);
        server.start();
        System.out.println("Server started on port 1800");
    }
}

Quick explanations:

Imports & Setup
- Uses built-in com.sun.net.httpserver package
- Creates simple HTTP server without external dependencies
- Runs on port 1800
Server Configuration

HttpServer.create()

Creates new server instance

InetSocketAddress(1800)

Binds to port 1800
0 - Default backlog value for connection queue

Request Handling

createContext("/")

Handles all requests to root path "/"
Lambda expression defines request handler
Returns "Hello from Java!" for all requests

Response Flow
- Sets response code 200 (OK)
- Sets content length
- Writes response bytes to output stream
- Auto-closes stream with try-with-resources
Server Start

setExecutor(null)

Uses default executor

server.start()

Starts listening for requests
Prints confirmation message

Step 3

Create Dockerfile in the root of the project:

FROM amazoncorretto:8
WORKDIR /app
COPY target/simple-service-1.0-SNAPSHOT.jar app.jar
EXPOSE 1800
CMD ["java", "-jar", "app.jar"]

Step 4
Create docker-compose.yml to build and map container to port 1800

services:
  app:
    build: .
    ports:
      - "1800:1800"
    restart: unless-stopped

Step 5
Create build.sh

#!/bin/bash
mvn clean package
docker compose build
docker compose up

And allow exec permission for this file in terminal:

chmod +x build.sh

Build and execute the app

Simply run

./build.sh

You should have project builded, image created and container executed.

To test the app simply open the browser at the address http://localhost:1800/

Happy Coding!

dev-resources.site