第 2 章环境搭建 & Wrapper & 第一个项目

学习目标：装好 JDK，理解为什么"装 Gradle"和"用 Gradle"不是一回事；搞懂 Gradle Wrapper 是什么、为什么必须用它；亲手从零生成一个 Gradle 项目，跑通第一个 ./gradlew build。

2.1 装备清单

在开始之前，先确认你装好这两样东西：

工具	必须	推荐版本	为什么
JDK	✅	17 LTS 或 21 LTS	Gradle 自身跑在 JVM 上，且大多数项目要求 JDK 17+
Gradle	❌（不需要装）	/	用 Wrapper，不用全局装 —— 见 2.3 节
IDE	推荐	IntelliJ IDEA 2023.3+ / Android Studio	自带 Gradle 集成，可视化跑任务
Git	推荐	任意	把 wrapper 文件提交到仓库

💡 划重点：你不需要单独装 Gradle。装个 JDK 就够了。后面会解释。

2.2 第一步：装 JDK

2.2.1 推荐发行版

发行版	推荐场景	下载地址
Eclipse Temurin	最通用、跨平台、免费	https://adoptium.net/
Amazon Corretto	AWS 生态 / 服务器	https://aws.amazon.com/corretto/
Oracle JDK	企业商用、合规要求	https://www.oracle.com/java/
GraalVM	想玩 native-image 编译	https://www.graalvm.org/

📌 小白选哪个？ 直接 Temurin 17 LTS。打开网址，点对应平台的安装包，一路下一步。

2.2.2 验证安装

打开终端，运行：

bash

$ java -version
openjdk version "17.0.9" 2023-10-17 LTS
OpenJDK Runtime Environment Temurin-17.0.9+9 (build 17.0.9+9-LTS)
OpenJDK 64-Bit Server VM Temurin-17.0.9+9 (build 17.0.9+9-LTS, mixed mode)

$ javac -version
javac 17.0.9

只要这两条都打印出版本号，就 OK。

2.2.3 设置 JAVA_HOME

某些场景下（比如 IDE 启动 / CI）需要这个环境变量：

macOS / Linux —— 把以下加到 ~/.zshrc 或 ~/.bashrc：

bash

export JAVA_HOME=$(/usr/libexec/java_home -v 17)   # macOS
# 或者直接指向安装目录
export JAVA_HOME=/usr/lib/jvm/temurin-17

export PATH=$JAVA_HOME/bin:$PATH

Windows —— 「系统属性」→「环境变量」→ 新建 JAVA_HOME 指向 JDK 安装目录（如 C:\Program Files\Eclipse Adoptium\jdk-17.0.9），并把 %JAVA_HOME%\bin 加到 PATH。

💡 小白怎么省事？ 用 SDKMAN!（macOS / Linux）一键管理多版本 JDK：
bash
$ curl -s "https://get.sdkman.io" | bash
$ sdk install java 17.0.9-tem
$ sdk use java 17.0.9-tem
1
2
3
Windows 用户可以用 scoop：scoop install temurin17-jdk。

2.3 第二步：理解 Gradle Wrapper —— 不用装 Gradle 的秘密

2.3.1 痛点：没有 Wrapper 的世界

想象一下没有 wrapper 的场景：

   ┌─────────────────────────────────────────────────────────┐
   │ 你的同事 A：装的 Gradle 7.6                                │
   │ 你：装的 Gradle 8.5                                      │
   │ CI 服务器：装的 Gradle 6.8（很久没更新）                    │
   │                                                           │
   │ 同一个项目跑 ./gradle build：                              │
   │ A 那边：✅ 成功                                            │
   │ 你这边：❌ 报错 "Unsupported syntax"                       │
   │ CI 那边：❌ 报错 "Could not find method xxx()"             │
   │                                                           │
   │ 排查 3 天，发现是版本不一致导致 ......                        │
   └─────────────────────────────────────────────────────────┘

