Spring之Maven的依赖详解和打包方式

标签：maven 依赖 Spring boot jar Maven 详解 spring org

正常单个pom模块的项目

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>2.0.3.RELEASE</version>
        <relativePath/>
    </parent>
    <groupId>com.cn</groupId>
    <artifactId>TestDemo</artifactId>

    <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>2.0.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.19</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.0</version>
        </dependency>
        <!-- Lombok 工具 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.14</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.plugin</groupId>
            <artifactId>spring-plugin-core</artifactId>
            <version>2.0.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.5</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.1.1.RELEASE</version>
                <configuration>
                    <fork>true</fork> <!-- 如果没有该配置，devtools不会生效 -->
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.1.0</version>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                    <warName>${project.artifactId}</warName>
                </configuration>
            </plugin>
        </plugins>
        <finalName>${project.artifactId}</finalName>
    </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:类似于编译,但支持你期待 jdk 或者容器提供,类似于 classpath
          - runtime:在执行时需要使用
          - test:用于 test 任务时使用
          - system:需要外在提供相应的元素,通过 systemPath 来取得
          - systemPath:仅用于范围为 system,提供相应的路径
          - 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如何管理依赖的版本？

创建好的项目，找到它的pom.xml文件,里面可以看一个parent属性，代码如下。

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

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

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

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

<groupId>com.cn</groupId>
<artifactId>hviger</artifactId>
<version>${hviger.version}</version>

<!--父pom需要添加<packaging>pom</packaging>-->
<packaging>pom</packaging>

<name>project-parent</name>
<description>父级依赖管理模块</description>

<!--指定了当前POM模型的版本，对于Maven2及Maven3来说，它只能是4.0.0 -->
<modelVersion>${hviger.modelVersion}</modelVersion>
<!-- 版本管理 -->
<properties>
    <hviger.version>1.0.1</hviger.version> <!-- 当前项目版本 -->
    <hviger.modelVersion>4.0.0</hviger.modelVersion>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <java.version>1.8</java.version>
    <swagger.version>3.0.0</swagger.version>
    <mybatis-plus.boot.version>3.4.0</mybatis-plus.boot.version>
    <pagehelper.boot.version>1.4.1</pagehelper.boot.version>
    <fastjson.version>1.2.79</fastjson.version>
    <lombok.version>1.18.14</lombok.version>
    <hutool.version>5.7.7</hutool.version>
</properties>
<!-- 依赖声明 -->
<!-- 父pom声明依赖时<dependencies>外要嵌套<dependencyManagement>才能被子pom继承到 -->
<dependencyManagement><!-- 这个元素并不会真的引入依赖，只会标明依赖和版本，因此必须使用子模块来继承才能使用 -->
    <dependencies>
        <!-- SpringCloud的jar包依赖 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Dalston.SR1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

        <!-- SpringBoot的依赖配置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.5.10</version>
            <type>pom</type> <!-- 依赖类型,默认类型是jar，它通常表示依赖的文件扩展名 -->
            <scope>import</scope> <!-- 把父模块中的依赖包导入进来 -->
        </dependency>

        <!-- 子模块管理起来，可以相互引用 -->
        <dependency>
            <groupId>com.cn</groupId>
            <artifactId>cn-admin</artifactId>
            <version>${hviger.version}</version>
        </dependency>
        <dependency>
            <groupId>com.cn</groupId>
            <artifactId>cn-system</artifactId>
            <version>${hviger.version}</version>
        </dependency>
        <dependency>
            <groupId>com.cn</groupId>
            <artifactId>cn-common</artifactId>
            <version>${hviger.version}</version>
        </dependency>
    </dependencies>
</dependencyManagement>

<!-- 父pom需要用<modules>方式注明有哪些子模块 -->
<modules>
    <module>cn-admin</module>
    <module>cn-system</module>
    <module>cn-common</module>
</modules>

