Spring Boot 部署优化：打包体积缩小 80% 的实战方案

典型的大体积依赖

2. 瘦身机会识别

Fat JAR 150MB

优化策略

策略一：依赖精简

1.1 排除传递依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <!-- 排除默认的 Tomcat，改用 Undertow -->
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-tomcat</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <!-- Undertow 更轻量 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-undertow</artifactId>
    </dependency>
</dependencies>

1.2 使用范围限定依赖

<dependencies>
    <!-- 测试依赖仅在测试时使用 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!-- Lombok 仅在编译时需要 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <scope>provided</scope>
    </dependency>
</dependencies>

1.3 替换重型依赖

// 场景：Excel 导出功能
// 方案 A：使用 Apache POI（重型，~20MB）
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.*;

// 方案 B：使用 EasyExcel（轻量，~2MB）
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.write.metadata.WriteSheet;

// 代码对比
public class ExcelExportExample {
    // EasyExcel 实现（内存占用更小）
    public void exportLightweight(HttpServletResponse response) {
        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
        response.setCharacterEncoding("utf-8");
        EasyExcel.write(response.getOutputStream(), UserData.class)
            .sheet("用户数据")
            .doFinish(() -> { // 流式写入，内存友好
            });
    }
}

策略二：分层 JAR 构建

2.1 Spring Boot Layered JARs

Spring Boot 2.3+ 支持分层 JAR，配合 Docker 可以极大优化镜像大小。

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

2.2 分层结构说明

优化原理：Docker 构建时，只有变化的层会被重新构建和推送，变化频率低的层可以长期复用缓存。

2.3 多阶段 Dockerfile

# 构建阶段
FROM maven:3.8-openjdk-17 AS builder
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline
COPY src ./src
RUN mvn clean package -DskipTests

# 运行阶段 - 使用精简的基础镜像
FROM eclipse-temurin:17-jre-alpine
WORKDIR /app
# 只复制必要的文件
COPY --from=builder /app/target/*.jar app.jar
# 创建非 root 用户
RUN addgroup -S spring && adduser -S spring -G spring
USER spring:spring
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

策略三：自定义类加载

3.1 外部依赖 JAR

/**
 * 外部依赖加载器
 * 将依赖放在外部 lib/ 目录，减少主 JAR 体积
 */
public class ExternalDependencyLauncher {
    public static void main(String[] args) throws Exception {
        File libDir = new File("lib");
        URL[] jarUrls = Arrays.stream(Objects.requireNonNull(libDir.listFiles()))
            .filter(file -> file.getName().endsWith(".jar"))
            .map(File::toURI)
            .map(uri -> {
                try {
                    return uri.toURL();
                } catch (MalformedURLException e) {
                    throw new RuntimeException(e);
                }
            })
            .toArray(URL[]::new);
        URLClassLoader classLoader = new URLClassLoader(jarUrls);
        Thread.currentThread().setContextClassLoader(classLoader);
        // 启动 Spring Boot 应用
        Class<?> appClass = classLoader.loadClass("com.example.Application");
        Method mainMethod = appClass.getMethod("main", String[].class);
        mainMethod.invoke(null, (Object) args);
    }
}

3.2 Maven 配置

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>com.example.ExternalDependencyLauncher</mainClass>
                        <classpathPrefix>lib/</classpathPrefix>
                        <addClasspath>true</addClasspath>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <executions>
                <execution>
                    <id>copy-dependencies</id>
                    <phase>package</phase>
                    <goals>
                        <goal>copy-dependencies</goal>
                    </goals>
                    <configuration>
                        <outputDirectory>${project.build.directory}/lib</outputDirectory>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

策略四：GraalVM Native Image

4.1 原理说明

4.2 配置示例

<!-- pom.xml -->
<dependencies>
    <dependency>
        <groupId>org.springframework.experimental</groupId>
        <artifactId>spring-native</artifactId>
        <version>0.12.0</version>
    </dependency>
</dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.experimental</groupId>
            <artifactId>spring-aot-maven-plugin</artifactId>
            <version>0.12.0</version>
            <executions>
                <execution>
                    <id>test-generate</id>
                    <goals>
                        <goal>test-generate</goal>
                    </goals>
                </execution>
                <execution>
                    <id>generate</id>
                    <goals>
                        <goal>generate</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>
<profiles>
    <profile>
        <id>native</id>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.graalvm.buildtools</groupId>
                    <artifactId>native-maven-plugin</artifactId>
                    <version>0.9.13</version>
                    <executions>
                        <execution>
                            <id>build-native</id>
                            <goals>
                                <goal>build</goal>
                            </goals>
                            <phase>package</phase>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>

4.3 反射配置

// src/main/resources/META-INF/native-image/reflect-config.json
[
    {
        "name": "com.example.model.User",
        "allDeclaredConstructors": true,
        "allPublicConstructors": true,
        "allDeclaredMethods": true,
        "allPublicMethods": true,
        "allDeclaredFields": true,
        "allPublicFields": true
    },
    {
        "name": "com.example.controller.UserController",
        "allDeclaredConstructors": true,
        "allDeclaredMethods": true
    }
]

实战演示

完整优化配置

Maven 配置文件

