Gradle详解

最新推荐文章于 2024-07-20 08:45:00 发布

Tʀᴜsᴛ³⁴⁵

最新推荐文章于 2024-07-20 08:45:00 发布

阅读量1.8k

点赞数 2

分类专栏： Gradle Android 文章标签： gradle ProjectApi

本文链接：https://blog.csdn.net/baidu_40389775/article/details/103661518

版权

Android 同时被 2 个专栏收录

66 篇文章 2 订阅

订阅专栏

Gradle

7 篇文章 0 订阅

订阅专栏

文章目录

Gradle 是什么？

gradle 是一个基于 Apache Ant 和 Apache Maven 概念的项目自动化构建工具，他使用一种基于 groovy 的特定领域语言来声明项目的设置，而不是使用传统的 XML 。gradle 就是工程的管理，帮我们做好了依赖，打包，部署，发布，各种渠道的差异管理等工作

Gradle 的组成

在这里插入图片描述
gradle 完全使用的是 groovy 的语法。

Gradle 的优势

非常灵活，可以自行去扩展。一款最新的构建工具，使用它逼格更高。丰富的第三方插件，项目构建灵活性更高，Maven ，Ant 能做的 Gradle 都能做，Gradle 能做的它们不一定能做

Gradle 生命周期

在这里插入图片描述

Gradle 生命周期回调方法的时机：

/**
 * 配置阶段开始前回调监听
 */
this.beforeEvaluate {
}

/**
 * 配置阶段完成后回调监听
 */
this.afterEvaluate {
    println '配置阶段完成...'
}


/**
 * build 执行完毕
 */
this.buildFinished {
  
}
/**
 * 监听 task 的创建
 */
tasks.whenTaskAdded { task ->
    task.ext.srcDir = 'src/main/java'
}

/**
 * 监听某个task开始执行，结束执行
 */
gradle.taskGraph.addTaskExecutionListener(new TaskExecutionListener() {
    @Override
    void beforeExecute(Task task) {

    }

    @Override
    void afterExecute(Task task, TaskState state) {

   }
})

//其他的监听
this.gradle.addBuildListener(new BuildListener() {
    @Override
    void buildStarted(Gradle gradle) {
		//在构建启动时调用
    }

    @Override
    void settingsEvaluated(Settings settings) {
		//在加载和计算构建设置时调用,设置对象已完全配置完成可用来加载构建项目
    }

    @Override
    void projectsLoaded(Gradle gradle) {
		//从设置创建构建的项目时调用。这些项目都没有评估
    }

    @Override
    void projectsEvaluated(Gradle gradle) {
		//构建的项目评估后调用
    }

    @Override
    void buildFinished(BuildResult result) {
		//构建完成时调用
    }
})

Gradle 的生命周期分为三个阶段，初始化阶段，配置阶段，执行阶段。

初始化阶段：通过 setting.gradle 来判断项目有哪些项目需要初始化，加载需要被初始化的项目的build.gradle 文件，并为每个项目创建 project 对象。如果你的项目有好几个模块，你可以打开 setting.gradle ，每个模块的名字都在里面，如果删除某个模块的名字，则这个模块不会被构建。
```
include  ':app', ':core', ':detegateManager', ':tabHome', ':tabShop', ':tabDiscover', ':tabMall', ':tabMine', ':ui'
rootProject.name='CarSteward'
```
配置阶段，执行各个项目下的 build.gradle 脚本处理依赖等。完成 project 的配置，构造 Task 链表(这里的链表指的是存在依赖关系的 task 的集合，不是数据结构链表)
执行阶段

根据 task 链表执行某一个特定的task，这个被 task 所以来的其他task都会被先执行

Gradle 中的 Project

对于 gradle 来说，每一个模块都是一个 project ，对于他来说不存在什么 Library 等模块。他们都是一个项目，如下：

在这里插入图片描述

对于 android 来说这是一个项目，里面有很多模块，但是 gradle中每个模块也相当于一个 project。我们可以通过一个命令来查看一下：gradlew projects

