Hello Groovy

Groovy 是基于JVM虚拟机的一种动态语言，语法和Java非常相似。Groovy完全兼容Java，又在此基础上增加很多动态类型和灵活的特性，比如闭包，支持DSL，是一门非常灵活的动态脚本语言。

每个Gradle的脚本文件都是一个Groovy脚本文件，可以在里面写任何符合Groovy语法代码，比如自定义类，声明函数，定义变量等。Groovy又完全兼容Java，这 意味着在build脚本文件里写任何的Java代码，非常灵活方便。

字符串

' ' " " 都代表字符串，但是单引号没有运算能力，而双引号具有运算能力

task printStringClass  {
    def str1='单引号'
    def str2="双引号"
    println "单引号定义的字符串类型："+str1.getClass().name
    println "双引号定义的字符串类型："+str2.getClass().name
    def name="张三"
    println '单引号变量计算${name}'
    println "双引号变量计算${name}"
}

集合

• List

task printList{
    def numList=[1,2,3,4,5,6]
    println numList.getClass().name

    //访问第二个元素
    println numList[1]
    //访问最后一个元素
    println numList[-1]
    //访问第二到第四个元素
    println numList[1..3]

    numList.each{
        println it
    }
}

• Map

task printMap{
    def map=['width':1024,'height':768]

    println map.getClass().name


    println map['width']
    println map.height


    map.each{
        println "key:${it.key}  value:${it.value}"
    }

}

方法

• 括号可以省略

task invokeMethod{

    method1(1,2)
    method1 2,3

}

def method1(int a,int b){
   println a+b
}

• return 可以不写

task printMethodPrint{
    def add1=method2 1,2
    def add2=method2 2,3

    println "add1:${add1}  add2:${add2}"
}

def method2(int a,int b){
    if(a>b){
        a
    }else{
        b
    }
}

• 代码块可以作为参数传递

  map.each({
        println it
        })

    map.each(){
        println it
    }

    map.each{
        println it
    }

• JavaBean

class Person{
    private String name;
}

task hellJavaBean{
    Person p=new Person()

    println "name : ${p.name}"

    p.name="zhangsan"

    println "name: ${p.name}"
}

闭包

是Groovy的一个非常重要的特性，可以说它是DSL基础。闭包不是Groovy的首创，但是它支持这一重要特性。

• 自定义闭包

task helloClosure{
    customEach{
        println it
    }
}

def customEach(closure){
    for(int i in 1..10){
        closure(i)
    }
}

• 向闭包传递参数

task helloClosure{
    //多个参数
    eachMap{
        k,v -> println "k:$k  v:$v"
    }
}

def eachMap(closure){
    def map=["name":"zhangsan","age":18]
    map.each{
        closure(it.key,it.value)
    }
}

• 闭包委托

Groovy闭包有thisObject/owner/delegate 三个属性，当你在闭包内调用方式时，由它们来确定使用哪个对象来处理。默认情况下delegate/owner是相等的，但是delegate是可以被修改的，这个功能非常强大，Gradle中闭包的很多功能都是通过修改delegate实现的。

task helloDelegate{
    new Delegate().test{
        println "thisObject:${thisObject.getClass()}"
        println "owner:${owner.getClass()}"
        println "delegate:${delegate.getClass()}"
        method3()
        it.method1()
    }
}


def method3(){

        println "Context this:${this.getClass()} in root"

        println "method3 in root"

}

class Delegate{
    def method1(){
        println "Delegate this:${this.getClass()} in Delegate"

        println "method1 in Delegate"
    }

    def test(Closure<Delegate> closure){
        closure(this)
    }
}

task configClosure{

    personMethod{
        personName="zs"
        personAge=10
        dumpPerson()
    }

}


class PersonObj{
    String personName
    int personAge

    def dumpPerson(){
        println "name is ${personName} age is ${personAge}"
    }
}

def personMethod(Closure<PersonObj> closure){
    PersonObj p=new PersonObj()
    closure.delegate=p
    //委托模式优先
    closure.setResolveStrategy(Closure.DELEGATE_FIRST)
    closure(p)
}

DSL

Domain Specific Language 领域特定语言，是专门关注某一领域的语言，它在于专，而不是全。Gradle就是一门DSL，它是基于Groovy，专门解决自动化构建的DSL。