<?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.2.0</version>
        <relativePath/>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>optimized-spring-boot</artifactId>
    <version>1.0.0</version>
    <name>Optimized Spring Boot Application</name>
    <properties>
        <java.version>17</java.version>
        <spring-boot-admin.version>3.1.0</spring-boot-admin.version>
    </properties>
    <dependencies>
        <!-- Web 模块 - 使用 Undertow 替代 Tomcat -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-undertow</artifactId>
        </dependency>
        <!-- 只引入需要的模块 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        <!-- 数据库 - 按需引入 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!-- 驱动 - 使用 runtime scope -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- 工具类 - 选择轻量级替代品 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <!-- Lombok - provided scope -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>
        <!-- 测试依赖 - test scope -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <!-- Spring Boot 分层插件 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <layers>
                        <enabled>true</enabled>
                    </layers>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
            <!-- 依赖分析插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>analyze</id>
                        <goals>
                            <goal>analyze</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

优化后的 Dockerfile

# syntax=docker/dockerfile:1.4
# 多阶段构建 + BuildKit 缓存优化
# ===================================
# 阶段 1: 依赖解析 (利用 Docker 缓存)
# ===================================
FROM maven:3.8-eclipse-temurin-17 AS deps
WORKDIR /app
# 先复制 pom.xml，下载依赖（这一层会被缓存）
COPY pom.xml ./
RUN mvn dependency:go-offline -B

# ===================================
# 阶段 2: 编译 (代码变化时重新执行)
# ===================================
FROM maven:3.8-eclipse-temurin-17 AS builder
WORKDIR /app
# 从 deps 阶段复制本地仓库
COPY --from=deps /root/.m2 /root/.m2
# 复制源代码
COPY src ./src
# 构建应用
RUN mvn clean package -DskipTests -B && \
    mv target/*.jar app.jar

# ===================================
# 阶段 3: 运行时镜像 (最小化体积)
# ===================================
FROM eclipse-temurin:17-jre-alpine
# 安装必要的工具和时区数据
RUN apk add --no-cache tzdata && \
    cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && \
    echo "Asia/Shanghai" > /etc/timezone && \
    apk del tzdata
WORKDIR /app
# 创建非特权用户
RUN addgroup -S appgroup && \
    adduser -S appuser -G appgroup
# 复制应用 JAR
COPY --from=builder --chown=appuser:appgroup /app/app.jar app.jar
# 切换用户
USER appuser
# JVM 参数优化
ENV JAVA_OPTS="-XX:+UseContainerSupport \
               -XX:MaxRAMPercentage=75.0 \
               -XX:InitialRAMPercentage=50.0 \
               -XX:+UseG1GC \
               -Djava.security.egd=file:/dev/./urandom"
EXPOSE 8080
# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=40s \
    CMD wget --no-verbose --tries=1 --spider http://localhost:8080/actuator/health || exit 1
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]

应用配置优化

# application.yml
spring:
  # 禁用不需要的自动配置
  autoconfigure:
    exclude:
      - org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
      - org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration
  # Web 优化
  web:
    resources:
      chain:
        cache: true
      static-locations: classpath:/static/
  server:
    # Undertow 配置
    undertow:
      threads:
        io: 4
        worker: 20
      buffer-size: 1024
      direct-buffers: true
  # 管理端点
  management:
    endpoints:
      web:
        exposure:
          include: health, info, metrics
    endpoint:
      health:
        show-details: always
  # 日志配置
  logging:
    level:
      root: INFO
      com.example: DEBUG
    pattern:
      console: "%d{yyyy-MM-dd HH:mm:ss} - %msg%n"

效果对比

优化前后对比表

注意：构建时间略有增加是正常的，因为增加了分层构建和优化步骤，但这是一次性成本。

体积优化分解图

各优化策略贡献分析：

• 依赖精简：35%
• 分层构建：25%
• Undertow 替换：20%
• Native 编译：10%
• 其他优化：10%

不同方案适用场景

最佳实践

1. 持续监控

# 定期检查依赖大小
mvn dependency:tree | grep -E "compile|runtime"
# 使用 Maven 插件分析
mvn com.github.ferstl:depgraph-maven-plugin:aggregate

2. 依赖管理规范

<!-- 在父 POM 中统一管理版本 -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>3.2.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

3. CI/CD 集成

# .github/workflows/docker-build.yml
name: Build and Push Docker Image
on:
  push:
    branches: [main]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Set up JDK 17
        uses: actions/setup-java@v3
        with:
          java-version: '17'
          distribution: 'temurin'
      - name: Build with Maven
        run: mvn clean package -DskipTests
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v2
      - name: Login to Docker Hub
        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
      - name: Build and push
        uses: docker/build-push-action@v4
        with:
          context: .
          push: true
          tags: user/app:latest
          cache-from: type=gha
          cache-to: type=gha,mode=max
          build-args: |
            BUILDKIT_INLINE_CACHE=1

4. 避免的陷阱

总结

优化路线图

1. 开始：Fat JAR 150MB
2. 第一步：依赖分析
3. 第二步：依赖精简 (120MB)
4. 第三步：切换 Undertow (110MB)
5. 第四步：分层构建 (50MB)
6. 是否需要极致优化？
   • 是：第五步 Native Image (30MB)
   • 否：完成 (50MB)

关键要点

1. 先分析再优化：使用工具找出真正的体积大头
2. 分步优化：不要一次性应用所有策略，逐步验证
3. 权衡取舍：体积、性能、兼容性三者之间找平衡
4. 团队协作：建立依赖管理规范，防止体积膨胀
5. 持续改进：定期审查依赖，移除不再使用的库

参考资料

• Spring Boot Layered JARs 官方文档
• GraalVM Native Image 文档
• Docker Multi-stage Builds
• Maven Dependency Plugin