Gradle入门

【尚硅谷】Gradle 教程入门到进阶

https://www.bilibili.com/video/BV1yT41137Y7

# 1、Gradle 入门

# 1.1、Gradle 简介

Gradle 是一款 Google 推出的基于 JVM、通用灵活的项目构建工具，支持 Maven，JCenter 多种第三方仓库；支持传递性依赖管理、废弃了繁杂的 xml 文件，转而使用简洁的、支持多种语言 (例如：java、groovy 等) 的 build 脚本文件。

官网地址: https://gradle.org/

学习 Gradle 的原因：

1. 目前已经有相当一部分公司在逐渐使用 Gradle 作为项目构建工具了。
2. 作为 Java 开发程序员，如果想下载 Spring、SpringBoot 等 Spring 家族的源码，基本上基于 Gradle 构建的。

总之，虽然目前市面上常见的项目构建工具有 Ant、Maven、Gradle，主流还是 Maven，但是未来趋势 Gradle。

# 1.2、常见的项目构建工具

Ant: 2000 年 Apache 推出的纯 Java 编写构建工具，通过 xml [build.xml] 文件管理项目优点：使用灵活，速度快 (快于 gradle 和 maven)，

缺点：Ant 没有强加任何编码约定的项目目录结构，开发人员需编写繁杂 XML 文件构建指令，对开发人员是一个挑战。

Maven: 2004 年 Apache 组织推出的再次使用 xml 文件 [pom.xml] 管理项目的构建工具。

优点：遵循一套约定大于配置的项目目录结构，使用统一的 GAV 坐标进行依赖管理， 侧重于包管理。缺点：项目构建过程僵化，配置文件编写不够灵活、不方便自定义组件，构建速度慢于 gradle。

Gradle: 2012 年 Google 推出的基于 Groovy 语言的全新项目构建工具，集合了 Ant 和 Maven 各自的优势。

优点：集 Ant 脚本的灵活性 + Maven 约定大于配置的项目目录优势，支持多种远程仓库和插件 **, 侧重于大项目构建 **。缺点：学习成本高、资料少、脚本灵活、版本兼容性差等。

Whatever: 无论哪种项目构建工具，都有自身的优势和劣势，所以选择一款最适合自己的就是最好的。

# 1.3、Gradle 安装

# 1.3.1、Gradle 安装说明

轶哥提示：

Gradle 官网：https://gradle.org/

Gradle 官方下载安装教程页面：https://gradle.org/install/

Gradle 官方用户手册：https://docs.gradle.org/current/userguide/userguide.html

SpringBoot 官方文档明确指出，目前 SpringBoot 的 Gradle 插件需要 gradle6.8 版本及以上，所以我们这里选择 7.x 版本。

其中 SpringBoot 与 Gradle 存在版本兼容问题，Gradle 与 Idea 也存在兼容问题，所以考虑到 java 程序员会使用 SpringBoot，所以要选择 6.8 版本及高于 6.8 版本的 Gradle, 那么相应的 idea 版本也要升级，不能太老哦。

** 具体参考文档:**https://docs.spring.io/spring-boot/docs/2.5.0/gradle-plugin/reference/htmlsingle/#getting-started

# 1.3.2、安装 JDK

要求 Jdk 为 1.8 或者 1.8 版本以上。

# 1.3.3、下载并解压到指定目录

下载

• 解压到指定目录 **😗* D:\software\gradle-7.4.1

# 1.3.4、配置环境变量

轶哥提示：

在 win10 及更高版本中，一般按下 win+s 搜索 环境变量 即可快速找到设置

特别注意 **：这里我们接着再配置一个 ****GRADLE_USER_HOME** 环境变量:

GRADLE_USER_HOME 相当于配置 Gradle 本地仓库位置和 Gradle Wrapper 缓存目录。

轶哥提示：

Gradle 本地仓库可以和 Maven 本地仓库目录一致

# 1.3.5、检测是否安装成功

gradle -v 或者 gradle --version: 通过 gradle -v 或者 gradle --version 检测是否安装成功

