vlambda博客
学习文章列表

Gradle 的 核心大部分是用 Java 编写的（请参阅下面的信息）。 Java 是一门很棒的语言，但它并不是最适合编写脚本的语言。想象一下用 Java 编写脚本，由于 Java 的冗长和仪式，我们可能会编写另一个项目来定义我们的主项目的构建。 XML 在上一代构建工具（Ant 和 Maven）中被大量使用，对于声明性部分来说还可以，但对于编写逻辑来说不是很好。

Groovy 是 Java 的动态化身。如前所述，大多数 Java 语法也是有效的 Groovy 语法。如果我们了解 Java，我们已经可以编写 Groovy 代码。如果今天有大量可以编写 Java 的人，这是一个很大的优势。

Groovy 的语法简洁、富有表现力且功能强大。 Groovy 是动态风格的完美结合，同时仍然能够使用类型。它是少数支持可选类型的语言之一，也就是说，如果我们愿意，可以灵活地提供类型信息，而当我们不想提供类型信息时，可以将类型信息放在一边。由于一流的 lambda 支持和元编程功能，Groovy 是一种用于构建内部 DSL 的优秀语言。所有上述因素使其成为编写构建脚本的最合适的候选者之一。

虽然 我们可以在 Groovy 中编写 Java 风格的代码，但如果我们花一些时间来学习语言的动态特性和 Groovy 提供的一些语法增强功能，我们将能够编写更好的 Gradle 构建脚本和插件。如果我们还不了解 Groovy，这将会很有趣。

让我们充分了解 Groovy，以便我们能够正确理解 Gradle 脚本。我们将快速浏览一下 Groovy 的一些语言特性。

强烈建议尝试执行以下小节中的代码。此外，我们自己编写和尝试更多代码来探索 Groovy 将有助于我们加强对语言基础的理解。本指南并非详尽无遗，仅用于设置 Groovy 滚动。

def a = 10

Integer b = 10

int c = 10
println c.getClass()

class java.lang.Integer

String s = 'hello'

def name = "Gradle"
println "$name is an awesome build tool"

Gradle is an awesome build tool

def number = 4
println "number is even ? ${number % 2 == 0 }"

number is even ? true

def multilineString = '''\
    Hello
    World
'''
println multilineString

    Hello
    World

def r = /(\d)+/
println r.class

class java.lang.String

"(\\d)+"

def pattern = ~/(\d)+/
println pattern.class

class java.util.regex.Pattern

if ("groovy" ==~ /gr(.*)/)
  println "regex support rocks"

regex support rocks

def cl1 = {
    println "hello world!"
}

cl1.call()

hello world!

def cl2 = { n ->
    println "value of param : $n"
}
cl2.call(101)

value of param : 101

3.times(cl2)

value of param : 0
value of param : 1
value of param : 2

3.times { println it * it }

0
1
4

def aList = []
println aList.getClass()

class java.util.ArrayList

def anotherList = ['a','b','c']

def list = [10, 20, 30] + [40, 50]

list  <<  60 

list = list – [20, 30, 40] 
list  -= [20,30,40]

list.each {println it}

10
50
60

def aSet = [1,2,3] as Set
println aSet.class

class java.util.LinkedHashSet

TreeSet anotherSet = [1,2,3]
println anotherSet.class

class java.util.TreeSet

aSet << 4
aSet << 3
println aSet

[1, 2, 3, 4]

def a = [:]

def tool = [version:'2.8', name:'Gradle', platform:'all']

println tool.name
println tool["version"]
println tool.get("platform")

tool.version = "2.9"
tool["releaseDate"] = "2015-11-17"
tool.put("platform", "ALL")

int sum(int a, int b) {
  return a + b;
}

def sum(a, b) {
  a + b
}

sum(1,2)  
sum 1, 2  

def divide(number, by=2) {
    number/by
}

println divide (10, 5)
println divide (10)

2
5

def method(Map options) {
    def a = options.a ?: 10
    def b = options.b ?: 20
}

options.a ? options.a : 10

method([a:10,b:20])

method(a:10, b:20)

method b:30, a:40
method b:30

def sumSquares(...numbers) {
    numbers.collect{ it * it }.sum()
}
sumSquares 1, 2, 3

def myMethod (param, cls) {
    ...
}

myMethod(1,{ ... })
myMethod 2, {... }
myMethod(3) {...}

class Person {
  def name, age
}

def person = new Person(name:"John Doe", age:35)

println person.age
person.age = 36
println person.age

35
36

  void setAge(age){
    if (age < 0) 
      throw new IllegalArgumentException("age must be a positive number")
    else
      this.age = age
  }

def speak(){
  println "${this.name} speaking"
}

static def now(){
  new Date().format("yyyy-MM-dd HH:mm:ss")
}

现在我们已经了解了基本的 Groovy，让我们在 Gradle 构建脚本的上下文中使用它。在前面的章节中，我们已经看到了应用插件的语法。它看起来如下：

apply plugin: 'java'

如果我们仔细看，apply 是一个方法调用。我们可以将参数包装在括号中：

apply(plugin: 'java')

