一、继承
1、继承关系介绍
一个 Maven 项目 B 继承另外一个 Maven 项目 A ,那么 A 称为父项目, B 就称为子项目,所谓的项目之间的关系其实就是 pom 与 pom 之间的关系,(因为一个项目有且只有一个 pom.xml ,而 pom.xml 就是描述对应项目的)
使用场景:如果多个子项目中使用的是相同的依赖或插件,此时我们可以把相同的配置抽取到一个父项目中,进行统一的管理,保持一致性.
这里的管理具体是指:
- 子项目继承父项目的依赖,实现统一管理子项目有哪些依赖.
- 父项目管理依赖的版本,实现统一管理子项目依赖的版本.
值得一提的是,这里和全局变量 properties 有些不同, properties 常用来统一管理同一个项目中一类依赖的版本(例如统一管理 Spring 系列的 jar 包版本),而 Maven 继承常用来统一管理多个项目的同一个 jar 包版本
父子工程的项目,子项目最好是放在父项目的目录下,不要放在其它目录下,父项目不做任何逻辑处理,仅仅是为了管理所有的子项目,父项目里面只保留 pom.xml 就可以了.
2、IDEA 创建 Maven 项目
IDEA 创建 3 个 module ,名称分别为 parent、child01、child02
2.1、file---->new---->module
2.2、选择 Maven---->选择合适版本的 SDK---->选择合适的模板
我这里是利用 maven-archetype-quickstart 骨架创建一个 Java 项目
2.3、指定好相应配置
2.4、为了防止创建项目过慢,添加 archetypeCatalog=internal
2.5、child01、child02 创建方式和上面步骤相同,创建好的项目结构如下:
3、配置继承关系
我们这里配置成 child01、child02 都继承 parent 这个项目
这里说一下项目的打包方式, packaging 标签的取值有 jar (默认)、war、pom
打包方式：
jar： java 项目的打包方式,默认值.
war： web 项目的打包方式.
pom： 父项目的专有打包方式,该种方式,本项目不会被打包成 jar 或 war ,项目里 src 目录下代码无效(可删除), pom.xml 有效,只是作为其它项目的父项目使用.
3.1、设置父项目 pom.xml 配置打包方式为 pom
<groupId>com.xiaomaomao.archetype</groupId>
<artifactId>parent</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
3.2、child01
<groupId>com.xiaomaomao.mavenAnalyse</groupId>
<artifactId>child01</artifactId>
<version>1.0-SNAPSHOT</version>
<!--子项目将来打包成 jar 包-->
<packaging>jar</packaging>
<name>child01</name>
<!--使用 parent 标签表示该项目继承父项目,使用父项目具体坐标来引用父项目 -->
<parent>
<!--父项目的坐标-->
<groupId>com.xiaomaomao.mavenAnalyse</groupId>
<artifactId>parent</artifactId>
<version>1.0-SNAPSHOT</version>
<!--指定父项目的 pom.xml 文件的相对物理路径, ../是上一级目录,
../parent/pom.xml：相对于当前pom.xml ,先到上一级,再到 parent 目录,
找到parent目录下的 pom.xml ,鼠标左键点击如果能跳到 parent 项目的 pom.xml
那么就配置对了 -->
<relativePath>../parent/pom.xml</relativePath>
</parent>
3.3、child02
<groupId>com.xiaomaomao.mavenAnalyse</groupId>
<artifactId>child02</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>child02</name>
<parent>
<groupId>com.xiaomaomao.mavenAnalyse</groupId>
<artifactId>parent</artifactId>
<version>1.0-SNAPSHOT</version>
<relativePath>../parent/pom.xml</relativePath>
</parent>
3.4、在 parent 的 pom.xml 中添加一些测试的依赖,child01、child02 pom.xml 中不配置任何依赖
<dependencies>
<!--配置spring-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring-version}</version>
</dependency>
<!--配置webmvc-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring-version}</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
</dependencies>
3.5、依赖继承关系图
从图中可以很明显的看出, child01、child02 继承了 parent 中的依赖
4、父项目对子项目依赖的版本控制
举例: child01 模块使用 log4j 做日志记录,而 child02 模块使用 commons-logging 做日志记录(实际工作中并不会出现此种情况)
那么我们可以这样做
父工程中不引入 log4j 的依赖,也不引入 commons-logging 的依赖, child01 中声明使用 log4j
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
child02 中声明使用 commons-logging
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.0</version>
</dependency>
这样我们就实现了在不同的子工程中引用自己所需要的依赖了,这样看上去很美好,但是呢这里会遗留下一个问题,如果有一天我们需要对各个子模块的依赖进行版本切换,我们只能找到对应的子模块,然后到各个子模块中去切换依赖的版本,这样很不方便,这个时候怎么办呢?
你可能想到了我们不是有父模块吗?让父模块对子模块的依赖进行统一管理就可以了,不错,我们是可以使用父模块,但是还是会有问题,为什么呢?
如果父模块中同时引入 log4j 和 commons-logging 的依赖,确实可以统一对子模块中的依赖进行管理
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.0</version>
</dependency>
但是呢,这样做还是会存在一个问题, child01、child02 都会继承父模块中的依赖,这样原本只需要 log4j 的 child01 就会继承到自己不需要的 commons-logging,同理,child02 也会继承到 log4j ,这样的话
子模块中就很容易产生 jar 包的冲突,并且子模块会继承一些自己压根就不需要的 jar 包,那么怎么办呢?
这里我们可以使用 <dependencyManagement> 标签来解决我们上述的问题,这个标签的作用其实相当于一个对所依赖 jar 包进行版本管理的管理器.( dependencyManagement 里只是声明依赖,并不实现引入)
parent 中 pom.xml
<groupId>com.xiaomaomao.mavenAnalyse</groupId>
<artifactId>parent</artifactId>
<version>1.0-SNAPSHOT</version>
<!--父项目的特有的打包方式,必须声明为 pom-->
<packaging>pom</packaging>
<name>parent</name>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
<!--统一管理 Spring 系列的依赖的版本-->
<spring-version>5.2.8.RELEASE</spring-version>
</properties>
<!--dependencies 中的依赖会被子项目继承-->
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring-version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring-version}</version>
</dependency>
</dependencies>
<!--dependencyManagement 标签中声明的依赖,只是作为一个 jar 包统一管理的管理器
实际上该标签中声明的依赖不会被引入-->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.0</version>
</dependency>
</dependencies>
</dependencyManagement>
child 01 中 pom.xml
<groupId>com.xiaomaomao.mavenAnalyse</groupId>
<artifactId>child01</artifactId>
<version>1.0-SNAPSHOT</version>
<!--子项目将来打包成 jar 包,默认值就是 jar-->
<packaging>jar</packaging>
<name>child01</name>
<!--使用 parent 标签表示该项目继承父项目,使用具体坐标定位父项目-->
<parent>
<!--父项目的坐标-->
<groupId>com.xiaomaomao.mavenAnalyse</groupId>
<artifactId>parent</artifactId>
<version>1.0-SNAPSHOT</version>
<!--指定父项目的 pom.xml 文件的相对物理路径, ../是上一级目录,
../parent/pom.xml：相对于当前pom.xml ,先到上一级,再到 parent 目录,
找到parent目录下的 pom.xml ,鼠标左键点击如果能跳到 parent 项目的 pom.xml
那么就配置对了 -->
<relativePath>../parent/pom.xml</relativePath>
</parent>
<dependencies>
<!--依赖的版本已经由父项目通过 dependencyManagement 进行统一管理了
如果没有注明版本:那么就会默认使用父项目中的版本
如果显示的声明了版本,就使用自己声明的版本-->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
</dependency>
</dependencies>
child02 中 pom.xml
<groupId>com.xiaomaomao.mavenAnalyse</groupId>
<artifactId>child02</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>child02</name>
<parent>
<groupId>com.xiaomaomao.mavenAnalyse</groupId>
<artifactId>parent</artifactId>
<version>1.0-SNAPSHOT</version>
<relativePath>../parent/pom.xml</relativePath>
</parent>
<dependencies>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<!--子项目中显示的声明依赖版本,那么就使用子项目中声明的版本-->
<version>1.2</version>
</dependency>
</dependencies>
如上配置之后效果如下:
通过 dependencyManagement 标签,我们实现了最终的目的
子工程中相同的模块抽取到父工程的 dependencies 标签中,让每个子工程可以继承
子工程中不同的部分声明在父工程的 dependencyManagement 中,该标签中的依赖不会被父工程引用,但是使用了该标签可以对子模块中不同的依赖进行版本管理,例如:父工程中切换 log4j 和 commons-logging 的版本之后,如果子工程没有显示的声明版本,那么会随着父工程中版本的切换而同步切换
这里面还有一个 pluginManagement 标签,它是父工程对子工程插件版本的统一管理,和 dependencyManagement 的使用相同
二、聚合
聚合:将多个子项目添加到一个父项目中,然后通过对父项目进行操作( Maven 命令),从而实现对所有聚合的子项目的操作
例如:父项目执行 mvn package 操作,子项目也会被打包.
继承和聚合的区别
继承是告诉子项目它的父项目是谁,在哪里,聚合是告诉父项目它的子项目有哪些,分别在哪里
那么怎么实现聚合呢?
在父项目的 pom.xml 中配置
<!--子项目中定位父项目使用的是 pom.xml 来定位的
而父项目定位子项目使用的名字来定位的,为什么不使用
pom.xml 来定位呢?个人猜测可能是同一路径下有多个子
项目,使用 pom.xml 不能准确的定位到是哪个子项目-->
<modules>
<module>../child01</module>
<module>../child02</module>
</modules>
测试聚合后的效果
三、依赖关系
1、依赖关系的传递
项目A---->项目B---->项目C
概念:如果项目 A 依赖于项目 B ,项目 B 依赖于项目 C ，则项目 A 也依赖于项目 C ，这就叫做依赖的传递
如果觉得依赖这个词不是很好理解,可以把依赖翻译为使用,即项目 A 使用项目 B ,项目 B 使用项目 C
下面我们就来演示一个案例: child01 依赖 child02 , child02 依赖 child03 ,child03 依赖 log4j
// child01 的 pom.xml
<!--child01 依赖 child02-->
<dependencies>
<dependency>
<groupId>com.xiaomaomao</groupId>
<artifactId>child02</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
</dependencies>
// child02 的 pom.xml
<!--child02 依赖 child03-->
<dependencies>
<dependency>
<groupId>com.xiaomaomao</groupId>
<artifactId>child03</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
</dependencies>
// child03 的 pom.xml
<!--child03 依赖 log4j 1.2.12-->
<dependencies>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
</dependencies>
查看依赖关系
从上图中可以看到,实现了依赖传递
2、控制依赖的传递
并不是所有的依赖都会传递
scope 为 compile 的依赖会发生传递
下面这些情况的依赖是不会传递的
- scope 为 test 的依赖不具有依赖传递性,但是具有继承性
- scope 为 provided 的依赖不具有依赖的传递性,但是具有继承性
- 配置 optional 标签为 true 的依赖不具有依赖传递性
修改 child03 pom.xml 中的相关依赖
<dependencies>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.11.2</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.5</version>
<!--optional 的默认值为 false-->
<optional>true</optional>
</dependency>
</dependencies>
查看依赖的传递性
3、依赖传递的原则
使用 Maven 不会出现 jar 包冲突,因为其通过两个原则来保证
3.1、就近原则,依赖的 jar 包距离本项目的层级越近(路径越短),优先级越高.
依赖配置
// child01 中的 pom.xml
<dependencies>
<dependency>
<groupId>com.xiaomaomao</groupId>
<artifactId>child02</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
</dependencies>
// child02 中的 pom.xml
<dependencies>
<dependency>
<groupId>com.xiaomaomao</groupId>
<artifactId>child03</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
</dependencies>
// child03 中的 pom.xml
<dependencies>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
</dependencies>
查看结果
2、优先声明原则,在同一个 pom.xml 的 dependecy 标签里面, jar 包写在上面,优先级就越高.
依赖配置
// child01 中的 pom.xml
<dependencies>
<dependency>
<groupId>com.xiaomaomao</groupId>
<artifactId>child02</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
</dependencies>
// child02 中的 pom.xml
<dependencies>
<dependency>
<groupId>com.xiaomaomao</groupId>
<artifactId>child03</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.xiaomaomao</groupId>
<artifactId>child04</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
</dependencies>
// child03 中的 pom.xml
<dependencies>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
</dependencies>
// child04 中的 pom.xml
<dependencies>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
</dependencies>
查看结果
3、这两个原则的优先级关系?
首先按照就近原则,如果传递的依赖距离本项目的层级相同,那么再按照优先声明原则传递依赖
4、不要传递的依赖
在实际情况中有些依赖我们不希望传递,那么这些依赖该怎么处理呢?
4.1、如果当前的 pom 我们可以修改,使用 optional 标签即可
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.5</version>
<!--optional 的默认值为 false-->
<optional>true</optional>
</dependency>
4.2、如果当前的 pom.xml 我们不能修改,使用 exclusion 标签
<dependencies>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.11.2</version>
<exclusions>
<!--使用 exclusion 标签排除不需要的依赖-->
<exclusion>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>