📌 生活化类比：这就像三个人各拿不同版本的 Word 编辑同一份合同 —— 改完合并永远对不齐。

2.3.2 Wrapper 的解法

Gradle Wrapper = 项目自带一个"版本锁 + 自动下载器"。它保证：

所有人和 CI 用的都是项目锁定的那个 Gradle 版本
第一次用会自动下载，无需手动安装
升级版本只需改一个属性文件

每个用 Gradle 构建的项目都应该带这 4 个文件：

my-project/
├── gradlew                            ← Unix 启动脚本（200 多行 bash）
├── gradlew.bat                        ← Windows 启动脚本
└── gradle/
    └── wrapper/
        ├── gradle-wrapper.jar         ← 启动器 jar（约 60KB）
        └── gradle-wrapper.properties  ← 锁定 Gradle 版本号

gradle-wrapper.properties 长这样：

properties

distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
networkTimeout=10000
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
validateDistributionUrl=true

看到那个 gradle-8.5-bin.zip 没？这就是版本锁。所有人用 ./gradlew 都自动下载这个版本。

2.3.3 Wrapper 工作流程

   第一次跑 ./gradlew build：
   ┌─────────────────────────────────────────────────────────┐
   │  ① 启动 gradle-wrapper.jar                                │
   │  ② 读 gradle-wrapper.properties，看要哪个版本               │
   │  ③ 检查 ~/.gradle/wrapper/dists/ 里有没有                  │
   │     ├─ 有：直接用                                          │
   │     └─ 没有：从 distributionUrl 下载（约 100MB）             │
   │  ④ 解压 → 启动那个版本的 Gradle → 跑用户指定的 build         │
   └─────────────────────────────────────────────────────────┘

   后续跑：跳过 ③ ④ 的下载，直接复用本地缓存。

2.3.4 关键命令

命令	用途
`./gradlew --version`	看当前 wrapper 版本
`./gradlew wrapper --gradle-version 8.5`	升级/切换 wrapper 版本
`./gradlew wrapper --distribution-type all`	切换"all"版本（含源码，IDE 提示更全）

⚠️ 注意：Windows 用户在 PowerShell / cmd 里跑的是 .\gradlew.bat（或简写 gradlew）。本笔记后续都写 ./gradlew，请自行替换。

2.4 第三步：从零生成第一个 Gradle 项目

有 3 种方式：官方 init 命令（推荐）、IDEA 创建、手动创建。

2.4.1 方式 1：官方 init 命令（推荐）

如果你全局装了 Gradle（用 SDKMAN 或者下了 zip 解压加 PATH），可以直接：

bash

$ mkdir my-first-gradle
$ cd my-first-gradle
$ gradle init

会有交互式问题：

Select type of project to generate:
  1: basic
  2: application                ← 选这个，要有 main 方法的可执行项目
  3: library
  4: Gradle plugin
Enter selection (default: basic) [1..4] 2

Select implementation language:
  1: C++
  2: Groovy
  3: Java                       ← 选这个
  4: Kotlin
  5: Scala
  6: Swift
Enter selection (default: Java) [1..6] 3

Select build script DSL:
  1: Groovy
  2: Kotlin                     ← 选这个（推荐）
Enter selection (default: Kotlin) [1..2] 2

Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no] no

Project name (default: my-first-gradle): <回车>
Source package (default: my.first.gradle): com.example.first

跑完后目录长这样：

my-first-gradle/
├── app/
│   ├── build.gradle.kts            ← 这是真正写依赖、配编译的地方
│   └── src/
│       ├── main/java/com/example/first/App.java
│       └── test/java/com/example/first/AppTest.java
├── gradle/
│   ├── libs.versions.toml          ← Version Catalog
│   └── wrapper/...
├── settings.gradle.kts             ← 包含哪些子模块
├── gradlew
├── gradlew.bat
└── README

跑构建：

bash

