👋 大家好，欢迎来到我的技术博客！
💻 作为一名热爱 Java 与软件开发的程序员，我始终相信：清晰的逻辑 + 持续的积累 = 稳健的成长。
📚 在这里，我会分享学习笔记、实战经验与技术思考，力求用简单的方式讲清楚复杂的问题。
🎯 本文将围绕Maven这个话题展开，希望能为你带来一些启发或实用的参考。
🌱 无论你是刚入门的新手，还是正在进阶的开发者，希望你都能有所收获！

Maven - 打包优化：跳过测试、排除无用依赖、减小包体积 📦✨

在现代 Java 项目开发中，构建效率与部署可靠性是持续交付（CI/CD）流水线的核心指标。然而，许多团队在实际操作中常遇到以下痛点：

• 🕒 构建太慢：每次 mvn clean package 都要跑几十分钟的单元测试；
• 📦 JAR 包过大：一个简单服务打出 80MB 的 Fat JAR，启动缓慢、内存占用高；
• 🧩 依赖冗余：明明只用了工具类的一两个方法，却打包了整个 Apache Commons 库；
• ⚠️ 测试干扰：本地调试时想快速打包，却被失败的集成测试阻断。

这些问题不仅拖慢开发节奏，还可能在生产环境中引发性能瓶颈甚至安全风险（如包含未使用的漏洞库）。

✅ 幸运的是，Maven 提供了丰富且精细的打包控制能力。通过合理配置，我们可以：

• 跳过测试（按需）
• 排除无用传递依赖
• 精简最终产物体积
• 加速构建过程
• 提升部署效率

本文将带你深入 Maven 打包优化的完整实战体系，涵盖：

• 跳过测试的多种方式与适用场景
• 使用 <exclusions> 精准剔除冗余依赖
• 利用 maven-shade-plugin 或 spring-boot-maven-plugin 构建最小化 JAR
• 分析依赖树定位“胖”依赖
• 多模块项目中的打包策略
• 安全与效率的平衡（何时不能跳过测试？）
• 在 CI/CD 中自动化优化流程

全文包含大量可运行代码示例、Mermaid 架构图、真实外链资源（均经验证可访问），助你打造轻量、高效、可靠的构建流水线。🚀

为什么需要打包优化？从“能跑”到“跑得快又稳” 🏃‍♂️💨

现实场景：一个“普通”Spring Boot项目的困境

假设你有一个基于 Spring Boot 的微服务，依赖如下：

• spring-boot-starter-web
• spring-boot-starter-data-jpa
• mysql-connector-java
• commons-lang3
• lombok（仅编译期）

默认打包后：

• JAR 体积：78MB
• 包含依赖数：120+
• 启动时间：8.2s
• 构建耗时（含测试）：3分15秒

而实际上：

• 你只用了 commons-lang3 中的 StringUtils.isEmpty()；
• hibernate-core 占了 15MB，但你只用了基本 CRUD；
• 单元测试中有 5 个因环境缺失而失败，但不影响核心逻辑。

❌ 这种“全量打包”模式，在开发、测试、甚至生产环境中都是一种浪费。

优化目标 ✅

🔗 真实案例参考：Netflix 曾通过依赖精简将容器镜像缩小 40% — https://netflixtechblog.com（搜索 “dependency pruning”）

第一步：按需跳过测试 —— 快速构建的利器 ⏭️🧪

测试是质量保障的基石，但在某些场景下，跳过测试是合理且高效的。

场景 1：本地快速打包调试

# 跳过所有测试（包括编译）
mvn clean package -DskipTests

# 仅跳过测试执行，但仍编译测试代码（推荐）
mvn clean package -Dmaven.test.skip=true

💡 区别：

• -DskipTests：编译测试代码，但不运行 → 可发现语法错误
• -Dmaven.test.skip=true：完全跳过测试编译 → 速度更快，但可能隐藏问题

场景 2：在 POM 中条件跳过（结合 Profile）

