How does Docker work with Java?

Docker works with Java by packaging applications and dependencies into portable containers. To run a Java app in Docker, create a Dockerfile that defines the build steps. A basic Dockerfile uses a Java base image like openjdk:17-jdk-slim, sets a working directory, copies the JAR file, and specifies the entry command. Then, build the image with docker build -t my-java-app and run it with docker run. Choosing the right base image matters for stability, size, and licensing—options include eclipse-temurin, openjdk, and adoptopenjdk. For optimization, use multi-stage builds to reduce image size, group commands to minimize layers, and prefer slim or Alpine-based images. Handle configuration via environment variables or mounted volumes and manage logging via stdout/stderr or persistent volumes for debugging.

Docker works with Java by packaging Java applications and their dependencies into lightweight, portable containers. This setup ensures the app runs consistently across different environments—whether it’s your local machine, a testing server, or production. The main idea is that Docker wraps up everything your Java app needs (like the JVM, libraries, config files, etc.) into an image, which can then be run anywhere as a container.

How to Run a Java App in Docker

To get a Java application running in Docker, you typically create a Dockerfile. This file defines the steps needed to build your Docker image.

Here's a basic example:

# Use an official Java runtime as the base image
FROM openjdk:17-jdk-slim

# Set the working directory inside the container
WORKDIR /app

# Copy the compiled JAR file into the container
COPY my-app.jar app.jar

# Specify the command to run the Java application
ENTRYPOINT ["java", "-jar", "app.jar"]

Once you have this file, you can build the image using:

docker build -t my-java-app .

And run it like this:

docker run -p 8080:8080 my-java-app

This way, your Java app is now containerized and ready to go.

Choosing the Right Java Base Image

One of the most important decisions when using Docker with Java is choosing the right base image. Common choices include:

• eclipse-temurin: Official Temurin images maintained by the Eclipse Foundation.
• openjdk: Open source images (though less actively maintained these days).
• adoptopenjdk/openjdkXX-ubuntu: Previously popular, but AdoptOpenJDK has moved to Adoptium under Temurin.

You should pick based on:

• Stability and support
• Size (slim versions are better for smaller images)
• License concerns (some companies prefer Temurin for enterprise use)

For example, if you're building a Spring Boot app, using eclipse-temurin:17-jdk-jammy might be a good fit because it’s well-maintained and comes with a full JDK.

Optimizing Docker Builds for Java Apps

Java apps can lead to large Docker images if not handled carefully. Here are a few ways to keep things lean:

• Use multi-stage builds — compile your code in one stage and copy only the final JAR to a minimal runtime image.
• Avoid unnecessary layers — group commands where possible to reduce image size.
• Use slim or alpine-based images — especially in production.

Example of a multi-stage build:

# Build stage
FROM maven:3.8.6-jdk-17 AS build
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:resolve
COPY . .
RUN mvn package

# Runtime stage
FROM eclipse-temurin:17-jdk-alpine
WORKDIR /app
COPY --from=build /app/target/my-app.jar app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]

This approach keeps the final image small and clean while still letting you build your project inside Docker.

Handling Configuration and Logging

When running Java apps in Docker, configuration and logging need special attention.

• Configuration: Externalize your config using environment variables or config files mounted as volumes. For example:

  docker run -e SPRING_PROFILES_ACTIVE=prod my-java-app

• Logging: Don’t write logs to a file unless necessary. Instead, let the app log to stdout/stderr so Docker can capture them directly. You can view logs using:

  docker logs <container_id>

If you must write logs to a file, mount a volume to persist them:

docker run -v ./logs:/var/log/myapp my-java-app

This helps with debugging and monitoring without bloating your container.

That’s basically how Docker works with Java. It’s straightforward once you get the basics down, but there are plenty of small details—like picking the right base image or optimizing your build—that can make a big difference.

The above is the detailed content of How does Docker work with Java?. For more information, please follow other related articles on the PHP Chinese website!