$ ./gradlew build
> Task :app:compileJava
> Task :app:processResources NO-SOURCE
> Task :app:classes
> Task :app:jar
> Task :app:startScripts
> Task :app:distTar
> Task :app:distZip
> Task :app:assemble
> Task :app:compileTestJava
> Task :app:processTestResources NO-SOURCE
> Task :app:testClasses
> Task :app:test
> Task :app:check
> Task :app:build

BUILD SUCCESSFUL in 12s

跑应用：

bash

$ ./gradlew run
> Task :app:run
Hello World!

BUILD SUCCESSFUL in 2s

2.4.2 方式 2：IntelliJ IDEA 创建

File → New → Project
左侧选 Gradle（注意不是 Spring / Java，这两个会用模板）
JDK 选 17，DSL 选 Kotlin
Click Create

IDEA 会自动跑一次同步（导入项目、下依赖），完成后右上角能看到 Gradle 任务面板。

2.4.3 方式 3：手动创建（理解结构用）

最简化的 Gradle 项目只需要 3 个文件：

hello-gradle/
├── settings.gradle.kts
├── build.gradle.kts
└── src/main/java/Hello.java

settings.gradle.kts：

kotlin

rootProject.name = "hello-gradle"

build.gradle.kts：

kotlin

plugins {
    application
}

repositories { mavenCentral() }

application {
    mainClass = "Hello"
}

src/main/java/Hello.java：

java

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello from Gradle!");
    }
}

然后：

bash

$ gradle wrapper        # 第一次：先生成 wrapper（需要全局装 gradle）
$ ./gradlew run         # 之后都用 wrapper
> Task :run
Hello from Gradle!

BUILD SUCCESSFUL in 2s

💡 没有全局 gradle 怎么生成 wrapper？ 用其他 Gradle 项目的 gradlew 就行：把另一个项目的 gradle/、gradlew、gradlew.bat 拷过来，跑 ./gradlew wrapper --gradle-version 8.5 重新校准版本。

2.5 项目目录详解

跑完 gradle init，每个文件夹和文件都干嘛的？逐一拆开看。

my-project/
│
├── settings.gradle.kts         ★ ① 项目入口（Initialization 阶段读它）
│                                  - 项目名
│                                  - 包含哪些子模块
│                                  - 插件管理仓库（pluginManagement）
│
├── build.gradle.kts            ★ ② 主构建脚本（Configuration 阶段执行）
│                                  - 应用插件
│                                  - 配置依赖
│                                  - 自定义任务
│
├── gradle.properties           ③ 全局属性（可在脚本里以 project property 访问）
│                                  - org.gradle.jvmargs=-Xmx2g
│                                  - kotlin.code.style=official
│
├── gradle/
│   ├── libs.versions.toml      ④ Version Catalog（统一管理依赖版本）
│   └── wrapper/
│       ├── gradle-wrapper.jar           ⑤ Wrapper 启动器
│       └── gradle-wrapper.properties    ⑥ 锁定 Gradle 版本
│
├── gradlew                     ⑦ Unix 启动脚本（必须提交到 Git）
├── gradlew.bat                 ⑧ Windows 启动脚本
│
├── src/                        ⑨ 源代码目录（约定，不强制）
│   ├── main/
│   │   ├── java/                       Java 源码
│   │   ├── kotlin/                     Kotlin 源码
│   │   └── resources/                  资源文件（properties/yml/json）
│   └── test/
│       ├── java/                       测试源码
│       └── resources/                  测试资源
│
├── build/                      ⑩ 构建输出（不要提交！.gitignore 里加它）
│   ├── classes/                        编译产物
│   ├── libs/                           jar/war 包
│   ├── reports/                        测试 / 检查报告
│   └── tmp/
│
└── .gradle/                    ⑪ Gradle 工作区缓存（不要提交！）
                                       - 增量构建指纹
                                       - 配置缓存
                                       - 守护进程数据

2.5.1 哪些必须提交到 Git？

必须提交：

