java format 补足空格_初探Groovy——无缝兼容Java的脚本语言

前言

作为一名程序员，我的日常工作离不开bug的复现与测试。然而，修复一个bug往往需要十余次乃至数十次的重复操作。我需要一次又一次地运行报表、运行达析报告、修改I-Server的配置、将Cache载入内存。结果，大量的精力都在无止尽的重复操作中消耗殆尽。

那么，有没有什么办法能让计算机帮我进行这些操作呢？我自然而然地想到了各式各样的脚本语言。相较于我自己在WEB端上点击鼠标，利用脚本来直接调用WEB端的Java接口才是上策。Groovy语言就是在这种情况下进入我的视野的。

Groovy是一门基于JVM的脚本语言。它在兼容Java语法的同时，借鉴了Ruby、Python等语言的特性，有自己一套简洁而灵活的语法。同时，运行在JVM上也意味着它也可以使用Java语言编写的库。这两点结合，让Groovy极其适合编写Java代码的测试脚本。那么，就让我来为大家介绍一下这门神奇的语言吧。

从Hello world说起

Groovy的安装可以参考官网的安装文档（https://groovy-lang.org/install.html）。安装好了之后，自然是先写编程语言的传统入门程序——Hello world了。新建一个HelloWorld.groovy文件，写入以下代码：

public class HelloWorld {
    public static void main(String []args) {
        System.out.println("Hello, World!");
    }
}

之后，用groovy命令就可以直接执行这个脚本啦。

PS D:groovy_example> groovy ./HelloWorld.groovy
Hello, world!

看到这里，大家可能会说，这代码看起来跟Java没有区别啊。没错，Groovy是兼容Java的语法的，所以你可以直接编写Java的代码。因为Groovy兼容Java的语法，所以Groovy中if、switch、while、for等语句的语法与Java是一样的，这里我们不再赘述。下面让我们来看一看Groovy中富有特色的语法。

实际上在Groovy中，我们完全可以这样写Hello world：

static main(args) {
    println "Hello, world!"
}

从这段代码，大家可以看出Groovy与Java不同的地方：一是Groovy的main方法不需要定义在一个类中（实际上你甚至不需要定义main方法）；二是Groovy的方法调用可以用空格代替括号；三是分号可以省略。这可以体现出Groovy的最大的特点：语法灵活而简洁。

变量与类

上面就是最基本的Hello world程序的示例了，接下来，我们来看看Groovy中变量的定义与输出。编写variable.groovy文件：

def num = 1
def str = 'Hello'
def list = [1,2,3,4,5]
def map = [ one : 1, two : 2, three : 3]
println "number is ${num}, string is ${str}, list is ${list}, map is ${map}"

然后让我们执行这个脚本。

PS D:groovy_example> groovy variable.groovy
number is 1, string is Hello, list is [1, 2, 3, 4, 5], map is [one:1, two:2, three:3]

从这个例子，我们可以看出Groovy的另一些特点：一是Groovy与动态语言一样，可以用def关键字来定义变量，而不需要写明具体的类型（实际上def关键字也可以省略）；二是Groovy可以很轻松地定义Java中的List和Map；三是Groovy可以通过形如${var}的方式来进行字符串格式化（花括号也可以省略，字符串的两端用单引号的话则不会进行格式化）。相较于Java中冗长的List初始化与String.format方法，Groovy中的语法更为简洁，可读性也更高。

上面我们介绍了变量的定义，接下让我们来看一看Groovy中类是如何定义的。先来看看代码，新建class.groovy文件：

class Person {
    private String name
    int age
    def greet(String otherPerson) {
        "Hello ${otherPerson}, my name is ${name}"
    }
}

static main(args) {
    Person alice = new Person(age: 20)
    alice.name = 'Alice'
    println alice.greet('Bob')
    println alice.age
}

执行结果如下：

PS D:groovy_example> groovy class.groovy
Hello Bob, my name is Alice
20

可以看出，Groovy中类的定义与使用与Java类似，但是有一些不同的地方：一是Groovy会自动为变量加上get与set方法，上面代码中的alice.name = ‘Alice’实际上调用了set方法；二是Groovy的方法定义中可以省略return关键字；三是调用构造函数时可以用形如(name: value)的方式给特定参数传参。这些都是Groovy提供的语法糖。

闭包与函数式编程

Groovy对于闭包与函数式编程有完善的支持。这两个特性能让我们的代码更为简洁。让我们来看一个简单的示例closure.groovy：

numbers = 1..10
sum = numbers.findAll { num -> num  % 2 == 0}
        .each { num -> print "${num} " }
        .sum()
println "sum is ${sum}"

执行结果如下

