上一节中，容器化spring boot应用程序-CSDN博客我们介绍了基于简单的Dockerfile对spring boot进行容器化的过程，本讲将介绍如何基于Dockerfile进行多阶段的分层构建过程，希望对大家有所帮助。

Spring Boot从版本2.3.0开始支持分层构建容器化的镜像，在使用时需要注意，本文使用的spring boot的版本是：3.3.1

创建spring boot应用程序

pom.xml 依赖

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.1</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.zgy</groupId>
    <artifactId>container_docker</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>container_docker</name>
    <description>container_docker</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.14.0</version>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>3.3.1</version>
                <configuration>
                    <layers>
                        <enabled>true</enabled>
                    </layers>
                    <loaderImplementation>CLASSIC</loaderImplementation>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

需要注意的是使用的maven插件：spring-boot-maven-plugin ，为了使用容器化分层的能力，需要进行如下配置：

<plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>3.3.1</version>
                <configuration>
                    <layers>
                        <enabled>true</enabled>
                    </layers>
                    <loaderImplementation>CLASSIC</loaderImplementation>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
</plugin>

如上图，需要关注configuration部分的配置以及executions中的设置，否则会导致后续分层配置的失败，本文是经过测试可使用的，大家可以直接复制即可。

创建应用的端点

@RestController
@RequestMapping(value = "/layer")
public class LayerController {
    @GetMapping(value = "test")
    public void test() {
        System.out.println("layers/test/....");
    }

    @GetMapping(value = "tttest")
    public void tttest() {
        System.out.println("ttt test test!!");
    }
}

如上图，创建了一个controller类，用于启动容器后的测试。

打包

mvn clean package

执行该命令后，会在target目录下创建*.jar的包，这个需要后续上传到linux上用于进行镜像的构建

Dockerfile配置文件

FROM openjdk:17-jdk-alpine as builder
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} application.jar

RUN java -Djarmode=layertools -jar application.jar extract
FROM openjdk:17-jdk-alpine
RUN mkdir app
WORKDIR app
COPY --from=builder dependencies/ ./
COPY --from=builder snapshot-dependencies/ ./
COPY --from=builder spring-boot-loader/ ./
COPY --from=builder application/ ./
ENTRYPOINT ["java", "org.springframework.boot.loader.launch.JarLauncher"]

FROM openjdk:17-jdk-alpine as builder

该命令拉取open jdk 17的镜像，并将其作为第一个阶段

ARG JAR_FILE=target/*.jar

定义参数JAR_FILE，其值为之前打包的jar包程序

COPY ${JAR_FILE} application.jar

将打包后的jar包复制到容器内部，并重命名为application.jar

RUN java -Djarmode=layertools -jar application.jar extract

该命令是从application.jar中提取分层后的部分，这也是在maven中添加maven插件并添加配置的原因，否则无法提取jar包中的层级

FROM openjdk:17-jdk-alpine

开始第二个阶段，并使用jdk 17的镜像

RUN mkdir app

在容器内部创建目录app

WORKDIR app

将目录app作为上下文的工作环境

COPY --from=builder dependencies/ ./
COPY --from=builder snapshot-dependencies/ ./
COPY --from=builder spring-boot-loader/ ./
COPY --from=builder application/ ./

使用第一个阶段的内容，并将分层后的各个部分逐一的复制到容器内部

ENTRYPOINT ["java", "org.springframework.boot.loader.launch.JarLauncher"]

容器启动后，启动应用程序，需要注意的是，我们不是使用的jar -jar application.jar，而是使用的org.springframework.boot.loader.launch.JarLauncher，这个需要设置正确，否则会导致找不到启动类的报错。

构建镜像

上传资源

将target目录以及Dockerfile上传到linux中，用于构建镜像，linux上传后的目录如下所示

构建镜像

docker  build -t layer:v1 .

镜像构建后，可以看到如下镜像  创建容器 

docker conainer run –p 3000:8080 –name layer layer:v1

可以通过调用自定义的端点，可以进行验证

后续代码发生变更后，通过以上步骤，重新打包、构建新的镜像、删除已有的容器并启动新的容器，便可完成进行新代码的部署工作 。后续执行镜像操作的过程中，会比较快，因为镜像会进行缓存，如下图所示

这也是docker镜像缓存以及spring boot支持分层所带来的优化效果