创建日期：2026-09-08 ｜ 最近更新：2026-09-08 事实核对基于 Gradle 8.14.5（8.x 稳定线最后版本）在本机 JDK 11 离线实测（沙箱对 Java 的 HTTPS 出口有限制，故用零依赖示例跑通）；当前最新主线是 Gradle 9.x（需 JDK 17+）。下方日志为真实运行结果。

Gradle 入门：当构建脚本变成「可编程的任务图」

一句话：Gradle 是 Maven 的「灵活版」——同样解决「编译、测试、打包、依赖」的活，但把声明式 XML 换成 Groovy/Kotlin 脚本，把「固定生命周期」换成可组合的任务图。Maven 像「规定动作的清单」，Gradle 像「可编程的流水线」。

建议先读本站 Maven 入门拿到「坐标/仓库/生命周期」这套通用心智，再看这篇对照着学，理解最快。

1. Gradle vs Maven：什么时候该选它

	Maven	Gradle
配置	`pom.xml`（XML，声明式）	`build.gradle`(Groovy) / `build.gradle.kts`(Kotlin DSL)，可编程
模型	固定生命周期（`compile→test→package`）	任务图（task graph），任务可依赖/复用/跳过
构建模型	每次相对全量	增量 + 守护进程（daemon）+ 构建缓存，长项目更快
上手	平缓、规矩多	陡一点、自由度大
生态默认	Spring Boot / 大量老项目	Android、新 Kotlin/多模块大仓常见
版本	稳定 3.9.16（4.0 仍 RC）	9.x 当前（需 JDK 17+）；8.14.5 是最后的 8.x

选型直觉：老牌/教程多的走 Maven；想要增量快、多模块、Kotlin、或构建脚本里要写逻辑的走 Gradle。Spring Boot 两者都官方支持（build.gradle 配 org.springframework.boot 插件），心智一样。

2. 一个最小项目：看 Gradle 长什么样

目录（跟 Maven 同一套「src 约定」，不用教）：

greet/
├─ settings.gradle            # 项目名 / 多模块声明
├─ build.gradle               # 构建脚本（本体）
└─ src/main/java/com/example/Greet.java

settings.gradle：

rootProject.name = 'greet'

build.gradle（Groovy DSL，最简形态）：

plugins {
    id 'java'               // 内置：把「编译/测试/打 jar」串起来
    id 'application'        // 内置：给你 run / startScripts / distZip
}

java {
    sourceCompatibility = JavaVersion.VERSION_11
    targetCompatibility = JavaVersion.VERSION_11
}

application {
    mainClass = 'com.example.Greet'   // gradle run 的入口
}

源码就一个普通 main（本机实测）：

// src/main/java/com/example/Greet.java
package com.example;
public class Greet {
    public static void main(String[] args) {
        String name = args.length > 0 ? args[0] : "world";
        String cap = name.isEmpty() ? name
                : Character.toUpperCase(name.charAt(0)) + name.substring(1);
        System.out.println("Hello, " + cap + "!");
    }
}

对比 Maven：plugins {} 相当于「约定集合」，id 'java' 一加，build/classes、compileJava 这些任务就都齐了——比在 pom 里堆插件更省。

3. 核心心智：不是「阶段」，是「任务图」

Maven 想的是「阶段（phase）按顺序跑」；Gradle 想的是「一堆任务，互相声明依赖，跑一个会带出它依赖的整条链」。

assemble ─┬─ jar ──┬─ classes ──┬─ compileJava
          │        └─ processResources
          ├─ startScripts
          └─ distZip / distTar

check ─── test ─── testClasses ─── …（compileTestJava）

build = assemble + check        // 「可执行产物」+「质量门禁」两棵子树

好处：没变的任务直接 UP-TO-DATE 跳过；A/B 两个任务只要没互相依赖就能并行；还能用缓存跨机器复用产物。

实测输出（Gradle 8.14.5）

# 第一次 gradle run：真的编译
> Task :compileJava
> Task :processResources NO-SOURCE
> Task :classes
> Task :run
Hello, Alice!
BUILD SUCCESSFUL in 1s
2 actionable tasks: 2 executed

# 第二次 gradle run：什么都没改 → 编译直接跳过
> Task :compileJava UP-TO-DATE      ← 增量构建的证据
> Task :classes UP-TO-DATE
> Task :run
Hello, Lin!
BUILD SUCCESSFUL in 972ms