Gradle 7.4安装成功的提示文本

C:\Users\yooyi>gradle -v
Welcome to Gradle 7.4!
Here are the highlights of this release:

Aggregated test and JaCoCo reports
Marking additional test source directories as tests in IntelliJ
Support for Adoptium JDKs in Java toolchains

For more details see https://docs.gradle.org/7.4/release-notes.html

# Gradle 7.4
Build time:   2022-02-08 09:58:38 UTC

Revision:     f0d9291c04b90b59445041eaa75b2ee744162586
Kotlin:       1.5.31

Groovy:       3.0.9

Ant:          Apache Ant™ version 1.10.11 compiled on July 10 2021

JVM:          1.8.0_202 (Oracle Corporation 25.202-b08)

OS:           Windows 10 10.0 amd64

# 1.4、Gradle 项目目录结构

Gradle 项目默认目录结构和 Maven 项目的目录结构一致，都是基于约定大于配置【Convention Over Configuration】。其完整项目目录结构如下所示：

Tips:

1. 只有 war 工程才有 webapp 目录，对于普通的 jar 工程并没有 webapp 目录
2. gradlew 与 gradlew.bat 执行的指定 wrapper 版本中的 gradle 指令，不是本地安装的 gradle 指令哦。

# 1.5、Gradle 创建第一个项目

借助于 spring 脚手架创建 gradle 第一个项目：https://start.spring.io/

查看生成的 gradle 项目目录结构如下所示:

与上图对比会发现：总体的目录结构与上图说明的是一致的。

# 1.5.1、Gradle 中的常用指令

Gradle 常用命令说明:

需要注意的是：gradle 的指令要在含有 build.gradle 的目录执行 **。**

# 1.5.2、修改 maven 下载源

Gradle 自带的 Maven 源地址是国外的，该 Maven 源在国内的访问速度是很慢的，除非使用了特别的手段。一般情况下，我们建议使用国内的第三方开放的 Maven 源或企业内部自建 Maven 源。

认识 init.d 文件夹

我们可以在 gradle 的 init.d 目录下创建以.gradle 结尾的文件，.gradle 文件可以实现在 build 开始之前执行，所以你可以在

这个文件配置一些你想预先加载的操作。

在 init.d 文件夹创建 init.gradle 文件

allprojects {
    repositories {
        mavenLocal()
        maven { name "Alibaba" ; url "https://maven.aliyun.com/repository/public" } 
        maven { name "Bstek" ; url "https://nexus.bsdn.org/content/groups/public/" } 
        mavenCentral()
    }
    
    buildscript {
        repositories {
            maven { name "Alibaba" ; url 'https://maven.aliyun.com/repository/public' } 
            maven { name "Bstek" ; url 'https://nexus.bsdn.org/content/groups/public/' } 
            maven { name "M2" ; url 'https://plugins.gradle.org/m2/' }
        }
    }
}

拓展 1：启用 init.gradle 文件的方法有：

1. 在命令行指定文件，例如：gradle --init-script yourdir/init.gradle -q taskName。你可以多次输入此命令来指定多个 init 文件 2. 把 init.gradle 文件放到 USER_HOME/.gradle/ 目录下

1. 把以.gradle 结尾的文件放到 USER_HOME/.gradle/init.d/ 目录下
2. 把以.gradle 结尾的文件放到 GRADLE_HOME/init.d/ 目录下

如果存在上面的 4 种方式的 2 种以上，gradle 会按上面的 1-4 序号依次执行这些文件，如果给定目录下存在多个 init 脚本，会按拼音 a-z 顺序执行这些脚本，每个 init 脚本都存在一个对应的 gradle 实例，你在这个文件中调用的所有方法和属性，都会委托给这个 gradle 实例，每个 init 脚本都实现了 Script 接口。

拓展 2：仓库地址说明

mavenLocal (): 指定使用 maven 本地仓库，而本地仓库在配置 maven 时 settings 文件指定的仓库位置。如 E:/repository，gradle 查找 jar 包顺序如下：USER_HOME/.m2/settings.xml>> M2_HOME/conf/settings.xml >> USER_HOME/.m2/repository

