高级14-Java依赖管理：使用Maven与Gradle

于 2025-08-04 08:22:31 发布
阅读量321 收藏 2
点赞数 5
CC 4.0 BY-SA版权
分类专栏： Java高级篇 文章标签： java maven 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41187124/article/details/149895050
#『AI先锋杯·14天征文挑战第3期』#

Java依赖管理：使用Maven与Gradle

在Java开发中，几乎没有任何项目能完全从零开始编写所有代码。无论是使用标准库、第三方框架（如Spring、Hibernate），还是团队内部的共享组件，依赖管理都是项目构建过程中不可或缺的环节。手动管理依赖不仅效率低下，还容易导致版本冲突、依赖缺失等问题，严重影响开发效率和项目稳定性。

目前，Java生态中最主流的依赖管理工具是Maven和Gradle。Maven以其约定优于配置的理念简化了构建流程，而Gradle则凭借灵活性和高性能成为近年来的热门选择。本文将深入解析这两款工具的核心机制、使用方法与最佳实践，帮助开发者掌握Java依赖管理的精髓。

一、依赖管理基础：为什么需要依赖管理工具？

在探讨具体工具之前，我们首先需要理解“依赖管理”的本质及其重要性。简单来说，依赖管理是指对项目所需的外部库（JAR包）进行获取、版本控制、传递依赖处理、冲突解决的全过程。

1. 手动管理依赖的痛点

在没有工具的年代，开发者需要手动下载JAR包、放入项目的lib目录，并手动处理依赖关系，这会带来一系列问题：

  • 版本混乱：不同依赖可能依赖同一库的不同版本，手动选择版本易出错。
  • 传递依赖遗漏：一个库可能依赖其他库（如Spring Core依赖commons-logging），手动追溯依赖链效率极低。
  • 构建不一致：不同开发者的本地lib目录可能存在差异，导致“在我电脑上能运行”的困境。
  • 升级困难：更新依赖版本需要手动替换JAR包，容易遗漏关联依赖。

例如，假设我们需要使用Spring Boot开发一个Web应用，手动管理依赖时需下载至少10个以上的关联JAR包（Spring Core、Spring Web、Tomcat嵌入容器、Jackson等），且需确保版本兼容——这几乎是一项不可能完成的任务。

2. 依赖管理工具的核心功能

优秀的依赖管理工具应具备以下核心能力：

  • 依赖声明：通过配置文件（如pom.xml、build.gradle）声明项目所需依赖，工具自动解析并下载。
  • 传递依赖管理：自动识别并获取依赖的依赖（传递依赖），形成完整的依赖树。
  • 版本冲突解决：当多个依赖要求同一库的不同版本时，工具按规则选择最合适的版本。
  • 仓库管理：从中央仓库（如Maven Central）或私有仓库下载依赖，并缓存到本地，避免重复下载。
  • 构建集成：将依赖管理与编译、测试、打包等构建流程无缝集成。

Maven和Gradle均具备上述功能，但实现方式和灵活性存在显著差异。接下来，我们将分别深入讲解这两款工具。

二、Maven：约定优于配置的依赖管理

Maven（Apache Maven）是2004年推出的构建工具，其核心理念是“约定优于配置（Convention Over Configuration）”。它通过标准化的项目结构、固定的构建生命周期和XML格式的配置文件（pom.xml），简化了项目构建和依赖管理流程。

1. Maven基础：POM文件与项目结构

Maven的一切配置都围绕POM（Project Object Model，项目对象模型） 文件展开。pom.xml是项目的核心配置文件，包含项目基本信息、依赖声明、构建配置等内容。

标准项目结构（约定）

Maven规定了统一的项目目录结构，无需额外配置即可识别源代码、资源文件和测试代码：

src/
├── main/                 # 主代码目录
│   ├── java/             # Java源代码（自动加入编译路径）
│   ├── resources/        # 资源文件（如application.properties，自动复制到classpath）
│   └── webapp/           # Web项目的Web资源（如JSP、CSS，适用于Servlet项目）
├── test/                 # 测试代码目录
│   ├── java/             # 测试源代码（如JUnit测试类）
│   └── resources/        # 测试资源文件
└── pom.xml               # Maven核心配置文件
target/                   # 构建输出目录（自动生成，包含class文件、JAR包等）

这种约定的优势在于：开发者接手新项目时，无需学习目录结构规则，即可快速定位代码位置。

POM文件基本结构

一个最简化的pom.xml文件包含项目坐标、依赖声明等核心元素：

<?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">
    <!-- POM模型版本（固定为4.0.0） -->
    <modelVersion>4.0.0</modelVersion>

    <!-- 项目坐标：唯一标识一个项目 -->
    <groupId>com.example</groupId>   <!-- 组织/公司标识（通常是域名反转） -->
    <artifactId>demo-project</artifactId>  <!-- 项目名称 -->
    <version>1.0.0</version>         <!-- 项目版本 -->
    <name>Demo Project</name>        <!-- 项目显示名称 -->
    <description>A simple Maven project</description>  <!-- 项目描述 -->

    <!-- 依赖声明 -->
    <dependencies>
        <!-- 单个依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.7.0</version>  <!-- 依赖版本 -->
        </dependency>

        <!-- 测试依赖 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>  <!-- 依赖范围：仅测试阶段生效 -->
        </dependency>
    </dependencies>
</project>

核心概念：项目坐标（GAV）
Maven通过groupId:artifactId:version（简称GAV）唯一标识一个项目或依赖，这是依赖管理的基础。例如，org.springframework.boot:spring-boot-starter-web:2.7.0明确指向Spring Boot Web Starter的2.7.0版本。

2. 依赖声明与范围管理

