罗罗编程学习记录
本页内容 展开查看

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 里先写的依赖优先。

原理流程

  1. 项目 pom.xml 里直接依赖 A 和 B。
  2. A 传递依赖 C:1.0,路径是 项目 → A → C:1.0(深度 2)。
  3. B 传递依赖 C:2.0,路径是 项目 → B → C:2.0(深度 2)。
  4. 两条路径深度一样,按 first-declared-wins:pom.xml 里 A 写在 B 前面,所以选 C:1.0。
  5. 如果项目直接依赖 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 的依赖管理。

原理流程

  1. scope 控制依赖在哪个阶段可用。
  2. scope 还影响传递依赖:compile 的依赖会传递,provided 和 test 不会传递。
  3. 传递依赖的 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:排除某个传递依赖。

原理流程

  1. Gradle 收集所有依赖,不管路径深度,只要是同一个依赖。
  2. 有多个版本时,选最高的那个。
  3. 可以强制指定版本,或者排除不需要的传递依赖。

代码 / 示例

// 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 里直接声明的依赖。
  • 传递依赖:你依赖的东西,它自己依赖的其他东西,自动传给你。
  • 好处:不用手动管理所有依赖,框架会自动帮你加。
  • 问题:传递依赖可能带来版本冲突,或者引入你不想要的依赖。

原理流程

  1. 项目 pom.xml 声明依赖 spring-core。
  2. spring-core 自己依赖 spring-jcl。
  3. Maven 自动把 spring-jcl 也加进来,不用你手动声明。
  4. 这就是传递依赖。

代码 / 示例

<!-- 你只声明了 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 工具窗口。

原理流程

  1. 运行 mvn dependency:tree,看完整的依赖树。
  2. 找到冲突的依赖:同一个依赖有多个版本。
  3. 看哪个版本是你想要的,哪个是你不想要的。
  4. 在 pom.xml 里直接声明想要的版本(路径最短,nearest-wins 选它)。
  5. 或者用 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 是生产方控制。

原理流程

  1. exclusion:你在 pom.xml 里写 <exclusion>,告诉 Maven 这个传递依赖不要加进来。
  2. 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 等更细。

原理流程

  1. Maven 的 pom.xml 是声明式的,你只写配置,Maven 按约定执行。
  2. Gradle 的 build.gradle 是脚本,可以写代码、写逻辑、自定义任务。
  3. Gradle 增量编译:只重新编译修改过的文件,不用全量编译。
  4. 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。

原理流程

  1. 修了个 bug,改了 PATCH:1.2.3 → 1.2.4。
  2. 加了个新功能,向后兼容,改了 MINOR:1.2.4 → 1.3.0。
  3. 改了 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 与依赖收敛