maven {url 地址}，指定 maven 仓库，一般用私有仓库地址或其它的第三方库【比如阿里镜像仓库地址】。

mavenCentral ()：这是 Maven 的中央仓库，无需配置，直接声明就可以使用。

jcenter ():JCenter 中央仓库，实际也是是用的 maven 搭建的，但相比 Maven 仓库更友好，通过 CDN 分发，并且支持 https 访问，在新版本中已经废弃了，替换为了 mavenCentral ()。

总之，gradle 可以通过指定仓库地址为本地 maven 仓库地址和远程仓库地址相结合的方式，避免每次都会去远程仓库下载依赖库。这种方式也有一定的问题，如果本地 maven 仓库有这个依赖，就会从直接加载本地依赖，如果本地仓库没有该依赖，那么还是会从远程下载。但是下载的 jar 不是存储在本地 maven 仓库中，而是放在自己的缓存目录中，默认在 USER_HOME/.gradle/caches 目录，当然如果我们配置过 GRADLE_USER_HOME 环境变量，则会放在 GRADLE_USER_HOME/caches 目录，那么可不可以将 gradle caches 指向 maven repository。我们说这是不行的，caches 下载文件不是按照 maven 仓库中存放的方式。

在 gradle 中的使用说明：

# 1.5.3、Wrapper 包装器

Gradle Wrapper 实际上就是对 Gradle 的一层包装，用于解决实际开发中可能会遇到的不同的项目需要不同版本的 Gradle

问题。例如：把自己的代码共享给其他人使用，可能出现如下情况:

1. 对方电脑没有安装 gradle
2. 对方电脑安装过 gradle，但是版本太旧了

这时候，我们就可以考虑使用 Gradle Wrapper 了。这也是官方建议使用 Gradle Wrapper 的原因。实际上有了 Gradle Wrapper 之后，我们本地是可以不配置 Gradle 的，下载 Gradle 项目后，使用 gradle 项目自带的 wrapper 操作也是可以的。

那如何使用 Gradle Wrapper 呢？

项目中的 gradlew、gradlew.cmd 脚本用的就是 wrapper 中规定的 gradle 版本。参见源码

而我们上面提到的 gradle 指令用的是本地 gradle, 所以 gradle 指令和 gradlew 指令所使用的 gradle 版本有可能是不一样的。

gradlew、gradlew.cmd 的使用方式与 gradle 使用方式完全一致，只不过把 gradle 指令换成了 gradlew 指令。

当然，我们也可在终端执行 gradlew 指令时，指定指定一些参数，来控制 Wrapper 的生成，比如依赖的版本等，如下：

具体操作如下所示 ：

gradle wrapper --gradle-version=4.4：升级 wrapper 版本号，只是修改 gradle.properties 中 wrapper 版本，未实际下载

gradle wrapper --gradle-version 5.2.1 --distribution-type all : 关联源码用

# GradleWrapper 的执行流程：

1. 当我们第一次执行 ./gradlew build 命令的时候，gradlew 会读取 gradle-wrapper.properties 文件的配置信息
2. 准确的将指定版本的 gradle 下载并解压到指定的位置 (GRADLE_USER_HOME 目录下的 wrapper/dists 目录中)
3. 并构建本地缓存 (GRADLE_USER_HOME 目录下的 caches 目录中), 下载再使用相同版本的 gradle 就不用下载了 4. 之后执行的 ./gradlew 所有命令都是使用指定的 gradle 版本。如下图所示：

gradle-wrapper.properties 文件解读:

注意：前面提到的 GRALE_USER_HOME 环境变量用于这里的 Gradle Wrapper 下载的特定版本的 gradle 存储目录。如果我们没有配置过 GRALE_USER_HOME 环境变量，默认在当前用户家目录下的.gradle 文件夹中。

那什么时候选择使用 gradle wrapper、什么时候选择使用本地 gradle?

下载别人的项目或者使用操作以前自己写的不同版本的 gradle 项目时：用 Gradle wrapper, 也即:gradlew