第二次从「2s 全量」降到「~1s」——这就是 UP-TO-DATE + 守护进程带来的体感差异（Maven 也在追，但 Gradle 这套是它的招牌）。

打包产物

gradle build 产出（application 插件顺手还给了可分发包）：

> Task :jar        > Task :startScripts   > Task :distZip   > Task :distTar   > Task :assemble   > Task :build
BUILD SUCCESSFUL in 1s
build/libs/greet.jar       # 普通 jar（thin，同 Maven：不带第三方依赖）
build/distributions/       # zip/tar + 启动脚本（application 插件的「可分发」形态）

4. 依赖：写法和 Maven 几乎一一对应

repositories {
    mavenCentral()                       // 仓库：对应 Maven 的 <repositories>
}

dependencies {
    implementation 'org.apache.commons:commons-lang3:3.20.0'  // group:artifact:version，一行
    testImplementation 'org.junit.jupiter:junit-jupiter:5.11.0'
}

Maven 坐标写法	Gradle 写法	作用域对应
`<artifactId>x</artifactId>` 在 `<dependencies>`	`implementation 'g:a:v'`	`compile` 主代码用
`scope=provided`	`compileOnly`	编译期有、运行期没有（如 Lombok）
`scope=runtime`	`runtimeOnly`	运行期才有
`scope=test`	`testImplementation`	测试用

沙箱提示：本文的实测例子用了零第三方依赖（因为此环境对 Java 的 HTTPS 出口有限制）。真实项目按上面 repositories + dependencies 写即可，语法照抄。

5. 常用命令速查

命令	作用
`gradle run`	直接跑 application
`gradle build`	编译+测试+打包（`assemble + check`）
`gradle test` / `gradle clean`	单跑测试 / 清 `build/`
`gradle tasks`	看当前项目所有可用任务（探索好帮手）
`gradle dependencies`	打印依赖树（对应 Maven 的 dependency:tree）
`gradle --offline` / `--console=plain`	离线跑 / CI 友好输出
`gradle --watch-fs`	增量文件系统监听

守护进程：Gradle 会起一个后台 daemon 复用——第一次慢，之后都快。想停：gradle --stop。

6. Wrapper（`gradlew`）与 Kotlin DSL

Wrapper：工程里带 gradlew + gradle/wrapper/gradle-wrapper.properties（里面写 distributionUrl）。别人 ./gradlew build 会自动下载指定版本的 Gradle——跟 Maven 的 mvnw 一个道理，团队版本一致、无需全局装。生成：gradle wrapper --gradle-version 8.14.5。
Kotlin DSL：把 build.gradle 换成 build.gradle.kts——有类型补全、更适合作大型多模块。新项目官方默认倾向 Kotlin DSL。二者混着用也行，但一个项目别两套并存。
升级：直接改 distributionUrl 里的版本号，或 ./gradlew wrapper --gradle-version=9.x（9.x 需 JDK 17+）。

7. 想再进一步

多模块：settings.gradle 里 include ':app', ':lib'，子项目各自的 build.gradle——这是大仓标配，Maven 的 <modules> 对应物；
自写任务/插件：tasks.register('hello') { doLast { println 'hi' } }，把重复逻辑固化成任务；
与 Spring Boot 结合：plugins { id 'org.springframework.boot' ... } + implementation 'org.springframework.boot:spring-boot-starter-web'，bootJar 就是那枚「fat jar」（呼应 Spring 入门里的 repackage 概念）。

关联

上一篇（强烈建议先读）：Maven 入门——「坐标/仓库/生命周期/thin vs fat jar」通用心智
应用场景：本站 Spring 入门（Boot 的 pom 也可换成 build.gradle）

参考

官网：gradle.org、文档 docs.gradle.org
Gradle vs Maven 官方对比：docs.gradle.org/userguide/
版本（2026-09）：9.x 为当前主线（需 JDK 17+）；本文演示用 8.14.5 + JDK 11（沙箱对 Java HTTPS 出口受限，离线跑零依赖示例）
许可：Apache-2.0

1. Gradle vs Maven：什么时候该选它​

2. 一个最小项目：看 Gradle 长什么样​

3. 核心心智：不是「阶段」，是「任务图」​

实测输出（Gradle 8.14.5）​

打包产物​

4. 依赖：写法和 Maven 几乎一一对应​

5. 常用命令速查​

6. Wrapper（gradlew）与 Kotlin DSL​

7. 想再进一步​

关联​

参考​