settings.gradle.kts / build.gradle.kts（所有子模块的也要）
gradle.properties
gradlew / gradlew.bat
gradle/wrapper/*
gradle/libs.versions.toml
src/

绝对不要提交（写到 .gitignore）：

gitignore

# Gradle
.gradle/
build/
!gradle-wrapper.jar
!gradle-wrapper.properties

# IDE
.idea/
*.iml
*.ipr
*.iws
.vscode/

# OS
.DS_Store
Thumbs.db

⚠️ 千万别误把 wrapper 也 ignore 了。注意 !gradle-wrapper.jar 这条 —— 它是反向规则，确保 wrapper 文件不被忽略。

2.6 IDE 集成：把 Gradle 跟 IDEA 用爽

2.6.1 导入项目

IDEA 打开 → "Open" → 选根目录的 build.gradle.kts（或 settings.gradle.kts）
IDEA 弹出 "Import Gradle Project" → 点 OK
等右下角进度条跑完（第一次会下依赖，可能 1-3 分钟）

2.6.2 Gradle 工具窗口

按 Cmd/Ctrl + Shift + A 搜 "Gradle"，打开 Gradle 工具窗口（一般在右侧）。它显示：

   📂 my-project (root)
   ├── 📁 Tasks
   │   ├── 📁 application      ← 来自 application 插件
   │   │   └── ▶ run
   │   ├── 📁 build
   │   │   ├── ▶ assemble
   │   │   ├── ▶ build
   │   │   ├── ▶ clean
   │   │   └── ▶ jar
   │   ├── 📁 documentation
   │   ├── 📁 verification
   │   │   ├── ▶ check
   │   │   └── ▶ test
   │   └── ...
   └── 📁 Dependencies

双击 ▶ run 就跑 ./gradlew run，不用敲命令。

2.6.3 几个必备设置

打开 Settings → Build, Execution, Deployment → Build Tools → Gradle：

设置	推荐值	为什么
Use Gradle from	'gradle-wrapper.properties' file	用项目 wrapper 锁定的版本
Gradle JVM	Use Project SDK (17)	跟项目 JDK 一致
Build and run using	Gradle	IDE 调用 gradle 跑，行为跟命令行一致

2.6.4 同步报错怎么办？

80% 的同步报错原因 + 解法：

报错关键词	原因	解法
`Could not resolve all dependencies`	网络 / 仓库不通	配镜像（国内用阿里云）、检查代理
`Unsupported class file major version XX`	JDK 太老 / 太新	升 JDK 或切到合适版本
`Plugin 'xxx' not found`	插件版本号错 / 仓库未配	检查 plugins {} 块、settings 的 pluginManagement
`Could not find method xxx()`	用了别的版本的 DSL 语法	看 wrapper 锁定的 Gradle 版本，对照官方文档

国内仓库镜像（在 settings.gradle.kts 里配）：

kotlin

pluginManagement {
    repositories {
        maven("https://maven.aliyun.com/repository/gradle-plugin")
        gradlePluginPortal()
    }
}

dependencyResolutionManagement {
    repositoriesMode = RepositoriesMode.FAIL_ON_PROJECT_REPOS
    repositories {
        maven("https://maven.aliyun.com/repository/public")
        mavenCentral()
    }
}

2.7 第一次构建：到底发生了什么

跑 ./gradlew build 时屏幕上飞过的那些 Task，到底是什么？这里给个 30 秒讲解版（详细的留到第 3 章）：

$ ./gradlew build

> Task :compileJava                ① 编译 src/main/java
> Task :processResources           ② 拷贝 src/main/resources 到 build/
> Task :classes                    ③ 聚合任务：依赖前两步
> Task :jar                        ④ 打 jar 包到 build/libs/
> Task :assemble                   ⑤ 聚合：所有产物组装
> Task :compileTestJava            ⑥ 编译测试代码
> Task :processTestResources NO-SOURCE
> Task :testClasses                ⑦ 测试聚合
> Task :test                       ⑧ 跑 JUnit 测试
> Task :check                      ⑨ 聚合：所有验证（test + linter 等）
> Task :build                      ⑩ 大聚合：assemble + check

BUILD SUCCESSFUL in 12s

📌 要点：build 不是一个具体动作，是一个 聚合任务，依赖了 assemble + check 两个聚合，再依赖更细的任务。Gradle 会自动按依赖关系编排执行顺序，并行无依赖关系的任务。

2.8 常用命令速查表

命令	作用
`./gradlew tasks`	列出所有任务
`./gradlew tasks --all`	包括"内部"任务
`./gradlew help --task <name>`	看某个任务的详细文档
`./gradlew build`	完整构建（编译 + 测试 + 打包）
`./gradlew clean`	清空 `build/` 目录
`./gradlew clean build`	干净的构建（先 clean）
`./gradlew test`	只跑测试
`./gradlew test --tests "com.foo.MyTest"`	跑某个具体测试
`./gradlew run`	跑 `application` 插件的 main
`./gradlew dependencies`	看依赖树
`./gradlew dependencies --configuration runtimeClasspath`	看某个 configuration 的依赖
`./gradlew --refresh-dependencies build`	强制重新解析依赖（绕过缓存）
`./gradlew --offline build`	离线模式
`./gradlew build -x test`	跳过测试
`./gradlew build --info`	详细输出
`./gradlew build --debug`	超详细（很啰嗦）
`./gradlew build --stacktrace`	报错时打全栈
`./gradlew build --scan`	生成构建报告网址（很有用！）

2.9 章末小结

                        ★ 第 2 章核心知识图谱 ★
                                  │
        ┌─────────────────────────┼──────────────────────────┐
        │                         │                          │
   ┌────▼─────┐             ┌────▼──────┐              ┌────▼─────┐
   │ 装 JDK   │             │ Wrapper   │              │ 项目结构 │
   ├──────────┤             ├───────────┤              ├──────────┤
   │ 17 LTS   │             │ 锁版本    │              │ settings │
   │ 不装     │             │ 自动下载  │              │ build    │
   │  Gradle  │             │ 用./gradlew│              │ src/main │
   │  自身    │             │           │              │ build/   │
   └──────────┘             └───────────┘              └──────────┘

🎤 2.10 章末面试题（10 道高频题）

Q1. 安装 Gradle 必须装 Gradle 本体吗？

答：不需要。日常开发只需装 JDK，所有项目都通过 wrapper 用项目锁定的 Gradle 版本。手动装一个全局 Gradle 主要用于：① 生成新项目时跑 gradle init、gradle wrapper；② 临时跑没带 wrapper 的老项目。

Q2. Gradle Wrapper 是什么？为什么必须用？

答：Wrapper 是项目自带的 "Gradle 启动器 + 版本锁"，由 4 个文件组成（gradlew、gradlew.bat、gradle/wrapper/gradle-wrapper.jar、gradle/wrapper/gradle-wrapper.properties）。

为什么必须用：

版本一致性：所有人和 CI 用同一个 Gradle 版本，避免"在我电脑上能跑"；
零安装：新成员拉项目后直接 ./gradlew build，自动下载 Gradle；
可重现：distributionUrl 锁死版本和下载源，跨时间、跨地点构建一致。

Q3. 怎么升级 Gradle Wrapper 版本？

答：两种方式：

方式 1：直接改 gradle-wrapper.properties 里的 distributionUrl，把 gradle-8.5-bin.zip 改成 gradle-8.6-bin.zip，下次 ./gradlew 自动下载新版本。

方式 2（推荐）：跑命令

bash

$ ./gradlew wrapper --gradle-version 8.6

这条命令会更新 properties 文件，并验证 wrapper jar 兼容。

Q4. wrapper 相关的哪些文件需要提交到 Git？

答：4 个文件全部要提交：

gradlew（Unix 启动脚本）
gradlew.bat（Windows 启动脚本）
gradle/wrapper/gradle-wrapper.jar
gradle/wrapper/gradle-wrapper.properties

绝对不能 ignore wrapper.jar。常见的 IDE 自动生成的 .gitignore 可能错误地忽略 *.jar，要专门加反向规则：

gitignore

!gradle/wrapper/gradle-wrapper.jar

Q5. `settings.gradle.kts` 的作用是什么？没有它会怎样？

答：settings.gradle.kts 是 Gradle 的"项目入口文件"，作用：

声明项目名（rootProject.name = "..."）；
声明包含哪些子模块（include("app", "lib", ...)）；
配置插件仓库（pluginManagement {}）；
配置依赖仓库（dependencyResolutionManagement {}）。

没有它会怎样：Gradle 会向上层目录递归查找 settings.gradle(.kts)，可能误把整个磁盘当成"项目"，跑出诡异行为。所以任何项目都应该有 settings 文件。

Q6. `gradlew run` 报错 "JAVA_HOME is not set"，怎么解决？

答：3 种方案，按推荐度排序：

最佳：在 gradle.properties 里指定 toolchain，让 Gradle 自动管理 JDK：

properties

org.gradle.java.installations.fromEnv=JAVA_HOME_17

配合 build.gradle.kts 里的 java { toolchain { languageVersion = JavaLanguageVersion.of(17) } }，Gradle 会自动找/下载合适的 JDK。

次佳：在系统层面设置 JAVA_HOME 环境变量。
应急：在命令行临时指定：

bash

$ JAVA_HOME=/path/to/jdk17 ./gradlew run

Q7. `./gradlew build` 和 `./gradlew assemble` 有什么区别？

答：

assemble = 只生成产物（编译 + 打包）→ 拿到 jar / war / apk
check = 只跑验证（test + linter 等）
build = assemble + check = 完整构建

CI 上常分两步跑：先 assemble（生成产物可以早点上传），再 check（验证）。开发本地一般直接 build。

Q8. 第一次构建很慢，原因有哪些？

答：3 个主要原因：

下载 Gradle 自身（如果是新机器没缓存）：约 100MB；
下载所有依赖（jar 文件 + pom）：视项目规模，1MB-1GB 都有可能；
冷编译：所有 Task 都是首次执行，没有 UP-TO-DATE 跳过。

第二次起会快得多：Wrapper 缓存在 ~/.gradle/wrapper/dists/、依赖缓存在 ~/.gradle/caches/modules-2/、增量构建跳过未变 Task。如果还是慢，看第 9 章性能优化。

Q9. IDEA 同步 Gradle 项目和命令行 `./gradlew build` 一样吗？

答：几乎一样，但不完全一样。

同步（Sync）：IDEA 调用 Gradle 的 Tooling API 解析项目结构、下载依赖、配置 Source Sets 给 IDE 索引用，不执行 Task；
构建（Build）：执行实际 Task。

IDEA 的 "Reload Gradle Project" 按钮 = 同步；点 Run 按钮跑 task = 构建。

💡 常见坑：IDEA 同步成功不代表代码能编译。同步只看脚本能否解析、依赖能否下载；编译错误要点 Build → Build Project 才能看到。

Q10. 如何指定不同的 Gradle 安装目录？

答：3 种场景：

项目临时切换 Gradle 版本：改 gradle-wrapper.properties 的 distributionUrl。
全局指定一个本地 Gradle 安装：设环境变量 GRADLE_USER_HOME 改变缓存目录；用 gradle 命令直接指向某个 Gradle bin。
CI 环境优化（避免每次下载）：把 Gradle 发行版放进 Docker 镜像或 CI 缓存：

bash

$ ls ~/.gradle/wrapper/dists/
gradle-8.5-bin/   # 这就是 wrapper 的缓存

CI 缓存这个目录就能复用。

下一章 → 第 3 章 · 核心概念：Project / Task / Plugin / 生命周期 →

🎬 可视化演示

演示加载缓慢或样式异常？点此在新标签页打开 ↗

💻 示例代码

build.gradle.ktssettings.gradle.ktssrc/main/java/Hello.java

txt

/*
 * 第 2 章 · 环境搭建 — 最小可跑的 Hello Gradle 项目
 *
 * 这是史上最简的 Gradle 项目模板。
 *
 * 跑：
 *   ./gradlew run        —— 编译并跑 Hello.java 的 main
 *   ./gradlew build      —— 完整构建
 *   ./gradlew tasks      —— 列出所有任务
 *   ./gradlew envCheck   —— 自定义任务：检查环境
 */