什么时候使用本地 gradle? 新建一个项目时：使用 gradle 指令即可。

# 2、Gradle 与 Idea 整合

# 2.1、Groovy 简介

在某种程度上，Groovy 可以被视为 Java 的一种脚本化改良版，Groovy 也是运行在 JVM 上，它可以很好地与 Java 代码及其相关库进行交互操作。它是一种成熟的面向对象编程语言，既可以面向对象编程，又可以用作纯粹的脚本语言。大多数有效的 Java 代码也可以转换为有效的 Groovy 代码，Groovy 和 Java 语言的主要区别是：完成同样的任务所需的 Groovy 代码比 Java 代码更少。其特点为：

• 功能强大，例如提供了动态类型转换、闭包和元编程（metaprogramming）支持
• 支持函数式编程，不需要 main 函数
• 默认导入常用的包
• 类不支持 default 作用域，且默认作用域为 public。
• Groovy 中基本类型也是对象，可以直接调用对象的方法。
• 支持 DSL（Domain Specific Languages 领域特定语言）和其它简洁的语法，让代码变得易于阅读和维护。
• Groovy 是基于 Java 语言的，所以完全兼容 Java 语法，所以对于 java 程序员学习成本较低。详细了解请参考：http://www.groovy-lang.org/documentation.html

# 2.2、Groovy 安装 [非必须]

下载地址: https://groovy.apache.org/download.html

解压配置环境变量：

# 2.3、创建 Groovy 项目

# 2.4、Groovy 基本语法

类型转换：当需要时，类型之间会自动发生类型转换：字符串（String）、基本类型 (如 int) 和类型的包装类 (如 Integer)

类说明：如果在一个 groovy 文件中没有任何类定义，它将被当做 script 来处理，也就意味着这个文件将被透明的转换为一个 Script 类型的类，这个自动转换得到的类将使用原始的 groovy 文件名作为类的名字。groovy 文件的内容被打包进 run 方法，另外在新产生的类中被加入一个 main 方法以进行外部执行该脚本。

# 2.4.1、案例 1: 基本注意点

提示：方法调用时，在不含有歧义的地方可以省略方法调用时的括号。这类似于使用 ${变量名} 时，括号在不引起歧义的地方可以省略是一样的：如

def num1=1; 
def num2= 2;
println "$num1 + $num2 = ${num1+num2}"

# 2.4.2、案例 2: 引号说明

def num1=1; 
def num2=2;
def str1="1d"; //双引号
def str2='dsd'; //单引号
//双引号运算能力,单引号用于常量字符串,三引号相当于模板字符串，可以支持换行
println "$num1 + $num2 = ${num1 + num2}"
//基本数据类型也可以作为对象使用,可以调用对象的方法
println(num1.getClass().toString()) 
println(str1.getClass().toString()) 
println(str2.getClass().toString())

# 2.4.3、案例 3: 三个语句结构

Groovy 支持顺序结构从上向下依次解析、分支结构 (if…else、if…else if …else…、switch…case、for、while、do…while)

具体参考官网：http://www.groovy-lang.org/semantics.html#_conditional_structures

# 2.4.4、案例 4: 类型及权限修饰符

# Groovy 中的类型有:

1. 原生数据类型及包装类

1. 类、内部类、抽象类、接口
2. 注解
3. Trait: 可以看成是带有方法实现的接口

权限修饰符: public、protected、private

拓展：Groovy 类与 Java 类之间的主要区别是:

1. 没有可见性修饰符的类或方法自动是公共的 (可以使用一个特殊的注释来实现包的私有可见性)。
2. 没有可见性修饰符的字段将自动转换为属性，不需要显式的 getter 和 setter 方法。
3. 如果属性声明为 final，则不会生成 setter。
4. 一个源文件可能包含一个或多个类 (但是如果一个文件不包含类定义的代码，则将其视为脚本)。脚本只是具有一些特殊约定的类，它们的名称与源文件相同 (所以不要在脚本中包含与脚本源文件名相同的类定义)。