PS D:groovy_example> groovy closure.groovy
2 4 6 8 10 sum is 30

在Java中，函数式编程是通过Stream类来实现的。虽然Stream API给了我们很大的便利，但我们还是需要将List转换为Stream，之后才能利用其特性。Groovy则是给Java的集合类添加了一些方法，让我们可以直接使用函数式编程的特性，而无需额外的转换。在上面的代码中，findAll和each都是Groovy中添加的以闭包为参数的方法。闭包是通过

{ [closureParameters -> ] statements }

的形式定义的。在Groovy中，闭包可以作为对象、参数和返回值，所以Groovy对高阶函数也有良好的支持。下面就是这一特性的示例：

def addX = { int x ->
    return { int y ->
        println "x is $x, y is $y"
        return x + y
    }
}
def add1 = addX(1)
println add1(2)

上面的代码中，闭包addX会返回另外一个闭包。之后我们直接调用闭包addX，得到了闭包add1，再直接调用闭包add1进行输出。上面的代码会输出

x is 1, y is 2
3

除此之外，利用闭包，Groovy甚至可以动态地给一个类或对象添加方法。

class Cat {
    def name
}
Cat kitty = new Cat(name: 'Kitty')
kitty.metaClass.meow = { println "Meow" }
kitty.meow()

这几点结合起来，让Groovy如同Ruby一样，有了强大的元编程能力，可以用来编写领域专用语言（DSL）。我们常用的Java的构建工具Gradle就用到了Groovy的这一特性。

语法糖

相信大家从上面的例子可以看出，Groovy提供了大量的语法糖来方便我们编写脚本。实际上，这也是我选择Groovy的一大原因——语法糖实在是太甜了。在官方文档中，这些语法糖的介绍分散在各个章节，不太容易了解。所以，我总结了一下我之前用过的语法糖，来方便大家查阅。

• 灵活的Range定义

在上面的例子中，我们看到了可以用形如numbers = 1..10的方式来定义List。实际上，Groovy中定义List十分灵活，下面是一个示例。

def arrayList = 'A'..'D' as ArrayList
def linkedList = 1..<5 as LinkedList
println arrayList
println linkedList
assert arrayList instanceof ArrayList
assert linkedList instanceof LinkedList

运行的结果是

[A, B, C, D]
[1, 2, 3, 4]

可以看出，利用 ..< 运算符可以定义半开区间。而在定义List或Map的时候，as关键字可以详细指定List或Map的类型。上面代码中的assert可以检查表达式是否为true。当表达式为false时，assert会打印出表达式里对象或方法的值，从而方便我们分析。

• List的运算符

def list1 = []
def list2 = list1 + 'Hello'
println "$list1 $list2"
def list3 = list2 << 'World'
println "$list2 $list3"
println([1,2]+[3,4])

输出如下：

[] [Hello]
[Hello, World] [Hello, World]
[1, 2, 3, 4]

在Groovy中，可以用加号往List里添加元素，或者将两个List直接相加。在这种情况下，返回的是一个新的List。如果使用“<<”号，那么修改的则是原有的List。

• times方法

与Ruby类似，groovy提供了times方法，让我们能写出更简洁的循环。

3.times { i -> print "$i " }
def list = [1,2,3]
list.size().times { i -> print "$i "}

输出如下：

0 1 2 0 1 2

• 正则表达式

在Java中，我们可以使用正则包java.util.regex。而Groovy中也提供了与正则表达式相关的语法糖，让我们能更轻松地定义正则表达式。

def text = "some text to match"
def word = "text"
def pattern1 = ~/match/
def pattern2 = ~"$word"
def matcher1 = (text =~ pattern1)
def matcher2 = (text =~ pattern2)
if (matcher1) {
    println "Matched"
}
if (matcher2) {
    println "Matched"
}
if (text =~ /some/) {
    println "Matched"
}

输出如下：

Matched
Matched
Matched

我们可以看出，Groovy使用正则表达式的方式非常灵活，你可以用~运算符来定义一个正则的pattern，而且在定义pattern的时候甚至可以使用其它变量。而在匹配的时候，Groovy提供了与Perl和Ruby一样的=~运算符，从而使代码相比Java更加简洁。至于匹配出的Matcher，groovy也提供了下标运算符来供我们匹配到的捕获组。

def pattern = ~/A is (d+), B is (d+)/
def matcher = ("A is 10, B is 15. A is 20, B is 25" =~ pattern)
assert matcher[0][1] == "10" && matcher[0][2] == "15"
assert matcher[1][1] == "20" && matcher[1][2] == "25"

上面的例子中，pattern第一次匹配到的是”A is 10, B is 15”，因此matcher[0][1]是10而matcher[0][2]是15（matcher[0][0]是匹配到的”A is 10, B is 15”）。