plugins {
    application
}

group = "com.example.gradle.env"
version = "1.0.0"

java {
    toolchain {
        // 指定 JDK 版本，Gradle 会自动找/下载（toolchain 机制）
        languageVersion = JavaLanguageVersion.of(17)
    }
}

application {
    // application 插件需要知道 main class 在哪
    mainClass = "Hello"
}

// 自定义一个"环境自检"任务，演示读 system property
tasks.register("envCheck") {
    group = "verification"
    description = "打印当前 Gradle / JVM / OS 信息"

    doLast {
        println("================ Environment Check ================")
        println("Gradle version : " + gradle.gradleVersion)
        println("JVM version    : " + System.getProperty("java.version"))
        println("JVM vendor     : " + System.getProperty("java.vendor"))
        println("JAVA_HOME      : " + (System.getenv("JAVA_HOME") ?: "(not set)"))
        println("OS             : " + System.getProperty("os.name") + " " + System.getProperty("os.arch"))
        println("Project dir    : " + projectDir.absolutePath)
        println("====================================================")
    }
}

txt

/*
 * 第 2 章 · 环境搭建演示项目 — settings.gradle.kts
 *
 * 这是一个最小可跑的 Gradle 项目设置文件。
 *
 * 跑的步骤：
 *   1. 把这个目录拷出来
 *   2. 第一次：先生成 wrapper —— 借用任何已有 Gradle 项目的 gradlew，或全局 gradle:
 *        gradle wrapper --gradle-version 8.5
 *   3. ./gradlew run    —— 跑 Hello.java
 *   4. ./gradlew tasks  —— 看所有可用任务
 */