在Maven中，依赖通过<dependencies>标签声明。每个依赖包含GAV坐标，还可通过<scope>指定依赖范围，控制依赖在不同构建阶段的可见性。

依赖范围（Scope）

Maven定义了6种依赖范围，用于限制依赖的传递性和生效阶段：

范围描述编译期可见测试期可见运行期可见传递性依赖
compile默认范围，适用于主代码和测试代码，打包时会包含✅✅✅✅
test仅用于测试代码（如JUnit），主代码不可用，打包时不包含❌✅❌❌
provided编译和测试时需要，但运行时由容器提供（如Servlet API），打包时不包含✅✅❌❌
runtime编译时不需要（如JDBC驱动），但运行和测试时需要，打包时包含❌✅✅✅
system类似provided，但依赖需手动指定本地路径（不推荐，易导致构建不一致）✅✅❌❌
import仅用于<dependencyManagement>，导入其他POM的依赖管理配置（ Maven 2.0.9+）----

示例：不同范围的依赖声明

<dependencies>
    <!-- 编译、测试、运行都需要（默认compile） -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.13.3</version>
    </dependency>

    <!-- 仅测试时需要 -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.9.2</version>
        <scope>test</scope>
    </dependency>

    <!-- 编译和测试需要，运行时由Tomcat容器提供 -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
        <scope>provided</scope>
    </dependency>

    <!-- 编译时不需要（动态加载），运行时需要 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.30</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>
可选依赖与依赖排除

在实际开发中，我们可能需要控制传递依赖的行为：

  • 可选依赖（Optional）：当项目A依赖项目B，且B中的某些依赖不应传递给A的使用者时，可将B中的依赖标记为<optional>true</optional>。
  • 依赖排除（Exclusion）：当项目引入的依赖包含不需要的传递依赖时，可通过<exclusions>主动排除。

示例：可选依赖与排除

<!-- 项目B的pom.xml：声明可选依赖 -->
<dependencies>
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>31.1-jre</version>
        <optional>true</optional>  <!-- 此依赖不会传递给依赖B的项目 -->
    </dependency>
</dependencies>

<!-- 项目A的pom.xml：排除传递依赖 -->
<dependencies>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>project-b</artifactId>
        <version>1.0.0</version>
        <!-- 排除project-b传递的log4j依赖（避免与logback冲突） -->
        <exclusions>
            <exclusion>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <!-- 无需指定版本，排除所有版本 -->
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

3. 依赖传递与冲突解决

Maven的传递依赖机制是其核心优势之一：当项目依赖A，而A依赖B时，Maven会自动将B引入项目，无需手动声明。但传递依赖也可能导致版本冲突（多个依赖要求同一库的不同版本），Maven通过特定规则解决冲突。

传递依赖的解析规则

Maven通过“依赖树”描述项目的所有依赖（包括传递依赖）。例如，项目依赖spring-boot-starter-web，而它又依赖spring-core、tomcat-embed-core等，形成多层依赖关系。

可通过以下命令查看项目的依赖树：

mvn dependency:tree

输出示例（简化）：

[INFO] com.example:demo-project:jar:1.0.0
[INFO] \- org.springframework.boot:spring-boot-starter-web:jar:2.7.0:compile
[INFO]    +- org.springframework.boot:spring-boot-starter:jar:2.7.0:compile
[INFO]    |  +- org.springframework.boot:spring-boot:jar:2.7.0:compile
[INFO]    |  \- org.springframework.boot:spring-boot-autoconfigure:jar:2.7.0:compile
[INFO]    +- org.springframework.boot:spring-boot-starter-json:jar:2.7.0:compile
[INFO]    |  +- com.fasterxml.jackson.core:jackson-databind:jar:2.13.3:compile
[INFO]    |  \- com.fasterxml.jackson.datatype:jackson-datatype-jsr310:jar:2.13.3:compile
[INFO]    \- org.springframework:spring-web:jar:5.3.21:compile
版本冲突解决策略

当依赖树中出现同一库的多个版本时，Maven按以下优先级选择版本：

  1. 路径最近者优先：直接声明的依赖版本优先于传递依赖的版本。例如，项目直接声明jackson-databind:2.14.0，而传递依赖引入2.13.3，则使用2.14.0。

  2. 第一声明者优先：当多个传递依赖的路径长度相同时（如同一层级的不同依赖都依赖同一库），在POM中先声明的依赖对应的版本被选中。

示例：冲突场景与解决

假设项目依赖：

  • spring-boot-starter-web:2.7.0 传递依赖 jackson-databind:2.13.3
  • 项目直接声明 jackson-databind:2.14.0

此时，Maven会选择2.14.0（路径最近者优先）。

若需强制指定版本（覆盖默认规则），可使用依赖管理（Dependency Management）。

4. 依赖管理（Dependency Management）

dependencyManagement用于集中管理依赖版本，解决多模块项目中版本不一致的问题。它的作用是声明依赖版本，而非实际引入依赖；子模块可通过简化声明继承版本。

单模块项目中的依赖管理
<project>
    <!-- 其他配置... -->
    <dependencyManagement>
        <dependencies>
            <!-- 声明Spring Boot版本 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>2.7.0</version>
            </dependency>
            <!-- 声明Jackson版本 -->
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>2.14.0</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- 实际依赖：无需指定version，继承dependencyManagement中的版本 -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <!-- 版本由dependencyManagement控制 -->
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <!-- 版本由dependencyManagement控制 -->
        </dependency>
    </dependencies>
</project>
多模块项目中的依赖管理

在多模块项目中，通常在父POM中定义dependencyManagement，子模块继承父POM并简化依赖声明：

