深入解析 Maven 与 Gradle：Java 项目构建工具的安装、使用

引言

在 Java 开发体系中，项目构建是连接源码与可运行产物的核心环节，涵盖编译、依赖管理、测试、打包、部署等一系列流程。手动完成这些操作不仅效率低下，还容易因环境差异、版本冲突导致 "本地能跑、线上报错" 的问题。为解决这一痛点，自动化构建工具应运而生。

Maven 与 Gradle 作为当前 Java 生态中最主流的两大构建工具，各自承载着不同的使命：Maven 以 "约定优于配置" 的理念标准化了构建流程，成为 Java 项目的 "事实标准"；Gradle 则融合了 Maven 的稳定性与 Ant 的灵活性，凭借更高的构建效率和更强大的扩展性，成为 Spring Boot、Android 等主流框架的首选构建工具。

本文将从实际开发需求出发，全面讲解 Maven 与 Gradle 的安装配置、核心原理、基本使用及高级特性，结合大量实战案例帮助开发者快速上手，同时对比两者的优劣差异，为项目构建工具的选型提供参考。全文约 5000 字，兼顾入门指导性与实战参考价值，适合 Java 初学者、中级开发者及架构师阅读。

一、Maven：标准化 Java 项目构建的基石

1.1 Maven 简介

Maven 是 Apache 软件基金会推出的开源项目构建工具，基于 "约定优于配置"（Convention Over Configuration）的核心思想，通过统一的项目结构、标准化的构建生命周期和自动化的依赖管理，解决了传统 Java 项目中 "构建流程混乱""依赖管理繁琐" 的问题。

Maven 的核心价值体现在三个方面：

• 标准化构建流程：定义了清洁（clean）、验证（validate）、编译（compile）、测试（test）、打包（package）、安装（install）、部署（deploy）等统一的生命周期阶段，无需手动配置每个环节；
• 自动化依赖管理：通过 "坐标" 机制唯一标识依赖包，自动从仓库下载依赖并解决依赖冲突，无需手动拷贝 JAR 文件；
• 跨平台兼容性：基于 Java 开发，可在 Windows、Linux、MacOS 等所有支持 JVM 的系统上运行，确保团队开发环境一致。

截至 2025 年，Maven 的最新稳定版本为 3.9.8，其生态系统已覆盖几乎所有 Java 开源项目，是 Java 后端开发、开源项目贡献的必备工具。

1.2 Maven 安装与配置

1.2.1 安装前提

Maven 基于 Java 开发，安装前需确保系统已配置 JDK 环境（推荐 JDK 8 及以上版本）。验证 JDK 环境：

# Windows/Linux/MacOS通用命令
java -version
javac -version

若输出 JDK 版本信息（如java version "1.8.0_391"），则说明 JDK 已配置完成；若未配置，需先下载 JDK 并设置JAVA_HOME环境变量。

1.2.2 下载与安装

1. 下载 Maven：访问Maven 官方下载页，选择最新稳定版本的二进制压缩包（如apache-maven-3.9.8-bin.zip）；
2. 解压安装：将压缩包解压到任意目录（推荐无中文、无空格路径，如D:\apache-maven-3.9.8或/usr/local/apache-maven-3.9.8）；
3. 配置环境变量：
   • Windows 系统：
     1. 右键 "此电脑"→"属性"→"高级系统设置"→"环境变量"；
     2. 新建系统变量MAVEN_HOME，值为 Maven 解压目录（如D:\apache-maven-3.9.8）；
     3. 编辑系统变量Path，添加%MAVEN_HOME%\bin；
   • Linux/MacOS 系统：

     1. 打开终端，编辑环境变量配置文件（如~/.bashrc或~/.zshrc）：

        vi ~/.bashrc

     2. 添加以下内容：

        export MAVEN_HOME=/usr/local/apache-maven-3.9.8
        export PATH=$PATH:$MAVEN_HOME/bin

     3. 生效配置：

        source ~/.bashrc

1.2.3 验证安装

打开新终端（Windows 需重启命令提示符），执行以下命令验证 Maven 是否安装成功：

mvn -v

若输出以下信息，则说明安装配置完成：