rootProject.name = "ch02-hello-gradle"

// 演示如何配置插件仓库和依赖仓库
// 大多数情况下保持默认即可（mavenCentral）
pluginManagement {
    repositories {
        gradlePluginPortal()
        // 国内可选镜像加速
        // maven("https://maven.aliyun.com/repository/gradle-plugin")
    }
}

dependencyResolutionManagement {
    // FAIL_ON_PROJECT_REPOS 防止子模块各自定义 repositories 导致混乱
    repositoriesMode = RepositoriesMode.FAIL_ON_PROJECT_REPOS
    repositories {
        mavenCentral()
        // maven("https://maven.aliyun.com/repository/public")
    }
}

java

/**
 * 第 2 章 · 环境搭建 — 第一段 Java 代码
 *
 * 这是配套 build.gradle.kts 的 main class。
 * 跑：./gradlew run
 */
public class Hello {
    public static void main(String[] args) {
        System.out.println("====================================");
        System.out.println("  Hello from Gradle!");
        System.out.println("  Java version: " + System.getProperty("java.version"));
        System.out.println("  Args: " + java.util.Arrays.toString(args));
        System.out.println("====================================");
    }
}

build.gradle.kts ↗ · settings.gradle.kts ↗ · src/main/java/Hello.java ↗