<!-- 父POM（pom.xml） -->
<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>parent-project</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>  <!-- 父模块必须为pom打包 -->
    <modules>
        <module>module-a</module>  <!-- 子模块A -->
        <module>module-b</module>  <!-- 子模块B -->
    </modules>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>2.7.0</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

<!-- 子模块A的pom.xml -->
<project>
    <parent>
        <groupId>com.example</groupId>
        <artifactId>parent-project</artifactId>
        <version>1.0.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>module-a</artifactId>

    <dependencies>
        <!-- 直接继承父POM的版本 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>
导入外部依赖管理配置

对于Spring Boot、Spring Cloud等框架，官方提供了预定义的依赖管理POM，可通过<scope>import</scope>导入，避免手动声明版本：

<dependencyManagement>
    <dependencies>
        <!-- 导入Spring Boot的依赖管理 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.7.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <!-- 使用Spring Boot依赖，无需指定版本 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
</dependencies>

5. 仓库配置：从哪里获取依赖？

Maven依赖默认从中央仓库（Maven Central） 下载，但在实际开发中，我们可能需要从私有仓库（如公司内部仓库）或其他第三方仓库获取依赖。

仓库类型

Maven支持多种仓库类型：

  • 中央仓库（Central Repository）：默认仓库，无需配置即可使用，包含绝大多数开源Java库，地址：https://repo.maven.apache.org/maven2。
  • 远程仓库：第三方或私有仓库（如Nexus、Artifactory），需手动配置。
  • 本地仓库：依赖下载到本地的缓存目录（默认~/.m2/repository），避免重复下载。
配置远程仓库

可在POM中或Maven全局配置（~/.m2/settings.xml）中声明远程仓库：

在POM中配置远程仓库：

<repositories>
    <!-- 阿里云Maven镜像（加速国内下载） -->
    <repository>
        <id>aliyun-central</id>
        <name>Aliyun Central Repository</name>
        <url>https://maven.aliyun.com/repository/central</url>
        <releases>
            <enabled>true</enabled>  <!-- 允许下载发布版 -->
        </releases>
        <snapshots>
            <enabled>false</enabled> <!-- 禁用快照版（可选） -->
        </snapshots>
    </repository>

    <!-- Spring Snapshots仓库（获取开发中的快照版本） -->
    <repository>
        <id>spring-snapshots</id>
        <name>Spring Snapshots</name>
        <url>https://repo.spring.io/snapshot</url>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
</repositories>

在settings.xml中配置全局仓库：

全局配置对所有项目生效，推荐用于配置镜像仓库（如阿里云）加速下载：

<!-- ~/.m2/settings.xml -->
<settings>
    <mirrors>
        <!-- 阿里云镜像（替代中央仓库） -->
        <mirror>
            <id>aliyun-mirror</id>
            <mirrorOf>central</mirrorOf>  <!-- 镜像中央仓库 -->
            <name>Aliyun Mirror</name>
            <url>https://maven.aliyun.com/repository/central</url>
        </mirror>
    </mirrors>
</settings>
私有仓库配置

企业开发中，通常使用私有仓库（如Sonatype Nexus）管理内部组件和第三方依赖缓存。配置方式如下：

<repositories>
    <repository>
        <id>company-nexus</id>
        <name>Company Private Repository</name>
        <url>http://nexus.company.com/repository/maven-public/</url>
        <releases>
            <enabled>true</enabled>
        </releases>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
</repositories>

<!-- 若私有仓库需要认证，在settings.xml中配置 -->
<servers>
    <server>
        <id>company-nexus</id>  <!-- 与repository的id一致 -->
        <username>your-username</username>
        <password>your-password</password>
    </server>
</servers>

6. Maven插件与依赖管理扩展

Maven的功能通过插件扩展，许多插件与依赖管理密切相关，例如分析依赖、复制依赖到指定目录等。

常用依赖管理插件

  1. dependency插件：用于分析依赖树、复制依赖、检查未使用依赖等。

    # 查看依赖树
mvn dependency:tree

# 复制项目所有依赖到target/lib目录
mvn dependency:copy-dependencies -DoutputDirectory=target/lib

# 分析未使用的依赖
mvn dependency:analyze

  2. versions插件：用于管理依赖版本升级，检查是否有新版本可用。

    # 显示可升级的依赖
mvn versions:display-dependency-updates

# 自动更新POM中的依赖版本到最新
mvn versions:use-latest-releases

  3. enforcer插件：强制依赖版本规范，避免引入未授权的依赖或冲突版本。

    <build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-enforcer-plugin</artifactId>
            <version>3.2.1</version>
            <executions>
                <execution>
                    <goals>
                        <goal>enforce</goal>
                    </goals>
                    <configuration>
                        <rules>
                            <!-- 强制Jackson版本必须为2.14.x -->
                            <dependencyConvergence />
                            <requireDependencyVersion>
                                <includes>
                                    <include>com.fasterxml.jackson.core:*</include>
                                </includes>
                                <versionPattern>2.14.*</versionPattern>
                            </requireDependencyVersion>
                        </rules>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

三、Gradle：灵活高效的新一代构建工具

Gradle 诞生于2012年，它融合了Maven的约定优于配置理念和Ant的灵活性，采用Groovy或Kotlin作为构建脚本语言，支持增量构建和高性能依赖管理，已成为Android开发的默认工具，并在Java生态中迅速普及。

1. Gradle基础：项目结构与构建脚本

Gradle的项目结构与Maven类似（遵循约定），但构建脚本格式更灵活，默认使用build.gradle（Groovy DSL）或build.gradle.kts（Kotlin DSL）。

标准项目结构

Gradle默认项目结构与Maven一致，无需额外配置即可识别源代码和资源：

