【Gradle】三、深入了解Gradle

r囧r小猫 2023-10-09 15:10 60阅读 0赞

#### 这里写目录标题 ####

*  一、 Gradle项目的生命周期
 *   *  Initialization 阶段
     *  Configuration 阶段：
     *  Execution 阶段：
 *  二、settings.gradle 文件
 *  三、Task
 *   *  1、 案例
 *  四、Dependencies
 *   *  1、依赖的分类
     *  2、依赖的下载
     *  3、依赖的类型
     *  4、api与implementation的区别
     *  5、依赖冲突及解决方案
     *   *  Exclude 排除某个依赖
         *  不允许依赖传递
         *  强制使用某个版本
         *  查看当前项目中到底有哪些依赖冲突：
 *  五、Gradle 插件
 *   *  1、插件的作用
     *  2、插件的分类和使用
     *   *  脚本插件
     *  3、buildSrc
     *  4、 插件的使用
 *  六、build.gradle 文件
 *   *  1、Repositories
     *  2、 Subprojects 与 与 All projects
     *  3、ext 用户自定义属性
     *  gradle.properties
     *  Buildscript
 *  六、publishing 项目 发布
 *   *  1、引入 maven
     *  2 、设置发布代码
     *  3 、 执行发布指令
 *  七 、 生命周期中 Hook
 *   *  Gradle 初始化阶段:
     *  Gradle 配置阶段:
     *  Gradle 执行阶段:

## 一、 Gradle项目的生命周期 ##

Gradle 项目的生命周期分为三大阶段:  
Initialization -> Configuration -> Execution.  
每个阶段都有自己的职责,具体如下图所示  
![在这里插入图片描述][7f0f5847f9064a2da144874e5e541d61.png]

### Initialization 阶段 ###

主要目的是初始化构建, 它又分为两个子过程,一个是执行 Init Script,另一个是执行 Setting Script。

*  init.gradle 文件会在每个项目 build 之前被调用，用于做一些初始化的操作，它主要有如下作用：

配置内部的仓库信息（如公司的 maven 仓库信息）；
    配置一些全局属性；
    配置用户名及密码信息（如公司仓库的用户名和密码信息）。

*  Setting Script 则更重要, 它初始化了一次构建所参与的所有模块。

### Configuration 阶段： ###

这个阶段开始加载项目中所有模块的 Build Script。所谓 “加载” 就是执行 build.gradle 中的语句,  
根据脚本代码创建对应的 task, 最终根据所有 task 生成由 Task 组成的有向无环图(Directed Acyclic Graphs)，如下:  
![在这里插入图片描述][2acbf407e09248ff947e0cb02336191c.png]  
![在这里插入图片描述][c8804044e6fb4c79bbcdbe69d469f613.png]

### Execution 阶段： ###

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

## 二、settings.gradle 文件 ##

