Gradle 语法汇总

JTBlink
213 阅读3分钟

变量定义

在Gradle中，变量的定义和使用是构建脚本的基本组成部分。以下是Gradle中变量定义的基本语法和用法：

1. 定义变量

在Gradle中，可以使用def关键字来定义变量，或者直接使用变量名（在Groovy中，变量可以隐式定义）。以下是几种常见的变量定义方式：

// 使用 def 关键字定义变量
def myVariable = "Hello, Gradle!"

// 直接定义变量
myOtherVariable = 42

// 定义列表
def myList = ['item1', 'item2', 'item3']

// 定义映射（字典）
def myMap = [
    key1: 'value1',
    key2: 'value2'
]

2. 使用变量

定义变量后，可以在构建脚本的其他部分使用它们。使用变量时，只需引用变量名即可：

println myVariable // 输出: Hello, Gradle!
println myOtherVariable // 输出: 42

// 使用列表
myList.each { item ->
    println item // 输出: item1, item2, item3
}

// 使用映射
println myMap.key1 // 输出: value1

3. 变量作用域

  • 局部变量: 在任务或闭包内部定义的变量是局部的，只能在该闭包或任务中访问。
  • 全局变量: 在构建脚本的顶层定义的变量是全局的，可以在整个脚本中访问。

4. 变量类型

Gradle使用Groovy作为其构建脚本语言，因此变量的类型是动态的。可以根据需要赋予不同类型的值，例如字符串、数字、列表、映射等。

5. 访问项目属性

Gradle还允许访问项目属性，这些属性可以在构建脚本中作为变量使用：

// 访问项目名称
def projectName = project.name

// 访问版本信息
def version = project.version

6. 使用系统属性

可以通过System.getProperty或project.findProperty访问系统属性或Gradle属性：

// 访问系统属性
def mySystemProperty = System.getProperty('user.dir')

// 访问Gradle属性
def myGradleProperty = project.findProperty('myProperty') ?: 'defaultValue'

示例

以下是一个简单的Gradle构建脚本示例，展示了变量的定义和使用：

// 定义变量
def appVersion = "1.0.0"
def supportedLanguages = ['en', 'fr', 'es']

// 打印变量
println "App Version: $appVersion"
println "Supported Languages: $supportedLanguages"

// 使用映射
def config = [
    minSdk: 21,
    targetSdk: 34
]

println "Min SDK: ${config.minSdk}"

总结

Gradle中的变量定义和使用非常灵活，允许开发者根据需要创建和管理不同类型的变量。这使得构建脚本更加动态和可配置。

控制语句

在Gradle构建脚本中，控制语句用于控制代码的执行流程。由于Gradle使用Groovy作为其脚本语言，因此可以使用Groovy的控制语句。以下是一些常见的Gradle控制语句及其用法：

1. 条件语句

if-else 语句
if (condition) {
    // 当条件为真时执行的代码
} else {
    // 当条件为假时执行的代码
}

示例:

def isDebug = project.hasProperty('debug') && project.debug.toBoolean()

if (isDebug) {
    println 'Debug mode is enabled.'
} else {
    println 'Debug mode is disabled.'
}

2. 循环语句

for 循环
for (item in collection) {
    // 对每个 item 执行的代码
}

示例:

def languages = ['Java', 'Kotlin', 'Groovy']

for (language in languages) {
    println "I love $language!"
}
while 循环
while (condition) {
    // 当条件为真时执行的代码
}

示例:

def count = 0
while (count < 5) {
    println "Count is $count"
    count++
}

3. switch 语句

switch (variable) {
    case value1:
        // 当 variable 等于 value1 时执行的代码
        break
    case value2:
        // 当 variable 等于 value2 时执行的代码
        break
    default:
        // 当 variable 不匹配任何 case 时执行的代码
}

示例:

def version = '1.0'

switch (version) {
    case '1.0':
        println 'Version 1.0 is selected.'
        break
    case '2.0':
        println 'Version 2.0 is selected.'
        break
    default:
        println 'Unknown version.'
}

4. try-catch 语句

用于处理异常。

try {
    // 可能抛出异常的代码
} catch (ExceptionType e) {
    // 处理异常的代码
}

示例:

try {
    def result = 10 / 0 // 这将抛出异常
} catch (ArithmeticException e) {
    println 'Caught an arithmetic exception: ' + e.message
}

5. 方法定义

在Gradle中，可以定义方法来封装重复的逻辑。

def myMethod(param) {
    // 方法体
    return result
}

示例:

def greet(name) {
    return "Hello, $name!"
}

println greet('Gradle')

6. 闭包

闭包是Groovy中的一种重要概念，可以用于定义可重用的代码块。

def myClosure = { param ->
    println "Hello, $param!"
}

