万字详解Maven打包策略：从基础插件到多模块实战

苍煜2026-01-31 21:42

文章目录

系列文章：
解惑Maven插件关系：为什么有时只用一个插件，也能打出Fat JAR？

Maven作为Java项目的核心构建工具，打包是其最核心的能力之一。不同的业务场景（单模块微服务、多模块企业应用、频繁迭代的大型项目）需要不同的打包策略，而灵活运用Maven插件则是实现各类打包需求的关键。本文将从核心插件解析入手，系统讲解Maven打包的底层逻辑，并结合实战场景拆解Fat JAR、分离打包等主流模式，覆盖从单模块到多模块的全场景应用。

一、Maven打包核心插件解析

Maven本身仅提供基础的构建生命周期（clean、compile、package等），具体的打包逻辑完全依赖插件实现。下面先吃透5个最核心的打包插件，这是理解所有打包策略的基础。

1. maven-compiler-plugin：编译的"基石"

核心作用

唯一职责是将Java源码编译为class字节码文件，是所有打包流程的前置步骤，没有编译就没有后续的打包操作。

核心配置项

  • source/target：指定源码编译的Java版本（如1.8），避免版本不兼容；
  • encoding：指定源码编码（如UTF-8），解决中文乱码；
  • fork：是否启用独立进程编译，提升编译稳定性（尤其Spring Boot项目）。

典型配置

xml 复制代码 
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.10.1</version> <!-- 推荐稳定版本 -->
    <configuration>
        <source>8</source>
        <target>8</target>
        <encoding>UTF-8</encoding>
        <fork>true</fork> <!-- 独立进程编译 -->
    </configuration>
</plugin>

适用场景

所有Java项目必备，无例外。

2. maven-jar-plugin：基础JAR打包工具

核心作用

Maven原生的JAR打包插件，负责将编译后的class文件、资源文件打包为普通JAR包（仅包含项目自身代码，不包含任何第三方依赖）。

核心能力

  • 生成标准的JAR文件；
  • 配置MANIFEST.MF文件（指定主类、类路径、依赖前缀等）；
  • 控制JAR包的包含/排除内容。

关键配置（分离打包核心）

xml 复制代码 
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>3.3.0</version>
    <configuration>
        <archive>
            <manifest>
                <addClasspath>true</addClasspath> <!-- 自动添加类路径 -->
                <classpathPrefix>lib/</classpathPrefix> <!-- 依赖文件前缀（指向外部lib目录） -->
                <mainClass>com.example.Application</mainClass> <!-- 程序入口类 -->
                <useUniqueVersions>false</useUniqueVersions> <!-- 依赖名不带版本号，简化管理 -->
            </manifest>
        </archive>
    </configuration>
</plugin>

适用场景

  • 生成普通JAR包（仅自身代码）；
  • 分离打包时配置MANIFEST.MF，让JAR能找到外部依赖。

3. spring-boot-maven-plugin：Spring Boot专属打包神器

核心作用

Spring Boot项目的核心插件，解决了普通JAR无法直接运行的问题，核心能力有：

  • 生成可执行Fat JAR（内置所有依赖+Spring Boot启动器）；
  • 支持devtools热部署（需配置fork=true）；
  • 过滤/包含指定依赖（实现混合分离打包）；
  • 处理system范围的本地依赖打包。

核心原理

将普通JAR重新打包（repackage目标），在JAR内部生成：

  • BOOT-INF/classes：项目自身代码；
  • BOOT-INF/lib：所有第三方依赖；
  • META-INF/MANIFEST.MF：包含Spring Boot启动类和类加载逻辑。

典型配置（Fat JAR）

xml 复制代码 
<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <version>2.7.18</version> <!-- 与Spring Boot版本一致 -->
    <configuration>
        <fork>true</fork> <!-- 支持devtools热部署 -->
        <includeSystemScope>true</includeSystemScope> <!-- 包含system范围依赖 -->
    </configuration>
    <executions>
        <execution>
            <goals>
                <goal>repackage</goal> <!-- 核心目标：生成可执行JAR -->
            </goals>
        </execution>
    </executions>
</plugin>

适用场景

所有Spring Boot项目（单模块/多模块），是生成可执行JAR的首选插件。