1、settings 文件作用：主要是在项目初始化阶段确定一下引入哪些工程需要加入到项目构建中,为构建项目工程树做准备。  
2、工程树：gradle 中有工程树的概念，类似于 maven 中的 project 与 module。  
![在这里插入图片描述][3d62462ebbb140738e272ecbe077f258.png]  
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 对象的集合。一个 Task 表示一个逻辑上较为独立的执行过程，比如编译 Java 源代码，拷贝文件，  
打包 Jar 文件，甚至可以是执行一个系统命令。另外，一个 Task 可以读取和设置 Project 的 Property 以完成特定的操作。  
可参考官方文档：[https://docs.gradle.org/current/userguide/tutorial\_using\_tasks.html][https_docs.gradle.org_current_userguide_tutorial_using_tasks.html]

### 1、 案例 ###

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:区分任务的配置段和任务的行为,任务的配置段在配置阶段执行,任务的行为在执行阶段执行

## 四、Dependencies ##

### 1、依赖的分类 ###

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 也提供了依赖的类型,具体如下所示

<table> 
 <thead> 
  <tr> 
   <th>分类</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>compileOnly</td> 
   <td>由java插件提供,曾短暂的叫provided,后续版本已经改成了compileOnly,适用于编译期需要而不需要打包的情况</td> 
  </tr> 
  <tr> 
   <td>runtimeOnly</td> 
   <td>由 java 插件提供,只在运行期有效,编译时不需要,比如 mysql 驱动包。,取代老版本中被移除的 runtime</td> 
  </tr> 
  <tr> 
   <td>implementation</td> 
   <td>由 java 插件提供,针对源码[src/main 目录] ,在编译、运行时都有效,取代老版本中被移除的 compile</td> 
  </tr> 
  <tr> 
   <td>testCompileOnly</td> 
   <td>由 java 插件提供,用于编译测试的依赖项，运行时不需要</td> 
  </tr> 
  <tr> 
   <td>testRuntimeOnly</td> 
   <td>由 java 插件提供,只在测试运行时需要，而不是在测试编译时需要,取代老版本中被移除的 testRuntime</td> 
  </tr> 
  <tr> 
   <td>testImplementation</td> 
   <td>由 java 插件提供,针对测试代码[src/test 目录] 取代老版本中被移除的 testCompile</td> 
  </tr> 
  <tr> 
   <td>providedCompile</td> 
   <td>war 插件提供支持，编译、测试阶段代码需要依赖此类 jar 包，而运行阶段容器已经提供了相应的支持，所以无需将这些文件打入到 war 包中了;例如 servlet-api.jar、jsp-api.jar</td> 
  </tr> 
  <tr> 
   <td>compile</td> 
   <td>编译范围依赖在所有的 classpath 中可用，同时它们也会被打包。在 gradle 7.0 已经移除</td> 
  </tr> 
  <tr> 
   <td>runtime</td> 
   <td>依赖在运行和测试系统的时候需要,在编译的时候不需要,比如 mysql 驱动包。在 gradle 7.0 已经移除</td> 
  </tr> 
  <tr> 
   <td>api</td> 
   <td>java-library 插件提供支持,这些依赖项可以传递性地导出给使用者，用于编译时和运行时。取代老版本中被</td> 
  </tr> 
  <tr> 
   <td>移除的 compile</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>compileOnlyApi</td> 
   <td>java-library 插件提供支持,在声明模块和使用者在编译时需要的依赖项，但在运行时不需要。</td> 
  </tr> 
 </tbody> 
</table>

官方文档参考：  
[https://docs.gradle.org/current/userguide/java\_library\_plugin.html\#java\_library\_plugin:][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_upgrading_version_6.html_sec_configuration_removal] : 依赖范围升级和移除  
[https://docs.gradle.org/current/userguide/java\_library\_plugin.html\#java\_library\_plugin][https_docs.gradle.org_current_userguide_java_library_plugin.html_java_library_plugin 1]：API 和 implemention 区别  
[https://docs.gradle.org/current/userguide/java\_plugin.html\#java\_plugin][https_docs.gradle.org_current_userguide_java_library_plugin.html_java_library_plugin 1]: 执行 java 命令时都使用了哪些依赖范围的依赖。  
**java 插件提供的功能，java-library 插件都提供。**

### 4、api与implementation的区别 ###

![在这里插入图片描述][08528f8bef074dbea3c76ed9ed0a15d3.png]  
总结：除非涉及到多模块依赖，为了避免重复依赖，咱们会使用 api,其它情况我们优先选择 implementation，拥有大量的 api 依赖项会显著增加构建时间。

### 5、依赖冲突及解决方案 ###

依赖冲突是指 “在编译过程中, 如果存在某个依赖的多个版本, 构建系统应该选择哪个进行构建的问题”,如下所示:  
![在这里插入图片描述][69ad33d901d2417e95bb5b759d88b2b3.png]  
A、B、C 都是本地子项目 module，log4j 是远程依赖。  
编译时： B 用 1.4.2 版本的 log4j，C 用 2.2.4 版本的 log4j,B 和 C 之间没有冲突  
打包时： 只能有一个版本的代码最终打包进最终的A对应的jar |war包，对于 Gradle 来说这里就有冲突了

*  **默认的解决方法**  
    默认下，Gradle 会使用最新版本的 jar 包【考虑到新版本的 jar 包一般都是向下兼容的】，实际开发中，还是建议使用官方自带的这种解决方案。  
    当然除此之外，Gradle 也为我们提供了一系列的解决依赖冲突的方法: `exclude`  
    移除一个依赖，不允许依赖传递，强制使用某个版本

#### Exclude 排除某个依赖 ####

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'){
        
    //排除某一个库(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()
    }

## 五、Gradle 插件 ##

### 1、插件的作用 ###

1、可以添加任务【task】到项目中，从而帮助完成测试、编译、打包等。  
2、可以添加依赖配置到项目中。  
3、可以向项目中拓展新的扩展属性、方法等。  
4、可以对项目进行一些约定，如应用 Java 插件后，约定 src/main/java 目录是我们的源代码存在位置，编译时编译这个  
目录下的 Java 源代码文件。

### 2、插件的分类和使用 ###

![在这里插入图片描述][1e9a9bbb33224d52b82bafd4db4af407.png]

#### 脚本插件 ####

脚本插件的本质就是一个脚本文件，使用脚本插件时通过 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}"
    }
    }

