在 Maven 构建的 Spring Boot 项目中使用 ProGuard 进行代码混淆时，需要正确配置 Maven 插件和 ProGuard 的混淆规则。由于 Spring Boot 项目通常会依赖大量的反射机制和动态代理，因此必须特别小心确保这些部分在混淆过程中不会被破坏。

步骤 1：添加 ProGuard 插件

你需要在 pom.xml 中配置 ProGuard Maven 插件，以便在构建过程中自动执行代码混淆。

首先，确保你的 pom.xml 文件中包含了 ProGuard 插件的依赖和配置。

		<dependency>
            <groupId>com.guardsquare</groupId>
            <artifactId>proguard-base</artifactId>
            <version>7.1.1</version>
        </dependency>

        <dependency>
            <groupId>com.guardsquare</groupId>
            <artifactId>proguard-retrace</artifactId>
            <version>7.1.1</version>
        </dependency>

1.2 在 pom.xml 中添加 ProGuard 插件

<build>
        <plugins>
            <plugin>
                <groupId>com.github.wvengen</groupId>
                <artifactId>proguard-maven-plugin</artifactId>
                <version>2.6.0</version>
                <executions>
                    <!-- 以下配置说明执行mvn的package命令时候，会执行proguard-->
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>proguard</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <!-- 就是输入Jar的名称，我们要知道，代码混淆其实是将一个原始的jar，生成一个混淆后的jar，那么就会有输入输出。 -->
                    <injar>${project.build.finalName}.jar</injar>
                    <!-- 输出jar名称，输入输出jar同名的时候就是覆盖，也是比较常用的配置。 -->
                    <outjar>${project.build.finalName}.jar</outjar>
                    <!-- 是否混淆 默认是true -->
                    <obfuscate>true</obfuscate>
                    <!-- 配置一个文件，通常叫做proguard.cfg,该文件主要是配置options选项，也就是说使用proguard.cfg那么options下的所有内容都可以移到proguard.cfg中 -->
                    <proguardInclude>${project.basedir}/proguard.cfg</proguardInclude>
                    <!-- 额外的jar包，通常是项目编译所需要的jar -->
                    <libs>
                        <lib>${java.home}/lib/rt.jar</lib>
                        <lib>${java.home}/lib/jce.jar</lib>
                        <lib>${java.home}/lib/jsse.jar</lib>
                    </libs>
                    <!-- 对输入jar进行过滤比如，如下配置就是对META-INFO文件不处理。 -->
                    <inLibsFilter>!META-INF/**,!META-INF/versions/9/**.class</inLibsFilter>
                    <!-- 这是输出路径配置，但是要注意这个路径必须要包括injar标签填写的jar -->
                    <outputDirectory>${project.basedir}/target</outputDirectory>
                    <!--这里特别重要，此处主要是配置混淆的一些细节选项，比如哪些类不需要混淆，哪些需要混淆-->
                    <options>
                        <!-- 可以在此处写option标签配置，不过我上面使用了proguardInclude，故而我更喜欢在proguard.cfg中配置 -->
                    </options>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring.boot.version}</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                        <configuration>
                            <mainClass>com.example.proguard.ProguardApplication</mainClass>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

配置项说明：

• injar：指定输入的 JAR 文件，通常是构建后的可执行 JAR 文件。
• outjar：指定输出的混淆后的 JAR 文件。
• options：ProGuard 的混淆规则，包含了一些必要的保留规则，避免 Spring 和 Spring Boot 的关键类被混淆。

步骤 2：创建 ProGuard 混淆规则文件

为了确保 Spring Boot 项目的特性在混淆后能够正常运行，你需要配置 ProGuard 的规则文件。将这些规则放入项目的某个目录（如 proguard.cfg），并在 pom.xml 中引用。

2.1 创建 proguard.cfg 文件

在 src/main/resources 目录下创建一个 proguard-rules.pro 文件，并添加以下内容：

#指定Java的版本
-target 1.8
#proguard会对代码进行优化压缩，他会删除从未使用的类或者类成员变量等
-dontshrink
#是否关闭字节码级别的优化，如果不开启则设置如下配置
-dontoptimize
#混淆时不生成大小写混合的类名，默认是可以大小写混合
-dontusemixedcaseclassnames
# 对于类成员的命名的混淆采取唯一策略
-useuniqueclassmembernames
#混淆时不生成大小写混合的类名，默认是可以大小写混合
-dontusemixedcaseclassnames
#混淆类名之后，对使用Class.forName('className')之类的地方进行相应替代
-adaptclassstrings

#对异常、注解信息予以保留
-keepattributes Exceptions,InnerClasses,Signature,Deprecated,SourceFile,LineNumberTable,*Annotation*,EnclosingMethod
# 此选项将保存接口中的所有原始名称（不混淆）-->
-keepnames interface ** { *; }
# 此选项将保存所有软件包中的所有原始接口文件（不进行混淆）
#-keep interface * extends * { *; }
#保留参数名，因为控制器，或者Mybatis等接口的参数如果混淆会导致无法接受参数，xml文件找不到参数
-keepparameternames
# 保留枚举成员及方法
-keepclassmembers enum * { *; }
# 不混淆所有类,保存原始定义的注释-
-keepclassmembers class * {
                        @org.springframework.context.annotation.Bean *;
                        @org.springframework.beans.factory.annotation.Autowired *;
                        @org.springframework.beans.factory.annotation.Value *;
                        @org.springframework.stereotype.Service *;
                        @org.springframework.stereotype.Component *;
                        }

#忽略warn消息
-ignorewarnings
#忽略note消息
-dontnote
#打印配置信息
-printconfiguration
-keep public class com.example.proguard.ProguardApplication {
        public static void main(java.lang.String[]);
    }

步骤 3：构建项目并执行 ProGuard 混淆

在配置好 ProGuard 插件和混淆规则后，你可以执行构建命令并让 ProGuard 自动处理混淆过程。

3.1 执行 Maven 构建

mvn clean package

执行完构建命令后，ProGuard 将会根据配置对生成的 JAR 文件进行混淆，并输出一个混淆后的 JAR 文件。混淆后的文件将保存在目标目录下（通常是 target/）。

你可以在目标目录中找到如下的文件：

├── proguard-0.0.1.jar
├── proguard-0.0.1.jar.original
├── proguard-0.0.1_proguard_base.jar
├── proguard_map.txt
├── proguard_seed.txt

3.2 验证混淆后的 JAR 文件

为了确保混淆后项目仍然能够正常运行，特别是 Spring Boot 的应用程序，你需要测试生成的混淆后的 JAR 文件是否能够正常启动：

java -jar proguard-0.0.1.jar

如果没有问题，则说明混淆过程成功。可以看到堆栈输出中已经混淆

3.3 查看混淆后的 JAR 文件

使用GUI 工具可以看到已经代码已经混淆

总结

通过上面的步骤，你可以在 Maven 构建的 Spring Boot 项目中使用 ProGuard 进行代码混淆。关键点包括：

• 配置 proguard-maven-plugin 插件，并设置输入和输出 JAR 文件。
• 添加必要的保留规则，确保 Spring Boot 特性如反射、代理和注解能够正常工作。
• 混淆完成后，测试生成的 JAR 文件，确保应用程序能够正常启动。

通过这些步骤，你就可以在 Spring Boot 项目中实现代码混淆，提高安全性并减小 JAR 文件的大小。