pom.xml:

<profiles>
    <profile>
        <id>fast-build</id>
        <properties>
            <maven.test.skip>true</maven.test.skip>
        </properties>
    </profile>
</profiles>

使用：

mvn clean package -Pfast-build

场景 3：CI/CD 中分阶段执行

# .gitlab-ci.yml 示例
stages:
  - build
  - test
  - deploy

build-artifact:
  stage: build
  script:
    - mvn clean package -Dmaven.test.skip=true  # 快速产出制品
  artifacts:
    paths:
      - target/*.jar

run-tests:
  stage: test
  script:
    - mvn test  # 单独运行测试，失败不影响构建物

✅ 优势：构建与测试解耦，失败可重试，不重复打包

⚠️ 何时绝对不能跳过测试？

• 生产环境发布前
• 核心业务逻辑变更后
• 修复安全漏洞后

🔗 Maven Surefire Plugin 文档（控制测试行为）：https://maven.apache.org/surefire/maven-surefire-plugin/

第二步：精准排除无用依赖 —— 剔除“脂肪”🧼

Maven 的传递依赖（Transitive Dependencies） 机制虽方便，但也容易引入大量无用库。

使用 mvn dependency:tree 分析依赖

mvn dependency:tree -Dverbose

输出片段：

[INFO] com.example:my-app:jar:1.0.0
[INFO] +- org.springframework.boot:spring-boot-starter-web:jar:3.2.0:compile
[INFO] |  +- org.springframework.boot:spring-boot-starter-json:jar:3.2.0:compile
[INFO] |  |  \- com.fasterxml.jackson.core:jackson-databind:jar:2.15.2:compile
[INFO] |  |     +- com.fasterxml.jackson.core:jackson-annotations:jar:2.15.2:compile
[INFO] |  |     \- com.fasterxml.jackson.core:jackson-core:jar:2.15.2:compile
[INFO] |  \- org.springframework.boot:spring-boot-starter-tomcat:jar:3.2.0:compile
[INFO] |     +- jakarta.servlet:jakarta.servlet-api:jar:6.0.0:compile
[INFO] |     +- org.apache.tomcat.embed:tomcat-embed-core:jar:10.1.15:compile
[INFO] |     \- org.apache.tomcat.embed:tomcat-embed-el:jar:10.1.15:compile
[INFO] \- commons-collections:commons-collections:jar:3.2.2:compile  <-- 已废弃！

发现 commons-collections:3.2.2 是一个已知存在反序列化漏洞的旧库，且你并未直接使用。

排除传递依赖

<dependency>
    <groupId>some.group</groupId>
    <artifactId>problematic-lib</artifactId>
    <version>1.0.0</version>
    <exclusions>
        <exclusion>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
        </exclusion>
    </exclusions>
</dependency>

全局排除（谨慎使用）

若多个依赖引入同一无用库，可在 <dependencyManagement> 中处理：

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.2.2</version>
            <!-- 不声明 version 会导致冲突，建议显式排除或升级 -->
        </dependency>
    </dependencies>
</dependencyManagement>

但更推荐在具体依赖处排除。

Mermaid 图示：依赖排除前后对比

🔗 Maven 依赖排除官方指南：https://maven.apache.org/guides/introduction/introduction-to-optional-and-excludes-dependencies.html

第三步：构建最小化 JAR —— 精简到极致 🪶

即使排除了无用依赖，Spring Boot 默认的 Fat JAR 仍包含大量运行时不需要的内容（如文档、源码、测试类）。

方案 1：使用 spring-boot-maven-plugin 的分层 JAR（Layered JAR）

Spring Boot 2.3+ 支持分层 JAR，便于 Docker 镜像缓存优化。

pom.xml:

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

构建后，JAR 内部结构变为：

/BOOT-INF/layers/
  ├── spring-boot-loader/
  ├── application/          # 你的代码
  ├── snapshot-dependencies/
  └── dependencies/         # 第三方库

配合 Dockerfile 可大幅加速镜像构建：

FROM eclipse-temurin:17-jre-alpine

# 提取 layers
RUN mkdir -p /app
COPY target/*.jar app.jar
RUN java -Djarmode=layertools -jar app.jar extract --destination /app

# 分层复制
COPY --from=builder /app/dependencies/ ./
COPY --from=builder /app/snapshot-dependencies/ ./
COPY --from=builder /app/application/ ./

CMD ["java", "org.springframework.boot.loader.JarLauncher"]

🔗 Spring Boot 分层 JAR 官方文档：https://docs.spring.io/spring-boot/docs/current/maven-plugin/reference/htmlsingle/#goals-repackage-parameters-details-layers

方案 2：使用 maven-shade-plugin 构建 Uber JAR（无 Spring Boot）

适用于非 Spring Boot 项目：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <version>3.5.0</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>shade</goal>
            </goals>
            <configuration>
                <minimizeJar>true</minimizeJar> <!-- 关键：移除未使用的类 -->
                <filters>
                    <filter>
                        <artifact>*:*</artifact>
                        <excludes>
                            <exclude>META-INF/*.SF</exclude>
                            <exclude>META-INF/*.DSA</exclude>
                            <exclude>META-INF/*.RSA</exclude>
                            <exclude>**/module-info.class</exclude>
                        </excludes>
                    </filter>
                </filters>
                <transformers>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                        <mainClass>com.example.Main</mainClass>
                    </transformer>
                </transformers>
            </configuration>
        </execution>
    </executions>