### 3、buildSrc ###

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'
    }
    }

### 4、 插件的使用 ###

*  插件的引用

apply plugin: '插件名'

*  主要的功能\[任务\]  
    当我们在工程中引入插件后，插件会自动的为我们的工程添加一些额外的任务来完成相应的功能。以 Java 插件为例，当  
    我们加入 java 插件之后，就加入了如下功能：  
    ![在这里插入图片描述][fd25003ecf1e4c58b12d3b9ff3d18350.png]
 *  工程目录结构  
    一些插件对工程目结构有约定，所以我们一般遵循它的约定结构来创建工程，这也是 Gradle 的“约定优于配置”原则。  
    例如 java 插件规定的项目源集目录结构如下所示：  
    ![在这里插入图片描述][a6775b9eb5b54bcf89ffa94cb3787901.png]
 *  常用的属性  
    ![在这里插入图片描述][afdba36f8a0e46f09983fe38ff6561a5.png]  
    ![在这里插入图片描述][36217e6b21094e6dbfefa11a81e6f526.png]

## 六、build.gradle 文件 ##

*  build.gradle 是一个 gradle 的构建脚本文件,支持 java、groovy 等语言。
 *  每个 project 都会有一个 build.gradle 文件,该文件是项目构建的入口,可配置版本、插件、依赖库等信息。
 *  每个 build 文件都有一个对应的 Project 实例,对 build.gradle 文件配置，本质就是设置 Project 实例的属性和方法。
 *  由于每个 project 都会有一个 build 文件,那么 Root Project 也不列外.Root Project 可以获取到所有 Child Project,所以在
 *  Root Project 的 build 文件中我们可以对 Child Project 统一配置,比如应用的插件、依赖的 maven 中心仓库等。
 *  build 文件中常见的属性和方法如下所示：

![在这里插入图片描述][c7f70f95367e48c6a0dba88d505919fa.png]

//指定使用什么版本的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"
    }

### 1、Repositories ###

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()
    }

### 2、 Subprojects 与 与 All projects ###

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中的方法。
    }

*  1: 如果是直接在根 project 配置 repositories 和 dependencies 则只针对根工程有效。
 *  我们也可以在对单个 Project 进行单独配置：

project('subject01') {
        
    task subject01 {
        
    doLast {
        
    println 'for subject01'
    }
    }
    }

### 3、ext 用户自定义属性 ###

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}"
    }
    }

### gradle.properties ###

1: ext 配置的是用户自定义属性，而 gradle.properties 中一般定义 系统属性、环境变量、项目属性、JVM 相关配置。  
加快构建速度的，gradle.properties 文件中的属性会自动在项目运行时加载。  
详细请参考：[https://docs.gradle.org/current/userguide/build\_environment.html\#sec:gradle\_configuration\_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=true

### Buildscript ###

buildscript 里是 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)
    }
    }

*  1buildscript\{\}必须在 build.gradle 文件的最前端。
 *  2.对于多项目构建，项目的 buildscript ()方法声明的依赖关系可用于其所有子项目的构建脚本。
 *  3.构建脚本依赖可能是 Gradle 插件。

/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' //社区插件，需要事先引入,才能应用，不必写版本号

## 六、publishing 项目 发布 ##

### 1、引入 maven ###

plugins {
        
    id 'java-library' //如果发布war包，需要war插件,java-library支持带源码、文档发布
    id 'maven-publish'
    }

### 2 、设置发布代码 ###

/带源码和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'
    // }
    }
    }
    }

### 3 、 执行发布指令 ###

执行发布命令，将项目发布到本地仓库或者远程仓库。常见的发布指令有：

*  **generatePomFileForPubNamePublication**: 生成 pom 文件
 *  **publishPubNamePublicationToRepoNameRepository**:发布项目到指定仓库,如果没有仓库名，默认为 maven
 *  **publishPubNamePublicationToMavenLocal**: 将 PubName 发布复制到本地 Maven 仓库中包括 POM 文件和其他元数据。
 *  **publish**: 发布到 repositories 中指定的仓库(为比如 Maven 私服)
 *  **publishToMavenLocal**: 执行所有发布任务中的操作发布到本地 maven 仓库。

## 七 、 生命周期中 Hook ##

生命周期中的这些钩子函数都是由 gradle 自动回调完成的,利用这些钩子函数可以帮助我们实现一些我们想要的功能。

![在这里插入图片描述][f6fd37cdac1c47f68903e9f02e8744fa.png]  
Gradle 在生命周期各个阶段都提供了用于回调的钩子函数:

