Docker容器Java项目打包与部署全过程

2025-11-10 10:42 开发作者： Zestapse

一、基础概念

（一）Docker镜像

Docker镜像是一个包含代码、运行时环境、库、环境变量和配置文件的不可变模板，它是创建Docker容器的基础。如果把Docker容器比作按照食谱做出的食物，那么Docker镜像就是那份详细的食谱，里面精确地规定了制作这道“食物”所需的各种“食材”和“步骤”。

例如，一个用于运行Java项目的Docker镜像，会包含Java运行时环境（JRE）、项目的JAR包、项目运行所需的依赖库以及相关的配置信息等。当我们基于这个镜像创建容器时，就如同按照食谱制作食物，容器会依据镜像中的内容来运行Java项目。

（二）Java项目部署常见方式

传统的Java项目部署方式有很多，比如直接在服务器上安装JDK，然后将打包好的JAR包或WAR包上传到服务器，通过命令启动项目。这种方式需要手动配置服务器环境，包括安装JDK、设置环境变量、处理依赖等，不同服务器之间的环境可能存在差异，容易导致项目在不同环境中运行出现问题。

还有一种方式是使用虚拟机，在虚拟机中配置好Java运行环境，然后部署项目。但虚拟机资源占用较大，启动速度慢，且不易于扩展和管理。

而使用Docker部署Java项目，可以将项目及其依赖环境打包到一个镜像中，实现了“一次构建，到处运行”，避免了环境差异带来的问题，同时也便于项目的扩展、管理和版本控制。

二、Java项目准备

（一）Java项目结构

一个典型的Java项目结构如下：

my-java-project/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           ├── controller/
│   │   │           ├── service/
│   │   │           ├── model/
│   │   │           └── Main.java
│   │   └── resources/
│   │       ├── application.properties
│   │       └── logback.XML
│   └── test/
│       └── java/
│           └── com/
│               └── example/
│                   ├── controller/
│                   └── service/
├── pom.xml
└── README.md

src/main/java：存放项目的主要Java源代码。
src/main/resources：存放项目的配置文件、资源文件等。
src/test/java：存放项目的测试代码。
pom.xml：Maven项目的配置文件，用于管理项目的依赖、构建等信息。

（二）依赖管理

在Java项目中，通常使用Maven或Gradle进行依赖管理。以Maven为例，pom.xml文件中会定义项目所需的依赖，例如：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.7.0</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

当执行mvn clean package命令时，Maven会自动从远程仓库下载所需的依赖，并将其添加到项目的构建路径中。

（三）打包方式

Java项目常见的打包方式有JAR和WAR。

JAR（Java Archive）文件是一种用于打包Java类文件、相关资源和元数据的归档文件格式，通常用于封装独立的Java应用程序或库。对于Spring Boot项目，默认打包为JAR包，其中包含了嵌入式的Web服务器（如Tomcat），可以直接通过java -jar命令运行。
WAR（Web Application Archive）文件则是专为Web应用程序设计的归档格式，包含Servlet、JSP、html、css、javascript等Web相关资源。WAR包需要部署到外部的Web服务器（如Tomcat、Jetty）中才能运行。

在Docker部署中，如果是Spring Boot等包含嵌入式服务器的项目，选择JAR包更为方便，因为可以直接在容器中通过编程客栈java -jar命令启动。如果是传统的Web项目，没有嵌入式服务器，则需要打包为WAR包，并在Docker镜像中配置相应的Web服务器来部署。

三、Dockerfile编写

Dockerfile是一个文本文件，包含了一系列构建Docker镜像的指令。通过编写Dockerfile，可以定义如何将Java项目及其依赖环境打包到镜像中。

（一）基础镜像选择

选择合适的基础镜像是编写Dockerfile的第一步。对于Java项目，常用的基础镜像是openjdk。可以根据项目所需的Java版本选择相应的openjdk镜像，同时还可以选择不同的操作系统版本，如Alpine版本的镜像体积更小。

例如，选择openjdk 11的Alpine版本作为基础镜像：

FROM openjdk:11-jre-alpine

openjdk:11-jre-alpine表示该镜像包含Java 11的运行时环境（JRE），基于Alpine linux，体积较小，适合作为Java项目的基础镜像。

（二）工作目录设置

设置工作目录可以使后续的命令操作更加清晰，避免文件路径混乱。使用WORKDIR指令设置工作目录：

WORKDIR /app

