Gradle

StoneLiu999

已于 2023-08-17 09:46:50 修改

阅读量598

点赞数

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

于 2023-08-16 21:43:31 首次发布

本文链接：https://blog.csdn.net/momo0853/article/details/132328341

版权

Android 专栏收录该内容

26 篇文章 5 订阅

订阅专栏

文章目录

Gradle
gradlew
- 生成gradlew和gradlew.bat
- gradle-wrapper.properties
gradle.properties
settings.gradle
Groovy
- 基础知识
- 例子

Gradle

Gradle 是一个常用的构建工具，可以用于构建和管理项目。它使用基于 Groovy 或 Kotlin 的领域特定语言 (DSL) 来定义构建脚本。

如果你想在项目中使用 Gradle，以下是一些基本步骤：

安装 Gradle：首先，你需要安装 Gradle。你可以从 Gradle 官方网站下载最新版本的 Gradle 发行版并按照官方文档进行安装。
创建 Gradle 项目：在你的项目目录下创建一个新的文件夹，并在该文件夹中创建一个名为 build.gradle 的文件，这是 Gradle 构建脚本的默认名称。
配置构建脚本：打开 build.gradle 文件，使用 Groovy 或 Kotlin DSL 格式来编写构建脚本。在构建脚本中，你可以定义项目的依赖项、任务、插件等。
运行 Gradle 命令：在命令行或终端中导航到你的项目目录，并执行 Gradle 命令来运行构建任务。例如，要构建项目，可以运行 gradle build 命令。

Gradle 还提供了许多其他功能，如多项目构建、增量构建、任务并行执行等。你可以通过学习 Gradle 文档以及参考示例项目来深入了解 Gradle 的更多功能和用法。

关键字

Gradle 是一个功能强大的构建工具，在其构建脚本中有许多关键字可以用来配置和控制构建过程。以下是 Gradle 中的一些常见关键字及其详细解释：