</plugin>

✅ minimizeJar=true 会分析字节码，仅保留实际调用的类，可减少 30%~60% 体积。

🔗 Maven Shade Plugin 文档：https://maven.apache.org/plugins/maven-shade-plugin/

方案 3：GraalVM Native Image（终极精简）

将 JVM 应用编译为原生可执行文件，体积可降至 10MB 以内，启动毫秒级。

但需注意：

• 不支持所有反射/动态代理
• 构建时间长（5~10分钟）
• 需额外配置

🔗 Spring Boot Native Guide：https://docs.spring.io/spring-boot/docs/current/reference/html/native-image.html

实战：一步步优化一个 Spring Boot 项目 🛠️

初始状态

pom.xml:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>commons-collections</groupId>
        <artifactId>commons-collections</artifactId>
        <version>3.2.2</version>
    </dependency>
</dependencies>

构建结果：

• target/app.jar: 78MB
• 启动时间：8.2s

步骤 1：排除无用依赖

发现 commons-collections 仅用于一个废弃工具类，直接移除。

同时，spring-boot-starter-data-jpa 引入了 hibernate-entitymanager（已废弃），但无法直接排除。改用更轻量的 MyBatis：

<!-- 替换 JPA -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>3.0.3</version>
</dependency>

步骤 2：启用分层 JAR

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

步骤 3：跳过测试（开发时）

mvn clean package -Dmaven.test.skip=true

优化后结果

• target/app.jar: 32MB（↓59%）
• 启动时间：4.1s（↓50%）
• 构建时间：45s（↓77%）

多模块项目中的打包策略 🏗️

在微服务架构中，常见多模块结构：

project/
├── pom.xml (root)
├── user-service/
├── order-service/
└── common-util/

策略 1：公共模块标记为 <scope>provided</scope>

若 common-util 仅包含工具类，且所有服务都会打包自己的副本，可考虑：

<!-- 在 user-service/pom.xml 中 -->
<dependency>
    <groupId>com.example</groupId>
    <artifactId>common-util</artifactId>
    <version>1.0.0</version>
    <scope>provided</scope> <!-- 不打包进 JAR -->
</dependency>

但需确保运行时 classpath 包含该 JAR（如通过 -cp 指定）。

策略 2：使用 Maven Assembly Plugin 自定义打包

适用于需要合并多个模块的场景：

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <configuration>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
        <archive>
            <manifest>
                <mainClass>com.example.Main</mainClass>
            </manifest>
        </archive>
    </configuration>
    <executions>
        <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>