Root project 'CarSteward'
+--- Project ':app'
+--- Project ':core'
+--- Project ':detegateManager'
+--- Project ':tabDiscover'
+--- Project ':tabHome'
+--- Project ':tabMall'
+--- Project ':tabMine'
+--- Project ':tabShop'
\--- Project ':ui'

可以看到有一个 Root project ，其他的则是子project。从这个结构可以看出来 gradle 是以树的结构来管理所有的 project。但是这个树只有两层，因为我们不可能在 module 中新建一个模块

Project 是脚本的核心，每个 project 的初始化都是通过 build.gradle 文件，所以构建的核心脚本都要编写在 build.gradle 中

每一个模块都必须有一个 build.gradle 文件，否则他就不会被任务是一个 project。

根 Project 的作用就是用来管理所有的子project，他提供了一系列的 api 来进行管理。

子 Project 则是用来对应输出的，一个子 project 对应一个输出，例如上面的 app project就对应着一个 apk 的输出，而 core 等其他的就对应一个 aar 的输出。如果是 java 的项目，则对应的就是 jar 的输出。

Project Api

在这里插入图片描述

project 相关的api

让当前 project 可以操做他的父 project 以及管理它子 project 的能力

def getProjects() {
    println "------------"
    //获取所有project 并遍历
    this.getAllprojects().eachWithIndex {
        Project entry, int i ->
            if (i == 0) {
                println "Root Project ${entry.name}"
            } else {
                println "+--- Project ${entry.name}"
            }
    }
    println "------------"
}
this.getProjects()
//结果：
------------
Root Project CarSteward
+--- Project app
+--- Project core
+--- Project detegateManager
+--- Project tabDiscover
+--- Project tabHome
+--- Project tabMall
+--- Project tabMine
+--- Project tabShop
+--- Project ui
------------

    
//获取所有子 project 并遍历
 this.getSubprojects().eachWithIndex {
        Project entry, int i ->
            println "+--- Project ${entry.name}"
}

//获取父 project，需要在子 project 中执行
def getParentProject() {
    println "----" + this.getParent().name
}
//获取 RootProject
println "----" + this.getRootProject().name

注意：不管是project 中的方法也好，代码也好都是在配置阶段执行的。

//获取指定的 project，第一个参数为路径，第二个为闭包
project("core") {
    Project project ->
        println project.name //获取 name
        apply plugin: 'com.android.library' //指定 plugin
        group 'com.123'  //指定 group
        version '1.0.0' //指定 版本号
        dependencies { //指定 依赖

        }
        android { //指定 android

        }
}

我们可以直接在RootProject 中获取子 Project，并且调用一些方法，如上，可以完全将 core 中的配置移到 RootProject 中也没有任何问题。但是一般都不会这样做。

//配置当前结点工程和所有子 project
allprojects {
    version '2.0.0'
    group 'com.ww.com'
}
println project('core').group
println project('core').version
//结果：
com.ww.com
2.0.0

//不包括当前结点工程，只包含他的子 project
subprojects {
    version '2.0.0'
    group 'com.ww.com'
}

使用 allprojects 就可以替换当前及子 project 中的配置。

task 相关 api

为当前的 project 提供了新增 task 以及使用当前 project 中 task 的能力

task 内容有点多，需要单独提出来

属性相关的 api

gradle 本身提供了一些属性，属性 api 让我们在 project 中可以添加额外的属性能力

public interface Project extends Comparable<Project>, ExtensionAware, PluginAware {

    /**
     * 默认的项目构建文件名,所以我们的自 project 中才必须有 build.gradle
     */
    String DEFAULT_BUILD_FILE = "build.gradle";
	/**
     * 分割符
     */
    String PATH_SEPARATOR = ":";
    
    /**
     * 每个 project 都有一个build 文件夹，就是下面这个属性，文件夹中则是输出
     */
    String DEFAULT_BUILD_DIR_NAME = "build";
	/**
	 * 这个字段是一个文件，这个文件中定义的所有属性都是全局的，在所有的.gradle 文件中
	 * 以使用，注意只能是 key value 类型
	 */
    String GRADLE_PROPERTIES = "gradle.properties";

    ......
}

扩展属性：

在 RootProject 中定义扩展属性，如下：

