Building and Deploying Your First Java App with Docker in Just inutes

Let's create a simple java app which returns text and available on port 1800 of your local environment using Docker container in 5 minutes (depends on your internet connection speed).

You can always grab the full source code from my public repository:
https://github.com/alexander-uspenskiy/simple-service

Dependencies Setup

Step 1: Prerequisites

1. Install Java 8
2. Install Maven
3. Install Docker
4. 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

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:

1. Imports & Setup

   • Uses built-in com.sun.net.httpserver package
   • Creates simple HTTP server without external dependencies
   • Runs on port 1800

2. Server Configuration

HttpServer.create()

• Creates new server instance

InetSocketAddress(1800)

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

1. Request Handling

createContext("/")

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

1. Response Flow

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

2. 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:

# 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

Build and execute the app

Simply run

# 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

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!

The above is the detailed content of Building and Deploying Your First Java App with Docker in Just inutes. For more information, please follow other related articles on the PHP Chinese website!