Maven的依赖详解和打包方式

设置maven

maven下载与安装教程： https://blog.csdn.net/YOL888666/article/details/122008374

1. 在File->settings->搜索maven
2. Mavan home directory--设置maven安装包的bin文件夹所在的位置
3. User settings file--设置setting文件所在的位置
4. Local repository--设置本地仓库（来用存储项目下载的依赖包，可以随便配置个目录，建议就在maven安装目录下新增个文件夹repository）

IDEA有自带的maven为什么还要下载Mavan

1、如果你是新手的话，建议自行配置maven，有助于你更好的学习和理解maven，毕竟IDE会屏蔽很多细节，不利于新手学习。
2、idea自带的maven在它自己的路径和配置中，为避免升级（无论升级idea还是想升级maven）时发生莫名其妙的问题，自定义配置更能少遇到错误。
3、不依赖IDEA，你也可以在其他的IDE上开发。如果你恰好还要同时用eclipse，独立出来会更好管理，可在两个环境间共享配置和仓库。
4、idea自带的maven配置文件和仓库都在C盘，而且C盘一般不要放东西，自行配置maven，不仅可以自由管理配置文件和仓库的位置，而且可以任意换maven的版本。

SpringBoot项目pom.xml的正常配置

1、springboot项目首先继承spring-boot-starter-parent
2、引入父级springboot相关的依赖默认会使用父级中的版本号
3、其它非父级springboot中的依赖资源必须都要指定具体的版本号

<?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 http://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.3.5</version>
        <relativePath/>
    </parent>
    <groupId>com.cn</groupId>
    <artifactId>TestDemo</artifactId>

    <packaging>jar</packaging> <!-- 打包方式，默认jar，还有war包-->

    <dependencies>
        <!--springBoot-web相关依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
            <version>2023.0.1.2</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-bootstrap</artifactId>
            <version>4.1.4</version>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <version>8.2.0</version>
        </dependency>
        <!-- Lombok 工具 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.32</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.5</version>
        </dependency>
    </dependencies>
    <build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>3.3.5</version>
                <configuration>
                    <fork>true</fork> <!-- 如果没有该配置，devtools不会生效 -->
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

dependency 依赖属性详情

<!-- 该元素描述了项目相关的所有依赖，这些依赖组成了项目构建过程中的一个个环节，它们自动从项目定义的仓库中下载。要获取更多信息,请看项目依赖机制-->
<dependencies>
    <dependency>
        <groupId>org.apache.maven</groupId><!-- 依赖的group ID -->
        <artifactId>maven-artifact</artifactId><!-- 依赖的artifact ID -->
        <version>3.8.1</version><!-- 依赖的版本号。在 Maven 2 里,也可以配置成版本号的范围 -->
        <type>jar</type><!-- 依赖类型,默认类型是jar.它通常表示依赖的文件扩展名 -->
        <classifier></classifier><!-- 依赖的分类器。分类器可以区分属于同一个 POM,但不同构建方式的构件，分类器名被附加到文件名的版本号后面。例如,如果你想要构建两个单独的构件成 JAR , 一个使用 Java 1.4 编译器,另一个使用 Java 6 编译器,你就可以使用分类器来生成两个单独的 JAR 构件 -->
        <scope>test</scope><!-- 依赖范围。在项目发布过程中,帮助决定哪些构件被包括进来。欲知详情请参考依赖机制。常用取值如下所示
          - compile：默认范围，编译时可用：依赖在编译、测试和运行时都可用
          - provided：编译时可用，运行时不可用，由运行环境提供，如JDK8支持javax.servlet-api
          - runtime：在运行和测试时可用，编译时不可用，用于仅在运行时需要的库，如 JDBC 驱动
          - test：仅在测试编译和测试运行时可用，用于测试框架和库，如 JUnit、Mockito
          - system：类似于 provided，但依赖必须手动提供路径，需要在<systemPath>元素中指定依赖的路径
          - import：仅在 <dependencyManagement> 中使用：允许项目继承和管理依赖版本
          - optional：当项目自身被依赖时，标注依赖是否传递。 -->
        <systemPath></systemPath><!-- 仅供 scope 为 system 范围使用。注意,不鼓励使用这个元素,并且在新的版本中该元素可能被覆盖掉。该元素为依赖规定了文件系统上的路径。需要绝对路径而不是相对路径。推荐使用属性匹配绝对路径,例如 ${java.home} -->
        <!-- 当计算传递依赖时,从依赖构件列表里,列出被排除的依赖构件集，即告诉 maven 你只依赖指定的项目,不依赖下面的依赖。此元素主要用于解决版本冲突问题 -->
        <exclusions>
            <exclusion>
                <artifactId>spring-core</artifactId>
                <groupId>org.springframework</groupId>
            </exclusion>
        </exclusions>
        <optional>true</optional><!-- 可选依赖,如果你在项目 B 中把 C 依赖声明为可选,你就需要在依赖于 B 的项目（例如项目 A）中显式的引用对 C 的依赖。可选依赖阻断依赖的传递性 -->
    </dependency>