src/
├── main/
│   ├── java/         # 主Java代码
│   └── resources/    # 主资源文件
├── test/
│   ├── java/         # 测试Java代码
│   └── resources/    # 测试资源文件
├── build.gradle      # Gradle构建脚本（Groovy DSL）
└── settings.gradle   # 项目设置（如模块名称）
build/                # 构建输出目录（自动生成）
构建脚本基本结构（Groovy DSL）

一个基础的build.gradle包含插件声明、依赖管理、仓库配置等：

// 应用Java插件（提供编译、测试、打包等基础任务）
plugins {
    id 'java'
    id 'application'  // 应用程序插件（支持运行主类）
}

// 项目基本信息
group = 'com.example'
version = '1.0.0'
description = 'A simple Gradle project'

// 主类配置（application插件需要）
mainClassName = 'com.example.DemoApplication'

// 仓库配置（从哪里下载依赖）
repositories {
    mavenCentral()  // Maven中央仓库
    maven { url 'https://maven.aliyun.com/repository/central' }  // 阿里云仓库
}

// 依赖声明
dependencies {
    // 编译期依赖（对应Maven的compile）
    implementation 'org.springframework.boot:spring-boot-starter-web:2.7.0'

    // 测试依赖（对应Maven的test）
    testImplementation 'junit:junit:4.13.2'

    // 运行时依赖（对应Maven的runtime）
    runtimeOnly 'mysql:mysql-connector-java:8.0.30'

    // 编译期需要，运行时由容器提供（对应Maven的provided）
    providedCompile 'javax.servlet:javax.servlet-api:3.1.0'
}

// 自定义任务：打印项目信息
task printProjectInfo {
    doLast {
        println "Project: ${project.name}, Version: ${project.version}"
    }
}
Kotlin DSL示例（build.gradle.kts）

Kotlin DSL语法更严谨，适合喜欢静态类型检查的开发者：

plugins {
    java
    application
}

group = "com.example"
version = "1.0.0"
description = "A simple Gradle project"

mainClassName.set("com.example.DemoApplication")

repositories {
    mavenCentral()
    maven { url = uri("https://maven.aliyun.com/repository/central") }
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web:2.7.0")
    testImplementation("junit:junit:4.13.2")
    runtimeOnly("mysql:mysql-connector-java:8.0.30")
    providedCompile("javax.servlet:javax.servlet-api:3.1.0")
}

tasks.register("printProjectInfo") {
    doLast {
        println("Project: ${project.name}, Version: ${project.version}")
    }
}

2. 依赖配置与范围

Gradle通过依赖配置（Configuration） 管理依赖的作用范围，类似于Maven的scope，但更灵活。每个配置代表一组依赖的集合，用于特定的构建阶段或任务。

核心依赖配置

Java插件预定义了多个常用配置，对应不同的依赖场景：

配置名称描述对应Maven范围
implementation编译和运行时需要，传递依赖对下游项目不可见（推荐默认使用）compile
api编译和运行时需要，传递依赖对下游项目可见（适用于库项目的公共API依赖）compile
compileOnly仅编译期需要，运行时不需要（如Lombok）provided
runtimeOnly运行时需要，编译期不需要（如JDBC驱动）runtime
testImplementation测试编译和运行时需要（如JUnit）test
testCompileOnly仅测试编译期需要test（provided）
testRuntimeOnly仅测试运行时需要test（runtime）

示例：不同配置的依赖声明

dependencies {
    // 核心依赖（编译和运行时需要，传递依赖不暴露给下游）
    implementation 'com.fasterxml.jackson.core:jackson-databind:2.13.3'

    // 库项目的公共API依赖（传递依赖暴露给下游）
    api 'org.springframework:spring-core:5.3.21'

    // 仅编译期需要（Lombok在编译时生成代码）
    compileOnly 'org.projectlombok:lombok:1.18.24'
    annotationProcessor 'org.projectlombok:lombok:1.18.24'  // Lombok注解处理器

    // 运行时需要（数据库驱动）
    runtimeOnly 'com.h2database:h2:2.1.214'

    // 测试依赖
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.2'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.2'
}

关键区别：implementation vs api

  • 使用implementation时，依赖的传递依赖对下游项目不可见（下游需显式声明自己的依赖），可减少依赖传递，提升构建性能。
  • 使用api时，依赖的传递依赖对下游项目可见（类似Maven的compile），适用于库项目中暴露给使用者的API依赖。
自定义依赖配置

Gradle允许创建自定义配置，满足特殊需求：

// 定义自定义配置
configurations {
    // 用于集成测试的依赖
    integrationTestImplementation {
        extendsFrom implementation  // 继承implementation的依赖
        canBeConsumed = false
        canBeResolved = true
    }
}

// 使用自定义配置
dependencies {
    integrationTestImplementation 'org.springframework.boot:spring-boot-starter-test:2.7.0'
}

// 自定义集成测试任务
task integrationTest(type: Test) {
    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = configurations.integrationTestImplementation + sourceSets.integrationTest.runtimeClasspath
}

3. 依赖传递与冲突解决

与Maven类似，Gradle自动处理传递依赖，并提供更灵活的冲突解决策略。

查看依赖树

通过以下命令查看项目依赖树：

# 查看所有依赖
gradle dependencies

# 查看特定配置的依赖（如implementation）
gradle dependencies --configuration implementation

# 查看测试依赖
gradle dependencies --configuration testImplementation

输出示例（简化）：

implementation - Implementation only dependencies for source set 'main'.
+--- org.springframework.boot:spring-boot-starter-web:2.7.0
|    +--- org.springframework.boot:spring-boot-starter:2.7.0
|    |    +--- org.springframework.boot:spring-boot:2.7.0
|    |    \--- org.springframework.boot:spring-boot-autoconfigure:2.7.0
|    +--- org.springframework.boot:spring-boot-starter-json:2.7.0
|    |    +--- com.fasterxml.jackson.core:jackson-databind:2.13.3
|    |    \--- com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.13.3
|    \--- org.springframework:spring-web:5.3.21
依赖冲突解决策略