该指令会在镜像中创建/app目录，并将后续命令的工作目录设置为/app。

（三）文件复制

需要将打包好的Java项目JAR包复制到镜像中。使用COPY指令：

COPY target/my-java-project-1.0.0.jar app.jar

这条指令将本地项目中target目录下的my-java-project-1.0.0.jar文件复制到镜像的/app目录下，并命名为app.jar。

（四）依赖安装

如果项目在运行过程中需要额外的依赖，可以通过相应的命令进行安装。例如，在Alpine基础镜像中安装一些工具：

RUN apk add --no-cache curl

apk是Alpine Linux的包管理工具，--no-cache表示不缓存包索引，减少镜像体积。这条指令会在镜像中安装curl工具。

（五）端口暴露

Java项目通常会占用一个端口运行，需要在镜像中暴露该端口，以便外部可以访问容器中的应用。使用EXPOSE指令：

EXPOSE 8080

这条指令表示该镜像中的应用会监听8080端口。需要注意的是，EXPOSE指令只是声明了容器运行时会使用的端口，并不会自动将端口映射到宿主机，还需要在运行容器时通过-p参数进行端口映射。

（六）启动命令设置

最后，需要设置容器启动时运行的命令，即启动Java项目。使用CMD指令：

CMD ["java", "-jar", "app.jar"]

这条指令表示当容器启动时，会执行java -jar app.jar命令，启动Java项目。

完整的Dockerfile示例：

# 基础镜像
FROM openjdk:11-jre-alpine

# 设置工作目录
WORKDIR /app

# 复制JAR包到镜像中
COPY target/my-java-project-1.0.0.jar app.jar

# 暴露端口
EXPOSE 8080

# 启动命令
CMD ["java", "-jar", "app.jar"]

四、镜像构建

编写好Dockerfile后，就可以使用docker build命令构建Docker镜像了。

（一）基本构建命令

在Dockerfile所在的目录下，执行以下命令：

docker build -t my-java-app:1.0.0 .

-t：指定镜像的标签，格式为仓库名:标签，这里my-java-app是镜像名，1.0.0是版本标签。
.：表示Dockerfile所在的当前目录，Docker会从该目录开始查找构建镜像所需的文件。

执行命令后，Docker会按照Dockerfile中的指令逐步构建镜像。构建过程中，会输出每一步的操作信息，如果出现错误，会提示相应的错误信息，需要根据错误信息修改Dockerfile或相关文件后重新构建。

（二）多阶段构建

多阶段构建可以减少镜像的大小，只将最终需要运行的文件复制到最终的镜像中，避免把构建过程中产生的不必要文件也包含进来。

例如，对于一个使用Maven构建的Java项目，可以分为两个阶段：

第一个阶段：使用包含Maven的基础镜像，进行项目的编译和打包，生成JAR包。
第二个阶段：使用openjdk的基础镜像，将第一个阶段生成的JAR包复制到该镜像中，作为最终的运行镜像。

多阶段构建的Dockerfile示例：

# 第一阶段：构建阶段
FROM maven:3.8.5-openjdk-11 AS builder

# 设置工作目录
WORKDIR /app

# 复制pom.xml和源代码
COPY pom.xml .
COPY src ./src

# 编译打包
RUN mvn clean package -jsDmaven.test.skip=true

# 第二阶段：运行阶段
FROM openjdk:11-jre-alpine

# 设置工作目录
WORKDIR /app

# 从第一阶段复制JAR包到当前镜像
COPY --from=builder /app/target/my-java-project-1.0.0.jar app.jar

# 暴露端口
EXPOSE 8080

# 启动命令
CMD ["java", "-jar", "app.jar"]

使用多阶段构建时，构建命令不变，仍然是docker build -t my-java-app:1.0.0 .。通过这种方式，最终的镜像只包含了运行Java项目所需的JRE和JAR包，大大减小了镜像体积。

（三）构建缓存优化

Docker在构建镜像时，会对每一步指令进行缓存，如果后续构建时指令没有变化，会直接使用缓存，从而提高构建效率。为了充分利用缓存，可以合理安排Dockerfile中指令的顺序。

通常，将变化较少的指令放在前面，变化较多的指令放在后面。例如，对于Maven项目，pom.xml文件的变化频率相对较低，而源代码的变化频率较高。在多阶段构建中，可以先复制pom.xml文件，下载依赖，然后再复制源代码进行编译打包。这样，当源代码发生变化时，只有复制源代码和编译打包的步骤会重新执行，而下载依赖的步骤可以利用缓存。