</dependencies>

当项目中使用 CXF + Spring 做 webservice 调用时，部分 dependency 的 type 属性取值为 pom。
因为阿里云中央仓库中 central/org/apache/cxf/apache-cxf/2.5.3/ 下的文件列表中没有 jar 文件。

如何管理SpringBoot依赖和配置

继承spring-boot-starter-parent

特点：

继承关系：直接继承 spring-boot-starter-parent。
默认配置：
- 默认的 Java 版本。
- 默认的插件配置（如 maven-compiler-plugin、maven-surefire-plugin 等）。
- 默认的资源过滤和编码设置。
依赖管理：通过 dependencyManagement 管理 Spring Boot 相关依赖的版本。
简单易用：适合大多数 Spring Boot 项目，尤其是新手。

优点：

开箱即用，减少配置。
统一管理依赖版本和插件配置。

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.3.5</version>
    <relativePath/> <!-- 设定一个空值将始终从仓库中获取，不从本地路径获取 -->
</parent>

MAVEN构建jar包时候查找顺序：relativePath元素中的地址>本地仓库>远程仓库

点进去其实你会发现他也是继承于spring-boot-dependencies

申明spring-boot-dependencies

spring-boot-dependencies 是一个 BOM（Bill of Materials），它仅提供依赖管理，不包含插件配置或其他构建配置。

如果你不想使用spring-boot-starter-parent，你依然可以通过使用spring-boot-dependencies的scope=import利用依赖管理的便利。

特点：

依赖管理：通过 dependencyManagement 管理 Spring Boot 相关依赖的版本。
灵活性：不强制继承父 POM，适合已经继承了其他父 POM 的项目。
无默认配置：需要手动配置插件和其他构建参数。

优点：

更灵活，适合复杂的项目结构。
可以与其他父 POM 结合使用。

缺点：

需要手动配置插件和其他构建参数。

<!-- 依赖声明 -->
<!-- 这个元素并不会真的引入依赖，只会标明依赖和版本，因此必须使用子模块来继承才能使用 -->
<dependencyManagement>
    <dependencies>
        <!-- SpringBoot的依赖配置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>3.3.5</version>
            <type>pom</type> <!-- 依赖类型,默认类型是jar，它通常表示依赖的文件扩展名 -->
            <scope>import</scope> <!-- 把父模块中的依赖包导入进来 -->
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
    <!--springBoot-web相关依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
</dependencies>

内置属性使用

<properties>
    <!--这里定义一个my.version的属性在下面的地方可以直接${my.version}引用这个属性-->
    <my.version>1.1.0</my.version>
</properties>
<dependencies>
    <dependency>
        <groupId>xxx.xxxx</groupId>
        <artifactId>xxxx</artifactId>
        <version>${my.version}</version>
    </dependency>
</dependencies>

引用外部jar包

方式一：dependency 本地jar包

<dependency>
    <groupId>com.im</groupId>  <!--自定义-->
    <artifactId>sdk</artifactId>    <!--自定义-->
    <version>1.0</version> <!--自定义-->
    <scope>system</scope> <!--system，类似provided，需要显式提供依赖的jar以后，Maven就不会在Repository中查找它-->
    <systemPath>${basedir}/src/main/resources/lib/sdk-1.0.jar</systemPath> <!-- 项目中的lib路径，也可以指定具体的磁盘路径-->