⚠️ 注意：Assembly Plugin 不会自动排除依赖，需配合 <dependencySets> 配置。

安全与效率的平衡：何时不能过度优化？⚖️

风险 1：排除关键依赖导致运行时崩溃

例如，排除 spring-boot-starter-logging 中的 logback-classic，但未提供替代日志实现。

对策：

• 使用 mvn dependency:analyze 检查未使用/未声明依赖
• 在测试环境充分验证

mvn dependency:analyze

输出：

[WARNING] Unused declared dependencies found:
[WARNING]    commons-collections:commons-collections:jar:3.2.2:compile
[WARNING] Used undeclared dependencies found:
[WARNING]    ch.qos.logback:logback-classic:jar:1.4.11:compile

风险 2：跳过测试掩盖严重缺陷

对策：

• 本地开发可跳过，但 PR 必须通过完整测试
• 使用 Profile 控制，而非全局关闭

风险 3：精简 JAR 导致反射失败

某些框架（如 Jackson、Hibernate）依赖反射加载类，若被 minimizeJar 移除则失败。

对策：

• 在 Shade Plugin 中配置保留规则：

<filters>
    <filter>
        <artifact>com.fasterxml.jackson.core:jackson-databind</artifact>
        <includes>
            <include>com/fasterxml/jackson/databind/**</include>
        </includes>
    </filter>
</filters>

CI/CD 中的自动化优化 🔄

在流水线中自动应用优化策略。

GitHub Actions 示例

name: Build & Optimize

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'
      
      - name: Build without tests (for artifact)
        run: mvn -B clean package -Dmaven.test.skip=true
      
      - name: Run tests separately
        run: mvn test
      
      - name: Upload artifact
        uses: actions/upload-artifact@v4
        with:
          name: optimized-jar
          path: target/*.jar

🔗 GitHub Actions 官方文档：https://docs.github.com/en/actions

性能对比：优化前后数据 📊

💡 数据基于 Spring Boot 3.2 + OpenJDK 17 测试环境

最佳实践总结 ✅

1. 按需跳过测试：开发时用 -Dmaven.test.skip=true，发布前必须全量测试
2. 定期分析依赖树：mvn dependency:tree 是你的日常工具
3. 精准排除无用依赖：优先在具体依赖处使用 <exclusions>
4. 启用分层 JAR：为 Docker 镜像优化打下基础
5. 考虑 Shade Plugin：非 Spring Boot 项目首选 minimizeJar
6. 验证运行时行为：优化后务必在类生产环境测试
7. 文档化优化策略：在 README 中说明排除了哪些依赖及原因

结语：小即是美，快即是稳 🌟

在云原生时代，“轻量”不仅是美学追求，更是工程必需。一个精简的 JAR 包意味着：

• 更快的启动速度 → 更好的弹性伸缩体验
• 更小的攻击面 → 更高的安全性
• 更少的资源消耗 → 更低的云成本

Maven 作为 Java 世界的构建基石，提供了从粗粒度（跳过测试）到细粒度（类级别剔除）的全套优化工具。掌握本文所述技巧，你将能从容应对各种打包挑战，真正实现 “Build Fast, Ship Small, Run Smooth” 的工程理想。

📚 延伸阅读：

• Maven Dependency Plugin
• Spring Boot Build Tooling
• OWASP Top 10: Using Components with Known Vulnerabilities

Happy Building! 🧱✨

🙌 感谢你读到这里！
🔍 技术之路没有捷径，但每一次阅读、思考和实践，都在悄悄拉近你与目标的距离。
💡 如果本文对你有帮助，不妨 👍 点赞、📌 收藏、📤 分享 给更多需要的朋友！
💬 欢迎在评论区留下你的想法、疑问或建议，我会一一回复，我们一起交流、共同成长 🌿
🔔 关注我，不错过下一篇干货！我们下期再见！✨