Apache Maven 3.9.8 (4c87b05d9aedce574290d1acc98575ed5eb6cd3)
Maven home: D:\apache-maven-3.9.8
Java version: 1.8.0_391, vendor: Oracle Corporation, runtime: D:\Java\jdk1.8.0_391\jre
Default locale: zh_CN, platform encoding: GBK
OS name: "windows 10", version: "10.0", arch: "amd64", family: "windows"

1.2.4 核心配置优化

Maven 默认配置需优化以提升使用体验，核心配置文件为MAVEN_HOME/conf/settings.xml（全局配置）或~/.m2/settings.xml（用户级配置，推荐优先使用）。

1. 配置本地仓库：本地仓库是 Maven 缓存依赖包的目录，默认路径为~/.m2/repository（Windows 为C:\Users\用户名\.m2\repository）。建议修改为自定义路径（如D:\maven-repository），避免 C 盘空间不足：

   <localRepository>D:\maven-repository</localRepository>

2. 配置镜像源：Maven 默认从中央仓库（Maven Central）下载依赖，但国内访问速度较慢。推荐配置阿里云镜像源加速：

   <mirrors>
     <mirror>
       <id>aliyunmaven</id>
       <name>阿里云中央仓库</name>
       <url>https://maven.aliyun.com/repository/public</url>
       <mirrorOf>central</mirrorOf>
     </mirror>
   </mirrors>

3. 配置 JDK 版本：指定 Maven 编译项目时使用的 JDK 版本，避免版本兼容问题：

   <profiles>
     <profile>
       <id>jdk8</id>
       <activation>
         <activeByDefault>true</activeByDefault>
         <jdk>1.8</jdk>
       </activation>
       <properties>
         <maven.compiler.source>1.8</maven.compiler.source>
         <maven.compiler.target>1.8</maven.compiler.target>
         <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
       </properties>
     </profile>
   </profiles>

1.3 Maven 核心概念

1.3.1 项目对象模型（POM）

POM（Project Object Model）是 Maven 的核心，通过pom.xml文件描述项目的基本信息、依赖、构建规则等。每个 Maven 项目都必须包含pom.xml，其核心元素如下：

• 基本信息：groupId（项目组标识，如com.example）、artifactId（项目唯一标识，如demo-project）、version（项目版本，如1.0.0-SNAPSHOT），三者构成项目的唯一坐标；
• 依赖配置：<dependencies>节点下声明项目依赖，每个依赖通过坐标唯一标识；
• 构建配置：<build>节点下配置编译插件、打包类型等。

示例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>maven-demo</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <!-- 打包类型：jar（Java项目）、war（Web项目）、pom（父项目） -->
    <packaging>jar</packaging>
    <name>Maven Demo</name>
    <description>A simple Maven project</description>

    <!-- 依赖配置 -->
    <dependencies>
        <!-- 单元测试依赖 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope> <!-- 依赖作用域：test表示仅测试阶段生效 -->
        </dependency>
        <!-- Spring Core依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.30</version>
        </dependency>
    </dependencies>

    <!-- 构建配置 -->
    <build>
        <plugins>
            <!-- 编译插件，指定JDK版本 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

1.3.2 依赖管理

Maven 的依赖管理核心是 "坐标机制" 和 "依赖传递"：

• 坐标构成：groupId:artifactId:version（如org.springframework:spring-core:5.3.30），通过坐标可在仓库中唯一定位依赖包；
• 依赖传递：若项目 A 依赖项目 B，项目 B 依赖项目 C，则 Maven 会自动下载 B 和 C，无需手动声明 C；
• 依赖作用域：通过<scope>指定依赖生效阶段，常见值：
  • compile（默认）：编译、测试、运行阶段均生效；
  • test：仅测试阶段生效（如 JUnit）；
  • provided：编译、测试阶段生效，运行阶段由容器提供（如 Servlet API）；
  • runtime：测试、运行阶段生效，编译阶段不生效（如数据库驱动）；
• 依赖冲突解决：当多个依赖传递引入同一包的不同版本时，Maven 按 "路径最短优先""声明顺序优先" 原则解决，也可通过<exclusions>排除冲突依赖。

1.3.3 构建生命周期