</dependency>

方式二：编译阶段指定外部lib

<plugin>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.3.2</version>
    <configuration>
        <source>1.8</source>
        <target>1.8</target>
        <encoding>UTF-8</encoding>
        <compilerArguments>
            <extdirs>lib</extdirs><!--指定外部lib-->
        </compilerArguments>
    </configuration>
</plugin>

方式三：将外部jar打入本地maven仓库

mvn install:install-file -Dfile=sdk-1.0.jar -DgroupId=com.im -DartifactId=sdk -Dversion=1.0 -Dpackaging=jar

引入jar包：

<dependency>
    <groupId>com.im</groupId>
    <artifactId>sdk</artifactId>
    <version>1.0</version>
</dependency>

解决JAR包冲突的三种方式

当项目所依赖的多个项目均依赖于某个相同项目名和组名的jar包，但是这些项目所依赖的jar版本号不相同时，就会导致jar包冲突，因此需要学会解决jar冲突。

1）第一声明优先原则：坐标出现在较上面的位置的jar包优先声明，先声明的jar包的依赖包能够先进入项目中

2）路径近者优先原则：直接依赖包的路径比传递依赖包近，那么最终导入项目的jar包是路径近的直接依赖包

注：maven导入jar包的一些概念：
直接依赖：项目中直接导入的jar包就是该项目的直接依赖包。
传递依赖：项目中没有直接导入的jar包，可以通过项目直接依赖包传递到项目中去

3）直接排除法：排除某个jar包下的依赖包，通过配置<exclusions>标签来实现，不用声明版本号

排查JAR包冲突，最有效方式就是Idea安装 Maven Helper 插件
查找和排除冲突依赖项的简便方法，为包含当前文件或根模块的模块运行/调试maven目标的操作，运行/调试当前测试文件的操作
打开项目的pom文件,会多出 Dependency Analyzer 的tab页

打包项目的几种方式

1、spring-boot-maven-plugin（springboot)

打jar包所有依赖都在jar包

打包原理：把依赖的 jar 打包到 jar 包的 lib 目录。

<build>
    <finalName>${project.artifactId}</finalName><!-- 打包的jar名称 -->
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <!-- 打包配置 -->
            <executions>
                <execution>
                    <goals>
                        <!-- 重新打包，把所有依赖都打进jar包中，使jar包能独立运行。-->
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

2、maven-assembly-plugin

将项目中的代码、资源、所有依赖包打成一个jar包（spring框架下有问题）

打包方式：mvn package assembly:single

高级打包方式，支持自定义的打包结构，比如sql/shell等，也可以定制依赖项等

打包后会在target目录下生成一个xxx-jar-with-dependencies.jar文件，这个文件不但包含了自己项目中的代码和资源，还包含了所有依赖包的内容。所以可以直接通过java -jar来运行。

<build>
    <finalName>${project.artifactId}</finalName><!-- 打包的jar名称 -->
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>3.4.2</version>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>com.cn.WebApplication</mainClass><!-- 指定启动类 -->
                    </manifest>
                </archive>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
            <!-- 这块配置表示可以直接通过mvn package来打包，在执行package打包时，执行assembly:single -->
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

3、maven-jar-plugin和maven-dependency-plugin（排除了依赖）

默认的打包插件，用来打普通项目Jar包，需建立lib目录里来存放需要的依赖包。

这种方式生成jar包有个缺点，就是生成的jar包太多不便于管理，上面两种方式只生成一个jar文件，包含项目本身的代码、资源以及所有的依赖包。

<build>
    <finalName>${project.artifactId}</finalName><!-- 打包的jar名称 -->
    <plugins>
        <!-- 用于生成META-INF/MANIFEST.MF文件的部分内容，但不将依赖包打包，会出现找不到依赖的异常 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>3.3.0</version>
            <configuration>
                <archive>
                    <manifest>
                        <!--  会在MANIFEST.MF加上Class-Path项并配置依赖包 -->
                        <addClasspath>true</addClasspath>
                        <!--  指定依赖包所在目录 -->
                        <classpathPrefix>lib</classpathPrefix>
                        <!--  指定MANIFEST.MF中的Main-Class -->
                        <mainClass>com.cn.WebApplication</mainClass>
                    </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>
                        <!--  将依赖包打包至target下的lib目录 -->
                        <outputDirectory>${project.build.directory}/lib</outputDirectory>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