subprojects {
   ext{
        compile_sdk_version = 29
     	min_sdk_version = 15
      	target_sdk_version = 29
    	version_code = 1
    	version_name = APP_VERSION
    	build_tools_version = "29.0.2"
    }
}

通过这种方式就可以子 project 中直接使用这些属性了。只需要定义一次，就可以定义在所有的子 project 中。

但是这种有一个缺陷，虽然看起来我们只定义了一次，但是本质上 gradle 会为每一个project 都定义这些属性，我们只是感觉操作方便了一些而已。

改进一哈：

直接在 RootProject 中定义 ext。而不是定义在 subprojects 中。这样子工程就可以直接通过获取 rootProject来获取这些属性了。

ext{
        compile_sdk_version = 29
     	min_sdk_version = 15
      	target_sdk_version = 29
    	version_code = 1
    	version_name = APP_VERSION
    	build_tools_version = "29.0.2"
}

子工程的获取：

compileSdkVersion this.rootProject compile_sdk_version

gradle 规定父类中所有的属性都可以被子类继承，所以这里就可以这样写：

compileSdkVersion compile_sdk_version

但是如果将所有的扩展属性都定义在 RootProject 中，感觉会非常臃肿，所以我们可以新建一个 config.gradle 文件，将扩展属性定义在里面，然后在 RootProject 中引入即可，如下：

//从根工程下寻找 config.gradle 文件
apply from: file('config.gradle')

我们还可以再 gradle.properties 文件中定义属性，但是在这个文件中只能定义 key value 类型的属性，所以他的使用有些限制。使用如下：


android.useAndroidX=true
android.enableR8=false
isDebug=false
# 版本
APP_VERSION=1.0.3

如上面是引入 AndroidX，关闭 R8。下面的 isDebug 是我们自定义的，定义完后我们就可以在任何的 .gradle 文件中使用 isDebug。如下所示：

if (isDebug.toBoolean()){
    apply plugin: 'com.android.application'
}else {
    apply plugin: 'com.android.library'
}

file 相关的 api

这个 file 主要用于操作当前 project 下文件的处理

println getRootDir().absolutePath //获取根工程路径
println getBuildDir().absolutePath //获取 build 路径
println getProjectDir().absolutePath //获取工程的路径

//结果：
C:\Users\Administrator\Desktop\345\Project\CarSteward
C:\Users\Administrator\Desktop\345\Project\CarSteward\build
C:\Users\Administrator\Desktop\345\Project\CarSteward

上面就是获取路径

//文件定位，以当前的 project 来寻找文件
def getContent(String pach) {
    try {
        //返回文件内容
        return file(pach).text
    } catch (GradleException e) {
        println "file not found..."
    }
}

println getContent("config.gradle")
//结果：
ext{

    compile_sdk_version = 29
    min_sdk_version = 15
    target_sdk_version = 29
    version_code = 1
    version_name = APP_VERSION
    build_tools_version = "29.0.2"

}

可以看到已经找到 config.gradle 并且将他的内容全部打印出来了。file只能定位一个文件，但是 files 可以定位多个。

//copy
//将 app 下的签名文件 copy 到 根工程的 build 目录下
copy {
    from(file('CarSteward.jks'))
    into getRootProject().getBuildDir()
}
//copy 文件夹
copy {
    from(file('build/outputs/'))
    into getRootProject().getBuildDir().path + "/outputs/"
}

//copy 文件夹
copy {
    from(file('build/outputs/'))
    into getRootProject().getBuildDir().path + "/outputs/"
    exclude {
        //可以配置哪些不需要copy
    }
    rename {
        //可以修改 name
    }
}

注意 copy 完后需要刷新一下。。。

//对文件树进行遍历
fileTree('build/') {
    FileTree fileTree ->
        fileTree.visit {
            FileTreeElement element ->
                println element.file.name
                // copy 内容
                copy {
                    from element.file
                    into getRootProject().getBuildDir().path + "/"
                }
        }
}

gradle 生命周期的 api

这个在上面已经说过了

其他 api

例如对 project 添加依赖，添加配置，引入外部文件等等

buildscript

