Gradle 项目的生命周期分为三大阶段:
Initialization ->Configuration ->Execution.
每个阶段都有自己的职责,具体如下图所示
主要目的是初始化构建, 它又分为两个子过程,一个是执行 Init Script,另一个是执行 Setting Script。
配置内部的仓库信息（如公司的 maven 仓库信息）；
配置一些全局属性；
配置用户名及密码信息（如公司仓库的用户名和密码信息）。这个阶段开始加载项目中所有模块的 Build Script。所谓 “加载” 就是执行 build.gradle 中的语句,
根据脚本代码创建对应的 task, 最终根据所有 task 生成由 Task 组成的有向无环图(Directed Acyclic Graphs)，如下:
这个阶段会根据上个阶段构建好的有向无环图，按着顺序执行 Task【Action 动作】。
二、settings.gradle 文件1、settings 文件作用：主要是在项目初始化阶段确定一下引入哪些工程需要加入到项目构建中,为构建项目工程树做准备。
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 对象。
项目实质上是 Task 对象的集合。一个 Task 表示一个逻辑上较为独立的执行过程，比如编译 Java 源代码，拷贝文件，
打包 Jar 文件，甚至可以是执行一个系统命令。另外，一个 Task 可以读取和设置 Project 的 Property 以完成特定的操作。
可参考官方文档：https://docs.gradle.org/current/userguide/tutorial_using_tasks.html
task A {println "root taskA"
doFirst(){println "root taskA doFirst"
}
doLast(){println "root taskA doLast"
}
}在文件所在的目录执行命令: gradle A。
提示 1 :task 的配置段是在配置阶段完成
提示 2 :task 的 doFirst、doLast 方法是执行阶段完成，并且 doFirst 在 doLast 执行之前执行。
提示 3:区分任务的配置段和任务的行为,任务的配置段在配置阶段执行,任务的行为在执行阶段执行
Gradle 中的依赖分别为直接依赖，项目依赖，本地 jar 依赖
dependencies {// ① .依赖当前项目下的某个模块[子工程]
implementation project(':subject01')
// ② .直接依赖本地的某个jar文件
implementation files('libs/test.jar', 'libs/test2.jar')
// ② .配置某文件夹作为依赖项
implementation fileTree(dir: 'libs', include: ['*.jar'])
//③.直接依赖
implementation 'org.apache.logging.log4j:log4j:2.18.2'
}直接依赖：在项目中直接导入的依赖，就是直接依赖
implementation 'org.apache.logging.log4j:log4j:2.18.2'完整写法
implementation group: 'org.apache.logging.log4j', name: 'log4j', version: '2.18.2'项目依赖: 从项目的某个模块依赖另一个模块
implementation project(':subject01')这种依赖方式是直接依赖本工程中的 libary module，这个 libary module 需要在 setting.gradle 中配置。
2、依赖的下载当执行 build 命令时，gradle 就会去配置的依赖仓库中下载对应的 Jar，并应用到项目中。
3、依赖的类型类似于 Maven 的 scope 标签，gradle 也提供了依赖的类型,具体如下所示
| 分类 | 说明 |
|---|---|
| compileOnly | 由java插件提供,曾短暂的叫provided,后续版本已经改成了compileOnly,适用于编译期需要而不需要打包的情况 |
| runtimeOnly | 由 java 插件提供,只在运行期有效,编译时不需要,比如 mysql 驱动包。,取代老版本中被移除的 runtime |
| implementation | 由 java 插件提供,针对源码[src/main 目录] ,在编译、运行时都有效,取代老版本中被移除的 compile |
| testCompileOnly | 由 java 插件提供,用于编译测试的依赖项，运行时不需要 |
| testRuntimeOnly | 由 java 插件提供,只在测试运行时需要，而不是在测试编译时需要,取代老版本中被移除的 testRuntime |
| testImplementation | 由 java 插件提供,针对测试代码[src/test 目录] 取代老版本中被移除的 testCompile |
| providedCompile | war 插件提供支持，编译、测试阶段代码需要依赖此类 jar 包，而运行阶段容器已经提供了相应的支持，所以无需将这些文件打入到 war 包中了;例如 servlet-api.jar、jsp-api.jar |
| compile | 编译范围依赖在所有的 classpath 中可用，同时它们也会被打包。在 gradle 7.0 已经移除 |
| runtime | 依赖在运行和测试系统的时候需要,在编译的时候不需要,比如 mysql 驱动包。在 gradle 7.0 已经移除 |
| api | java-library 插件提供支持,这些依赖项可以传递性地导出给使用者，用于编译时和运行时。取代老版本中被 |
| 移除的 compile | |
| compileOnlyApi | java-library 插件提供支持,在声明模块和使用者在编译时需要的依赖项，但在运行时不需要。 |
官方文档参考：
https://docs.gradle.org/current/userguide/java_library_plugin.html#java_library_plugin: 各个依赖范围的关系和说明
https://docs.gradle.org/current/userguide/upgrading_version_6.html#sec:configuration_removal : 依赖范围升级和移除
https://docs.gradle.org/current/userguide/java_library_plugin.html#java_library_plugin：API 和 implemention 区别
https://docs.gradle.org/current/userguide/java_plugin.html#java_plugin: 执行 java 命令时都使用了哪些依赖范围的依赖。
java 插件提供的功能，java-library 插件都提供。
总结：除非涉及到多模块依赖，为了避免重复依赖，咱们会使用 api,其它情况我们优先选择 implementation，拥有大量的 api 依赖项会显著增加构建时间。
依赖冲突是指 “在编译过程中, 如果存在某个依赖的多个版本, 构建系统应该选择哪个进行构建的问题”,如下所示:
A、B、C 都是本地子项目 module，log4j 是远程依赖。
编译时： B 用 1.4.2 版本的 log4j，C 用 2.2.4 版本的 log4j,B 和 C 之间没有冲突
打包时： 只能有一个版本的代码最终打包进最终的A对应的jar |war包，对于 Gradle 来说这里就有冲突了
excludedependencies {testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
implementation('org.hibernate:hibernate-core:3.6.3.Final'){//排除某一个库(slf4j)依赖:如下三种写法都行
exclude group: 'org.slf4j'
exclude module: 'slf4j-api'
exclude group: 'org.slf4j',module: 'slf4j-api'
}
//排除之后,使用手动的引入即可。
implementation 'org.slf4j:slf4j-api:1.4.0'
}dependencies {testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
implementation('org.hibernate:hibernate-core:3.6.3.Final'){//不允许依赖传递，一般不用
transitive(false)
}
//排除之后,使用手动的引入即可
implementation 'org.slf4j:slf4j-api:1.4.0'
}在添加依赖项时,如果设置 transitive 为 false,表示关闭依赖传递。即内部的所有依赖将不会添加到编译和运行时的类路径
强制使用某个版本dependencies {testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
implementation('org.hibernate:hibernate-core:3.6.3.Final')
//强制使用某个版本!!【官方建议使用这种方式】
implementation('org.slf4j:slf4j-api:1.4.0!!')
//这种效果和上面那种一样,强制指定某个版本
implementation('org.slf4j:slf4j-api:1.4.0'){version{strictly("1.4.0")
}
}
}//下面我们配置，当 Gradle 构建遇到依赖冲突时，就立即构建失败
configurations.all() {Configuration configuration ->//当遇到版本冲突时直接构建失败
configuration.resolutionStrategy.failOnVersionConflict()
}1、可以添加任务【task】到项目中，从而帮助完成测试、编译、打包等。
2、可以添加依赖配置到项目中。
3、可以向项目中拓展新的扩展属性、方法等。
4、可以对项目进行一些约定，如应用 Java 插件后，约定 src/main/java 目录是我们的源代码存在位置，编译时编译这个
目录下的 Java 源代码文件。
脚本插件的本质就是一个脚本文件，使用脚本插件时通过 apply from:将脚本加载进来就可以了，后面的脚本文件可以是
本地的也可以是网络上的脚本文件，下面定义一段脚本，我们在 build.gradle 文件中使用它，具体如下：
//version.gradle文件
ext {company= "test名字"
cfgs = [
compileSdkVersion : JavaVersion.VERSION_1_8
]
spring = [
version : '5.0.0'
]下面将将在构建文件中使用这个脚本文件，具体如下:
//build.gradle文件
//map作为参数
apply from: 'version.gradle'
task taskVersion{doLast{println "公司名称为：${company},JDK版本是${cfgs.compileSdkVersion},版本号是${spring.version}"
}
}buildSrc 是 Gradle 默认的插件目录，编译 Gradle 的时候会自动识别这个目录，将其中的代码编译为插件。
1.首先先建立一个名为 buildSrc 的 java Module,将 buildSrc 从 included modules 移除,重新构建,然后只保留 build.gradle和 src/main 目录，其他全部删掉,注意名字一定是 buildSrc,不然会找不到插件。
2.然后修改 Gradle 中的内容
apply plugin: 'groovy' //必须
apply plugin: 'maven-publish'
dependencies {implementation gradleApi() //必须
implementation localGroovy() //必须
}
repositories {google()
jcenter()
mavenCentral() //必须
}
//把项目入口设置为src/main/groovy
sourceSets {main {groovy {srcDir 'src/main/groovy'
}
}apply plugin: '插件名'
//指定使用什么版本的JDK语法编译源代码,跟编译环境有关,在有java插件时才能用
sourceCompatibility = 1.8
//指定生成特定于某个JDK版本的class文件:跟运行环境有关,在有java插件时才能用
targetCompatibility = 1.8
//业务编码字符集,注意这是指定源码解码的字符集[编译器]
compileJava.options.encoding "UTF-8"
//测试编码字符集,注意这是指定源码解码的字符集[编译器]
compileTestJava.options.encoding "UTF-8"
//编译JAVA文件时采用UTF-8:注意这是指定源码编码的字符集【源文件】
tasks.withType(JavaCompile) {options.encoding = "UTF-8"
}
//编译JAVA文件时采用UTF-8:注意这是指定文档编码的字符集【源文件】
tasks.withType(Javadoc) {options.encoding = "UTF-8"
}Gradle 没有自己的远程仓库，而是使用 Maven、jcenter、jvy、google 这些远程仓库。
repositories {//gradle中会按着仓库配置的顺序，从上往下依次去对应的仓库中找所需要的jar包:
//如果找到，则停止向下搜索，如果找不到，继续在下面的仓库中查找
//指定去本地某个磁盘目录中查找:使用本地file文件协议:一般不用这种方式
maven {url 'file:///D:/mavenrepos3.5.4'}
maven {url "$rootDir/lib/release" }
//指定去maven的本地仓库查找
mavenLocal()
//指定去maven的游戏或者第三方镜像仓库查找
maven {name "Alibaba" ; url "https://maven.aliyun.com/repository/public" }
maven {name "Bstek" ; url "https://nexus.bsdn.org/content/groups/public/" }
//指定去maven的远程仓库查找:即 https://repo.maven.apache.org/maven2/
mavenCentral()
//去google仓库查找
google()
}allprojects 是对所有 project(包括 Root Project+ child Project[当前工程和所有子工程])的进行统一配置，而
subprojects是对所有 Child Project 的进行统一配置。
llprojects {tasks.create('hello') {doLast {task ->println "project name is $task.project.name"
}
}
}
subprojects {hello.doLast{task->println "here is subprojects $task.project.name"
}
}通常在 subprojects 和 allprojects 中:
allprojects(){//本质Project中的allprojects方法，传递一个闭包作为参数。
apply plugin: 'java'
ext {junitVersion = '4.10'
..
}
task allTask{...
}
repositories {...
}
dependencies {...
}
}
subprojects(){…//同上面allprojects中的方法。
}project('subject01') {task subject01 {doLast {println 'for subject01'
}
}
}Project 和 Task 都允许用户添加额外的自定义属性，要添加额外的属性，通过应用所属对象的 ext 属性即可实现。添加之后可以通过 ext 属性对自定义属性读取和设置，如果要同时添加多个自定义属性,可以通过 ext 代码块:
/自定义一个Project的属性
ext.age = 99
//通过代码块同时自定义多个属性
ext {phone = 1199
address="猜猜"
}
task extCustomProperty {//在task中自定义属性
ext {desc = "备注"
}
doLast {println "1是：${age}"
println "2是：${phone}"
println "3是：${address}"
println "4是：${desc}"
}
}1: ext 配置的是用户自定义属性，而 gradle.properties 中一般定义 系统属性、环境变量、项目属性、JVM 相关配置。
加快构建速度的，gradle.properties 文件中的属性会自动在项目运行时加载。
详细请参考：https://docs.gradle.org/current/userguide/build_environment.html#sec:gradle_configuration_properties
## 设置此参数主要是编译下载包会占用大量的内存，可能会内存溢出
org.gradle.jvmargs=-Xms1024m -Xmx536m
## 开启gradle缓存
org.gradle.caching=true
#开启并行编译
org.gradle.parallel=true
#启用新的孵化模式
org.gradle.configureondemand=true
#开启守护进程
org.gradle.daemon=truebuildscript 里是 gradle 脚本执行所需依赖，分别是对应的 maven 库和插件。
import org.apache.commons.codec.binary.Base64
buildscript {repositories {mavenCentral()
}
dependencies {classpath group: 'commons-codec', name: 'commons-codec', version: '1.2'
}
}
tasks.register('encode') {doLast {def byte[] encodedStrings = new Base64().encode('hello world\'.getBytes())
println new String(encodedStrings)
}
}/apply插件的引用方式,使用apply+buildscript
buildscript {ext {springBootVersion = "2.3.7.RELEASE"
}
repositories {mavenLocal()
maven {url 'http://maven.aliyun.com/nexus/content/groups/public' }
jcenter()
}
//此处引入插件
dependencies {classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
}
}
apply plugin: 'java' //核心插件，无需事先引入
apply plugin: 'org.springframework.boot' //社区插件，需要事先引入,才能应用，不必写版本号plugins {id 'java-library' //如果发布war包，需要war插件,java-library支持带源码、文档发布
id 'maven-publish'
}/带源码和javadoc的发布:需要'java-library'插件支持:它是java的升级版，java插件的功能java-library都有
//javadoc.options.encoding="UTF-8"
//java {// withJavadocJar()
// withSourcesJar()
//}
publishing {publications {myLibrary(MavenPublication) {groupId = 'org.gradle.sample' //指定GAV坐标信息
artifactId = 'library'
version = '1.1'
from components.java//发布jar包
//from components.web///引入war插件，发布war包
}
}
repositories {//本地仓库位于USER_HOME/.m2/repository
mavenLocal()
//发布项目到游戏中
maven {name = 'testRepo' //name属性可选,表示仓库名称，url必填
//发布地址:可以是本地仓库或者maven游戏
//url = layout.buildDirectory.dir("repo")
// change URLs to point to your repos, e.g. http://test/repo
def releasesRepoUrl = layout.buildDirectory.dir('v/releases')
def snapshotsRepoUrl = layout.buildDirectory.dir('v/snapshots')
url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
//认证信息:用户名和密码
// credentials {// username = 'zhangssn'
// password = '123456'
// }
}
}
}执行发布命令，将项目发布到本地仓库或者远程仓库。常见的发布指令有：
生命周期中的这些钩子函数都是由 gradle 自动回调完成的,利用这些钩子函数可以帮助我们实现一些我们想要的功能。
Gradle 在生命周期各个阶段都提供了用于回调的钩子函数:
1、Gradle 对象：在项目初始化时构建，全局单例存在，只有这一个对象
2、Project 对 象：每一个build.gradle文件 都会转换成一个 Project 对象,类似于maven中的pom.xml文件
3、Settings 对象：settings.gradle 会转变成一个 settings 对象,和整个项目是一对一的关系,一般只用到include方法
4.、Task对象: 从前面的有向无环图中，我们也可以看出，gradle最终是基于Task的,一个项目可以有一个或者多个Task在 root project 的 settings.gradle 文件中添加：
gradle.settingsEvaluated {//1.settingsEvaluated钩子函数,在初始化阶段完成
println "settingsEvaluated"
}
gradle.projectsLoaded {//2.projectsLoaded钩子函数,在初始化阶段完成
println "projectsLoaded"
}
//声明一个变量：表示当前项目名,在每次执行某个项目的beforeEvaluate方法时先给projectName变量赋值
//这样方便在：gradle.beforeProject和afterProject两个钩子函数使用。
def projectName=""
gradle.addProjectEvaluationListener( new ProjectEvaluationListener(){//3.执行各个project的beforeEvaluate：在配置阶段完成
@Override
void beforeEvaluate(Project project) {projectName=project.name
println "${project.name} Project beforeEvaluate"
}
//5.执行各个project的afterEvaluate：在配置阶段完成
@Override
void afterEvaluate(Project project, ProjectState projectState) {println "${project.name} Project afterEvaluate"
}
});
gradle.beforeProject {//4.执行各个project的beforeProject：在配置阶段完成
println "${projectName} beforeProject..."
}
gradle.afterProject {//6.执行各个project的afterProject：在配置阶段完成
println "${projectName} afterProject..."
}
//7.所有工程的 build.gradle 执行完毕后，回调 Gradle 对象的 projectsEvaluated 方法：在配置阶段完成
def rootProjectName=rootProject.getName()
gradle.projectsEvaluated {println "${rootProjectName} projectsEvaluated..."
}
//8.配置阶段完毕后，回调 TaskExecutionGraph 对象的 whenReady 方法：在配置阶段完成
gradle.taskGraph.whenReady {println "${rootProjectName} taskGraph whenReady..."
}
//9.在当前Task执行之前,会回调 TaskExecutionGraph 对象的 beforeTask方法：在执行阶段完成
gradle.taskGraph.beforeTask {task ->println "this is the task ${task.name} of the project ${task.getProject().name} beforeTask.."
}
//10.在当前Task执行之后,会回调 TaskExecutionGraph 对象的 afterTask方法：在执行阶段完成
gradle.taskGraph.afterTask {task ->println "this is the task ${task.name} of the project ${task.getProject().name} afterTask.."
}
//11.当所有的 Task 执行完毕后，会回调 Gradle 对象的 buildFinish 方法：在执行阶段完成
gradle.buildFinished {println "${rootProjectName} buildFinished..."
}你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