Maven 定义了三套相互独立的构建生命周期：clean（清理）、default（核心构建）、site（生成项目站点），每个生命周期包含多个阶段（Phase），执行某个阶段时会自动执行该阶段之前的所有阶段。

核心生命周期（default）关键阶段：

1. validate：验证项目配置是否正确；
2. compile：编译项目源码为字节码（输出到target/classes）；
3. test：运行单元测试（使用 JUnit 等框架）；
4. package：将编译后的代码打包（JAR/WAR，输出到target目录）；
5. install：将打包产物安装到本地仓库，供其他项目依赖；
6. deploy：将打包产物部署到远程仓库（如私有仓库），供团队共享。

1.4 Maven 常用命令与实战

1.4.1 基础命令

Maven 命令格式为mvn [生命周期阶段/插件目标]，常用命令：

• mvn clean：清理target目录（删除编译、打包产物）；
• mvn compile：编译源码（仅编译src/main/java）；
• mvn test：编译并运行单元测试（编译src/test/java并执行测试用例）；
• mvn package：打包（根据packaging生成 JAR/WAR，输出到target）；
• mvn install：打包并安装到本地仓库；
• mvn deploy：打包并部署到远程仓库（需配置远程仓库地址）；
• mvn dependency:tree：查看项目依赖树（排查依赖冲突）；
• mvn clean package -DskipTests：打包并跳过测试（快速构建，不执行测试用例）；
• mvn clean install -U：强制更新快照版本依赖（SNAPSHOT 版本）。

1.4.2 实战：创建 Maven 项目

1. 手动创建项目（遵循 Maven 约定目录结构）：

   maven-demo/
   ├── pom.xml          # 项目核心配置文件
   ├── src/
   │   ├── main/        # 主程序目录
   │   │   ├── java/    # 源码目录（如com/example/Demo.java）
   │   │   └── resources/ # 资源文件目录（如application.properties）
   │   └── test/        # 测试程序目录
   │       ├── java/    # 测试源码目录（如com/example/DemoTest.java）
   │       └── resources/ # 测试资源文件目录
   └── target/          # 构建产物目录（自动生成）

2. 使用archetype快速生成项目（推荐）：Maven 提供archetype插件可快速生成标准化项目结构，命令：

   mvn archetype:generate -DgroupId=com.example -DartifactId=maven-demo -Dversion=1.0.0-SNAPSHOT -Dpackage=com.example -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

   • archetypeArtifactId=maven-archetype-quickstart：Java 项目模板；
   • archetypeArtifactId=maven-archetype-webapp：Web 项目模板；
   • interactiveMode=false：非交互模式（无需手动输入参数）。

3. 编译与运行项目：

   • 编写主程序src/main/java/com/example/Demo.java：

     package com.example;
     
     public class Demo {
         public String sayHello() {
             return "Hello Maven!";
         }
     
         public static void main(String[] args) {
             System.out.println(new Demo().sayHello());
         }
     }

   • 编写测试程序src/test/java/com/example/DemoTest.java：

     package com.example;
     
     import org.junit.Test;
     import static org.junit.Assert.assertEquals;
     
     public class DemoTest {
         @Test
         public void testSayHello() {
             Demo demo = new Demo();
             assertEquals("Hello Maven!", demo.sayHello());
         }
     }

   • 执行构建命令：

     mvn clean package # 清理并打包
     java -cp target/maven-demo-1.0.0-SNAPSHOT.jar com.example.Demo # 运行JAR包

   • 输出结果：Hello Maven!，说明构建与运行成功。

1.4.3 Web 项目实战

1. 生成 Web 项目：

   mvn archetype:generate -DgroupId=com.example -DartifactId=maven-web-demo -Dversion=1.0.0-SNAPSHOT -Dpackage=com.example -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false

2. 项目结构（核心目录）：

   maven-web-demo/
   ├── pom.xml
   ├── src/
   │   ├── main/
   │   │   ├── java/    # 源码目录
   │   │   ├── resources/ # 资源文件
   │   │   └── webapp/  # Web应用目录
   │   │       ├── WEB-INF/
   │   │       │   └── web.xml # Web配置文件
   │   │       └── index.jsp # 首页
   └── target/
       └── maven-web-demo-1.0.0-SNAPSHOT.war # 打包产物