提 示 : 有 关 Groovy 中 各 种 各 样 的 数 据 类 型 和 权 限 修 饰 符 及 Goovy 与 Java 区 别 请 参 考 ：

http://www.groovy-lang.org/objectorientation.html#_modifiers_on_a_property

# 2.4.5、案例 5: 集合操作

Groovy 支持 List、Map 集合操作，并且拓展了 Java 中的 API, 具体参考如下方法：

List :

• add() : 添加某个元素 plus (): 添加某个 list 集合
• remove(): 删除指定下标的元素 removeElement (): 删除某个指定的元素 removeAll (): 移除某个集合中的元素
• pop() : 弹出 list 集合中最后一个元素 putAt (): 修改指定下标的元素
• each() : 遍历
• size() : 获取 list 列表中元素的个数
• contains() : 判断列表中是否包含指定的值，则返回 true

Map :

• put() : 向 map 中添加元素
• remove() : 根据某个键做移除，或者移除某个键值对
• +、- ：支持 map 集合的加减操作
• each() : 遍历 map 集合

请参考官网:http://www.groovy-lang.org/syntax.html#_number_type_suffixes

提示：可以把不同的基本类型添加到同一集合中。

# 2.4.6、案例 6: 类导入

Groovy 遵循 Java 允许 import 语句解析类引用的概念。

import groovy.xml.MarkupBuilder 
def xml = new MarkupBuilder() 
assert xml != null

Groovy 语言默认提供的导入

import java.lang.* 
import java.util.* 
import java.io.* 
import java.net.* 
import groovy.lang.* 
import groovy.util.*
import java.math.BigInteger
import java.math.BigDecimal

这样做是因为这些包中的类最常用。通过导入这些样板代码减少了。

参考官网地址：http://www.groovy-lang.org/structure.html#_imports

# 2.4.7、案例 7: 异常处理

Groovy 中的异常处理和 java 中的异常处理是一样的。

def z 
try {
    def i = 7, j = 0 
    try {
        def k = i / j 
        assert false
    } finally {
        z = 'reached here'
    }
} catch ( e ) {
    assert e in ArithmeticException 
    assert z == 'reached here'
}

参考官网地址： http://www.groovy-lang.org/semantics.html#_try_catch_finally

# 2.4.8、案例 8: 闭包

闭包：Groovy 中的闭包是一个开放的、匿名的代码块，它可以接受参数、也可以有返回值。闭包可以引用其周围作用域中声明的变量。

语法： { [closureParameters -> ] statements }

其中 [ closureParameters-> ] 是一个可选的逗号分隔的参数列表，参数后面是 Groovy 语句。参数类似于方法参数列表， 这些参数可以是类型化的，也可以是非类型化的。当指定参数列表时，需要使用 -> 字符，用于将参数与闭包体分离。

参考：http://www.groovy-lang.org/closures.html

//闭包体完成变量自增操作
{ item++ }
//闭包使用 空参数列表 明确规定这是无参的
{ -> item++ }
//闭包中有一个默认的参数[it]，写不写无所谓
{ println it }
{ it -> println it }
//如果不想使用默认的闭包参数it,那需要显示自定义参数的名称
{ name -> println name }
//闭包也可以接受多个参数
{ String x, int y ->
    println "hey ${x} the value is ${y}"
}
//闭包参数也可是一个对象
{ reader ->
    def line = reader.readLine() 
    line.trim()
}

闭包调用方式： 闭包是 groovy.lang.Closure 的实例。它可以像任何其他变量一样分配给一个变量或字段。

闭包对象 (参数)

闭包对象.call (参数)

def isOdd = { int i -> i%2 != 0 } 
assert isOdd(3) == true
assert isOdd.call(2) == false

def isEven = { it%2 == 0 } 
assert isEven(3) == false 
assert isEven.call(2) == true

特殊说明： 可以把闭包当作一个对象，作为参数传递给方法使用

//无参闭包
def run(Closure closure){ 
    println("run start...")
    closure() println("run end...")
}

run {
    println "running......"
}