第 2 章 环境搭建 & Wrapper & 第一个项目 ​

2.1 装备清单 ​

2.2 第一步：装 JDK ​

2.2.1 推荐发行版 ​

2.2.2 验证安装 ​

2.2.3 设置 JAVA_HOME ​

2.3 第二步：理解 Gradle Wrapper —— 不用装 Gradle 的秘密 ​

2.3.1 痛点：没有 Wrapper 的世界 ​

2.3.2 Wrapper 的解法 ​

2.3.3 Wrapper 工作流程 ​

2.3.4 关键命令 ​

2.4 第三步：从零生成第一个 Gradle 项目 ​

2.4.1 方式 1：官方 init 命令（推荐） ​

2.4.2 方式 2：IntelliJ IDEA 创建 ​

2.4.3 方式 3：手动创建（理解结构用） ​

2.5 项目目录详解 ​

2.5.1 哪些必须提交到 Git？ ​

2.6 IDE 集成：把 Gradle 跟 IDEA 用爽 ​

2.6.1 导入项目 ​

2.6.2 Gradle 工具窗口 ​

2.6.3 几个必备设置 ​

2.6.4 同步报错怎么办？ ​

2.7 第一次构建：到底发生了什么 ​

2.8 常用命令速查表 ​

2.9 章末小结 ​