优化后的多阶段构建Dockerfile示例：

# 第一阶段：构建阶段
FROM maven:3.8.5-openjdk-11 AS builder

# 设置工作目录
WORKDIR /app

# 复制pom.xml
COPY pom.xml .

# 下载依赖
RUN mvn dependency:go-offline

# 复制源代码
COPY src ./src

# 编译打包
RUN mvn clean package -Dmaven.test.skip=true

# 第二阶段：运行阶段
FROM openjdk:11-jre-alpine

# 设置工作目录
WORKDIR /app

# 从第一阶段复制JAR包到当前镜像
COPY --from=builder /app/target/my-java-project-1.0.0.jar app.jar

# 暴露端口
EXPOSE 8080

# 启动命令
CMD ["java", "-jar", "app.jar"]

五、镜像测试和验证

构建好Docker镜像后，需要进行测试和验证，确保应用程序能正常启动和运行。

（一）运行容器

使用docker run命令运行容器：

docker run -d -p 8080:8080 --name my-java-container my-java-app:1.0.0

-d：表示后台运行容器。
-p 8080:8080：将宿主机的8080端口映射到容器的8080端口，这样可以通过宿主机的8080端口访问容器中的应用。
--name my-java-container：为容器指定一个名称。
my-java-app:1.0.0：指定要运行的镜像。

（二）检查容器状态

使用docker ps命令查看容器的运行状态：

docker ps

如果容器状态为Up，表示容器正在正常运行。如果容器没有正常运行，可以使用docker logs命令查看容器的日志，排查问题：

docker logs my-java-container

（三）访问应用程序

通过浏览器或curl命令访问宿主机的8080端口，检查应用程序是否能正常响应。例如：

curl http://localhost:8080

如果能得到应用程序的正常响应，说明镜像构建和部署成功。

六、Docker镜像仓库

Docker镜像仓库用于存储和管理Docker镜像，方便在不同环境中拉取和使用镜像。

（一）公共镜像仓库

常用的公共镜像仓库有Docker Hub、阿里云容器镜像服务、腾讯云容器镜像服务等。

Docker Hub是最大的公共Docker镜像仓库，包含了大量的官方和社区镜像。可以通过docker pull命令从Docker Hub拉取镜像，例如：

docker pull openjdk:11-jre-alpine

（二）私有镜像仓库搭建

对于企业内部的项目，通常会搭建私有镜像仓库，以保证镜像的安全性和私密性。可以使用Docker Registry来搭建私有镜像仓库。

拉取Docker Registry镜像：

docker pull registry:2

运行Docker Registry容器：

docker run -d -p 5000:5000 --name my-registry -v /my/registry/data:/var/lib/registry registry:2

-v /my/registry/data:/var/lib/registry：将宿主机的/my/registry/data目录挂载到容器的/var/lib/registry目录，用于持久化存储镜像数据。

配置Docker客户端，允许访问私有仓库。对于Linux系统，需要在/etc/docker/daemon.json文件中添加以下内容：

{
  "insecure-registries": ["localhost:5000"]
}

然后重启Docker服务：

systemctl restart docker

（三）镜像推送和拉取

给镜像打标签，标签格式为私有仓库地址:端口/镜像名:标签：

docker tag my-java-app:1.0.0 localhost:5000/my-java-app:1.0.0

将镜像推送到私有仓库：

docker push localhost:5000/my-java-app:1.0.0

在其他环境中拉取私有仓库的镜像：

docker pull localhost:5000/my-java-app:1.0.0

七、Docker Compose使用

当Java项目涉及到多个服务，比如数据库、缓存等，使用Docker Compose可以方便地定义和运行多个容器应用。

（一）docker-compose.yml文件编写

docker-compose.yml文件用于定义多个服务的配置。例如，一个Java应用服务和一个mysql数据库服务的配置：

version: '3'
services:
  java-app:
    build: .
    ports:
      - "8080:8080"
    depends_on:
      - mysql
    environment:
      - SPRING_DATASOURCE_URL=jdbc:mysql://mysql:3306/my_db
      - SPRING_DATASOURwww.devze.comCE_USERNAME=root
      - SPRING_DATASOURCE_PASSWORD=123456
  mysql:
    image: mysql:8.0
    ports:
      - "3306:3306"
    environment:
      - MYSQL_ROOT_PASSWORD=123456
      - MYSQL_DATABASE=my_db
    volumes:
      - mysql-data:/var/lib/mysql
