04.1.5.1 依赖调解与版本冲突
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.1 Java / 04.1.5 Maven 与 Gradle
覆盖范围
- Maven 依赖调解规则:nearest-wins、first-declared-wins
- Gradle 依赖冲突解析:最高版本优先
- 依赖范围(scope)与传递依赖
- 排除依赖与 optional
- 依赖排查工具:mvn dependency:tree、gradle dependencies
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 04.1.5.1-001 | Maven 依赖调解规则 | 进阶 | ★★★★★ |
| 04.1.5.1-002 | Maven scope 有哪些 | 基础 | ★★★★☆ |
| 04.1.5.1-003 | Gradle 版本冲突怎么解决 | 进阶 | ★★★★☆ |
| 04.1.5.1-004 | 传递依赖是什么 | 基础 | ★★★★☆ |
| 04.1.5.1-005 | 怎么排查依赖冲突 | 进阶 | ★★★★★ |
| 04.1.5.1-006 | exclusion 和 optional 区别 | 进阶 | ★★★★☆ |
| 04.1.5.1-007 | Maven 依赖 vs Gradle 依赖 | 进阶 | ★★★★☆ |
| 04.1.5.1-008 | 版本号语义化版本是什么 | 基础 | ★★★★☆ |
04.1.5.1-001 Maven 的依赖调解规则是什么?
频率 ★★★★★ | 难度 进阶
一句话结论
Maven 依赖调解两条规则:第一是 nearest-wins(最短路径优先),依赖树里路径短的版本胜出;第二是 first-declared-wins(声明顺序优先),路径长度一样时,pom.xml 里先声明的依赖胜出。
概念解释
- 依赖树:项目 A 依赖 B,B 依赖 C,形成一棵树。
- nearest-wins:同一个依赖有多个版本时,离项目最近的版本被选中。
- first-declared-wins:路径长度一样时,pom.xml 里先写的依赖优先。
原理流程
- 项目 pom.xml 里直接依赖 A 和 B。
- A 传递依赖 C:1.0,路径是 项目 → A → C:1.0(深度 2)。
- B 传递依赖 C:2.0,路径是 项目 → B → C:2.0(深度 2)。
- 两条路径深度一样,按 first-declared-wins:pom.xml 里 A 写在 B 前面,所以选 C:1.0。
- 如果项目直接依赖 C:3.0(深度 1),那不管 A 和 B 依赖什么,都选 C:3.0(nearest-wins)。
代码 / 示例
<!-- pom.xml 示例 -->
<dependencies>
<dependency>
<groupId>org.example</groupId>
<artifactId>A</artifactId>
<version>1.0</version>
</dependency>
<dependency>
<groupId>org.example</groupId>
<artifactId>B</artifactId>
<version>1.0</version>
</dependency>
</dependencies>
<!-- 假设 A 依赖 C:1.0,B 依赖 C:2.0 -->
<!-- 路径都是 2 层,A 先声明,所以用 C:1.0 -->
常见误区
- 误区:Maven 总是选最高版本?正解:Maven 是 nearest-wins,不是 highest-wins;Gradle 才是 highest-wins。
- 误区:路径长度一样时选哪个不确定?正解:first-declared-wins,pom.xml 里先写的依赖优先。
追问 / 延伸
- 怎么强制用某个版本?答:在 pom.xml 里直接声明这个依赖,路径最短,nearest-wins 就会选它。
- 什么是依赖收敛?答:把所有版本不一致的依赖统一到一个版本,避免冲突。
04.1.5.1-002 Maven 的 scope 有哪些?
频率 ★★★★☆ | 难度 基础
一句话结论
compile(默认,编译测试运行都有)、provided(编译测试有,运行时容器提供)、runtime(运行时和测试有,编译没有)、test(只有测试有)、system(系统路径,不推荐)、import(导入 dependencyManagement)。
概念解释
- compile:默认 scope,所有阶段都有,会传递。
- provided:编译和测试时可用,运行时由容器提供(比如 servlet-api),不传递。
- runtime:运行时和测试时可用,编译时不可用(比如 JDBC 驱动),会传递。
- test:只有测试编译和测试运行时可用,不传递。
- system:和 provided 类似,但要手动指定系统路径,不推荐。
- import:只在 dependencyManagement 里用,导入其他 pom 的依赖管理。
原理流程
- scope 控制依赖在哪个阶段可用。
- scope 还影响传递依赖:compile 的依赖会传递,provided 和 test 不会传递。
- 传递依赖的 scope 组合:compile → compile,provided → provided/provided+compile,runtime → runtime,test → test。
代码 / 示例
<dependencies>
<!-- compile:默认,所有阶段都有 -->
<dependency>
<groupId>org.example</groupId>
<artifactId>common-utils</artifactId>
<version>1.0</version>
</dependency>
<!-- provided:编译测试有,运行时 Tomcat 提供 -->
<dependency>
<groupId>jakarta.servlet</groupId>
<artifactId>jakarta.servlet-api</artifactId>
<version>6.0.0</version>
<scope>provided</scope>
</dependency>
<!-- runtime:运行时才需要,编译时只要接口 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.33</version>
<scope>runtime</scope>
</dependency>
<!-- test:只有测试用 -->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>5.9.2</version>
<scope>test</scope>
</dependency>
</dependencies>
常见误区
- 误区:provided 也会传递?正解:provided 不传递,因为运行时容器提供,传递了也没用。
- 误区:runtime 编译时能用?正解:runtime 编译时不可用,只有运行时和测试时可用。
追问 / 延伸
- 为什么 servlet-api 用 provided?答:Tomcat 已经带了 servlet-api,打包时再带会冲突。
- 什么是传递依赖?答:你依赖 A,A 依赖 B,那 B 就是你的传递依赖。
04.1.5.1-003 Gradle 的版本冲突怎么解决?
频率 ★★★★☆ | 难度 进阶
一句话结论
Gradle 默认是 highest-wins(最高版本优先),同一个依赖有多个版本时选最高的;可以用 resolutionStrategy 强制指定版本,或者用 exclude 排除某个依赖。
概念解释
- highest-wins:Gradle 默认策略,同一个依赖有多个版本,选最高的那个。
- Maven 是 nearest-wins,Gradle 是 highest-wins,这是两者最大的区别。
- force:强制用某个版本。
- exclude:排除某个传递依赖。
原理流程
- Gradle 收集所有依赖,不管路径深度,只要是同一个依赖。
- 有多个版本时,选最高的那个。
- 可以强制指定版本,或者排除不需要的传递依赖。
代码 / 示例
// build.gradle
dependencies {
implementation 'org.example:A:1.0'
implementation 'org.example:B:1.0'
// 假设 A 依赖 C:1.0,B 依赖 C:2.0
// Gradle 默认选 C:2.0(最高版本)
}
// 强制用某个版本
configurations.all {
resolutionStrategy {
force 'org.example:C:1.0'
}
}
// 排除某个传递依赖
dependencies {
implementation('org.example:A:1.0') {
exclude group: 'org.example', module: 'unwanted-dependency'
}
}
常见误区
- 误区:Gradle 和 Maven 依赖调解规则一样?正解:Maven 是 nearest-wins,Gradle 是 highest-wins,完全不同。
- 误区:Gradle 选最高版本一定好?正解:高版本可能不兼容,导致运行时报错;要测试后再升级。
追问 / 延伸
- 为什么 Gradle 选最高版本?答:认为高版本兼容性更好,向后兼容;但实际不一定。
- 怎么看依赖树?答:gradle dependencies 命令。
04.1.5.1-004 传递依赖是什么?
频率 ★★★★☆ | 难度 基础
一句话结论
你依赖 A,A 依赖 B,那 B 就是你的传递依赖,你不需要直接声明 B,Maven/Gradle 会自动把 B 加进来;传递依赖也有 scope 和版本冲突的问题。
概念解释
- 直接依赖:你在 pom.xml 里直接声明的依赖。
- 传递依赖:你依赖的东西,它自己依赖的其他东西,自动传给你。
- 好处:不用手动管理所有依赖,框架会自动帮你加。
- 问题:传递依赖可能带来版本冲突,或者引入你不想要的依赖。
原理流程
- 项目 pom.xml 声明依赖 spring-core。
- spring-core 自己依赖 spring-jcl。
- Maven 自动把 spring-jcl 也加进来,不用你手动声明。
- 这就是传递依赖。
代码 / 示例
<!-- 你只声明了 spring-core -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>6.0.0</version>
</dependency>
<!-- 实际上 classpath 里还有 spring-jcl,因为 spring-core 依赖它 -->
常见误区
- 误区:传递依赖都是 compile scope?正解:传递依赖的 scope 由直接依赖的 scope 决定,compile 会传递,provided 和 test 不会。
- 误区:传递依赖越多越好?正解:传递依赖太多会导致 classpath 臃肿,版本冲突概率大。
追问 / 延伸
- 怎么排除传递依赖?答:用 exclusion 标签。
- 什么是 optional 依赖?答:optional=true 的依赖不传递,需要用时自己手动声明。
04.1.5.1-005 怎么排查依赖冲突?
频率 ★★★★★ | 难度 进阶
一句话结论
用 mvn dependency:tree 看依赖树,找到冲突的版本,然后在 pom.xml 里直接声明想要的版本,或者用 exclusion 排除不需要的传递依赖。
概念解释
- 依赖树:打印整个项目的依赖结构,能看到每个依赖是从哪里来的。
- mvn dependency:tree:Maven 自带的依赖分析工具。
- gradle dependencies:Gradle 的依赖树命令。
- IDE 里也能看:IDEA 的 Maven 工具窗口。
原理流程
- 运行 mvn dependency:tree,看完整的依赖树。
- 找到冲突的依赖:同一个依赖有多个版本。
- 看哪个版本是你想要的,哪个是你不想要的。
- 在 pom.xml 里直接声明想要的版本(路径最短,nearest-wins 选它)。
- 或者用 exclusion 排除掉不需要的传递依赖。
代码 / 示例
# 查看依赖树
mvn dependency:tree
# 输出示例:
# [INFO] +- org.example:A:jar:1.0:compile
# [INFO] | \- org.example:C:jar:1.0:compile
# [INFO] \- org.example:B:jar:1.0:compile
# [INFO] \- org.example:C:jar:2.0:compile
# 这里 C 有 1.0 和 2.0 两个版本,冲突了
# 只看某个依赖的来源
mvn dependency:tree -Dincludes=org.example:C
# 输出 C 是从哪里来的
# 解决:在 pom.xml 里直接声明 C:2.0
# <dependency>
# <groupId>org.example</groupId>
# <artifactId>C</artifactId>
# <version>2.0</version>
# </dependency>
常见误区
- 误区:依赖冲突就是运行时报 ClassNotFoundException?正解:运行时报错不一定是依赖冲突,也可能是 scope 不对(比如 provided 运行时没有)。
- 误区:依赖冲突不用管,Maven 自动处理?正解:Maven 自动选一个版本,但选的不一定是你想要的,可能运行时出错。
追问 / 延伸
- 什么是依赖收敛?答:把所有版本不一致的依赖统一到一个版本,避免冲突。
- 怎么在 IDE 里看依赖?答:IDEA 的 Maven 工具窗口,或者 Ctrl+Alt+U 看依赖图。
04.1.5.1-006 exclusion 和 optional 有什么区别?
频率 ★★★★☆ | 难度 进阶
一句话结论
exclusion 是排除某个依赖的传递依赖,对所有使用这个依赖的项目生效;optional 是声明这个依赖是可选的,不会传递给依赖它的项目。
概念解释
- exclusion:在 pom.xml 里排除某个传递依赖,比如 A 依赖 B,但你不想要 B,就 exclusion 掉。
- optional:在 A 的 pom.xml 里声明 B 是 optional,那别人依赖 A 时不会自动带 B,需要时自己手动加。
- 区别:exclusion 是消费方控制,optional 是生产方控制。
原理流程
- exclusion:你在 pom.xml 里写
<exclusion>,告诉 Maven 这个传递依赖不要加进来。 - optional:A 的作者在 pom.xml 里写
<optional>true</optional>,表示 B 是可选的,依赖 A 的人不会自动得到 B。
代码 / 示例
<!-- exclusion:你排除 A 传递过来的 B -->
<dependency>
<groupId>org.example</groupId>
<artifactId>A</artifactId>
<version>1.0</version>
<exclusions>
<exclusion>
<groupId>org.example</groupId>
<artifactId>B</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- optional:A 的作者声明 B 是可选的 -->
<!-- A 的 pom.xml -->
<dependency>
<groupId>org.example</groupId>
<artifactId>B</artifactId>
<version>1.0</version>
<optional>true</optional>
</dependency>
<!-- 别人依赖 A 时,不会自动带 B,需要时自己手动声明 -->
常见误区
- 误区:optional 依赖完全不能用?正解:本项目用是可以的,只是不传递给依赖它的项目。
- 误区:exclusion 对所有项目都生效?正解:exclusion 是写在你自己的 pom.xml 里的,只对你的项目生效。
追问 / 延伸
- 什么时候用 optional?答:有些依赖是可选功能,比如数据库驱动,用户用 MySQL 就自己加 MySQL 驱动,用 PostgreSQL 就加 PostgreSQL 驱动。
- 什么时候用 exclusion?答:传递依赖版本冲突,或者你不想要某个传递依赖,就 exclusion 掉。
04.1.5.1-007 Maven 依赖和 Gradle 依赖有什么区别?
频率 ★★★★☆ | 难度 进阶
一句话结论
Maven 是 XML 配置,约定优于配置,依赖调解是 nearest-wins;Gradle 是 Groovy/Kotlin DSL 脚本,灵活可扩展,依赖调解是 highest-wins,构建速度更快。
概念解释
- Maven:XML 配置,约定优于配置,生命周期固定,构建慢。
- Gradle:Groovy/Kotlin DSL 脚本,灵活可自定义,构建快(增量编译、构建缓存)。
- 依赖调解:Maven nearest-wins,Gradle highest-wins。
- 依赖配置:Maven 固定的 scope,Gradle 的 implementation/api/compileOnly 等更细。
原理流程
- Maven 的 pom.xml 是声明式的,你只写配置,Maven 按约定执行。
- Gradle 的 build.gradle 是脚本,可以写代码、写逻辑、自定义任务。
- Gradle 增量编译:只重新编译修改过的文件,不用全量编译。
- Gradle 构建缓存:之前构建过的任务结果可以复用,不用重新跑。
代码 / 示例
// Gradle 的依赖配置
dependencies {
implementation 'com.google.guava:guava:31.1-jre'
// implementation:编译和运行时都有,但不暴露给下游模块
api 'com.google.guava:guava:31.1-jre'
// api:编译和运行时都有,且暴露给下游模块
compileOnly 'org.projectlombok:lombok:1.18.26'
// compileOnly:只有编译时用,运行时不带
testImplementation 'junit:junit:4.13.2'
// testImplementation:只有测试用
}
常见误区
- 误区:Gradle 一定比 Maven 快?正解:小项目差不多,大项目 Gradle 快很多,因为增量编译和缓存。
- 误区:Gradle 就是 Groovy 版的 Maven?正解:Gradle 是完全不同的构建系统,更灵活,也更复杂。
追问 / 延伸
- 什么是 api 和 implementation?答:api 会传递给下游模块,implementation 不会,减少下游模块的编译依赖,加快构建速度。
- 为什么 Android 用 Gradle?答:Gradle 灵活,适合 Android 多渠道、多版本、多 Flavor 的复杂构建需求。
04.1.5.1-008 语义化版本是什么?
频率 ★★★★☆ | 难度 基础
一句话结论
语义化版本格式是 主版本.次版本.修订号(MAJOR.MINOR.PATCH),主版本变了说明有不兼容的 API 变更,次版本变了是向后兼容的新功能,修订号变了是向后兼容的 bug 修复。
概念解释
- MAJOR:主版本,不兼容的 API 变更。
- MINOR:次版本,向后兼容的新功能。
- PATCH:修订号,向后兼容的 bug 修复。
- 例子:1.2.3,主版本 1,次版本 2,修订号 3。
原理流程
- 修了个 bug,改了 PATCH:1.2.3 → 1.2.4。
- 加了个新功能,向后兼容,改了 MINOR:1.2.4 → 1.3.0。
- 改了 API,不兼容旧版本,改了 MAJOR:1.3.0 → 2.0.0。
代码 / 示例
<!-- pom.xml 里的版本号 -->
<version>1.2.3</version>
<!-- 依赖里的版本号 -->
<dependency>
<groupId>org.example</groupId>
<artifactId>my-lib</artifactId>
<version>1.2.3</version>
</dependency>
<!-- 版本范围写法 -->
<version>[1.0,2.0)</version>
<!-- 表示 >= 1.0 且 < 2.0 -->
常见误区
- 误区:版本号随便编?正解:语义化版本有严格规则,用户根据版本号判断升级风险。
- 误区:次版本升级一定安全?正解:理论上向后兼容,但实际可能有意外,要测试。
追问 / 延伸
- 什么是 SNAPSHOT 版本?答:开发中的版本,会自动更新,不是正式发布版。
- 什么是版本范围?答:Maven 支持 [1.0,2.0) 这种范围写法,但不推荐,因为构建不可复现。
待整理清单
- [ ] Maven 生命周期详解
- [ ] Gradle 任务与构建缓存
- [ ] 私服 Nexus 与镜像配置
- [ ] BOM 与依赖收敛