myClosure('Gradle') // 调用闭包

总结

Gradle构建脚本中使用的控制语句与Groovy语言的控制语句相似，允许开发者实现条件逻辑、循环、异常处理和方法定义。这些控制语句使得构建脚本更加灵活和可维护。通过合理使用这些控制语句，可以有效地管理构建过程中的各种逻辑。

afterEvaluate

在Gradle中，afterEvaluate是一个用于在项目评估完成后执行特定代码块的闭包。它通常用于需要在所有项目配置完成后进行的操作，比如修改任务、添加依赖关系或执行其他配置。

基本用法

afterEvaluate的基本语法如下：

afterEvaluate {
    // 这里放置需要在评估后执行的代码
}

何时使用

  • 修改任务: 如果你需要在所有任务都被定义后修改某些任务的行为，可以使用afterEvaluate。
  • 添加依赖: 在某些情况下，依赖关系可能依赖于其他项目的配置，使用afterEvaluate可以确保在所有项目都被评估后添加依赖。
  • 条件逻辑: 如果某些配置需要基于项目的最终状态进行调整，可以在afterEvaluate中实现。

示例

以下是一些使用afterEvaluate的示例：

示例 1: 修改任务
tasks.register('myTask') {
    doLast {
        println 'This is myTask.'
    }
}

afterEvaluate {
    tasks.myTask.doFirst {
        println 'This will run before myTask.'
    }
}

在这个示例中，myTask任务在执行之前会打印一条消息。

示例 2: 添加依赖
dependencies {
    implementation 'com.example:library:1.0'
}

afterEvaluate {
    if (project.hasProperty('useNewLibrary') && project.useNewLibrary.toBoolean()) {
        dependencies {
            implementation 'com.example:new-library:1.0'
        }
    }
}

在这个示例中，只有在项目属性useNewLibrary存在且为true时，才会添加新的依赖。

示例 3: 条件逻辑
afterEvaluate {
    if (project.version == '1.0.0') {
        tasks.register('release') {
            doLast {
                println 'Releasing version 1.0.0'
            }
        }
    }
}

在这个示例中，只有当项目版本为1.0.0时，才会注册release任务。

注意事项

  • afterEvaluate中的代码在项目的所有配置完成后执行，因此可以安全地访问和修改所有任务和属性。
  • 如果在afterEvaluate中定义的任务依赖于其他任务，确保这些任务在afterEvaluate中被正确配置。

总结

afterEvaluate是Gradle中一个强大的工具，允许开发者在项目评估完成后执行特定的操作。它可以用于修改任务、添加依赖和实现条件逻辑，使得构建脚本更加灵活和动态。

Copy

在Gradle中，Copy是一个内置的任务类型，用于复制文件和目录。它提供了灵活的方式来定义源文件和目标位置，以及在复制过程中可以应用的各种操作。以下是Copy用法的详细说明：

基本用法

tasks.register('copyTaskName', Copy) {
    from 'source/directory/or/file' // 源文件或目录
    into 'destination/directory'     // 目标目录
}

主要属性和方法

  1. from:

    • 指定要复制的源文件或目录。可以是单个文件、多个文件或目录。
    • 可以使用通配符（如**/*.txt）来匹配特定类型的文件。

  2. into:

    • 指定复制的目标目录。如果目标目录不存在，Gradle会自动创建它。

  3. include/exclude:

    • include和exclude方法可以用来指定要包含或排除的文件。例如： 
      include '**/*.txt' // 只复制所有文本文件
exclude '**/*.log' // 排除所有日志文件

  4. rename:

    • 用于重命名复制的文件。可以传入一个闭包，返回新的文件名。例如： 
      rename { fileName -> "newPrefix_$fileName" }

  5. filter:

    • 可以对文件内容进行过滤处理。例如，可以使用filter方法来替换文件中的某些文本： 
      filter { line -> line.replace('oldText', 'newText') }

  6. doFirst/doLast:

    • 可以在任务执行前或后添加自定义操作。例如： 
      doFirst {
    println 'Starting copy task...'
}
doLast {
    println 'Copy task completed.'
}

示例

以下是一个完整的示例，展示了如何使用Copy任务：

tasks.register('copyResources', Copy) {
    from 'src/main/resources' // 源目录
    into 'build/resources'    // 目标目录
    include '**/*.properties'  // 只复制属性文件
    exclude '**/*.tmp'        // 排除临时文件
    rename { fileName -> "config_$fileName" } // 重命名文件
    doLast {
        println 'Resources copied successfully.'
    }
}

总结

Copy任务在Gradle构建中非常有用，尤其是在需要处理文件和资源的情况下。通过灵活的配置选项，开发者可以轻松地管理文件的复制和重命名，确保构建过程的顺利进行。

avatar
文章
阅读
粉丝