4、maven-shade-plugin (推荐)

和maven-assembly-plugin插件的作用一样，将自己项目的代码资源以及依赖第三方的资源一起打成一个jar包。

shade可以指定或排除哪些项目依赖项，还可以配置为自动删除项目未使用的所有依赖类，从而最大限度地减少产生的jar文件的大小。

因为现在大多项目是基于springboot搭建的，没有特别情况就按springboot自带的方式一打包即可。

如果springboot需要集成maven-shade-plugin插件打包，方式如下：

<build>
    <finalName>${project.artifactId}</finalName><!-- 打包的jar名称 -->
    <plugins>
        <!-- shade打包插件 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>3.2.4</version>
            <!-- springboot本身就带有自己的打包插件spring-boot-maven-plugin，如果再引用Shade打包插件会导致一些冲突。-->
            <dependencies>
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>2.0.3.RELEASE</version>
                </dependency>
            </dependencies>
            <executions>
                <execution>
                    <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <!-- 自动移除项目中没有使用到的依赖，以此来最小化jar包的体积,建议maven-shade-plugin的版本为3.2.4，低版本会报错-->
                            <minimizeJar>true</minimizeJar>
                            <!-- 默认为 false，这避免了并行构建的构建冲突，而无需将 dependency-reduced 的 POM 移动到其他目录。 -->
                            <keepDependenciesWithProvidedScope>true</keepDependenciesWithProvidedScope>
                            <!-- 默认值为true，则依赖项保留在 pom 中，但其 scope 为 provided；如果为 false，则删除依赖项。 -->
                            <createDependencyReducedPom>true</createDependencyReducedPom>
                            <!-- 在打包时将jar包中的一些内容排除，防止重复引用打包失败 -->
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                            <!-- 使用artifactSet排除不需要的依赖，指定 groupId:artifactId 的标识-->
                            <artifactSet>
                                <excludes>
                                    <exclude>junit:junit</exclude>
                                    <exclude>jmock:*</exclude>
                                    <exclude>*:xml-apis</exclude>
                                    <exclude>org.apache.maven:lib:tests</exclude>
                                <exclude>log4j:log4j:jar:</exclude>
                            </excludes>
                        </artifactSet>
                        <transformers>
                            <!--处理多个jar包中存在重名的配置文件的合并-->
                            <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                <resource>META-INF/spring.handlers</resource>
                            </transformer>
                            <transformer implementation="org.springframework.boot.maven.PropertiesMergingResourceTransformer">
                                <resource>META-INF/spring.factories</resource>
                            </transformer>
                            <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                <resource>META-INF/spring.schemas</resource>
                            </transformer>
                            <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
                            <!--java -jar 默认启动的主类-->
                            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                 <mainClass>com.cn.WebApplication</mainClass>
                            </transformer>
                        </transformers>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

maven-war-plugin

第一步：修改打包类型，添加如下依赖

<packaging>war</packaging>

第二步：在spring-boot-starter-web依赖下排除掉spring boot内置的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>

第三步：添加servlet依赖

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>

第四步：添加maven-war-plugin打包插件，实现一些自定义配置

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-war-plugin</artifactId>
            <version>3.1.0</version>
            <configuration>
                <failOnMissingWebXml>false</failOnMissingWebXml>
                <!-- war包名字 -->
                <warName>${project.artifactId}</warName>
            </configuration>
        </plugin>
    </plugins>
</build>

第五步，增加下面这个类，或直接在启动类继承SpringBootServletInitializer类

/**
 * web容器中进行部署
 */
public class WebServletInitializer extends SpringBootServletInitializer
{
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application)
    {
        return application.sources(WebApplication.class);
    }
}

SpringBoot 在打包部署的时候打包成 jar 和 war 有什么不同?