3. 配置 Tomcat 插件（无需本地安装 Tomcat 即可运行）：在pom.xml中添加 Tomcat 插件：

   <build>
       <plugins>
           <plugin>
               <groupId>org.apache.tomcat.maven</groupId>
               <artifactId>tomcat7-maven-plugin</artifactId>
               <version>2.2</version>
               <configuration>
                   <port>8080</port> <!-- 端口号 -->
                   <path>/</path> <!-- 访问路径 -->
               </configuration>
           </plugin>
       </plugins>
   </build>

4. 运行 Web 项目：

   mvn clean tomcat7:run

   访问http://localhost:8080，即可看到首页内容。

1.5 Maven 高级特性

1.5.1 父工程与模块管理

当项目包含多个子模块（如user-service、order-service）时，可通过父工程统一管理依赖版本、构建配置，避免重复配置。

1. 父工程配置（packaging为pom）：

   <groupId>com.example</groupId>
   <artifactId>demo-parent</artifactId>
   <version>1.0.0-SNAPSHOT</version>
   <packaging>pom</packaging>
   <name>Demo Parent</name>
   
   <!-- 子模块声明 -->
   <modules>
       <module>user-service</module>
       <module>order-service</module>
   </modules>
   
   <!-- 统一依赖版本管理 -->
   <dependencyManagement>
       <dependencies>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-dependencies</artifactId>
               <version>2.7.18</version>
               <type>pom</type>
               <scope>import</scope>
           </dependency>
       </dependencies>
   </dependencyManagement>

2. 子模块配置（继承父工程）：

   <parent>
       <groupId>com.example</groupId>
       <artifactId>demo-parent</artifactId>
       <version>1.0.0-SNAPSHOT</version>
       <!-- 父工程pom.xml路径（若子模块在父工程目录下可省略） -->
       <relativePath>../pom.xml</relativePath>
   </parent>
   
   <artifactId>user-service</artifactId>
   <name>User Service</name>
   
   <!-- 依赖无需指定版本（父工程已管理） -->
   <dependencies>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
   </dependencies>

1.5.2 私有仓库配置

企业内部项目通常需搭建私有仓库（如 Nexus）存储内部依赖，配置settings.xml实现私有仓库的认证与访问：

<servers>
    <server>
        <id>company-nexus</id> <!-- 与镜像源id一致 -->
        <username>nexus-username</username> <!-- 私有仓库用户名 -->
        <password>nexus-password</password> <!-- 私有仓库密码 -->
    </server>
</servers>

<mirrors>
    <mirror>
        <id>company-nexus</id>
        <name>Company Private Nexus</name>
        <url>http://nexus.company.com/repository/maven-public/</url>
        <mirrorOf>*</mirrorOf> <!-- 所有依赖都从私有仓库下载 -->
    </mirror>
</mirrors>

二、Gradle：下一代 Java 项目构建工具

2.1 Gradle 简介

Gradle 是由 Gradle Inc. 开发的开源构建工具，首次发布于 2012 年，融合了 Maven 的 "约定优于配置" 和 Ant 的 "灵活配置" 两大优势，同时解决了 Maven 构建速度慢、配置繁琐的问题。

Gradle 的核心优势：

• 灵活性：支持基于 Groovy 或 Kotlin 的 DSL（领域特定语言）配置，可自定义构建流程，无需严格遵循约定；
• 高效性：采用增量构建（仅构建修改的模块）和构建缓存（复用本地 / 远程缓存的构建产物），构建速度比 Maven 快 50% 以上；
• 多语言支持：除 Java 外，还支持 Kotlin、Scala、C++ 等语言，同时兼容 Maven、Ivy 的依赖仓库；
• 生态完善：是 Spring Boot 2.x+、Android、Quarkus 等框架的默认构建工具，支持 Docker、Kubernetes 等容器化部署。

截至 2025 年，Gradle 的最新稳定版本为 8.10，其市场占有率持续上升，成为大型 Java 项目、微服务架构的首选构建工具。

2.2 Gradle 安装与配置

2.2.1 安装前提