apply：用于应用插件或脚本。可以通过指定插件 ID 或文件路径来引入需要的插件或脚本。
plugins：用于声明在构建中使用的插件。插件提供了预定义的任务和功能，用于执行特定的构建操作或提供构建支持。
repositories：指定从哪里获取项目依赖项的仓库。可以配置多个仓库，如 Maven 中央仓库、JCenter 等。
dependencies：列出项目的依赖项。可以指定所需库的组织、名称和版本等信息，Gradle 将自动下载并包含这些依赖项。
task：定义一个自定义任务。任务是构建过程中执行的最小单元，可以自定义任务的行为和执行逻辑。
sourceSets：用于定义项目的源代码集。源代码集包括主要源代码（如 Java 文件）和其他资源文件（如配置文件、图像等），可以根据需要进行自定义。
buildscript：用于配置构建脚本自身的依赖项和仓库。该部分通常用于引入构建所需的 Gradle 插件。
configurations：定义项目的配置。配置是一组依赖项的逻辑分组，用于控制依赖项的引入和使用。
repositories：指定构建脚本自身的仓库。与上述 repositories 不同，这里指定的仓库用于获取构建脚本中的依赖项。
gradle：指代当前 Gradle 运行时的一些属性和方法。可以通过 gradle.xxx 来访问这些属性和方法，例如 gradle.projectDir 表示项目的根目录。
project：指代当前项目的对象。可以通过 project.xxx 来访问项目的属性和方法，例如 project.name 表示项目的名称。
dependencies：在 buildscript 中使用，用于指定构建脚本自身的依赖项。
allprojects：用于对所有子项目应用相同的配置。可以在根项目中使用，将配置应用于所有子项目，避免重复代码。
subprojects：类似于 allprojects，但仅对直接子项目应用配置。
taskGraph：表示当前任务图的对象。可以使用它来检查和操作任务之间的依赖关系。
buildTypes：用于定义不同的构建类型，如 debug、release 等。每个构建类型可以具有自己的配置和特定的构建行为。
flavorDimensions：用于定义产品风味的维度。产品风味是指根据不同需求和要求创建的变体，如免费版和付费版等。
flavors：用于定义产品风味。每个产品风味可以具有自己的构建配置和依赖项。
tasks：用于获取所有已定义的任务列表。可以使用 tasks.getByName("taskName") 来获取特定任务对象。
doFirst 和 doLast：用于在任务执行开始和结束时添加自定义行为。可以通过这些方法来扩展任务的功能和行为。
inputs 和 outputs：用于声明任务的输入和输出。这些信息用于判断任务是否需要重新执行，以提高构建过程的效率。
clean：预定义的任务，用于删除构建生成的文件和目录，清理构建结果。
jar：预定义的任务，用于创建 JAR 文件。
war：预定义的任务，用于创建 WAR 文件。
compile：预定义的任务，用于编译源代码。
test：预定义的任务，用于运行测试。
assemble：预定义的任务，用于将构建生成的文件打包，准备发布。
build：预定义的任务，用于执行完整的构建过程，包括编译、测试、打包等。
defaultTasks：用于指定默认执行的任务列表。当运行 Gradle 构建时，这些任务将自动被执行。
repositories.gradlePluginPortal()：用于从 Gradle 插件门户（Gradle Plugin Portal）获取插件。可以简化插件的引入和配置过程。
buildDir：表示项目构建输出目录。可以通过 buildDir.path 获取该目录的路径。
sourceCompatibility：用于指定源代码的兼容性版本。根据指定的版本号，Gradle 会对源代码进行编译和处理。
targetCompatibility：用于指定目标兼容性版本。与 sourceCompatibility 类似，Gradle 会根据指定的版本号进行目标文件的编译和处理。
options：用于指定编译器选项。可以定义不同编译选项，如优化级别、警告级别等。
repositories.mavenLocal()：用于从本地 Maven 仓库获取依赖项。适用于开发和测试阶段，可以避免每次都去远程仓库下载依赖项。
provided：一种特殊的配置，用于声明在编译时需要使用但在运行时由其他方式提供的依赖项。
exclude：用于排除特定的依赖项。可以排除特定的组织、模块或版本。
buildSrc：用于创建一个专门的构建源代码目录，其中包含构建脚本所需的自定义逻辑和任务。
copy：预定义的任务，用于复制文件和目录。
delete：预定义的任务，用于删除文件和目录。

例子(build.gradle)

当然，下面是一个示例的 build.gradle 文件，其中包含之前列举的所有关键字及其使用方法：

plugins {
    id 'java'
}

repositories {
    mavenCentral()
    jcenter()
}

dependencies {
    implementation 'com.example:library:1.0.0'
    testImplementation 'junit:junit:4.13.2'
}

buildscript {
    repositories {
        gradlePluginPortal()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:7.0.2'
    }
}

apply plugin: 'com.android.application'