接受映射的方法可以像命名参数一样传递键值。但是，为了更清楚地表示 Map，我们可以将参数包装在 [] 中：

apply([plugin: 'java'])

最后，apply 方法被隐式应用到 project 对象上（我们将在本章接下来的部分中看到这一点） .所以，我们也可以在 project 对象的引用上调用它：

project.apply([plugin: 'java'])

因此，从 前面的示例中，我们可以看到将插件应用于项目的语句仅仅是对 上的方法调用的语法糖code class="literal">project 对象。我们只是使用 Gradle API 编写 Groovy 代码。此外，一旦我们意识到这一点，我们对理解构建脚本语法的看法就会改变。

Gradle首先判断当前项目是否有子项目，或者它是否是构建中的唯一项目。对于多项目构建，Gradle 会确定哪些项目（或子模块，许多人更喜欢称之为）必须包含在构建中。我们将在下一章看到多项目构建。 Gradle 然后为根项目和项目的每个子项目创建一个 Project 实例。对于我们目前看到的单模块项目，在这个阶段没有太多需要配置的。

在这个 阶段，参与项目的构建脚本将根据在初始化阶段创建的相应项目对象进行评估。在多模块项目的情况下，评估以广度方式进行，也就是说，所有兄弟项目将在子项目之前进行评估和配置。但是，此行为是可配置的。

请注意，执行脚本并不意味着任务也被执行。为了快速验证这一点，我们可以在 build.gradle 文件中添加一个 println 语句，并创建一个打印一个信息：

task myTask << {
  println "My task is executed"
}
// The following statement will execute before any task 
println "build script is evaluated"

如果我们执行以下代码：

$ gradle -q myTask

我们将看到以下输出：

build script is evaluated
My task is executed

事实上，也可以选择任何内置任务，例如 help：

$ gradle -q help

在执行任何任务之前，我们仍然会看到我们的 构建脚本被评估 消息。这是为什么？

当一个脚本 被求值时，脚本中的所有语句都会按顺序执行。这就是执行根级别的 println 语句的原因。如果你注意到，一个任务动作实际上是一个闭包。因此，它仅在语句执行期间附加到任务。但是，闭包本身尚未执行。动作闭包中的语句仅在任务执行时执行，这仅在下一阶段发生。

仅在此阶段配置任务。无论要调用什么任务，都会配置所有任务。 Gradle 准备了一个 有向无环图 (DAG) 表示任务以确定任务依赖性和执行顺序。

在这个 阶段，Gradle 根据作为命令行参数传递的任务名称和当前目录等参数确定需要运行哪些任务。这是将执行任务操作的地方。因此，在这里，如果任务要运行，动作闭包将实际执行。

:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:compileTestJava UP-TO-DATE
:processTestResources UP-TO-DATE
:testClasses UP-TO-DATE
:test UP-TO-DATE

Gradle 提供了各种钩子，用于在生命周期事件的各个点执行代码。我们可以在构建脚本中实现回调接口或为 DSL 提供回调闭包。例如，我们可以使用 beforeEvaluate 和 afterEvaluate 方法监听项目评估之前和之后的事件="literal">项目。我们不打算单独查看它们，而是 Project 和 Gradle（接口名称不要与如果我们觉得需要实现生命周期回调，API 和 DSL 文档是检查可用回调的正确位置。

我们一直在使用 project API，甚至没有意识到我们正在调用 project 对象上的方法。根据一些管理规则，如果没有提供显式引用，则构建脚本中的所有顶级方法调用都会在项目对象上调用。

让我们重写 第 1 章 运行你的第一个 Gradle 任务< /em> 将项目引用用于方法调用：

project.apply plugin: 'java'

project.repositories {
    mavenCentral()
}

project.dependencies {
    testCompile 'junit:junit:4.11'
}

正如我们在本章前面所看到的，apply 是 项目 。所谓dependencies块其实就是project dependencies()的方法code> 接受闭包。 repositories 部分也是如此。我们可以在闭包块周围添加括号，使其看起来像一个普通的旧方法调用：

project.repositories({...})
project.dependencies({...})

这个对象还有很多有趣的方法，我们将在接下来的章节和章节中再次看到，无论是否明确引用 project 对象。

boolean hasProperty(String propertyName)

Object property(String propertyName)

void setProperty(String name, Object value)

description = "a sample project"
version = "1.0"

task printProperties << {
    println project.version
    println project.property("description")
}

$ gradle -q printProperties
1.0
a sample project

ext.abc = "123"
task printExtraProperties << {
    println project.abc
    println project.property("abc")
    println project.ext.abc
}

$ gradle -q printExtraProperties
123
123
123

Task 对象，，例如上面创建的对象，并没有多大作用。事实上，它没有附加任何动作。我们需要将操作附加到 Task 对象，以便 Gradle 在任务运行时执行这些操作。

Task 对象有一个名为 doLast 的方法，它接受一个闭包。 Gradle 确保传递给此方法的所有闭包都按照它们传递的顺序执行：

someTask.doLast({
    println "this should be printed when the task is run"
})

我们现在可以做的是再次调用 doLast ：