与 Maven 一致，Gradle 需依赖 JDK 8 及以上版本，先通过java -version验证 JDK 环境。

2.2.2 下载与安装

Gradle 提供两种安装方式：手动安装与 SDKMAN! 安装（推荐 Linux/MacOS）。

1. 手动安装（Windows/Linux/MacOS 通用）：

   • 下载 Gradle：访问Gradle 官方下载页，选择最新稳定版本的二进制压缩包（如gradle-8.10-bin.zip）；
   • 解压安装：将压缩包解压到任意目录（如D:\gradle-8.10或/usr/local/gradle-8.10）；
   • 配置环境变量：
     • Windows：新建GRADLE_HOME变量（值为解压目录），编辑Path添加%GRADLE_HOME%\bin；
     • Linux/MacOS：编辑~/.bashrc，添加export GRADLE_HOME=/usr/local/gradle-8.10和export PATH=$PATH:$GRADLE_HOME/bin，执行source ~/.bashrc生效。

2. SDKMAN! 安装（Linux/MacOS）：SDKMAN! 是 Java 生态工具的包管理器，可快速安装 Gradle：

   # 安装SDKMAN!
   curl -s "https://get.sdkman.io" | bash
   # 生效配置
   source "$HOME/.sdkman/bin/sdkman-init.sh"
   # 安装最新版Gradle
   sdk install gradle

2.2.3 验证安装

执行以下命令验证 Gradle 是否安装成功：

gradle -v

若输出以下信息，则说明安装完成：

Gradle 8.10
------------------------------------------------------------
Build time:   2024-08-01 16:48:12 UTC
Revision:     4d5e80d1c65a3dc117bc9cf215dc2dd333d6990d
Kotlin:       1.9.20
Groovy:       3.0.21
Ant:          Apache Ant(TM) version 1.10.14 compiled on January 17 2023
JVM:          1.8.0_391 (Oracle Corporation 25.391-b13)
OS:           Windows 10 10.0 amd64

2.2.4 核心配置优化

1. 配置本地仓库与镜像源：Gradle 默认使用 Maven 的本地仓库（~/.m2/repository），也可自定义本地仓库路径。创建~/.gradle/gradle.properties文件（用户级配置），添加以下配置：

   # 自定义本地仓库路径
   gradle.user.home=D:\gradle-repository
   # 阿里云镜像源（加速依赖下载）
   systemProp.gradle.wrapperUser=gradle
   systemProp.gradle.wrapperPassword=gradle
   # Maven中央仓库镜像
   repositories {
       maven { url 'https://maven.aliyun.com/repository/public' }
       mavenCentral()
   }

2. 配置 JVM 参数（提升构建速度）：在gradle.properties中添加 JVM 堆内存配置，避免构建时内存不足：

   # 构建时JVM最大堆内存
   org.gradle.jvmargs=-Xmx2g -XX:MaxMetaspaceSize=512m
   # 启用增量构建（默认开启）
   org.gradle.incremental=true
   # 启用构建缓存
   org.gradle.caching=true
   # 并行构建多模块项目
   org.gradle.parallel=true
   # 启用守护进程（后台运行Gradle，加速后续构建）
   org.gradle.daemon=true

2.3 Gradle 核心概念

2.3.1 构建脚本

Gradle 的构建配置文件为build.gradle（Groovy DSL）或build.gradle.kts（Kotlin DSL），核心元素包括：

• 项目信息：group（对应 Maven 的groupId）、version（版本）、description（描述）；
• 插件配置：plugins节点引入插件（如 Java 插件、Spring Boot 插件），插件会自动添加构建任务和约定；
• 依赖配置：dependencies节点声明依赖，支持 Maven/Ivy 坐标；
• 仓库配置：repositories节点指定依赖仓库；
• 任务配置：tasks节点自定义构建任务（如编译、打包、部署）。

示例build.gradle（Groovy DSL）：

// 项目信息
group 'com.example'
version '1.0.0-SNAPSHOT'
description 'A simple Gradle project'

// 引入Java插件（提供compile、test、jar等任务）
plugins {
    id 'java'
    id 'application' // 应用程序插件（支持run任务）
    id 'maven-publish' // Maven发布插件
}

// 应用程序主类
mainClassName = 'com.example.Demo'