其实最重要的就是 buildscript 方法了，如下：

//buildscript 中就是依赖配置的核心方法
buildscript {
    ScriptHandler scriptHandler ->
        //配置工程的仓库地址
        scriptHandler.repositories {
            RepositoryHandler repositories ->
                repositories.jcenter()
                repositories.mavenCentral()
                repositories.mavenLocal()
                repositories.ivy {}
                repositories.maven {}
        }
        //配置工程中插件的地址
        scriptHandler.dependencies {
        }

}


buildscript 方法接收一个闭包参数，查看源码可以知道这个闭包的参数是 ScriptHandle ，

而 ScriptHandle 有一个 repositories 方法，我看看一哈源码：

```java
	/**为脚本依赖项配置存储库。对{@link执行给定的闭包
	   这个处理程序的RepositoryHandler}。{@link RepositoryHandler}作为闭包的闭	   包传递给闭包委托。
	 */
  void repositories(Closure configureClosure);

在这个方法中为脚本依赖配置存储库。具体的实现在闭包中，我们也可以看到他的参数是一个闭包。由注释可以看到闭包的参数为 RepositoryHandler。下面看一哈这个类

public interface RepositoryHandler extends ArtifactRepositoryContainer {
    MavenArtifactRepository jcenter();
    MavenArtifactRepository mavenCentral(Map<String, ?> args);
    MavenArtifactRepository mavenCentral();
    MavenArtifactRepository mavenLocal();
    MavenArtifactRepository google();
    MavenArtifactRepository maven(Closure closure);
}

这里我列举了几个非常常见的，是不是非常熟悉。我们为脚本依赖配置的存储库都是在这里进行引入的，一般使用比较多的就是 jcenter，google，maven 等。注意 maven 还可以传入闭包，意味着他可以进行深入的配置，其实它内部可以配置，地址，name，账号密码等。

最上面 buildscript 中的代码写的是非常容易理解的，我们将参数都列举了出来，并且调用的时候都使用了参数进行调用，其实我们可以完全进行简写，当然，前提是你对 groovy 的闭包非常熟练。如下所示：

buildscript {
    ScriptHandler scriptHandler ->
        //配置工程的仓库地址
        repositories {
            RepositoryHandler repositories ->
                jcenter()
                mavenCentral()
                mavenLocal()
                ivy {}
                maven {}
        }
        //配置工程中插件的地址
        scriptHandler.dependencies {

        }
}

可以看到这里直接是调用方法，前面并没有使用参数.方法()，这是为啥呢？还记得 owner 吗，默认情况下他指的是当前类对象，单是如果闭包嵌套的话他指的就是闭包，然后 delegate 默认和 owner 是一样的。这里如果没有使用参数调用的话默认使用的就是 delegate 了。

其实闭包只有一个参数，也可以不用写的。如下

buildscript {
        //配置工程的仓库地址
        repositories {
                jcenter()
                mavenCentral()
                mavenLocal()
//                ivy {}
//                maven {}
        }
        //配置工程中插件的地址
//        scriptHandler.dependencies {
//
//        }
}

是不是非常熟悉，这就是 as 自动为我们创建的东西，而刚才我们只是了解了一下他的过程而已，至于这里我注释了几行代码，是因为 ivy 和 mave 参数都是闭包，要运行的话必须传入闭包，所以我给注释掉了。下面的 dependencies 其实也一样。下面来看一下 dependencies

scriptHandler 中还有一个 dependencies 方法。

/ ** 
  *配置脚本的依赖项。针对此处理程序，针对{@link DependencyHandler}执行给定的关闭。    {@link DependencyHandler}作为闭包的委托传递到闭包。 
  * 
  * @param configureClosure闭包用于配置依赖项。 
  * /
 void dependencies(Closure configureClosure);

可以看到这是用来配置脚本依赖的(注意是脚本依赖，也就是 gradle 用到的插件依赖)，传入一个闭包，闭包的参数为 DependencyHandler。

所以这里定义的插件是给 gradle 使用的。并非是应用程序。

   dependencies {
        classpath 'com.android.tools.build:gradle:3.5.2'
        classpath 'com.jakewharton:butterknife-gradle-plugin:10.1.0'
        // 美团多渠道打包插件
        classpath 'com.meituan.android.walle:plugin:1.1.6'
        //bugly
        classpath "com.tencent.bugly:tinker-support:1.2.1"
    }

如上面这些，都是给 gradle 使用的，关于 classpatch 我在 DependencyHandler 中并没有发现这个方法，但按住 ctrl 点击这个方法又看到他是 DependencyHandler 中的方法，点击去后跳的位置是错误的，不晓得是为啥。。。。

dependencies

应用程序使用的 dependencies ，我们看一下 dependencies 下都能配置什么内容，点击去看一下你就会发现他是 Project 类下的方法：

/ ***
    <p>配置此项目的依赖项。
    * 
    * <p>此方法针对此项目的{@link DependencyHandler}执行给定的关闭。 {@link 
    * DependencyHandler}作为闭包的委托传递到闭包。 
    * 
    * <h3>示例：</ h3> 
    *请参见{@link DependencyHandler}文档
    *
    * @param configureClosure闭包以用于配置依赖项。
    * /
    void dependencies(Closure configureClosure);

查看参数是一个闭包，这个闭包可以用于配置依赖项，参数为 DependencyHandler。

使用如下：

dependencies {
    implementation project(path: ':core')
    implementation project(path: ':detegateManager')
    implementation 'com.tencent.bugly:crashreport_upgrade:1.4.2'
    implementation 'com.tinkerpatch.sdk:tinkerpatch-android-sdk:1.2.14'
    implementation 'com.tencent.bugly:nativecrashreport:3.7.1'
}

在 RootProject 的 gradle 中 dependencies 是为gradle添加插件的，而子 project 则是给应用程序添加依赖。

如果项目中的依赖太多的话就会有可能导致依赖冲突。如一个第三方库依赖了别的第三方库，而指不定还有些库也依赖了别的第三方库。如果第三方库相同就会导致依赖冲突。有冲突后编译器就会报错。

api('com.joanzapata.iconify:android-iconify-fontawesome:2.2.2') {
        exclude group: 'com.android.support'
}

例如上面的 iconify 库，编译器报了依赖冲突，查看后发现是 suport 的冲突，可以使用 exclude 方法来解决排除掉 support 库即可。还有一种方式如下：

exclude module : 'com.android.support'

如果你不想使用第三方库中所依赖的库，可以使用以下关键字禁用

api('com.joanzapata.iconify:android-iconify-fontawesome:2.2.2') {
        exclude group: 'com.android.support'
        transitive false
}

将 transitive 设置为 false 后当前项目就不会调用到库中所依赖的库了。

赖了别的第三方库，而指不定还有些库也依赖了别的第三方库。如果第三方库相同就会导致依赖冲突。有冲突后编译器就会报错。

api('com.joanzapata.iconify:android-iconify-fontawesome:2.2.2') {
        exclude group: 'com.android.support'
}

例如上面的 iconify 库，编译器报了依赖冲突，查看后发现是 suport 的冲突，可以使用 exclude 方法来解决排除掉 support 库即可。还有一种方式如下：

exclude module : 'com.android.support'

如果你不想使用第三方库中所依赖的库，可以使用以下关键字禁用

api('com.joanzapata.iconify:android-iconify-fontawesome:2.2.2') {
        exclude group: 'com.android.support'
        transitive false
}

将 transitive 设置为 false 后当前项目就不会调用到库中所依赖的库了。

到这里 Gradle 的基础就说的差不多了。已经常用的 api 使用等，关于 task 将会在下一篇中讲解。而且他是非常重要的！！！

Tʀᴜsᴛ³⁴⁵

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
Gradle详解

Gradle 是什么？ gradle 是一个基于 Apache Ant 和 Apache Maven 概念的项目自动化构建工具，他使用一种基于 groovy 的特定领域语言来声明项目的设置，而不是使用传统的 XML 。gradle 就是工程的管理，帮我们做好了依赖，打包，部署，发布，各种渠道的差异管理等工作Gradle 的组成 gradle 完全使用的是 groovy 的语法。...
复制链接

扫一扫