自己动手应用Groovy实现Gradle的DSL—Task定义

Groovy是基于JVM的敏捷开发语言之一。由于它的语法特性,常常用来构建领域性的DSL。我们今天的另外一个主角就是通过Groovy所构建出来的一门DSL语言Gradle。如果是用过Apache的ant还有Maven等项目自动化构建工具,相信你听过甚至已经逐渐往Gradle方向转换。由于Gradle使用了Groovy的基本语法,使得结构更加清晰,紧凑,更加方便理解。本篇文章会涉及到一些Groovy的语法（作者假定各位都是了解Groovy语法和使用过Gradle的开发者）。

我们先来看一下简单的Gradle脚本。我们知道按照Gradle的既有约定,Gradle的脚本一般写在build.gradle的配置文件中，其中以task为基本单位。

```
task helloworld {
        println "helloworld!!"
}//结构1
 
task sayHello<< {
        println "sayHello!!"
}//结构2
```

这里,如果我们把 task 理解为方法的话,我们可以假设 task 方法所传入的参数就是一个 Task 对象。我们先抽象出来一个简单的 Task 对象(POGO 对象)。通过第一个结构:

```
task helloworld {
        println "helloworld!!"
}
```

我们看出Task有一个执行闭包,还有一个基本属性name。而这种结构中“helloworld”可以理解为一个Groovy方法名,而闭包作为这个方法的参数。但由于"helloworld"这个名字是由用户自己定义的,因此需要用到Groovy的MOP知识,调用动态方法。这里我们用invokeMethod方法来实现。综上我们所定义的内容我们先实验一个简单的代码:

```
def task(Task t) {
 
}
 
class Task {
        def name
        def closure
}
 
def invokeMethod(String name,args) {
 
        println "call method $name()"
}
 
task helloworld {
        println "helloworld!!"
}
```

我们通过命令行看到输出:" call method helloworld() "。接下去我们要为结构1细化Task的构建流程,也就是细化你的invoke方法。 我们使用invokeMethod来动态调用方法的缺点在于方法并不是真正的动态注入(如果需要真正的调用可以使用metaClass机制),而是通过AOP拦截的方式来拦截调用。当你定义了一个“helloworld”的Task了以后,后面可能还需要用到。那么那个时候你的程序还是会调用invokeMethod方法来构造。为了避免重复构造或者查询异常,我们需要有一个机制来缓存我们已经构造好的Task。这里,我定义一个TaskPool数据结构来享元我们的task。

```
class TaskPool {
        def map = [:]
        def push(String name,Task t) {
                map.put(name,t)
        }
 
        def get(String name) {
                map.get(name)
        }
}
 
taskPool = new TaskPool()
```

invokeMethod 方法可以改为:

```
def invokeMethod(String name,args) {
        println "call method $name()"
        t = taskPool.get(name)
        if (t == null) {
                if (args[0] instanceof Closure) {
                        t = new Task(name:name,closure:args[0])
                }
        }
        t
}
```

可以看到,这里实际上我给了一个类型为Task的返回值t。给出这个类型的目的是为了提供给task方法使用。而直到这里,我们可以把 “Task push Pool”这个操作放在Task create后的任意位置,但是我把“Task push Pool”的操作放到task方法中,因为我们在使用结构2 `"<<"`的时候需要通过另外一个动态调用入口。我们还需要给Task类增加一个execute方法来运行我们task的闭包参数:

```
class Task {
        def name
        def closure
        def execute() {
                println "task $name start >>"
                closure()
                println "task $name end <<"
        }
}
```

```
def task(Task t) {
        taskPool.push(t.name,t)
        t.execute()
}
```

好了,我们赶紧敲一下 groovy 命令来实验一下我们的结构 1 吧:

```java
call method helloworld()
task helloworld start >>
helloworld!!
task helloworld end <<
```

你是否得到了跟我一样的结果呢?这样我们通过 groovy 来实现了结构 1 样式的 task。那么我们该如何实现结构 2 范式呢？
我们来回顾一下结构 2 范式:

```java
task sayHello<< {
        println "hello!! david!"
}
```

task 之后我们还是要传入一个 Task 的变量,而"<<"是对象内的操作,这样我们就不能再把 sayHello 作为方法,而应该作为一个参数变量来看,而这个参数变量的类型很显然是 Task 类型。因此我们先在我们的 Task 类中重载我们的"<<"符号:

```java
class Task {
        def name
        def closure
        def leftShift(c) {
                this.closure = c
                this
        }
        def execute() {
                println "task $name start >>"
                closure()
                println "task $name end <<"
        }
}
```

而作为参数变量的 sayHello 我们需要调用 Groovy 的另外一个动态接口 getProperty(String name)。类中所有获取属性的调用都会被这个方法所拦截,我们按照与 invokeMethod 相同的模式来实现它:

```java
def getProperty(String name) {
 
        def t = taskPool.get(name)
        if (t == null) {
                t = new Task(name:name)
        }
        t
}
```

但这样是有问题的,为什么呢?因为你的 taskPool 也是作为你的属性,这种情况下你很有可能造成递归堆栈溢出,那么该怎么解决呢？

由于你的 taskPool 变量属于你原有属性,因此需要调用你原有的调用过程。所以需要将代码改为:

```
def getProperty(String name) {
        def t
        try {
                t  = super.getProperty(name)
        } catch(e) {
 
                t = taskPool.get(name)
                if (t == null) {
                        t = new Task(name:name)
                }   
        }   
        t   
}
```

下面我们用我们的两种结构来实验一下我们定义的 DSL 吧:

```java
task helloworld {
        println "helloworld!!"
}
task sayHello<< {
        println "hello!! david!"
}
```

最后输出的结果为:

```java
task helloworld start >>
helloworld!!
task helloworld end <<
 
task sayHello start >>
hello!! david!
task sayHello end <<
```