//有参闭包
def caculate(Closure closure){
    def num1=1;
    def num2=3; 
    println("caculate start...")
    closure(num1,num2) 
    println("caculate end...")
}
caculate {x,y -> println "计算结果为：$x+$y=${x+y}"} //在build.gradle文件中我们见到的很多都是闭包格式的。

# 2.5、在 idea 中创建普通 java 工程

# 具体整合：

第一步：创建由 Gradle 管理的项目

第二步：修改当前项目使用本地安装的 gradle：可以加快下载项目依赖 jar 包的速度【配置了私服地址】。

特别提示 1：使得在 Terminal 中执行以 gradlew 开头命令和操作图形化的 IDEA 使用 Gradle 版本不一定是同一个版本哦。

1.Terminal 中以 gradlew 开头指令用的是 Wrapper 规定的 gradle 版本，wrapper 中规定版本默认和 idea 插件中规定的版本一致。

2. 而图形化的 IDEA 使用 Gradle 是本地安装的哦。

** 特别提示 2：** 目前只能是在创建项目时重新设置本地 gradle, 创建新项目需要重新去改。

** 特别提示 3：** 当 我 们 在 gradle.build 文 件 添 加 依 赖 之 后 ， 这 些 依 赖 会 在 下 载 到 GRADLE_USER_HOME/caches/modules-2/files-2.1 目录下面，所以这里的 GRADLE_USER_HOME 相当于 Gradle 的本地仓库，当然也可以如下方式找到 jar 包位置。

轶哥提示：

• 此处可以设置 Gradle user home，如需更改 idea 新项目的设置可以通过 文件 —— 新项目的设置更改

• 调整使用的 Gradle 位置，可以加速 Gradle 构建

# 2.6、在 idea 中创建 web 工程

在 idea 新版本的创建项目中，无法自己选择创建项目是普通 java 工程还是 web 工程了【IDEA 旧版本是可以的】，所以我们如果想创建 web 工程，只需要自己在 src/main/ 目录下添加 webapp/WEB-INF/web.xml 及页面即可。

代码演示：参考视频 + 资料

接下来在我们对 gradle 的其它知识点讲解之前我们先提一下在 gradle 文件中需要用到的 Groovy 语法。

# 2.7、项目部署

当我们将一个 java 项目打成 war 包之后，就需要部署到服务器运行，这里有两种方式：

• 我们将项目打成 war 包，部署到本地 tomcat 运行：演示
• 使用 Gretty 插件中内置服务器方式部署项目：演示

# 2.7.1、Gretty 部署项目

Gretty 是一个功能丰富的 gradle 插件，用于在嵌入的 servlet 容器上运行 web 应用程序，让项目开发和部署更加简单。目前 Gretty 插件已经作为 gradle 的核心库使用了，Gretty 其核心功能为：

1. 底层支持 jetty,tomcat 等 Servlet 容器
2. 支持项目热部署、HTTPS、调试

Gretty 官网地址：http://akhikhl.github.io/gretty-doc/index.html

# 2.7.2、具体使用

第一步：引入 Gretty 插件

plugins {
    id 'war'
    id 'org.gretty' version '2.2.0'
}

第二步：指定 maven 仓库

repositories {
    //指定jcenter仓库，一定要放在前面
    jcenter() 
    mavenCentral()
}

第三步：针对 Gretty 插件的设置

gretty {
    httpPort = 8888
    contextPath = "/web"
    debugPort = 5005	// default 
    debugSuspend = true // default 
    httpsEnabled = true
    managedClassReload=true // 修改了类之后重新加载
    //servletContainer = 'tomcat8' //如果不指定默认的servlet容器，支持tomcat7/8，默认是使用的是Jetty服务器
    httpsPort = 4431
}

第四步：执行 Gretty 插件

gradle appRun

如 果 大 家 想 进 一 步 了 解 的 属 性 配 置，比 如 Gretty 热 部 署 等 设 置 ， 欢 迎 参 考 其 官 方 文 档

http://akhikhl.github.io/gretty-doc/Gretty-configuration.html。

# 2.8、Gradle 对测试支持