Maven常用插件

maven-compiler-plugin

作用：该插件用于编译项目的源代码。

Maven 默认使用内置的编译器来编译 Java 源代码。

如果你需要对编译过程进行更细粒度的控制，比如指定编译器的具体版本或者编译参数，那么你应该显式地配置 maven-compiler-plugin。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.10.1</version>
    <configuration>
        <source>1.8</source>
        <source>1.8</source>
        <encoding>UTF-8</encoding>
    </configuration>
</plugin>

screw-maven-plugin

作用：用来生成数据库表结构。

<plugin>
    <groupId>cn.smallbun.screw</groupId>
    <artifactId>screw-maven-plugin</artifactId>
    <version>${lastVersion}</version>
    <dependencies>
        <!-- HikariCP -->
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
            <version>3.4.5</version>
        </dependency>
        <!--mysql driver-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.20</version>
        </dependency>
    </dependencies>
    <configuration>
        <!--username-->
        <username>root</username>
        <!--password-->
        <password>password</password>
        <!--driver-->
        <driverClassName>com.mysql.cj.jdbc.Driver</driverClassName>
        <!--jdbc url-->
        <jdbcUrl>jdbc:mysql://127.0.0.1:3306/xxxx</jdbcUrl>
        <!--生成文件类型-->
        <fileType>HTML</fileType>
        <!--打开文件输出目录-->
        <openOutputDir>false</openOutputDir>
        <!--生成模板-->
        <produceType>freemarker</produceType>
        <!--文档名称 为空时:将采用[数据库名称-描述-版本号]作为文档名称-->
        <fileName>测试文档名称</fileName>
        <!--描述-->
        <description>数据库文档生成</description>
        <!--版本-->
        <version>${project.version}</version>
        <!--标题-->
        <title>数据库文档</title>
    </configuration>
    <executions>
        <execution>
            <phase>compile</phase>
            <goals>
                <goal>run</goal>
            </goals>
        </execution>
    </executions>
</plugin>

classfinal-maven-plugin

作用：对jar包进行加密混淆，防止反编译查看源码。

<plugin>
    <!--
                1. 加密后,方法体被清空,保留方法参数、注解等信息.主要兼容swagger文档注解扫描
                2. 方法体被清空后,反编译只能看到方法名和注解,看不到方法体的具体内容
                3. 加密后的项目需要设置javaagent来启动,启动过程中解密class,完全内存解密,不留下任何解密后的文件
                4. 启动加密后的jar,生成xxx-encrypted.jar,这个就是加密后的jar文件,加密后不可直接执行
                5. 无密码启动方式,java -javaagent:xxx-encrypted.jar -jar xxx-encrypted.jar
                6. 有密码启动方式,java -javaagent:xxx-encrypted.jar='-pwd= 密码' -jar xxx-encrypted.jar
            -->
    <groupId>net.roseboy</groupId>
    <artifactId>classfinal-maven-plugin</artifactId>
    <version>1.2.1</version>
    <configuration>
        <password>#</password>
        <!-- #表示启动时不需要密码,事实上对于代码混淆来说,这个密码没什么用,它只是一个启动密码 -->
        <excludes>org.spring</excludes>
        <packages>${groupId}</packages>
        <!-- 加密的包名,多个包用逗号分开 -->
        <cfgfiles>application.yml,application-dev.yml</cfgfiles>
        <!-- 加密的配置文件,多个包用逗号分开 -->
        <libjars>hutool-all.jar</libjars>
        <!-- jar包lib下面要加密的jar依赖文件,多个包用逗号分开 -->
        <code>xxxx</code>
        <!-- 指定机器启动,机器码 -->
    </configuration>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>classFinal</goal>
            </goals>
        </execution>
    </executions>
</plugin>

上一篇Java反射机制原理详解

下一篇SpringBoot集成Nacos配置中心和服务注册

本文作者：盗梦笔记

本文链接：https://www.cnblogs.com/zhaojinhui/p/16728142.html

posted @ 2022-09-25 16:40 盗梦笔记阅读(2383) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

zhaojh

痴于道，专于道，勤于道，再不济，也是大器晚成。