// 仓库配置（优先从阿里云下载）
repositories {
    maven { url 'https://maven.aliyun.com/repository/public' }
    mavenCentral()
}

// 依赖配置
dependencies {
    // 实现依赖（对应Maven的compile）
    implementation 'org.springframework:spring-core:5.3.30'
    // 测试依赖（对应Maven的test）
    testImplementation 'junit:junit:4.12'
    // 运行时依赖（对应Maven的runtime）
    runtimeOnly 'mysql:mysql-connector-java:8.0.33'
}

// 编译配置（指定JDK版本）
java {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
}

// 自定义任务（打印项目信息）
task printProjectInfo {
    doLast {
        println "Project Name: ${project.name}"
        println "Project Version: ${project.version}"
    }
}

2.3.2 插件系统

插件是 Gradle 的核心扩展机制，用于添加构建功能、约定和任务。常见插件：

• 核心插件：无需指定版本，由 Gradle 内置，如java（Java 项目支持）、application（应用程序运行支持）、war（Web 项目支持）、maven-publish（发布到 Maven 仓库）；
• 第三方插件：需指定插件 ID 和版本，如 Spring Boot 插件（org.springframework.boot）、Android 插件（com.android.application）。

引入第三方插件示例（Spring Boot）：

plugins {
    id 'org.springframework.boot' version '2.7.18'
    id 'io.spring.dependency-management' version '1.0.15.RELEASE'
    id 'java'
}

// Spring Boot依赖管理（无需指定版本）
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

2.3.3 依赖配置

Gradle 的依赖配置比 Maven 更灵活，常见依赖范围：

• implementation：编译、运行阶段生效，不暴露给依赖当前项目的模块（推荐优先使用）；
• compileOnly：仅编译阶段生效，运行阶段不包含（对应 Maven 的provided）；
• testImplementation：仅测试阶段生效（对应 Maven 的test）；
• runtimeOnly：仅运行阶段生效（对应 Maven 的runtime）；
• api：编译、运行阶段生效，且暴露给依赖当前项目的模块（类似 Maven 的compile，谨慎使用）。

依赖冲突解决：Gradle 默认采用 "最新版本优先" 原则，也可通过resolutionStrategy自定义冲突规则：

configurations.all {
    resolutionStrategy {
        // 强制使用指定版本的依赖
        force 'org.springframework:spring-core:5.3.30'
        // 当出现冲突时失败（避免隐式冲突）
        failOnVersionConflict()
    }
}

2.3.4 构建生命周期与任务

Gradle 的构建生命周期基于 "任务"（Task），任务是构建的最小执行单元（如compileJava、test、jar），任务之间可通过dependsOn指定依赖关系。

核心任务（Java 项目，引入java插件后自动生成）：

• clean：清理构建产物（默认删除build目录）；
• compileJava：编译src/main/java源码；
• processResources：处理资源文件（复制src/main/resources到构建目录）；
• classes：依赖compileJava和processResources，生成编译后的类文件；
• compileTestJava：编译src/test/java源码；
• test：运行单元测试；
• jar：打包生成 JAR 文件（输出到build/libs目录）；
• assemble：打包所有产物（依赖jar等打包任务）；
• build：构建项目（依赖assemble和test）；
• install：将产物安装到本地 Maven 仓库（需引入maven-publish插件）。

2.4 Gradle 常用命令与实战

2.4.1 基础命令

Gradle 命令格式为gradle [任务名]，常用命令：

• gradle clean：清理构建产物；
• gradle compileJava：编译源码；
• gradle test：运行单元测试；
• gradle jar：打包生成 JAR 文件；
• gradle build：构建项目（清理、编译、测试、打包）；
• gradle run：运行应用程序（需引入application插件）；
• gradle install：安装产物到本地 Maven 仓库；
• gradle dependencies：查看项目依赖树；
• gradle build --info：输出详细构建日志（排查问题）；
• gradle build --scan：生成构建报告（在线查看，优化构建）。

2.4.2 实战：创建 Gradle 项目