• with方法

在使用Java的时候，常常会遇到需要在同一个对象上多次调用方法。Groovy也提供了相应的语法糖，这就是with方法。

StringBuilder stringBuilder = new StringBuilder()
stringBuilder.with {
    append "W"
    append "o"
    append "w"
}
println stringBuilder.toString()

输出如下

Wow

通过with方法，我们在调用对象方法时可以省略对象名。上面的例子中， 调用append方法时，变量名stringBuilder就被省略了。这样，我们可以让代码看起来更简洁。

• 增强的switch case

Groovy的switch case语法和Java类似，但是支持List、Range、整数、数字、正则、闭包的判断，可以看下面的实例：

def switchFunction(def x)
{
    def res
    switch ( x ) {
        case [1, 2, 3]:
            res = "in list"
            break
        case 10..30:
            res = "in range"
            break
        case Integer:
            res = "integer"
            break
        case Number:
            res = "number"
            break
        case ~/fo*/:
            res = "match regex"
            break
        case { str -> (str in String && str.length() == 1) }:
            res = "closure returns true"
            break
        default:
            println "default"
    }
}
assert switchFunction(1) == "in list"
assert switchFunction(11) == "in range"
assert switchFunction(4) == "integer"
assert switchFunction(0.1) == "number"
assert switchFunction("foooo") == "match regex"
assert switchFunction("a") == "closure returns true"

从这个例子中，我们可以看出，Groovy可以通过switch case判断表达式是否在list或range中，也可以判断表达式是否是整数或数字（包括小数），还可以进行正则的匹配（会先调用表达式的toString方法将其转换为String），甚至可以通过闭包来进行额外的判断操作（in是instanceof的简写，用于判断类型）。

• 其他语法糖

Groovy还有许多其它方便我们写脚本的语法糖。下面我会列出比较常用的部分。

同时定义两个变量

def (var1, var2) = [1, 2]

交换两个变量

int a = 1, b = 2
(a, b) = [b, a]

快速创建一个新线程

Thread thr = Thread.start {
    println "Hello, world!"
}
thr.join()

通过子进程执行shell命令

def process = "cmd /c dir".execute()
println process.text

函数默认参数

int function ( int a = 1, int b = 2 ) { a + b }
println function()

for in语法

for (i in 1..10)
{
    println "$i"
}

在闭包中递归调用自身

def fibonacci = { int n ->
    n == 1 ? 1 : n + call(n - 1)
}
println fibonacci(10)

使用Range访问List

list = [1, 2, 3, 4, 5]
assert list[0..2] == [1, 2, 3]
assert list[0..-2] == [1, 2, 3, 4]

文件读写

def file = new File('test.txt')
file.newOutputStream() << "Hello, world!"
assert file.text == "Hello, world!"

总结

写了这么多，相信大家已经可以看出我选择Groovy作为测试脚本的语言的原因了：

1. Groovy基于JVM，这使我能够调用产品的Java代码，也能够调用Java标准库里的代码。除些之外，我还可以通过Maven或Gradle使用大量的第三方Java库。
2. Groovy是动态语言，扩展了Java的容器类，提供了完善的函数式编程和元编程支持。这让我可以写出简洁而富有表现力的代码。
3. Groovy提供了大量的语法糖。与Java自身繁冗的代码相比，这些语法糖大大节约了我编写脚本的时间，减少了我的脚本的代码量。

然而，Groovy在带来上述三个优点的同时，也会带来有相应的缺点：

1. 效率问题。Groovy作为运行在JVM上的动态语言，运行效率是低于Java的。虽然可以用@CompileStatic注解来静态编译一些类以提高效率，但这样又会失去Groovy的一些动态语言的特性。
2. 语法过于灵活，运用不当会降低可读性与可维护性。Groovy支持元编程特性，可以在运行时动态添加方法。这一点自然可以简化代码，但也有很大的可能会降低可维护性。函数式编程与大量的语法糖会让不熟悉Groovy的人读起来一头雾水，反而降低了可读性。

不过，因为我仅仅是拿Groovy来编写bug的测试脚本，所以这两个缺点也就被相应的回避了。测试脚本不需要在意执行的效率，而修复了bug之后也无须继续维护，因此也不需要在意可维护性的问题。

总而言之，我感觉Groovy与Perl、 Ruby类似，是一门魔幻语言，有大量的咒语（语法糖）和魔法（元编程和函数式编程）。利用Groovy，你可以大大提高自己的工作效率，轻松地写出各式各样的脚本，从而方便地调用与测试Java编写的API。

参考链接

The Apache Groovy programming language​groovy-lang.org