springboot多种生产打包方式教程

在 Spring Boot 项目中，打包是一个非常重要的环节，因为它决定了应用程序如何部署到生产环境中。Spring Boot 提供了多种打包方式，以满足不同的需求和环境。以下是详细的教程，介绍 Spring Boot 的多种生产打包方式以及它们的适用场景。

1. 使用 Maven/Gradle 打包为可执行 JAR 文件

这是 Spring Boot 最常用的打包方式，适用于大多数场景。通过这种方式，可以生成一个包含所有依赖的“fat jar”文件。

步骤：

• Maven 配置：
  在 pom.xml 中确保使用了 spring-boot-maven-plugin 插件：

  <build>
      <plugins>
          <plugin>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-maven-plugin</artifactId>
          </plugin>
      </plugins>
  </build>
  

• Gradle 配置：
  在 build.gradle 中确保使用了 bootJar 插件：

  plugins {
      id 'org.springframework.boot' version '3.1.0'
      id 'io.spring.dependency-management' version '1.1.0'
      id 'java'
  }
  

• 打包命令：

  • Maven: mvn clean package
  • Gradle: gradle clean bootJar

• 运行方式：
  打包完成后会生成一个 .jar 文件（如 target/myapp.jar 或 build/libs/myapp.jar），可以通过以下命令运行：

  java -jar myapp.jar
  

优点：

• 简单易用，适合大多数微服务架构。
• 包含所有依赖，无需额外配置外部类路径。

缺点：

• 如果依赖较多，JAR 文件可能会较大。

2. 打包为 WAR 文件

如果需要将 Spring Boot 应用部署到传统的 Java EE 容器（如 Tomcat、Jetty 等），可以选择打包为 WAR 文件。

步骤：

• 修改启动类：
  将主类继承 SpringBootServletInitializer 并重写 configure 方法：

  @SpringBootApplication
  public class MyApplication extends SpringBootServletInitializer {
      @Override
      protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
          return application.sources(MyApplication.class);
      }
  
      public static void main(String[] args) {
          SpringApplication.run(MyApplication.class, args);
      }
  }
  

• Maven 配置：
  修改 pom.xml，设置打包类型为 war：

  <packaging>war</packaging>
  
  <dependencies>
      <!-- 排除嵌入式 Tomcat -->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-tomcat</artifactId>
          <scope>provided</scope>
      </dependency>
  </dependencies>
  

• Gradle 配置：
  在 build.gradle 中设置打包类型为 war：

  plugins {
      id 'war'
  }
  
  dependencies {
      providedRuntime 'org.springframework.boot:spring-boot-starter-tomcat'
  }
  

• 打包命令：

  • Maven: mvn clean package
  • Gradle: gradle clean war

• 部署方式：
  将生成的 .war 文件（如 target/myapp.war 或 build/libs/myapp.war）复制到目标容器的 webapps 目录下，并启动容器。

优点：

• 适合传统企业级应用部署。
• 可以与现有 Java EE 基础设施集成。

缺点：

• 需要额外配置外部容器。
• 不如 JAR 方便，灵活性较低。

3. 使用 Docker 容器化打包

现代微服务架构中，Docker 是一种常见的部署方式。Spring Boot 应用可以通过 Docker 容器化，实现跨平台部署。

步骤：

• 创建 Dockerfile：
  在项目根目录下创建 Dockerfile：

  # 使用官方 JDK 镜像作为基础镜像
  FROM openjdk:17-jdk-slim
  
  # 设置工作目录
  WORKDIR /app
  
  # 复制 JAR 文件到容器
  COPY target/myapp.jar app.jar
  
  # 暴露端口
  EXPOSE 8080
  
  # 启动命令
  ENTRYPOINT ["java", "-jar", "app.jar"]
  

• 构建 Docker 镜像：
  先打包 JAR 文件，然后执行以下命令：

  docker build -t myapp:1.0 .
  

• 运行容器：
  启动容器并映射端口：

  docker run -d -p 8080:8080 --name myapp-container myapp:1.0
  

优点：

• 轻量级、跨平台。
• 易于扩展和管理，适合云原生应用。

缺点：

• 需要熟悉 Docker 技术。
• 对资源消耗有一定要求。

4. 使用 Spring Boot Native Image 打包

Spring Boot 支持通过 GraalVM 将应用编译为本地镜像（Native Image）。这种方式可以显著提升启动速度和性能。

步骤：

• 添加依赖：
  在 pom.xml 中添加 spring-boot-starter-native 依赖：

  <dependency>
      <groupId>org.springframework.experimental</groupId>
      <artifactId>spring-boot-starter-native</artifactId>
      <version>0.12.1</version>
  </dependency>
  

• 安装 GraalVM：
  下载并安装 GraalVM，确保环境变量配置正确。

• 打包命令：
  使用 Maven 或 Gradle 打包：

  • Maven: mvn -Pnative clean package
  • Gradle: gradle nativeCompile

• 运行方式：
  打包完成后会生成一个本地可执行文件（如 target/myapp），直接运行即可：

  ./myapp
  

优点：

• 极快的启动速度。
• 更低的内存占用。

缺点：

• 配置复杂，对兼容性有一定限制。
• 需要额外学习 GraalVM。

5. 使用 Spring Boot Layered JAR

Spring Boot 支持分层 JAR 打包，便于优化 Docker 镜像构建过程。

步骤：

• 启用分层支持：
  在 pom.xml 中配置 spring-boot-maven-plugin：

  <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
      <configuration>
          <layers>
              <enabled>true</enabled>
          </layers>
      </configuration>
  </plugin>
  

• 打包命令：
  执行 mvn clean package。

• 查看分层结构：
  使用以下命令查看分层内容：

  java -Djarmode=layertools -jar myapp.jar list
  

• Dockerfile 示例：
  利用分层构建更高效的镜像：

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

优点：

• 优化 Docker 镜像构建，减少重复层。
• 提高镜像构建效率。

缺点：

• 配置稍复杂。

总结

根据实际需求选择合适的打包方式：

1. JAR 文件：简单高效，适合大多数微服务场景。
2. WAR 文件：适合传统 Java EE 容器部署。
3. Docker 容器：适合云原生和微服务架构。
4. Native Image：适合高性能和快速启动需求。
5. Layered JAR：优化 Docker 镜像构建。