1. 手动创建项目（遵循约定目录结构）：

   gradle-demo/
   ├── build.gradle      # 构建配置文件
   ├── settings.gradle   # 项目设置文件（指定项目名称、子模块）
   ├── src/
   │   ├── main/
   │   │   ├── java/    # 源码目录（com/example/Demo.java）
   │   │   └── resources/ # 资源文件目录
   │   └── test/
   │       ├── java/    # 测试源码目录
   │       └── resources/ # 测试资源文件目录
   └── build/            # 构建产物目录（自动生成）

2. 使用init命令快速生成项目：Gradle 提供init命令可交互式生成项目，支持 Java、Kotlin 等语言，命令：

   gradle init

   按提示选择：

   • 项目类型：application（应用程序）；
   • 语言：Java；
   • 构建脚本 DSL：Groovy（或Kotlin）；
   • 测试框架：JUnit 4；
   • 项目名称、包名等。

3. 编译与运行项目：

   • 主程序src/main/java/com/example/Demo.java与 Maven 示例一致；

   • 测试程序src/test/java/com/example/DemoTest.java与 Maven 示例一致；

   • 执行命令：

     gradle clean build # 构建项目
     gradle run # 运行应用程序（输出Hello Maven!）
     # 或直接运行JAR包
     java -cp build/libs/gradle-demo-1.0.0-SNAPSHOT.jar com.example.Demo

2.4.3 Spring Boot 项目实战

1. 生成 Spring Boot 项目：访问Spring Initializr，选择：

   • 构建工具：Gradle - Groovy；
   • 语言：Java；
   • Spring Boot 版本：2.7.18；
   • 依赖：Spring Web、Lombok；
   • 下载项目并解压。

2. 核心配置文件build.gradle：

   plugins {
       id 'org.springframework.boot' version '2.7.18'
       id 'io.spring.dependency-management' version '1.0.15.RELEASE'
       id 'java'
       id 'io.freefair.lombok' version '6.6.3' // Lombok插件
   }
   
   group = 'com.example'
   version = '0.0.1-SNAPSHOT'
   sourceCompatibility = '1.8'
   
   repositories {
       maven { url 'https://maven.aliyun.com/repository/public' }
       mavenCentral()
   }
   
   dependencies {
       implementation 'org.springframework.boot:spring-boot-starter-web'
       compileOnly 'org.projectlombok:lombok'
       annotationProcessor 'org.projectlombok:lombok'
       testImplementation 'org.springframework.boot:spring-boot-starter-test'
   }
   
   tasks.named('test') {
       useJUnitPlatform()
   }

3. 编写 Controller：

   package com.example.gradledemo;
   
   import lombok.RequiredArgsConstructor;
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RestController;
   
   @RestController
   @RequiredArgsConstructor
   public class HelloController {
   
       @GetMapping("/hello")
       public String hello() {
           return "Hello Gradle + Spring Boot!";
       }
   }

4. 运行与测试：

   gradle bootRun # 启动Spring Boot应用

   访问http://localhost:8080/hello，输出Hello Gradle + Spring Boot!。

2.5 Gradle 高级特性

2.5.1 多模块项目管理

Gradle 的多模块管理比 Maven 更灵活，支持跨模块依赖、统一配置。

1. 根项目settings.gradle（声明子模块）：

   rootProject.name = 'demo-parent'
   include 'user-service'
   include 'order-service'

2. 根项目build.gradle（统一配置）：

   // 所有子模块应用Java插件
   subprojects {
       apply plugin: 'java'
       apply plugin: 'maven-publish'
   
       group = 'com.example'
       version = '1.0.0-SNAPSHOT'
   
       repositories {
           maven { url 'https://maven.aliyun.com/repository/public' }
           mavenCentral()
       }
   
       java {
           sourceCompatibility = JavaVersion.VERSION_1_8
       }
   }

3. 子模块user-service/build.gradle（依赖其他模块）：

   dependencies {
       // 依赖order-service模块
       implementation project(':order-service')
       implementation 'org.springframework.boot:spring-boot-starter-web'
   }

2.5.2 构建缓存与增量构建

Gradle 的核心优势之一是构建效率，通过以下特性加速构建：

• 增量构建：仅重新构建修改过的文件和依赖模块，未修改的模块直接复用之前的构建结果；
• 构建缓存：将构建产物缓存到本地或远程服务器，其他开发者可复用缓存，避免重复构建。