volumes:
  mysql-data:

version: '3'：指定Docker Compojavascriptse的版本。
services：定义各个服务。
- java-app：Java应用服务，build: .表示根据当前目录的Dockerfile构建镜像，ports指定端口映射，depends_on表示该服务依赖于mysql服务，environment设置环境变量，用于配置数据库连接信息。
- mysql：MySQL数据库服务，image指定使用的镜像，ports指定端口映射，environment设置数据库的root密码和初始化数据库名，volumes用于持久化存储数据库数据。
volumes：定义数据卷，用于持久化存储数据。

（二）启动服务

在docker-compose.yml文件所在的目录下，执行以下命令启动所有服务：

docker-compose up -d

-d表示后台运行服务。

（三）停止服务

执行以下命令停止所有服务：

docker-compose down

如果需要删除数据卷，可以加上-v参数：

docker-compose down -v

（四）查看服务状态

执行以下命令查看服务的运行状态：

docker-compose ps

（五）查看服务日志

执行以下命令查看某个服务的日志：

docker-compose logs java-app

八、高级话题

（一）镜像优化

选择合适的基础镜像：尽量使用体积小的基础镜像，如Alpine版本的镜像。例如，openjdk:11-jre-alpine比openjdk:11-jre体积小很多。
减少镜像层数：Docker镜像由多个层组成，每一条指编程令都会创建一个新的层。可以将多个相关的指令合并为一个，减少镜像层数。例如，将多个RUN指令合并：

RUN apk add --no-cache curl && \
    apk add --no-cache wget

清理不必要的依赖和文件：在构建过程中，及时清理不需要的文件和依赖，减少镜像体积。例如，在Maven构建后，清理Maven的本地仓库缓存：

RUN mvn clean package -Dmaven.test.skip=true && \
    rm -rf ~/.m2/repository

（二）安全加固

避免使用root用户运行容器：在Dockerfile中创建普通用户，并使用该用户运行应用程序，限制容器的权限。

# 创建普通用户
RUN addgroup -S appgroup && adduser -S appuser -G appgroup

# 切换到普通用户
USER appuser

限制容器的资源：在运行容器时，通过--memory、--cpus等参数限制容器的内存和CPU使用，防止容器过度占用资源。

docker run -d -p 8080:8080 --memory=512m --cpus=0.5 my-java-app:1.0.0

定期更新基础镜像和依赖：及时更新基础镜像和项目依赖，修复已知的安全漏洞。

（三）镜像版本管理

使用有意义的标签：为镜像设置有意义的标签，如版本号、构建时间等，便于识别和管理不同版本的镜像。例如，my-java-app:1.0.0、my-java-app:2.0.0-20250804。
清理过期镜像：定期清理不再使用的镜像，释放存储空间。可以使用docker image prune命令清理悬空镜像（没有标签的镜像）：

docker image prune

也可以通过docker rmi命令删除指定的镜像：

docker rmi my-java-app:1.0.0

九、常见问题及解决方法

（一）依赖下载缓慢

在构建镜像时，如果依赖下载缓慢，可以配置国内的镜像源。例如，对于Maven项目，可以在pom.xml文件中配置阿里云的Maven镜像：

<repositories>
    <repository>
        <id>aliyunmaven</id>
        <name>阿里云公共仓库</name>
        <url>https://maven.aliyun.com/repository/public</url>
    </repository>
</repositories>

也可以在Maven的配置文件settings.xml中配置镜像源。

（二）端口冲突

在运行容器时，如果出现端口冲突的问题，可以修改端口映射，将容器的端口映射到宿主机的其他空闲端口。例如：

docker run -d -p 8081:8080 my-java-app:1.0.0

将宿主机的8081端口映射到容器的8080端口。

（三）容器启动后立即退出

如果容器启动后立即退出，可能是应用程序启动失败导致的。可以使用docker logs命令查看容器的日志，排查应用程序启动失败的原因，如配置错误、依赖缺失等。

（四）镜像体积过大

如果镜像体积过大，可以通过多阶段构建、选择合适的基础镜像、清理不必要的文件等方式进行优化，如前面在镜像优化部分所介绍的内容。

总结

到此这篇关于Docker容器Java项目打包与部署的文章就介绍到这了,更多相关Docker Java项目打包与部署内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！

继续阅读：docker打包java项目 java 打包部署 java项目打包和部署

目录