gradle基础概念及demo

泰山与水

已于 2022-04-01 16:45:02 修改

阅读量3.5k

点赞数 1

分类专栏：其它文章标签：架构

于 2022-04-01 15:32:28 首次发布

本文链接：https://blog.csdn.net/cqupt2012214390/article/details/123899160

版权

其它专栏收录该内容

6 篇文章 0 订阅

订阅专栏

projects

a project might represent a library JAR
a project might represent web application
It might represent a distribution ZIP assembled from the JARs produced by other projects
A project does not necessarily represent a thing to be built
It might represent a thing to be done, such as deploying your application to staging or production environments
Gradle’s build-by-convention support adds a more concrete definition for what a project is不要担心，项目的定义你可以自己定义

task

Gradle在一个项目上可以做的工作由一个或多个任务定义
任务代表构建执行的一些原子工作，比如：
1. 编译一些类
2. 创建Jar文件
3. 生成Javadoc文档
4. 发布一个构建（组件）到仓库
5. 通常，任务是通过应用插件提供的，这样您就不必自己定义它们，也可以自定义
定义一个task的语法

//tasks.register()：注册任务的函数
//hello：表示任务名
//doLast：表示任务在最后结束的时候执行


tasks.register('hello') {
    doLast {
        println 'Hello world!'
    }
}

Build scripts are code：构建脚本就是代码

tasks.register('upper') {
    doLast {
        String someString = 'mY_nAmE'
        println "Original: $someString"
        println "Upper case: ${someString.toUpperCase()}"
    }
}

Output of gradle -q upper

> gradle -q upper
Original: mY_nAmE
Upper case: MY_NAME

tasks.register('count') {
    doLast {
        4.times { print "$it " }
    }
}

Output of gradle -q count

> gradle -q count
0 1 2 3

Task dependencies：任务依赖，一个任务可以依赖另外一个任务

tasks.register('hello') {
    doLast {
        println 'Hello world!'
    }
}
tasks.register('intro') {
    dependsOn tasks.hello
    doLast {
        println "I'm Gradle"
    }
}

Output of gradle -q intro

> gradle -q intro
Hello world!
I'm Gradle

添加依赖项的时候，相应的任务不需要存在，也就是可以懒加载

tasks.register('taskX') {
    dependsOn 'taskY'
    doLast {
        println 'taskX'
    }
}
tasks.register('taskY') {
    doLast {
        println 'taskY'
    }
}

Output of gradle -q taskX

> gradle -q taskX
taskY
taskX

给一个task添加依赖可以参考这个：Authoring Tasks

Flexible task registration：灵活注册任务

可以使用它在循环中注册同一类型的多个任务

4.times { counter ->
    tasks.register("task$counter") {
        doLast {
            println "I'm task number $counter"
        }
    }
}

Output of gradle -q task1

> gradle -q task1
I'm task number 1

Manipulating existing tasks：操纵任务

注册任务后，可以通过API访问它们。例如，您可以使用它在运行时向任务动态添加依赖项

4.times { counter ->
    tasks.register("task$counter") {
        doLast {
            println "I'm task number $counter"
        }
    }
}

tasks.named('task0') { dependsOn('task2', 'task3') }


//tasks.named('task0')：表示调用名为task0的task,在执行task0的时候动态依赖了task2、task3

Output of gradle -q task0

> gradle -q task0
I'm task number 2
I'm task number 3
I'm task number 0

The calls doFirst and doLast can be executed multiple times. They add an action to the beginning or the end of the task’s actions list. When the task executes, the actions in the action list are executed in order.

可以向现有任务添加行为

意思是任务调用的时候，还可以给任务内部添加代码逻辑
doFirst和doLast调用可以执行多次。它们会将一个操作添加到任务操作列表的开头或结尾。任务执行时，按顺序执行操作列表中的操作

tasks.register('hello') {
    doLast {
        println 'Hello Earth'
    }
}
tasks.named('hello') {
    doFirst {
        println 'Hello Venus'
    }
}
tasks.named('hello') {
    doLast {
        println 'Hello Mars'
    }
}
tasks.named('hello') {
    doLast {
        println 'Hello Jupiter'
    }
}

Output of gradle -q hello

> gradle -q hello
Hello Venus
Hello Earth
Hello Mars
Hello Jupiter

Using Ant Tasks：使用ant任务

这可能是你使用ant任务最多的场景

task loadfile {
    doLast {
        def files = file('./antLoadfileResources').listFiles().sort()
        files.each { File file ->
            if (file.isFile()) {
                ant.loadfile(srcFile: file, property: file.name)
                println " *** $file.name ***"
                println "${ant.properties[file.name]}"
            }
        }
    }
}

Output of gradle -q loadfile

> gradle -q loadfile
 *** agile.manifesto.txt ***
Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration  over contract negotiation
Responding to change over following a plan
 *** gradle.manifesto.txt ***
Make the impossible possible, make the possible easy and make the easy elegant.
(inspired by Moshe Feldenkrais)

Using methods：使用方法

Gradle在如何组织构建逻辑方面进行了扩展。在上面的例子中，组织构建逻辑的第一个层次是提取一个方法

task checksum {
    doLast {
        fileList('./antLoadfileResources').each { File file ->
            ant.checksum(file: file, property: "cs_$file.name")
            println "$file.name Checksum: ${ant.properties["cs_$file.name"]}"
        }
    }
}

task loadfile {
    doLast {
        fileList('./antLoadfileResources').each { File file ->
            ant.loadfile(srcFile: file, property: file.name)
            println "I'm fond of $file.name"
        }
    }
}

File[] fileList(String dir) {
    file(dir).listFiles({file -> file.isFile() } as FileFilter).sort()
}

Output of gradle -q loadfile

> gradle -q loadfile
I'm fond of agile.manifesto.txt
I'm fond of gradle.manifesto.txt

这里定义一个task和上面的注册一个task语法不一致，不晓得为什么？

参考这个来完成所有构建：Organizing Gradle Projects

Default tasks：默认任务

Gradle允许您定义一个或多个在未指定其他任务的情况下执行的默认任务

defaultTasks 'clean', 'run'

task clean {
    doLast {
        println 'Default Cleaning!'
    }
}

task run {
    doLast {
        println 'Default Running!'
    }
}

task other {
    doLast {
        println "I'm not a default task!"
    }
}

Output of gradle -q

> gradle -q
Default Cleaning!
Default Running!

This is equivalent to running gradle clean run

`External dependencies for the build script：构建脚本的外部依赖项`

建议使用带有自己类路径的插件，而不是直接操作脚本类路径
对于自定义构建逻辑，建议使用自定义插件
如果构建脚本需要使用外部库，可以将它们添加到构建脚本本身的脚本类路径中
您可以使用buildscript（）方法来实现这一点，并传入一个声明构建脚本类路径的代码块
传递给buildscript（）方法的块配置是一个ScriptHandler实例
通过向类路径配置添加依赖项来声明构建脚本类路径。例如，这与声明Java编译类路径的方式相同。您可以使用除项目依赖项之外的任何依赖项类型。

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath group: 'commons-codec', name: 'commons-codec', version: '1.2'
    }
}

声明了构建脚本类路径后，可以像使用类路径上的任何其他类一样使用构建脚本中的类。下面的示例添加到前面的示例中，并使用构建脚本类路径中的类

import org.apache.commons.codec.binary.Base64

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath group: 'commons-codec', name: 'commons-codec', version: '1.2'
    }
}

task encode {
    doLast {
        def byte[] encodedString = new Base64().encode('hello world\n'.getBytes())
        println new String(encodedString)
    }
}

Output of gradle -q encode