someTask.doLast({
    println "this should ALSO be printed when the task is run"
})

此外，在另一种语法中：

someTask {
    doLast {
        println "third line that should be printed"
    }
}

有多种方法可以将 doLast 逻辑添加到任务中，但最惯用的，也许是一种简洁的方法如下：

someTask << {
    println "the action of someTask"
}

就像 Project 对象，我们有 Task 可以访问其方法和属性的对象。但是，与 Project 对象不同，它在脚本的顶层并不隐式可用，而仅在任务的配置范围内可用。此外，直观地，我们可以说每个 build.gradle 会有多个 Task 对象。稍后我们将看到访问 Task 对象的各种方法。

项目中的任务 可能相互依赖。在本节中，我们将看到项目任务中可能存在的不同类型的关系。

$ gradle compile dist

task compile << {
    println 'compling the source'
}

task dist(dependsOn: compile) << {
    println "preparing a jar dist"
}

task distUsingTemp << {
  println ("preapring dist using a temp dir")
}

task cleanup << {
  println("removing tmp dir")
}

distUsingTemp.finalizedBy cleanup

cleanup.onlyIf { file("/tmp").exists()}

$ gradle build clean

build.mustRunAfter clean

Gradle 的一大优点是我们也可以动态创建任务。这意味着在编写构建时并不完全知道任务的名称和逻辑，但是根据一些可变参数，任务将自动添加到我们的 Gradle 项目中。

让我们试着用一个例子来理解：

10.times { number ->
  task "dynamicTask$number" << {
    println "this is dynamic task number # $number "
  }
}

在前面的人为示例中，我们正在创建并动态添加十个任务到我们的构建中。尽管它们都只是打印任务编号，但动态创建和添加任务到我们的项目的能力非常强大。

到目前为止，我们 一直在使用任务名称调用gradle 命令行界面。这在本质上是一种重复，尤其是在开发过程中，像 Gradle 这样的工具可以让我们覆盖：

defaultTasks "myTaskName", "myOtherTask"

设置默认任务是明智的，这样如果我们不指定任何任务名称，则默认执行设置的任务。

在前面的例子中，不带任何参数从命令行运行 gradle 会按照 defaultTasks。

到目前为止，我们看到的 任务本质上是临时性的。我们必须为任务执行时需要执行的任务操作编写代码。但是，无论我们在构建哪个项目，如果我们有能力对现有逻辑进行一些配置更改，那么任务操作的逻辑不需要更改。例如，当您复制文件时，只有源、目标和包含/排除模式发生变化，但如何将文件从一个位置复制到另一个位置以遵守包含/排除模式的实际逻辑保持不变。所以，如果一个项目中需要两个类似复制的任务，比如说 copyDocumentation 和 deployWar，我们真的想要写一个完整的逻辑来复制选定的文件两次？

这 适用于非常小的构建（例如我们章节中的示例），但该方法不能很好地扩展。如果我们继续编写任务操作来执行这些普通操作，那么我们的构建脚本将很快膨胀到无法管理的状态。

自定义任务类型是 Gradle 的解决方案，用于将可重用的构建逻辑抽象到自定义任务类中，从而在任务对象上公开输入/输出配置变量。这有助于我们调整类型化的任务以满足我们的特定需求。这有助于我们保持通用构建逻辑的可重用和可测试性。

临时任务操作的另一个问题是它本质上是必不可少的。为了工具的灵活性，Gradle 允许我们在构建脚本中强制编写自定义逻辑。但是，在我们的构建脚本中过度使用命令式代码会使构建脚本无法维护。 Gradle 应该尽可能以声明的方式使用。命令式逻辑应封装在自定义任务类中，同时公开任务配置供用户配置。在 Gradle 的术语中，自定义任务类被称为 增强的任务。

自定义任务类型充当模板，为通用构建逻辑提供一些合理的默认值。我们仍然需要在构建中声明一个任务，但我们只是告诉 Gradle 这个任务的类型并配置这个任务类型的设置，而不是重新编写整个任务动作块。 Gradle 已经附带了许多自定义任务类型；例如，复制、执行、删除、Jar, Sync, Test, JavaCompile , Zip 等等。我们也可以轻松编写自己的增强任务。我们将非常简要地了解这两种情况。

task copyDocumentation(type:Copy) {
from file("src/docs/html")
into file("$buildDir/docs")
}

class Print extends DefaultTask {
  @Input
  String message = "Welcome to Gradle"

  @TaskAction
  def print() {
    println "$message"
  }
}

task welcome(type: Print)

task thanks(type: Print) {
  message = "Thanks for trying custom tasks"
}

task bye(type: Print)
bye.message = "See you again"

thanks.dependsOn welcome
thanks.finalizedBy bye

$ gradle -q thanks
Welcome to Gradle
Thanks for trying custom tasks
See you again

有大量可用于 Groovy 的在线参考资料。我们可以从：

以下是关于 Groovy 的书籍列表：

Gradle 的官方 API 和 DSL 文档是探索和了解本章讨论的各种类的好地方。这些 API 和 DSL 非常丰富，值得我们花时间阅读。