启用远程构建缓存（在根项目settings.gradle中配置）：

buildCache {
    local {
        enabled = true
        directory = file("$rootDir/.gradle/build-cache")
    }
    remote(HttpBuildCache) {
        url = 'http://build-cache.company.com/cache/'
        credentials {
            username = 'cache-user'
            password = 'cache-password'
        }
    }
}

2.5.3 自定义任务与构建流程

Gradle 支持通过 Groovy/Kotlin DSL 自定义任务，满足复杂构建需求。例如，自定义打包任务将依赖包一起打包为可执行 JAR：

// 自定义胖JAR打包任务
task fatJar(type: Jar) {
    // 基础名称
    baseName = 'gradle-demo-fat'
    // 合并所有依赖的JAR包
    from { configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) } }
    // 包含自身编译后的类文件
    with jar
    // 配置MANIFEST.MF，指定主类
    manifest {
        attributes 'Main-Class': 'com.example.Demo'
    }
}

// 让build任务依赖fatJar任务
build.dependsOn fatJar

执行gradle build后，会在build/libs目录生成gradle-demo-fat-1.0.0-SNAPSHOT.jar，可直接运行。

三、Maven 与 Gradle 对比及选型建议

3.1 核心差异对比

对比维度	Maven	Gradle
配置风格	基于 XML，严谨但繁琐	基于 Groovy/Kotlin DSL，灵活简洁
构建速度	较慢（无增量构建、缓存）	极快（增量构建、本地 / 远程缓存、并行构建）
灵活性	低（约定优于配置，自定义困难）	高（支持自定义构建流程、任务）
依赖管理	支持传递依赖，冲突解决规则简单（路径最短 / 声明顺序）	支持传递依赖，冲突解决更灵活（最新版本优先 / 自定义规则）
多模块支持	支持，但配置重复较多	支持，统一配置更简洁，跨模块依赖更灵活
生态系统	成熟稳定，兼容所有 Java 项目	生态完善，支持多语言，Spring Boot/Android 默认选择
学习成本	低（规则固定，容易上手）	中（需学习 DSL 语法和灵活配置）
适用场景	小型项目、开源项目、团队追求标准化	大型项目、微服务、多模块项目、追求构建效率

3.2 选型建议

1. 选择 Maven 的场景：

   • 小型 Java 项目，需求简单，无需复杂构建流程；
   • 团队成员技术栈偏基础，追求低学习成本；
   • 开源项目（需兼容大多数开发者的使用习惯）；
   • 现有项目已使用 Maven，无明显性能瓶颈，无需迁移。

2. 选择 Gradle 的场景：

   • 大型项目、多模块项目（如微服务架构），需提升构建速度；
   • 项目需自定义构建流程（如多语言混合开发、复杂打包逻辑）；
   • 采用 Spring Boot 2.x+、Android 等框架（官方推荐 Gradle）；
   • 团队追求高效开发，能接受一定的学习成本。

3. 迁移建议：若需从 Maven 迁移到 Gradle，可使用 Gradle 自带的迁移工具：

   # 在Maven项目根目录执行，自动生成build.gradle和settings.gradle
   gradle init --type maven

   迁移后需手动优化构建脚本（如替换依赖范围、简化配置），逐步适配 Gradle 的最佳实践。

四、总结

Maven 与 Gradle 作为 Java 生态的两大构建工具，各自在不同场景下发挥着重要作用：Maven 以标准化、低学习成本成为 Java 项目的入门首选，其 "约定优于配置" 的理念规范了构建流程，支撑了无数开源项目的发展；Gradle 则以灵活性、高效性成为大型项目、现代框架的首选，解决了 Maven 在复杂场景下的痛点，推动了 Java 构建工具的进化。

作为开发者，掌握两者的核心使用场景与实战技巧，能显著提升项目构建效率、降低协作成本。小型项目可优先选择 Maven 快速落地，大型项目或追求高效构建的场景则推荐 Gradle。无论选择哪种工具，理解构建工具的核心原理（依赖管理、构建生命周期）都是关键，这也是 Java 开发从 "入门" 到 "进阶" 的重要一步。