当存在版本冲突时，Gradle默认采用“最新版本优先”策略（与Maven不同），即选择依赖树中版本号最高的版本。若需自定义策略，可通过以下方式配置：

  1. 强制指定版本：
dependencies {
    // 强制使用Jackson 2.14.0，覆盖所有传递依赖的版本
    implementation('com.fasterxml.jackson.core:jackson-databind:2.14.0') {
        force = true
    }
}
  1. 全局版本约束：在configuration中声明版本约束，统一控制依赖版本：
configurations.all {
    resolutionStrategy {
        // 所有配置中，Jackson版本必须为2.14.x
        force 'com.fasterxml.jackson.core:jackson-databind:2.14.0'
        force 'com.fasterxml.jackson.core:jackson-core:2.14.0'
    }
}
  1. 排斥传递依赖：排除特定依赖的传递依赖：
dependencies {
    implementation('org.springframework.boot:spring-boot-starter-web:2.7.0') {
        // 排除logback依赖（例如，改用log4j2）
        exclude group: 'ch.qos.logback', module: 'logback-classic'
    }
}
  1. 禁用传递依赖：对某个依赖完全禁用传递依赖：
dependencies {
    implementation('com.example:some-library:1.0.0') {
        transitive = false  // 不引入该库的任何传递依赖
    }
}

4. 依赖管理与版本 Catalog

Gradle提供了多种方式集中管理依赖版本，避免版本分散在多个地方。

集中版本声明

最基础的方式是在ext（额外属性）中声明版本，然后在依赖中引用：

// 集中声明版本
ext {
    springBootVersion = '2.7.0'
    jacksonVersion = '2.14.0'
    junitVersion = '5.9.2'
}

dependencies {
    implementation "org.springframework.boot:spring-boot-starter-web:${springBootVersion}"
    implementation "com.fasterxml.jackson.core:jackson-databind:${jacksonVersion}"
    testImplementation "org.junit.jupiter:junit-jupiter-api:${junitVersion}"
}
使用平台（Platform）管理版本

对于多模块项目，可通过“平台（Platform）”统一管理依赖版本，类似Maven的dependencyManagement：

  1. 创建平台模块（通常是一个java-platform类型的模块）：
// platform模块的build.gradle
plugins {
    id 'java-platform'  // 平台插件
}

group = 'com.example'
version = '1.0.0'

// 声明约束的版本
dependencies {
    constraints {
        api 'org.springframework.boot:spring-boot-starter-web:2.7.0'
        api 'com.fasterxml.jackson.core:jackson-databind:2.14.0'
        api 'org.junit.jupiter:junit-jupiter-api:5.9.2'
    }
}
  1. 在其他模块中引入平台：
// 应用平台约束
dependencies {
    implementation platform(project(':platform'))  // 引入本地平台模块
    // 或引入外部平台（如Spring Boot的平台）
    implementation platform('org.springframework.boot:spring-boot-dependencies:2.7.0')

    // 依赖无需指定版本，由平台控制
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'com.fasterxml.jackson.core:jackson-databind'
    testImplementation 'org.junit.jupiter:junit-jupiter-api'
}
版本Catalog（Gradle 7.0+）

Gradle 7.0引入了版本Catalog，这是一种更强大的集中版本管理方式，支持跨项目共享依赖版本定义。

  1. 定义Catalog：在settings.gradle中或单独的libs.versions.toml文件中声明：
# gradle/libs.versions.toml
[versions]
spring-boot = "2.7.0"
jackson = "2.14.0"
junit = "5.9.2"

[libraries]
spring-boot-web = { group = "org.springframework.boot", name = "spring-boot-starter-web", version.ref = "spring-boot" }
jackson-databind = { group = "com.fasterxml.jackson.core", name = "jackson-databind", version.ref = "jackson" }
junit-jupiter = { group = "org.junit.jupiter", name = "junit-jupiter-api", version.ref = "junit" }

[bundles]
# 依赖组合：一次引入多个相关依赖
spring-web = ["spring-boot-web", "jackson-databind"]
  1. 使用Catalog中的依赖：
// build.gradle
dependencies {
    // 引用单个依赖
    implementation libs.spring.boot.web
    implementation libs.jackson.databind
    testImplementation libs.junit.jupiter

    // 引用依赖组合
    implementation libs.bundles.spring.web
}

版本Catalog的优势在于：支持IDE自动补全、集中管理版本、易于跨项目共享。

5. 仓库配置与依赖缓存

Gradle支持从Maven仓库、Ivy仓库等获取依赖，并通过高效的缓存机制提升构建速度。

仓库配置

与Maven类似，Gradle在repositories块中配置仓库：

repositories {
    // Maven中央仓库
    mavenCentral()

    // 阿里云仓库（加速国内下载）
    maven {
        url 'https://maven.aliyun.com/repository/central'
        // 仓库认证（如需）
        credentials {
            username = 'your-username'
            password = 'your-password'
        }
    }

    // 本地Maven仓库（~/.m2/repository）
    mavenLocal()

    // Spring快照仓库
    maven {
        url 'https://repo.spring.io/snapshot'
        // 仅允许下载快照版本
        content {
            includeGroup 'org.springframework'
            includeStatus 'SNAPSHOT'
        }
    }
}

仓库优先级：依赖下载时，Gradle按仓库在repositories中的声明顺序查找，找到后停止搜索。建议将私有仓库或镜像仓库放在前面，提高下载速度。