4. maven-shade-plugin：进阶版Fat JAR工具

核心作用

通用的Fat JAR打包插件（非Spring Boot专属），核心能力：

  • 将项目代码+所有依赖打包为单个JAR；
  • 解决依赖冲突（重命名包名，如com.google.guava→com.example.shaded.guava）；
  • 合并同名资源文件（如META-INF/spring.handlers）；
  • 剔除冗余依赖，精简包体积。

典型配置

xml 复制代码 
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <version>3.4.1</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>shade</goal>
            </goals>
            <configuration>
                <mainClass>com.example.Application</mainClass> <!-- 指定主类 -->
                <!-- 剔除冗余依赖 -->
                <filters>
                    <filter>
                        <artifact>*:*</artifact>
                        <excludes>
                            <exclude>META-INF/*.SF</exclude>
                            <exclude>META-INF/*.DSA</exclude>
                        </excludes>
                    </filter>
                </filters>
            </configuration>
        </execution>
    </executions>
</plugin>

适用场景

  • 非Spring Boot项目的Fat JAR打包；
  • 存在依赖冲突的复杂项目；
  • 需要定制化Fat JAR内容的场景。

5. maven-assembly-plugin：灵活的打包工具

核心作用

最灵活的打包插件，支持生成JAR、ZIP、TAR、WAR等多种格式，核心能力：

  • 自定义打包内容（包含/排除指定文件/依赖）；
  • 支持多模块聚合打包；
  • 生成包含依赖的"组装包"（如ZIP包内含JAR+lib+启动脚本）。

典型配置（生成Fat JAR）

xml 复制代码 
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>3.6.0</version>
    <executions>
        <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>com.example.Application</mainClass>
                    </manifest>
                </archive>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef> <!-- 内置所有依赖 -->
                </descriptorRefs>
            </configuration>
        </execution>
    </executions>
</plugin>

适用场景

  • 需要生成非JAR格式的打包产物（如ZIP部署包）；
  • 高度定制化的打包需求（如包含配置文件、脚本、文档）。

6、核心插件对比表

插件名称 核心定位 核心优势 适用场景
maven-compiler-plugin 源码编译 基础必备，稳定 所有Java项目
maven-jar-plugin 普通JAR打包 轻量，支持MANIFEST配置 生成普通JAR、分离打包配置
spring-boot-maven-plugin Spring Boot可执行JAR 开箱即用，适配Spring Boot Spring Boot项目Fat JAR/分离打包
maven-shade-plugin 通用Fat JAR 解决依赖冲突，定制化强 非Spring Boot项目Fat JAR、复杂依赖
maven-assembly-plugin 多格式灵活打包 支持ZIP/TAR，自定义性强 生成部署包、多格式打包

这 5 个插件并非孤立存在，而是围绕 Maven 的构建生命周期（clean、validate、compile、package 等）形成 "分工协作 + 层级依赖" 的关系，用一张图能清晰说明：

二、Maven打包核心模式详解

基于上述插件，Maven有4种主流打包模式，覆盖从单模块到多模块的所有场景。先明确核心概念：

  • 普通JAR：仅包含项目自身代码，无依赖，无法直接运行；
  • Fat JAR（胖JAR） ：包含项目代码+所有依赖，可直接java -jar运行；
  • 分离打包：项目代码与依赖分离（JAR+lib目录），需指定类路径运行。

模式1：单模块Spring Boot Fat JAR（全量打包）

核心定义

单模块项目中，通过spring-boot-maven-plugin将项目代码+所有第三方依赖打包为单个可执行JAR，是Spring Boot最基础的打包方式。

核心优势

  • 部署极简：仅需上传一个JAR文件，java -jar xxx.jar即可运行；
  • 无环境依赖：内置所有依赖，避免服务器环境缺失依赖的问题；
  • 适配Spring Boot生态：自动处理Spring Boot的类加载、启动逻辑。

完整配置

xml 复制代码 
<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>spring-boot-single</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.18</version>
        <relativePath/>
    </parent>

    <properties>
        <java.version>8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <!-- 编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.10.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            <!-- Spring Boot Fat JAR插件 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.7.18</version>
                <configuration>
                    <fork>true</fork> <!-- 支持devtools -->
                    <includeSystemScope>true</includeSystemScope> <!-- 包含system依赖 -->
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal> <!-- 生成可执行JAR -->
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>
打包流程
  1. 执行mvn clean package；
  2. maven-compiler-plugin编译源码为class文件；
  3. spring-boot-maven-plugin先生成普通JAR，再执行repackage目标重新打包为Fat JAR；
  4. 最终在target目录生成可执行JAR（如spring-boot-single.jar）。
适用场景
  • 单模块Spring Boot微服务；
  • 小型工具类项目；
  • 追求部署便捷性的场景。
优缺点
优点 缺点
部署简单（单文件） 包体积大
无环境依赖 增量更新成本高（全量替换）
适配Spring Boot生态 依赖冲突需额外处理

模式2：多模块父工程聚合打包Fat JAR

核心定义

多模块项目中，父工程（packaging=pom）负责聚合子模块、统一配置，核心业务子模块（如admin）通过继承父配置生成Fat JAR，最终输出单个可执行JAR。

核心逻辑

  • 父工程：仅做"模块聚合+配置继承"，不生成JAR；
  • 子模块：核心业务模块（如admin）依赖其他子模块（如common、system），并配置spring-boot-maven-plugin生成包含所有子模块+第三方依赖的Fat JAR。

项目结构

复制代码 
multi-module-fatjar/
├── pom.xml（父工程）
├── demo-common/（通用模块）
│   └── pom.xml
├── demo-system/（系统模块）
│   └── pom.xml
└── demo-admin/（核心业务模块，生成Fat JAR）
    └── pom.xml

完整配置

1. 父工程pom.xml
xml 复制代码 
<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>multi-module-fatjar</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>

    <!-- 聚合子模块 -->
    <modules>
        <module>demo-common</module>
        <module>demo-system</module>
        <module>demo-admin</module>
    </modules>

    <!-- 统一管理依赖版本 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.7.18</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- 子模块版本管理 -->
            <dependency>
                <groupId>com.example</groupId>
                <artifactId>demo-common</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>com.example</groupId>
                <artifactId>demo-system</artifactId>
                <version>${project.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <properties>
        <java.version>8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!-- 统一配置插件（子模块继承） -->
    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.10.1</version>
                    <configuration>
                        <source>${java.version}</source>
                        <target>${java.version}</target>
                        <encoding>${project.build.sourceEncoding}</encoding>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>
2. 核心业务模块（demo-admin）pom.xml
xml 复制代码 
<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <groupId>com.example</groupId>
        <artifactId>multi-module-fatjar</artifactId>
        <version>1.0.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>demo-admin</artifactId>
    <packaging>jar</packaging>

    <dependencies>
        <!-- 依赖其他子模块 -->
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>demo-common</artifactId>
        </dependency>
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>demo-system</artifactId>
        </dependency>
        <!-- Spring Boot核心依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>

    <build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <!-- 继承父工程的编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
            </plugin>
            <!-- 生成Fat JAR -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.7.18</version>
                <configuration>
                    <fork>true</fork>
                    <includeSystemScope>true</includeSystemScope>
                    <!-- 指定主类 -->
                    <mainClass>com.example.demo.admin.DemoAdminApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

打包流程

  1. 在父工程根目录执行mvn clean package；
  2. Maven递归编译所有子模块（demo-common→demo-system→demo-admin）；
  3. demo-admin模块的spring-boot-maven-plugin将自身代码+依赖的子模块+第三方依赖打包为Fat JAR；
  4. 最终在demo-admin/target目录生成可执行JAR（如demo-admin.jar）。

适用场景

  • 多模块Spring Boot项目；
  • 希望输出单个可执行JAR，简化部署；
  • 子模块版本统一管理的场景。

优缺点

优点 缺点
多模块统一管理 包体积大（包含所有子模块）
部署简单（单文件） 子模块变更需全量重新打包
依赖版本统一 编译耗时较长

模式3：多模块混合分离打包（业务内置，第三方外置）

核心定义

差异化处理依赖的打包方式：

  • 内部业务模块（如common、system）：内置到主JAR（频繁更新，便于替换）；
  • 第三方依赖（如Spring、MyBatis）：外置到lib目录（稳定，无需频繁更新）。
    这是若依、RuoYi-Vue等主流开源框架的生产环境标配。

完整配置（父工程）

xml 复制代码 
<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>multi-module-mix</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>

    <modules>
        <module>yq-common</module>
        <module>yq-framework</module>
        <module>yq-system</module>
        <module>yq-admin</module>
    </modules>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.7.18</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.example</groupId>
                <artifactId>yq-common</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>com.example</groupId>
                <artifactId>yq-framework</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>com.example</groupId>
                <artifactId>yq-system</artifactId>
                <version>${project.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <properties>
        <java.version>8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.10.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>

            <!-- 1. Spring Boot插件：仅内置内部业务模块 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.7.18</version>
                <configuration>
                    <layout>JAR</layout>
                    <includeSystemScope>true</includeSystemScope>
                    <includes>
                        <include>
                            <groupId>com.example</groupId>
                            <artifactId>yq-common</artifactId>
                        </include>
                        <include>
                            <groupId>com.example</groupId>
                            <artifactId>yq-framework</artifactId>
                        </include>
                        <include>
                            <groupId>com.example</groupId>
                            <artifactId>yq-system</artifactId>
                        </include>
                    </includes>
                    <mainClass>com.example.yq.admin.YqAdminApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <!-- 2. 配置MANIFEST，指向外部lib -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.3.0</version>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <classpathPrefix>lib/</classpathPrefix>
                            <mainClass>com.example.yq.admin.YqAdminApplication</mainClass>
                            <useUniqueVersions>false</useUniqueVersions>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>

            <!-- 3. 拷贝第三方依赖到lib目录（排除内部模块） -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>3.6.0</version>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
                            <excludeTransitive>false</excludeTransitive>
                            <stripVersion>false</stripVersion>
                            <includeScope>runtime</includeScope>
                            <!-- 排除内部业务模块，不拷贝到lib -->
                            <excludeGroupIds>com.example</excludeGroupIds>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

打包流程

  1. 执行mvn clean package，编译所有子模块；
  2. maven-dependency-plugin拷贝所有第三方依赖到target/lib（排除内部业务模块）；
  3. maven-jar-plugin打包主JAR，配置MANIFEST.MF指向lib目录；
  4. spring-boot-maven-plugin过滤依赖，仅将内部业务模块内置到主JAR；
  5. 最终产物：target/yq-admin.jar（含业务模块） + target/lib（含第三方依赖）。

运行方式

bash 复制代码 
# 进入target目录
cd yq-admin/target
# 运行（指定类路径包含lib目录）
java -jar yq-admin.jar

适用场景

  • 若依类多模块企业应用；
  • 业务模块频繁迭代，第三方依赖稳定的场景；
  • 追求增量更新效率的生产环境。

优缺点

优点 缺点
增量更新成本低（仅替换主JAR） 部署需同时管理JAR+lib
包体积适中 需确保lib目录完整
业务迭代便捷 配置相对复杂

模式4：多模块全分离打包（所有依赖外置）

核心定义

极致轻量化打包：主JAR仅包含启动类和少量配置，所有依赖（内部模块+第三方库）全部外置到lib目录。

核心配置（基于模式3修改）

xml 复制代码 
<!-- 仅修改关键部分，其余同模式3 -->
<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <version>2.7.18</version>
    <configuration>
        <layout>JAR</layout>
        <includeSystemScope>true</includeSystemScope>
        <!-- 排除所有依赖，主JAR仅保留启动类 -->
        <includes>
            <include>
                <groupId>nothing</groupId>
                <artifactId>nothing</artifactId>
            </include>
        </includes>
        <mainClass>com.example.yq.admin.YqAdminApplication</mainClass>
    </configuration>
    <executions>
        <execution>
            <goals>
                <goal>repackage</goal>
            </goals>
        </execution>
    </executions>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>3.6.0</version>
    <executions>
        <execution>
            <id>copy-dependencies</id>
            <phase>package</phase>
            <goals>
                <goal>copy-dependencies</goal>
            </goals>
            <configuration>
                <outputDirectory>${project.build.directory}/lib</outputDirectory>
                <excludeTransitive>false</excludeTransitive>
                <stripVersion>false</stripVersion>
                <includeScope>runtime</includeScope>
                <!-- 不排除任何依赖，所有内容都拷贝到lib -->
            </configuration>
        </execution>
    </executions>
</plugin>

打包流程

  1. 编译所有子模块；
  2. maven-dependency-plugin拷贝所有依赖 （内部模块+第三方库）到target/lib；
  3. maven-jar-plugin打包轻量主JAR（仅启动类）；
  4. spring-boot-maven-plugin排除所有依赖，确保主JAR无内置内容；
  5. 最终产物：target/yq-admin.jar（仅启动类） + target/lib（含所有依赖）。

适用场景

  • 大型多模块项目；
  • 业务模块、基础模块均频繁迭代的场景；
  • 追求极致轻量化，需单独更新某个子模块的场景。

优缺点

优点 缺点
增量更新成本极低（替换单个模块JAR） 部署复杂度最高
主JAR体积极小 易出现依赖缺失问题
模块更新独立 配置最复杂

三、四种打包模式核心对比

对比维度 模式1：单模块Fat JAR 模式2：多模块Fat JAR 模式3：混合分离打包 模式4：全分离打包
打包产物 单个可执行JAR 单个可执行JAR 主JAR+lib（第三方） 主JAR+lib（所有）
依赖存放 全部内置 全部内置 业务内置/第三方外置 全部外置
部署复杂度 极低 极低 中等 高
增量更新成本 高 高 低 极低
包体积 大 大 适中 主JAR极小
核心插件 spring-boot-maven-plugin spring-boot-maven-plugin 三者组合 三者组合
典型应用 单模块微服务 多模块微服务 若依类企业应用 大型迭代项目

四、实战选型建议

  1. 小型项目/微服务：优先选模式1（单模块Fat JAR）或模式2（多模块Fat JAR），部署简单，降低运维成本；
  2. 中大型企业应用：优先选模式3（混合分离打包），兼顾更新效率和部署便捷性，是生产环境最优解；
  3. 超大型频繁迭代项目：选模式4（全分离打包），极致轻量化，适合模块化管理的大型系统；
  4. 非Spring Boot项目 ：Fat JAR用maven-shade-plugin，分离打包用maven-jar-plugin + maven-dependency-plugin。

五、总结

  1. 核心插件是基础 ：maven-compiler-plugin是编译基石，spring-boot-maven-plugin是Spring Boot打包核心，maven-jar-plugin + maven-dependency-plugin是分离打包的关键；
  2. 打包模式看场景：Fat JAR胜在部署简单，分离打包胜在更新高效，需根据项目规模和迭代频率选择；
  3. 多模块核心逻辑：父工程仅做聚合和配置继承，可执行JAR由核心业务子模块生成，插件配置优先在父工程统一管理，子模块继承使用。
相关推荐
有来技术2 小时前
Spring Boot 4 + Vue3 企业级多租户 SaaS：从共享 Schema 架构到商业化套餐设计
java·vue.js·spring boot·后端
东东5162 小时前
xxx医患档案管理系统
java·spring boot·vue·毕业设计·智慧城市
一个响当当的名号3 小时前
lectrue9 索引并发控制
java·开发语言·数据库
进阶小白猿3 小时前
Java技术八股学习Day30
java·开发语言·学习
hhy_smile4 小时前
Class in Python
java·前端·python
qq_12498707535 小时前
基于Srpingboot心晴疗愈社平台的设计与实现（源码+论文+部署+安装）
java·数据库·spring boot·spring·microsoft·毕业设计·计算机毕业设计
大爱编程♡5 小时前
SpringBoot统一功能处理
java·spring boot·后端
leiming65 小时前
FreeRTOS 的任务与 Linux
java·开发语言
小马爱记录5 小时前
枚举策略驱动
java
热门推荐
01GitHub 镜像站点02Clawdbot 中文汉化版 接入微信、飞书03OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)042026数学建模美赛题目特点与选题建议，常用四大模型汇总05Claude Code Skills 实用使用手册06一种新的LCA算法07UV安装并设置国内源08零门槛部署本地 AI 助手：Clawdbot/Meltbot 部署深度保姆级教程09Linux下V2Ray安装配置指南10在Trae中使用Pencil MCP