测试任务自动检测并执行测试源集中的所有单元测试。测试执行完成后会生成一个报告。支持 JUnit 和 TestNG 测试。

# 2.8.1、默认测试目录及标准输出

# 2.8.2、Junit 使用

Gradle 对于 Junit4.x 支持

dependencies {
    testImplementation group: 'junit' ,name: 'junit', version: '4.12'
}
test {
    useJUnit()
}

Gradle 对于 Junit5.x 版本支持

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1' 
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
}
test {
    useJUnitPlatform()
}

注意：无论是 Junt4.x 版本还是 Junit5.x 版本，我们只需在 build.gradle 目录下执行 gradle test 指令，gradle 就会帮我们执行所有的加了 @Test 注解的测试，并生成测试报告。

轶哥提示：

测试报告在项目 build-reports 目录下，浏览器打开 index.html 即可查看

# 2.8.3、包含和排除特定测试

test {
    enabled true 
    useJUnit() 
    include 'com/**'
    exclude 'com/abc/**'
}

gradle 在 junit 中的批量测试，可以设置包含或者排除某些特定测试。

# 3、Gradle 进阶说明

为了让大家快速的入门 gradle，本章将从整体构建脚本的角度介绍:

• 什么是 setting 文件，它有什么作用；
• 说明什么是 build 文件，它又有什么作用
• 我们可以创建多少个 build
• project 和 task, 他们有什么作用；又是什么关系，如何配置
• 项目的生命周期
• 项目发布
• 使用 Gradle 创建 SpringBoot 项目等

# 3.1、项目的生命周期

Gradle 项目的生命周期分为三大阶段: Initialization -> Configuration -> Execution. 每个阶段都有自己的职责，具体如下图所示:

• Initialization 阶段主要目的是初始化构建，它又分为两个子过程，一个是执行 Init Script, 另一个是执行 Setting Script。
• init.gradle 文件会在每个项目 build 之前被调用，用于做一些初始化的操作，它主要有如下作用：
• • 配置内部的仓库信息（如公司的 maven 仓库信息）；
  • 配置一些全局属性；
  • 配置用户名及密码信息（如公司仓库的用户名和密码信息）。
• Setting Script 则更重要，它初始化了一次构建所参与的所有模块。
• Configuration 阶段：这个阶段开始加载项目中所有模块的 Build Script。所谓 “加载” 就是执行 build.gradle 中的语句，根据脚本代码创建对应的 task, 最终根据所有 task 生成由 Task 组成的有向无环图 (Directed Acyclic Graphs)，如下:

从而构成如下有向无环树：

• Execution 阶段：这个阶段会根据上个阶段构建好的有向无环图，按着顺序执行 Task【Action 动作】。

# 3.2、settings 文件

首先对 settings 文件的几点说明：

1、作用：主要是在项目初始化阶段确定一下引入哪些工程需要加入到项目构建中，为构建项目工程树做准备。

2、工程树：gradle 中有工程树的概念，类似于 maven 中的 project 与 module。

3、内容：里面主要定义了当前 gradle 项目及子 project 的项目名称

4、位置：必须放在根工程目录下。

5、名字：为 settings.gradle 文件，不能发生变化

6、对应实例：与 org.gradle.api.initialization.Settings 实例是一一对应的关系。每个项目只有一个 settings 文件。

7、关注：作为开发者我们只需要关注该文件中的 include 方法即可。使用相对路径【 : 】引入子工程。

8. 一个子工程只有在 setting 文件中配置了才会被 gradle 识别，这样在构建的时候才会被包含进去。案例如下所示：

//根工程项目名
rootProject.name = 'root'
//包含的子工程名称
include 'subject01' 
include 'subject02' 
include 'subject03'
//包含的子工程下的子工程名称
include 'subject01:subproject011' 
include 'subject01:subproject012'

项目名称中 “:” 代表项目的分隔符，类似路径中的 “/”. 如果以 “:” 开头则表示相对于 root project 。然后 Gradle 会为每个带有 build.gradle 脚本文件的工程构建一个与之对应的 Project 对象。