android {
    compileSdkVersion 31
    buildToolsVersion "30.0.3"
    defaultConfig {
        applicationId "com.example.myapp"
        minSdkVersion 21
        targetSdkVersion 31
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

task customTask {
    doLast {
        println "This is a custom task"
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}

def flavorDimensions = ['version', 'environment']
def flavors = ['free', 'paid']

android {
    flavorDimensions(flavorDimensions)
    productFlavors {
        flavors.each { flavor ->
            create(flavor) {
                dimension 'version'
                applicationIdSuffix ".${flavor}"
            }
        }
    }
}

dependencies {
    flavors.each { flavor ->
        implementation "com.example:module-${flavor}:1.0.0"
    }
}

tasks.named('assembleDebug') {
    dependsOn customTask
}

tasks.register('myTask') {
    doLast {
        println 'This is a dynamically created task'
    }
}

assemble.dependsOn(myTask)

这个示例 build.gradle 文件包含了之前提到的所有关键字的用法示例，你可以根据需要进行修改和扩展。

请注意，这只是一个示例文件，具体的配置和依赖项应根据你的项目需求进行适当调整。

Plugin

Gradle 拥有众多的插件，可以帮助你扩展和定制你的构建过程。这些插件可以用于各种任务，例如编译代码、运行测试、生成文档等。以下是一些常用的 Gradle 插件示例：

java 插件：用于构建和管理 Java 项目。
application 插件：用于创建可执行的应用程序。
war 插件：用于构建 Java Web 应用程序的 WAR 文件。
android 插件：用于构建和管理 Android 应用程序。
jacoco 插件：用于代码覆盖率测试。
maven-publish 插件：用于将构建的文件发布到 Maven 仓库。
com.github.johnrengelman.shadow 插件：用于创建可执行的 fat JAR 文件。
spring-boot 插件：用于构建和管理 Spring Boot 应用程序。
checkstyle 插件：用于进行代码风格检查。
findbugs 插件：用于进行代码静态分析。
docker 插件：用于构建和管理 Docker 镜像。
flyway 插件：用于数据库迁移和管理。

以上只是一小部分常用的 Gradle 插件示例，还有更多丰富的插件供你选择。你可以通过在项目的 build.gradle 文件中应用相应的插件来使用它们。

另外，可以通过在 Gradle 官方网站和插件仓库中搜索插件名称来查找更多可用的插件，并了解如何配置和使用它们。

当涉及到 Android 开发时，Gradle 提供了一些特定的插件，以便于构建、打包和管理 Android 应用程序。以下是一些常用的 Android 相关的 Gradle 插件：

com.android.application：该插件用于构建 Android 应用程序项目。它允许你定义应用程序的源代码、资源文件、依赖项等，并生成 APK 文件。
com.android.library：该插件用于构建 Android 库项目。与应用程序插件相比，它生成的是可供其他应用程序使用的 AAR（Android Archive）库。
com.android.test：该插件用于创建 Android 测试项目。它允许你编写和运行单元测试和集成测试。
com.android.dynamic-feature：该插件用于创建动态特性模块（Dynamic Feature Module）。动态特性模块是一个可在应用程序安装后按需下载的组件，用于实现动态功能扩展。
androidx.navigation.safeargs：该插件用于安全地传递导航操作之间的参数。它简化了在不同目标之间传递数据的过程。
kotlin-android：如果你使用 Kotlin 进行 Android 开发，可以应用此插件，它将提供对 Kotlin 语言和相关工具的支持。
com.google.gms.google-services：该插件用于集成 Google Play 服务。它会自动将相关的 Google Play 服务配置添加到你的项目中，例如 Firebase、Google 地图等。

这些插件可以通过在项目的 build.gradle 文件中应用相应的插件 ID 来使用。同时，它们还提供了许多自定义选项和配置属性，以便于更好地管理和构建 Android 应用程序。

版本

Gradle的不同大版本之间存在一些重要的差异。以下是一些常见的差异：

Gradle 2.x系列和3.x系列：
- 引入了增量编译，提高了构建性能。
- 引入了增量任务图，使得只有需要重新执行的任务才会被执行。
- 默认支持Java 8，并提供了对新的语言功能的更好支持。
- 引入了新的增量式Java编译器（JavaCompile）。
- 提供了更好的多模块构建支持，并引入了新的构建配置方式。
Gradle 4.x系列：
- 引入了Gradle Kotlin DSL，使得构建脚本可以使用Kotlin语言编写。
- 引入了任务规则API，以支持更灵活的任务创建和配置。
- 提供了嵌套的构建支持，允许在一个项目中引用另一个项目的构建。
- 引入了构建缓存，可以共享和重用构建输出，提高构建性能。
- 对Java和Android构建进行了改进和优化。
Gradle 5.x系列：
- 引入了Gradle增量编译器（Gradle Compile Avoidance），以减少重新编译的需求。
- 改进了构建初始化时间，并提供了更快的配置评估。
- 提供了对构建缓存的进一步改进，并引入了配置缓存。
- 引入了Gradle任务API的稳定版本，以更好地支持构建自定义插件。
Gradle 6.0：
- 引入了Gradle的增量编译器（Incremental Compiler），它可以更精确地跟踪哪些源文件需要重新编译，从而提高了构建性能。
- 改进了依赖关系管理，引入了新的约定依赖模型（Dependency Model V2），提供了更强大的依赖解析和处理能力。
- 默认支持Java 13，并对其他JDK版本进行了改进和优化。
- 提供了对Kotlin DSL的改进支持，并引入了新的API和功能。
Gradle 6.1：
- 引入了新的配置属性 API，使得在构建脚本中可以更方便地声明和使用配置属性。
- 改进了Kotlin DSL的错误和警告处理机制，提供了更好的诊断和提示。
- 提供了对Eclipse附加源的原生支持，可以直接将构建的附加源连接到Eclipse项目中。
Gradle 6.2：
- 引入了新的构建缓存模式（Build Cache Modes），允许使用者根据需求进行更灵活的缓存配置。
- 提供了对Kotlin 1.3.70的支持，并更新了相关插件和工具链。
Gradle 6.3：
- 改进了构建初始化时间，在大型项目中启动构建时可以提供更快的反应。
- 引入了新的Lifecycles API，允许开发者以声明式方式定义构建生命周期。
Gradle 7.0：
- 改进的配置属性 API，使得在构建脚本中可以更方便地声明和使用配置属性。
- 兼容性增强，提供了对先前版本的增强和迁移支持。
- 删除了一些过时、不推荐使用的功能和插件。
Gradle 7.1：
- 引入了新的Java Toolchains API，以更好地管理和使用JDK工具链。
- 改进了构建初始化时间，提供更快的反应。
- 对Kotlin和GROOVY的支持进行了更新和优化。
Gradle 7.2：
- 引入了对新的JVM标准API的支持，包括对Java 16和Java 17的支持。
- 更新了内部组件，提供了更好的性能和稳定性。
- 添加了对Android Gradle插件的增强支持。

以上只是一些主要的差异，每个大版本还有其他细微的变化和改进。对于具体的差异和更新内容，建议查阅Gradle官方文档或相关资源。

Android Gradle 插件和 Gradle Wrapper

对于com.android.tools.build:gradle插件的版本，你可以查阅Android官方文档或Gradle Plugin Portal网站来获取最新的稳定版本。下面是一些常见的资源，你可以查找并确定com.android.tools.build:gradle插件的版本：

Android官方文档：访问Android开发者网站 gradle-plugin#groovy上的文档，查找与你使用的Android Gradle插件版本相对应的Gradle插件版本。在Android官方文档中，你可以找到与特定Android Gradle插件版本兼容的com.android.tools.build:gradle插件的推荐版本。例如，如果你正在使用Android Gradle插件4.3.0，那么对应的Gradle插件版本可能是7.0.2。
Gradle Plugin Portal：访问Gradle Plugin Portal网站上的插件目录，搜索com.android.tools.build:gradle插件，并查看可用的版本和其对应的Gradle版本。你可以在Gradle Plugin Portal网站找到com.android.tools.build:gradle插件的发布历史和最新版本。

gradlew

gradlew 是 Gradle Wrapper 的可执行脚本文件，用于在没有预先安装 Gradle 的情况下运行 Gradle 构建。Gradle Wrapper 是一个包装器，它会自动下载并使用指定版本的 Gradle。

在项目目录下运行 gradlew 命令可以执行与项目关联的 Gradle 构建任务，而无需手动安装和配置 Gradle。Gradle Wrapper 将在首次运行时自动下载指定版本的 Gradle 发布版，并将其与项目一起使用。

以下是 gradlew 命令的常见用法：

执行默认任务：./gradlew
运行项目中配置的默认任务。
执行特定任务：./gradlew <task>
运行指定的 Gradle 任务，例如 ./gradlew build。
查看可执行任务列表：./gradlew tasks
列出所有可执行的 Gradle 任务。
清理构建输出：./gradlew clean
清理构建过程中生成的输出文件。
构建并运行应用：./gradlew run
构建并运行可执行应用程序。
安装依赖项：./gradlew install
安装项目的依赖项到本地 Maven 或 Ivy 仓库。

请注意，在 Windows 系统上，需要运行 gradlew.bat 而不是 gradlew。

使用 Gradle Wrapper 的好处是可以保证项目在不同环境下都使用相同版本的 Gradle，而无需手动安装和配置。这使得协作开发更加方便，并且可以避免由于不同环境中 Gradle 版本不一致而导致的构建问题。

生成gradlew和gradlew.bat

要生成gradlew和gradlew.bat文件，你需要使用Gradle Wrapper（Gradle包装器）。Gradle Wrapper是一个用于下载和运行特定版本Gradle的脚本，它可以使你的项目保证使用相同的Gradle版本，无论在何处构建。

以下是在项目中生成gradlew和gradlew.bat文件的步骤：

确保在项目根目录下存在build.gradle文件（这是Gradle项目的配置文件）。
打开终端或命令提示符，并导航到项目根目录。
运行以下命令来生成gradlew和gradlew.bat文件：
- 对于 macOS/Linux：
```
./gradlew wrapper
```
- 对于 Windows：
```
gradlew wrapper
```
Gradle将自动下载并安装Gradle Wrapper所需的文件。这将包括gradlew和gradlew.bat脚本以及gradle/wrapper/gradle-wrapper.jar文件。
完成后，你将在项目根目录下看到生成的gradlew和gradlew.bat文件。

现在，你可以使用./gradlew（macOS/Linux）或gradlew.bat（Windows）命令来执行Gradle任务，无需事先安装Gradle。Gradle Wrapper会自动下载并使用与项目配置的Gradle版本一致的Gradle发行版。

请注意，如果项目已经使用Gradle Wrapper并且已经存在gradlew和gradlew.bat文件，运行上述命令将会更新Gradle Wrapper及其相关的文件到最新版本。

gradle-wrapper.properties

项目结构：

MyApp
 ├── build.gradle
    ├── app
    │   ├── CMakeLists.txt
    │   ├── build.gradle
    │   ├── proguard-rules.pro
    │   └── src
    │       └── main
    │           ├── AndroidManifest.xml
    │           ├── AndroidManifest.xml
    │           ├── cpp
    │           │   └── grpc-helloworld.cc
    │           ├── java
    ├── gradle
    │   └── wrapper
    │       ├── gradle-wrapper.jar
    │       └── gradle-wrapper.properties
    ├── gradle.properties
    ├── gradlew
    ├── gradlew.bat
    └── settings.gradle

gradle-wrapper.properties 是 Gradle Wrapper 的配置文件，位于 Gradle Wrapper 目录下。Gradle Wrapper 是一个用于管理 Gradle 版本的工具，它使用该配置文件来指定要下载和使用的特定 Gradle 版本。

以下是一个示例 gradle-wrapper.properties 文件的内容：

distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-7.0.2-bin.zip

这个配置文件包含了以下属性：

distributionBase 和 distributionPath 定义了 Gradle 分发包（distribution）存储的基本路径。默认情况下，它们分别设置为 GRADLE_USER_HOME 和 wrapper/dists，这意味着 Gradle 分发包将存储在用户的 Gradle 缓存目录中。
zipStoreBase 和 zipStorePath 定义了分发包的 ZIP 存储路径。默认情况下，它们也设置为 GRADLE_USER_HOME 和 wrapper/dists。
distributionUrl 定义了要使用的具体 Gradle 分发包的 URL。在上面的示例中，使用的是 Gradle 7.0.2 版本的二进制分发包。Gradle Wrapper 将根据此 URL 下载相应的版本并在项目中使用。

通过编辑 gradle-wrapper.properties 文件，你可以更改 Gradle 版本、自定义分

gradle.properties

gradle.properties 是一个 Gradle 的属性文件，用于配置 Gradle 构建工具的一些属性和参数。它位于项目根目录下，可以用于定义全局的 Gradle 配置。

以下是一些常见的 gradle.properties 文件配置示例：

设置构建工具版本：
```
gradleVersion=7.0.2
```
配置项目的编译级别：
```
compileSdkVersion=31
```
配置项目的构建工具版本：
```
buildToolsVersion=30.0.3
```

配置项目的源码和目标兼容性：

sourceCompatibility=1.8
targetCompatibility=1.8

配置项目的仓库地址：

repositoryUrl=https://maven.example.com/

配置自定义属性：
```
customProperty=value
```

通过在 gradle.properties 文件中定义这些属性，可以对 Gradle 构建过程进行更加灵活和定制化的配置。

需要注意的是，gradle.properties 是一个纯文本属性文件，每一行都是一个属性定义，使用 key=value 格式。你可以根据项目的需求添加或修改这些属性。

希望这些信息对你有帮助！如有任何进一步的问题，请随时提问。

settings.gradle

settings.gradle 是 Gradle 的设置文件，它位于项目的根目录下。这个文件用于配置多项目构建和 Gradle 设置的一些属性。

以下是一个示例 settings.gradle 文件的结构和常见配置：

rootProject.name = 'MyProject'

include 'app', 'library'

rootProject.name 定义了根项目的名称。在这个示例中，根项目的名称被设置为 'MyProject'。
include 关键字用于定义需要构建的子项目。在这个示例中，子项目 'app' 和 'library' 将会被构建。

使用 settings.gradle 文件可以实现如下功能：

多项目构建：通过 include 关键字，你可以定义多个子项目，每个子项目都有其相应的构建脚本。这使得你可以在一个 Gradle 构建中同时构建多个相关的项目。
自定义项目名称：通过设置 rootProject.name，你可以指定根项目的名称，该名称将在构建过程中使用。

需要注意的是，settings.gradle 文件通常是可选的，特别是对于单个项目的简单构建来说。在某些情况下，你可能不需要使用 settings.gradle 文件。

Groovy

Groovy是一种基于Java语法并运行在Java虚拟机（JVM）上的动态编程语言。它结合了静态类型语言和动态类型语言的特性，为Java开发提供了更简洁、易读和灵活的语法。下面是一些Groovy的特点：

简化Java代码：Groovy可以与Java代码无缝集成，并提供了一些简化Java语法的功能，如简化变量声明、集合和数组操作、字符串处理等。这使得代码更加紧凑且易于阅读。
动态类型：Groovy支持动态类型，即在运行时可以改变变量的类型。这使得代码编写更加灵活，可以减少繁琐的类型转换。
闭包支持：Groovy内置了闭包的支持，使得函数式编程更加便捷。闭包可以作为参数传递给方法，也可以保存为变量，并具有强大的灵活性和表达能力。
脚本编写：Groovy可以作为脚本语言使用，可以直接执行Groovy脚本文件。这使得Groovy非常适合用于快速原型开发、自动化任务和脚本编写。
领域特定语言（DSL）支持：Groovy的语法简洁而灵活，非常适合创建领域特定语言。它允许开发者根据特定领域的需求定义自己的语法，以提高代码的可读性和可维护性。
测试支持：Groovy集成了多个测试框架，如Spock和JUnit，可以帮助开发者编写简洁、可读性强的单元测试和集成测试。

总的来说，Groovy是一门功能丰富的编程语言，可以与Java无缝集成，并提供了许多便利的特性和工具，使得开发更加高效和愉快。无论是作为一种脚本语言、开发工具还是测试框架，Groovy都可以提供强大而灵活的解决方案。

基础知识

如果你希望快速学习Groovy语法，以下是你应该掌握的主要知识点：

语法基础：
- 变量和数据类型：了解如何声明变量、Groovy中支持的基本数据类型以及类型转换的方法。
- 运算符：熟悉Groovy中支持的各种运算符，包括算术运算符、比较运算符、逻辑运算符等。
- 控制流语句：理解条件语句（if-else语句）、循环语句（for循环、while循环）等。
字符串操作：
- 字符串插值：掌握在字符串中插入变量或表达式的方法，可以使用${}包裹变量或表达式。
- 字符串方法：了解Groovy提供的字符串方法，如toUpperCase()、toLowerCase()、replace()等。
列表和映射：
- 列表（List）：学习如何创建列表、添加、删除和遍历列表中的元素以及常用的列表操作。
- 映射（Map）：了解如何创建映射、访问和修改映射中的键值对，以及常用的映射操作。
闭包：
- 学习什么是闭包以及如何声明和使用闭包。
- 了解闭包的特性，如捕获外部变量、参数传递等。
类和对象：
- 掌握如何定义类和创建对象。
- 理解构造函数、属性和方法的概念，以及如何使用它们。
异常处理：
- 学习如何捕获和处理异常。
- 了解常见的异常类型和处理异常的最佳实践。
文件操作：
- 了解如何读取和写入文件。
- 掌握基本的文件操作，如创建文件、检查文件是否存在、删除文件等。
脚本编写：
- 学习如何将Groovy代码作为脚本执行。
- 掌握命令行参数的读取和处理。

这些是你在快速学习Groovy语法时应该关注的主要知识点。通过学习和练习这些内容，你将能够熟悉Groovy的语法和常用功能，从而能够开始编写简单的Groovy程序。当然，深入学习Groovy还有更多的主题和概念，但以上列举的内容足以帮助你上手使用Groovy语言。

例子

// 定义变量和数据类型
def myVariable = 42
String myString = "Hello"

// 运算符
def result = myVariable + 10

// 控制流语句
if (result > 50) {
    println("Result is greater than 50")
} else {
    println("Result is less than or equal to 50")
}

// 字符串插值和方法
def name = "Alice"
println("Hello, ${name.toUpperCase()}!")

// 列表
List<String> myList = ["apple", "banana", "orange"]
println(myList[1])  // 输出：banana

// 映射
Map<String, Integer> myMap = [key1: 10, key2: 20, key3: 30]
println(myMap.key2)  // 输出：20

// 闭包
def myClosure = { x, y -> x + y }
def closureResult = myClosure(3, 4)
println(closureResult)  // 输出：7

// 类和对象
class Person {
    String name
    int age

    void sayHello() {
        println("Hello, I'm ${name} and I'm ${age} years old.")
    }
}

Person person = new Person()
person.name = "Bob"
person.age = 25
person.sayHello()

// 异常处理
try {
    def num = 10 / 0
} catch (ArithmeticException e) {
    println("Error: ${e.message}")
}

// 文件操作
File file = new File("myFile.txt")
file.write("Hello, world!")

// 脚本参数
if (project.hasProperty("message")) {
    def message = project.property("message")
    println(message)
}

请注意，这只是一个示例脚本，用于演示如何在Gradle中使用Groovy语言涵盖我提到的知识点。你可以根据具体需求进行修改和扩展。希望这个例子能够帮助你更好地理解和应用Groovy语法在Gradle构建中。

StoneLiu999

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Gradle

Gradle Wrapper 是一个用于管理 Gradle 版本的工具，它使用该配置文件来指定要下载和使用的特定 Gradle 版本。总的来说，Groovy是一门功能丰富的编程语言，可以与Java无缝集成，并提供了许多便利的特性和工具，使得开发更加高效和愉快。Gradle Wrapper是一个用于下载和运行特定版本Gradle的脚本，它可以使你的项目保证使用相同的Gradle版本，无论在何处构建。上的文档，查找与你使用的Android Gradle插件版本相对应的Gradle插件版本。
复制链接

扫一扫

专栏目录