### Gradle 初始化阶段: ###

*  在 settings.gradle 执行完后,会回调 Gradle 对象的 settingsEvaluated 方法
 *  在构建所有工程 build.gradle 对应的 Project 对象后,也既初始化阶段完毕,会回调 Gradle 对象的 projectsLoaded 方法

### Gradle 配置阶段: ###

*  Gradle 会循环执行每个工程的 build.gradle 脚本文件
 *  在执行当前工程build.gradle前,会回调Gradle对象的 beforeProject 方法和当前Project对象的 beforeEvaluate方法,  
    虽然 beforeEvalute 属于 project 的生命周期, 但是此时 build script 尚未被加载, 所以 beforeEvaluate 的设置依  
    然要在 init script 或 setting script 中进行,不要在 build script 中使用 project.beforeEvaluate 方法。
 *  在执行当前工程 build.gradle 后,会回调 Gradle 对象的 afterProject 方法和当前 Project 对象的 afterEvaluate 方法
 *  在所有工程的 build.gradle 执行完毕后，会回调 Gradle 对象的 projectsEvaluated 方法
 *  在构建 Task 依赖有向无环图后,也就是配置阶段完毕,会回调 TaskExecutionGraph 对象的 whenReady 方法

### Gradle 执行阶段: ###

*  Gradle 会循环执行 Task 及其依赖的 Task
 *  在当前 Task 执行之前,会回调 TaskExecutionGraph 对象的 beforeTask 方法
 *  在当前 Task 执行之后,会回调 TaskExecutionGraph 对象的 afterTask 方法  
    当所有的 Task 执行完毕后，会回调 Gradle 对象的 buildFinish 方法。  
    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..."
    }

[7f0f5847f9064a2da144874e5e541d61.png]: https://img-blog.csdnimg.cn/7f0f5847f9064a2da144874e5e541d61.png
[2acbf407e09248ff947e0cb02336191c.png]: https://img-blog.csdnimg.cn/2acbf407e09248ff947e0cb02336191c.png
[c8804044e6fb4c79bbcdbe69d469f613.png]: https://img-blog.csdnimg.cn/c8804044e6fb4c79bbcdbe69d469f613.png
[3d62462ebbb140738e272ecbe077f258.png]: https://img-blog.csdnimg.cn/3d62462ebbb140738e272ecbe077f258.png
[https_docs.gradle.org_current_userguide_tutorial_using_tasks.html]: https://docs.gradle.org/current/userguide/tutorial_using_tasks.html
[https_docs.gradle.org_current_userguide_java_library_plugin.html_java_library_plugin]: 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/upgrading_version_6.html#sec:configuration_removal
[https_docs.gradle.org_current_userguide_java_library_plugin.html_java_library_plugin 1]: https://docs.gradle.org/current/userguide/java_library_plugin.html#java_library_plugin
[08528f8bef074dbea3c76ed9ed0a15d3.png]: https://img-blog.csdnimg.cn/08528f8bef074dbea3c76ed9ed0a15d3.png
[69ad33d901d2417e95bb5b759d88b2b3.png]: https://img-blog.csdnimg.cn/69ad33d901d2417e95bb5b759d88b2b3.png
[1e9a9bbb33224d52b82bafd4db4af407.png]: https://img-blog.csdnimg.cn/1e9a9bbb33224d52b82bafd4db4af407.png
[fd25003ecf1e4c58b12d3b9ff3d18350.png]: https://img-blog.csdnimg.cn/fd25003ecf1e4c58b12d3b9ff3d18350.png
[a6775b9eb5b54bcf89ffa94cb3787901.png]: https://img-blog.csdnimg.cn/a6775b9eb5b54bcf89ffa94cb3787901.png
[afdba36f8a0e46f09983fe38ff6561a5.png]: https://img-blog.csdnimg.cn/afdba36f8a0e46f09983fe38ff6561a5.png
[36217e6b21094e6dbfefa11a81e6f526.png]: https://img-blog.csdnimg.cn/36217e6b21094e6dbfefa11a81e6f526.png
[c7f70f95367e48c6a0dba88d505919fa.png]: https://img-blog.csdnimg.cn/c7f70f95367e48c6a0dba88d505919fa.png
[https_docs.gradle.org_current_userguide_build_environment.html_sec_gradle_configuration_properties]: https://docs.gradle.org/current/userguide/build_environment.html#sec:gradle_configuration_properties
[f6fd37cdac1c47f68903e9f02e8744fa.png]: https://img-blog.csdnimg.cn/f6fd37cdac1c47f68903e9f02e8744fa.png