springboot 工程使用proguard混淆

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

步骤 1：添加 ProGuard 插件

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

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

xml 复制代码

		<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 插件

xml 复制代码

<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 文件，并添加以下内容：

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 构建

bash 复制代码

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 文件是否能够正常启动：

bash 复制代码

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 文件的大小。