Maven的继承和Java的继承一样，只能单继承，无法实现多继承。因为所有的jar包都混合在一起了，jar包分类就不在清晰了。

于是我们用另外一种方式实现多模块继承，这个方法就是使用<dependencyManagement>

<type>pom</type>
<scope>import</scope>

注意：这种方式只能用在<dependencyManagement></dependencyManagement>中

上面的做法其实就相当于实现了多继承，毕竟我们导入了SpringCloud和SpringBoot的两个父模块的jar包依赖

作用和好处

继承parent模块可以避免多个依赖使用相同技术时出现依赖版本冲突，当子模块再引用父级的依赖，只用写groupId和artifactId就行了，不用再指定版本号version

子模块引用父级模块

<!-- 子pom需要通过<parent></parent>指定父项目，声明依赖时就默认会用父pom中的版本了 -->
<parent>
    <artifactId>hviger</artifactId>
    <groupId>com.cn</groupId>
    <version>${hviger.version}</version><!-- 这里会报红，禁止在模块父定义中使用属性，可以不用管，也可以在Idea设置下即可 -->
</parent>
<modelVersion>${hviger.modelVersion}</modelVersion>
<artifactId>cn-common</artifactId><!-- 定义了当前maven项目在组中唯一的ID -->

<!-- 子pom默认会使用父pom中的依赖版本，如果这里再定义version就不会使用父pom里的版本了-->
<dependencies>
    <!-- Spring框架基本的核心工具 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
    </dependency>
    <!-- SpringWeb模块 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
    </dependency>
    <!-- spring security 安全认证 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</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}/lib/sdk-1.0.jar</systemPath> <!--项目根目录resources/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包下的依赖包，通过配置标签来实现，不用声明版本号

打包项目的几种方式

方式一：打jar包所有依赖都在jar包（spring）

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

方式二：打jar包所有依赖都在jar包(spring框架下有问题)

打包方式：

mvn package assembly:single

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

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

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>com.cn.WebApplication</mainClass><!-- 指定启动类 -->
                        </manifest>
                    </archive>
                    <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
            <!-- 排除一些信息不打入jar包中 -->
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <!-- 这块配置表示可以直接通过mvn package来打包，在执行package打包时，执行assembly:single -->
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

方式三：打jar包独立依赖

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

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

<build>
    <plugins>
        <!-- 配置打包，并配置MainClass，但不将依赖包打包，会出现找不到依赖的异常 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <!--   MANIFEST.MF 中 Class-Path -->
                        <classpathPrefix>lib/</classpathPrefix>
                        <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>

方式四：maven-shade-plugin (推荐)

spring 是把依赖的 jar 打包到 jar 包的 lib 目录
shade 是把依赖的 class 打包进 jar
将依赖的jar包打包到当前jar包，成为fat JAR包

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

因为大多项目是基于springboot搭建的，按springboot的教程，打包只需要使用方式一就可以。

但需要用到maven-shade-plugin插件打包，在maven-shade-plugin的dependencies添加spring-boot-maven-plugin即可，集成如下：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-maven-plugin</artifactId>
                        <version>2.1.5.RELEASE</version>
                </dependency>
            </dependencies>
            <configuration>
                <keepDependenciesWithProvidedScope>true</keepDependenciesWithProvidedScope>
                <createDependencyReducedPom>true</createDependencyReducedPom>
                <filters>
                    <filter>
                        <artifact>*:*</artifact>
                        <excludes>
                            <exclude>META-INF/*.SF</exclude>
                            <exclude>META-INF/*.DSA</exclude>
                            <exclude>META-INF/*.RSA</exclude>
                        </excludes>
                    </filter>
                </filters>
            </configuration>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                    <configuration>
                        <transformers>
                            <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"/>
                            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                <mainClass>com.xxx.App</mainClass>
                            </transformer>
                        </transformers>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

标签：maven,依赖,Spring,boot,jar,Maven,详解,spring,org
From： https://www.cnblogs.com/zhaojinhui/p/16728142.html