依赖缓存机制

Gradle的依赖缓存位于~/.gradle/caches/modules-2/files-2.1，相比Maven的缓存机制更高效：

  • 增量缓存：仅下载缺失或更新的依赖，避免重复下载。
  • 元数据缓存：缓存依赖的元数据（如POM文件），减少远程仓库请求。
  • 缓存清理：
# 清理所有缓存
gradle cleanBuildCache

# 清理特定依赖的缓存（需插件支持）
gradle dependencyPurge

6. Gradle任务与依赖管理自动化

Gradle的任务系统非常灵活，可通过自定义任务实现依赖相关的自动化操作。

常用依赖相关任务
任务名称描述
dependencies显示项目依赖树
dependencyInsight显示特定依赖的详细信息（如版本冲突原因）
downloadDependencies预下载所有依赖到本地缓存
projectReport生成项目报告（包含依赖信息）

示例：查看特定依赖的详细信息

gradle dependencyInsight --dependency jackson-databind --configuration implementation

输出示例：

com.fasterxml.jackson.core:jackson-databind:2.14.0 (selected by rule)
   variant "runtime" [
      org.gradle.status = release (not requested)
      org.gradle.usage = java-runtime (not requested)
      org.gradle.libraryelements = jar (not requested)
      org.gradle.category = library (not requested)
   ]
\--- implementation
自定义依赖相关任务

例如，创建一个任务将依赖复制到lib目录：