🎤 2.10 章末面试题（10 道高频题） ​

Q1. 安装 Gradle 必须装 Gradle 本体吗？ ​

Q2. Gradle Wrapper 是什么？为什么必须用？ ​

Q3. 怎么升级 Gradle Wrapper 版本？ ​

Q4. wrapper 相关的哪些文件需要提交到 Git？ ​

Q5. settings.gradle.kts 的作用是什么？没有它会怎样？ ​

Q6. gradlew run 报错 "JAVA_HOME is not set"，怎么解决？ ​

Q7. ./gradlew build 和 ./gradlew assemble 有什么区别？ ​

Q8. 第一次构建很慢，原因有哪些？ ​

Q9. IDEA 同步 Gradle 项目和命令行 ./gradlew build 一样吗？ ​

Q10. 如何指定不同的 Gradle 安装目录？ ​

🎬 可视化演示 ​

💻 示例代码 ​

第 2 章环境搭建 & Wrapper & 第一个项目

2.1 装备清单

2.2 第一步：装 JDK

2.2.1 推荐发行版

2.2.2 验证安装

2.2.3 设置 JAVA_HOME

2.3 第二步：理解 Gradle Wrapper —— 不用装 Gradle 的秘密

2.3.1 痛点：没有 Wrapper 的世界

2.3.2 Wrapper 的解法

2.3.3 Wrapper 工作流程

2.3.4 关键命令

2.4 第三步：从零生成第一个 Gradle 项目

2.4.1 方式 1：官方 init 命令（推荐）

2.4.2 方式 2：IntelliJ IDEA 创建

2.4.3 方式 3：手动创建（理解结构用）

2.5 项目目录详解

2.5.1 哪些必须提交到 Git？

2.6 IDE 集成：把 Gradle 跟 IDEA 用爽

2.6.1 导入项目

2.6.2 Gradle 工具窗口

2.6.3 几个必备设置

2.6.4 同步报错怎么办？

2.7 第一次构建：到底发生了什么

2.8 常用命令速查表

2.9 章末小结

🎤 2.10 章末面试题（10 道高频题）

Q1. 安装 Gradle 必须装 Gradle 本体吗？

Q2. Gradle Wrapper 是什么？为什么必须用？

Q3. 怎么升级 Gradle Wrapper 版本？

Q4. wrapper 相关的哪些文件需要提交到 Git？

Q5. `settings.gradle.kts` 的作用是什么？没有它会怎样？

Q6. `gradlew run` 报错 "JAVA_HOME is not set"，怎么解决？

Q7. `./gradlew build` 和 `./gradlew assemble` 有什么区别？

Q8. 第一次构建很慢，原因有哪些？

Q9. IDEA 同步 Gradle 项目和命令行 `./gradlew build` 一样吗？

Q10. 如何指定不同的 Gradle 安装目录？

🎬 可视化演示

💻 示例代码