// 复制runtime依赖到build/libs目录
task copyDependencies(type: Copy) {
    from configurations.runtimeClasspath
    into "${buildDir}/libs"
    // 排除重复的JAR包（保留最新版本）
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

// 让打包任务依赖此任务
jar.dependsOn copyDependencies

运行任务：

gradle copyDependencies

四、Maven与Gradle对比：如何选择？

Maven和Gradle各有优势，选择时需结合项目特点、团队熟悉度和生态需求。

1. 核心差异对比

特性MavenGradle
配置语言XML（固定格式，较繁琐）Groovy/Kotlin DSL（灵活，简洁）
依赖冲突解决路径最近者优先 → 第一声明者优先最新版本优先（可自定义策略）
构建性能无增量构建，性能一般增量构建、缓存优化，性能显著优于Maven
灵活性约定优于配置，定制化需编写插件高度灵活，支持通过任务和脚本定制流程
生态与插件生态成熟，插件丰富生态完善，支持Maven插件兼容
学习曲线低（XML配置简单直观）中（需学习Groovy/Kotlin和DSL语法）
多模块项目支持支持，但配置较繁琐支持，通过settings.gradle轻松管理
依赖管理高级特性依赖管理、导入POM版本Catalog、平台约束、依赖锁定

2. 适用场景分析

优先选择Maven的场景
  • 小型项目或快速启动：Maven的约定优于配置理念，无需复杂配置即可快速上手。
  • 团队熟悉XML：团队对XML配置更熟悉，学习成本更低。
  • 依赖简单且稳定：项目依赖少，版本冲突少，无需复杂的依赖管理策略。
  • 与传统工具集成：需与依赖Maven的老系统或工具集成。
优先选择Gradle的场景
  • 大型多模块项目：Gradle的增量构建和高性能可显著提升构建速度。
  • 复杂构建需求：需要自定义构建流程、多语言混合开发（如Java+Kotlin）。
  • 频繁版本迭代：需频繁更新依赖版本，Gradle的版本Catalog和冲突解决更灵活。
  • Android开发：Gradle是Android官方推荐的构建工具。
  • 追求构建效率：对构建速度有较高要求（如CI/CD环境）。

3. 从Maven迁移到Gradle

如果需要从Maven迁移到Gradle，可借助Gradle提供的自动转换工具：

# 在Maven项目根目录执行，自动生成Gradle构建脚本
gradle init --type pom

转换后需手动调整以下内容：

  • 依赖配置映射（如compile → implementation）。
  • 插件替换（Maven插件 → Gradle对应插件）。
  • 自定义任务迁移（Maven插件目标 → Gradle任务）。

示例：Maven插件与Gradle插件对应关系

Maven插件Gradle插件
maven-compiler-pluginjava 插件（内置编译功能）
maven-surefire-pluginjava-test-fixtures 插件
spring-boot-maven-pluginorg.springframework.boot 插件
maven-assembly-plugindistribution 插件

五、依赖管理最佳实践

无论使用Maven还是Gradle，遵循以下最佳实践都能提升依赖管理的效率和项目稳定性。

1. 集中管理依赖版本

  • 避免版本硬编码：将版本号集中声明（如Maven的dependencyManagement、Gradle的版本Catalog），便于统一升级。
  • 使用平台或BOM：对于框架（如Spring Boot、Jakarta EE），优先使用官方提供的BOM或平台，避免版本冲突。

示例：Spring Boot项目使用官方BOM

<!-- Maven -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.7.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

// Gradle
dependencies {
    implementation platform('org.springframework.boot:spring-boot-dependencies:2.7.0')
    implementation 'org.springframework.boot:spring-boot-starter-web' // 无需版本
}

2. 控制依赖数量与范围

  • 最小化依赖：仅引入必要的依赖，避免“为可能用到而引入”，减少冲突风险。
  • 合理使用依赖范围：例如，测试依赖用test/testImplementation，容器提供的依赖用provided/compileOnly。
  • 定期清理未使用依赖：使用mvn dependency:analyze或gradle dependencyInsight检测并移除未使用的依赖。

3. 处理版本冲突的策略

  • 明确指定版本：对核心依赖（如日志框架、JSON库）明确指定版本，避免传递依赖引入低版本或不兼容版本。
  • 排除冲突依赖：当传递依赖引入不兼容版本时，主动排除（Maven的<exclusions>、Gradle的exclude）。
  • 使用工具分析冲突：通过mvn dependency:tree或gradle dependencies找到冲突根源，而非盲目排除。

4. 使用私有仓库与镜像

  • 国内项目使用镜像仓库：如阿里云、腾讯云镜像，加速依赖下载（尤其国外仓库）。
  • 企业项目使用私有仓库：通过Nexus或Artifactory搭建私有仓库，管理内部组件、缓存第三方依赖，控制依赖来源安全性。
  • 配置仓库认证：对私有仓库配置账号密码，确保依赖下载权限可控。

5. 依赖版本规范

  • 遵循语义化版本：依赖版本应遵循Major.Minor.Patch格式（如2.7.0），便于理解版本兼容性。
    • Major：不兼容的API变更。
    • Minor：向后兼容的功能新增。
    • Patch：向后兼容的问题修复。
  • 避免使用动态版本：如2.7.+或LATEST，可能导致构建不稳定（依赖自动升级引入问题）。如需动态版本，建议限制范围（如2.7.x）。

6. 自动化与CI/CD集成

  • 预下载依赖：在CI/CD流程中添加预下载依赖的步骤（如gradle downloadDependencies），避免构建中断。
  • 缓存依赖：在CI/CD环境中缓存Maven/Gradle的本地仓库，加速构建。
  • 依赖安全扫描：集成工具（如OWASP Dependency-Check）扫描依赖中的安全漏洞，及时更新存在风险的依赖。

示例：GitHub Actions中缓存Gradle依赖

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Set up JDK 17
        uses: actions/setup-java@v3
        with:
          java-version: '17'
          distribution: 'temurin'
      - name: Cache Gradle dependencies
        uses: actions/cache@v3
        with:
          path: ~/.gradle/caches
          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*') }}
          restore-keys: |
            ${{ runner.os }}-gradle-
      - name: Build with Gradle
        run: ./gradlew build

##** 六、总结：构建高效可靠的依赖管理体系**依赖管理是Java项目构建的基石，直接影响项目的开发效率、稳定性和可维护性。Maven以其成熟的生态和简单的约定，适合中小型项目和团队快速上手；而Gradle凭借灵活性、高性能和现代特性，成为大型项目和复杂构建场景的首选。

无论选择哪种工具，核心目标都是实现依赖的可追溯、可控制和可维护。通过集中版本管理、合理控制依赖范围、主动解决冲突、使用私有仓库和自动化工具，我们可以构建一个高效可靠的依赖管理体系，让开发者从繁琐的依赖问题中解放出来，专注于业务逻辑实现。

随着Java生态的发展，依赖管理工具也在不断进化（如Gradle的版本Catalog、Maven的模块化改进），开发者应持续关注工具的新特性，不断优化项目的依赖管理策略。

参考资料

  • Maven官方文档：https://maven.apache.org/guides/
  • Gradle官方文档：https://docs.gradle.org/
  • 《Maven实战》（许晓斌著）
  • 《Gradle实战》（Benjamin Muschko著）
  • OWASP Dependency-Check：https://owasp.org/www-project-dependency-check/
Java 项目管理工具：Maven 与 Gradle 的深度对比与选择
shrgegrb的博客
05-21 1268
在 Java 开发中，Maven 和 Gradle 是两款主流的项目管理工具，各有其优势和适用场景。Maven 基于项目对象模型（POM），提供标准化的项目结构和构建生命周期，适合小型项目或对构建流程灵活性要求不高的场景。Gradle 则结合了 Ant 的灵活性和 Maven 的依赖管理功能，使用 Groovy 或 Kotlin DSL 作为构建脚本语言，适合大型项目或需要复杂自定义构建任务的场景。Gradle 在构建性能上优于 Maven，支持增量构建和并行构建，能显著缩短构建时间。选择时需根据项目规模、
使用gradle上传maven工件到新版maven central仓库central.sonatype.com
打不死的小五
06-25 1095
使用maven-publish插件总是提示401权限不对，于是使用了这个插件进行工件上传。
Gradle 如何配置全局 mavenCentral()
HONEY MOOSE
08-26 1047
上面代码的意思是，在 Gradle 进程启动之前进行初始化，在这个初始化的时候将会用自己的 Maven 仓库地址替换掉远程的 Maven 中央仓库地址。如果我们想把 mavenCentral() 的仓库地址全局替换掉别的仓库地址的话。在 Gradle 的配置文件中，通常有一个 mavenCentral()我们都知道 Gradle 会使用 Maven 的中央仓库。目录下创建一个 init.gradle 文件。
从Gradle自动将工件提升到Maven Central
最佳 Java 编程
05-28 331
快速教程，无需在带有Gradle Nexus Staging插件的Nexus GUI中单击即可将Gradle项目中的工件提升/发布到Maven Central。 介绍 Maven Central （又名“中央存储库”）（可能）是世界上最大的一组开源工件，这些工件被基于Java和JVM的项目使用。 它是由Apache Maven的创建者创建的，自2002年以来一直在提供工件。如今，有一些替...
gradle mavenCentral()、jcenter()、google()仓库配置成阿里云
学亮编程手记
03-23 1万+
//buildscript里是gradle脚本执行所需依赖，分别是对应的maven库和插件 buildscript { repositories { // google() // jcenter() maven { url 'http://maven.aliyun.com/nexus/content/repositories/google' } maven { url 'http://maven.aliyun.com/nexus/cont.
Gradle的maven使用
xu.hyj
09-12 1152
基础lib创建过程 1.创建工程 create a new project Empty project 2 新建一个 Test 组件 3.新建一个窗体 4.新建一个java 类 构建一个静态的方法 add package com.miex.sdk.test; public class MyTestModle { /** * @param a * @param b * @return */ public static double add
gradle_从Gradle自动将工件提升到Maven Central
cunfen6312的博客
12-19 212
gradle 快速教程，无需在带有Gradle Nexus Staging插件的Nexus GUI中单击即可将Gradle项目中的工件提升/发布到Maven Central。 介绍 Maven Central (又名The Central Repository)(可能是)是Java和基于JVM的项目使用的世界上最大的开源工件集。 它是由Apache Maven的创建者创建的，自2002年以来一直...
android-maven-gradle-plugin:弃。 现在由android build插件支持
04-01
对于那些需要与Maven仓库交互的项目，虽然直接的Maven集成不再通过`android-maven-gradle-plugin`，但仍然可以通过Gradle的Maven Publish插件实现，或者利用JFrog Artifactory等服务进行更高级的部署和管理。...
gradle-maven-plugin：Gradle 5.x Maven发布插件来部署工件
02-02
Gradle-Maven-Plugin是专门为Gradle 5.x版本设计的一个插件，它允许开发者使用Gradle构建系统来模拟Maven的发布流程，将工件部署到Maven仓库。这个插件对于那些同时使用Gradle和Maven的项目尤其有用，因为它实现了...
dependency-management-plugin:一个Gradle插件，提供类似Maven的依赖项管理功能
05-14
一个Gradle插件，提供类似Maven的依赖项管理和排除。 该插件提供了DSL，以直接配置依赖管理，也可以通过导入现有的Maven Bom来配置。 基于配置的依赖项管理，该插件将控制项目的直接和传递依赖项的版本，并将遵守...
Java 项目构建工具：Maven 与 Gradle 深度解析
Java小吕布的博客
11-19 1526
Maven 和 Gradle 都是优秀的 Java 项目构建工具，它们在依赖管理和构建自动化方面都有着出色的表现。Maven 以其成熟的生态和规范的 XML 配置，适用于对稳定性和规范性要求较高的大型项目；而 Gradle 凭借其简洁灵活的语法、卓越的构建性能和强大的依赖管理能力，在追求高效开发和复杂构建场景的项目中更具优势。在实际项目开发中，开发者可以根据项目的特点、团队的技术栈以及个人偏好等因素来选择合适的构建工具。
Gradle筑基——Gradle Maven仓库管理
Dream It Possible
05-26 4489
maven私服其实就是在部门·局域网·中设置一个maven仓库，所有在局域网中的开发人员都可以使用该仓库：PS:私服中可以添加自己本地的仓库，也可以代理中央仓库中的包。毕竟对于一些网络比较差的环境，去中央仓库里面获取数据是一个很耗时的操作。
Gradle 替换 默认的mavenCentral
热门推荐
acnt3w的专栏
11-21 1万+
在使用gradle的时候，下载速度很吗
2024.10 最新 Gradle 上传到 Maven Central 中央仓库
weixin_73391279的博客
10-15 1211
之前的都是旧的了，现在写一下新的，踩了不少坑。
Gradle 发布 JAR 包到 maven 中央仓库(sonatype )
代码有毒的博客
11-27 5970
发布包到 maven 仓库 本文不与 https://zq99299.github.io/note-book/gradle/push-to-maven.html 同步更新 在 sonatype 做准备工作 效果：发布到 https://oss.sonatype.org/#nexus-search;quick~mrcode 仓库中 首先需要到这个页面注册账户：https://issues.son...
Android Studio中的mavenCentral、jcenter、google仓库
2401_84132423的博客
04-14 1238
对于很多初中级Android工程师而言，想要提升技能，往往是自己摸索成长。而不成体系的学习效果低效漫长且无助。时间久了，付出巨大的时间成本和努力，没有看到应有的效果，会气馁是再正常不过的。所以学习一定要找到最适合自己的方式，有一个思路方法，不然不止浪费时间，更可能把未来发展都一起耽误了。如果你是卡在缺少学习资源的瓶颈上，那么刚刚好我能帮到你。《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！战项目源码讲义》点击传送门即可获取！**
Gradle 发布Jar到 Maven Central
最新发布
子墨的日常
02-08 1637
Gradle 插件可创建一项publish任务，自动将所有 Java、Kotlin 或 Android 库上传到任何 Maven 实例。此插件基于Chris Banes 的初始实现 ，并进行了增强以添加 Kotlin 支持并跟上最新变化。生成后就会的到这个配置，这个配置的内容就是你所需要的 name,pasdword。这里直接复制我的配置即可，所有的变量都是可以改变的。如果你不知道我在说什么请重新查阅阶段一的详细教程，该插件内置了许多插件因此可以直接使用大部分功能。我们需要在里面配置密钥，但是注意不要将。
Maven---Java项目依赖管理和构建工具
大杯七分糖的博客
08-20 1460
这种依赖传递结构可以形成一个依赖树。Maven 的依赖管理能够帮助开发人员自动解决软件包依赖问题，使得开发人员能够轻松地将其他开发人员开发的模块或第三方框架集成到自己的应用程序或模块中，避免出现版本冲突和依赖缺失等问题。Maven 是一个强大的构建工具，它提供一种标准化的项目结构，可以帮助开发者更容易地管理项目的依赖、构建、测试和发布等任务。总之，Maven 的依赖管理是 Maven 软件的一个核心功能之一，使得软件包依赖的管理和使用更加智能和方便，简化了开发过程中的工作，并提高了软件质量和可维护性。
使用 Gradle 发布开源项目到 Maven Central
weixin_33894992的博客
01-24 144
2019独角兽企业重金招聘Python工程师标准>>> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值