初識Groovy

• 1.基本語法
  groovy作為動態的腳本語言，底層實現為java，groovy文件在運行時，先被解釋成.class文件，本身為腳本語言，所以他的優勢在于動態加載；
  （1）定義變量及方法

//.groovy
def str = new String()
def str1 = 'abc'
def str2 = "$str1 : 556"

def getSome(var12) {
    println var12
}

在這里groovy不重視類型，但是也可以像java一樣，重視類型，基本操作與java相同；值得注意的是，在groovy中單引號和雙引號是有不同功能的，只是定義一個字符串，可以直接用單引號，在雙引號中可以格式化字符串，就像例子中的$str，會被解釋成abc
（2）強大的閉包

//讀取文件，按行輸出
new File('filePath').eachline('encoding') {
    //closure
    line -> println line
}
//定義閉包函數
def foo = {
    key, value -> 
    ..dosomething
    println "$key : $value"
}
//調用
foo.call('name', 'Mr.zou')

def list = [1,2,3,4,5]
list.each {
    println it
}

閉包其實類似于java中的lambda函數，在最后一個例子中，使用一個變量為it，這個是groovy的內置變量，在這里表示循環的item，可以看到在調用調用each的時候，方法沒有小括號，這是個有趣的地方，因為groovy允許如果函數的最后一個參數是一個閉包的話，那么小括號可以省略
（3）文件操作
上面的例子已經提到文件的讀方法，要比java簡單的多，下面看一下寫的例子

//補充讀文件的方法
def file = new File('filepath')
println file.text //直接輸出文件文本

//寫文件
    def file = new File("E:/test.txt")
    file.withWriter { writer ->
        writer << 'xixi \r\n'
        writer << 'haha \r\n'
    }

file對象提供了豐富的流對象，操作文件更方便
（4）json
groovy提供可很強大的針對json的操作功能，核心的類JsonSlurper，JsonOutput

def jsonStr = "{\"state\":{\"name\":\"zouYu\",\"age\":12}}"
def parser = new JsonSlurper().setType(JsonParserType.LAX)
def jsonResp = parser.parseText(jsonStr) as HashMap
def info = jsonResp.state as HashMap
def user = new Expando(info)
user.setProperty('abc', false)
println(user)
println JsonOutput.toJson(user)

上面的結果是
{name=zouYu, age=12, abc=false}
{“name”:”zouYu”,”age”:12,”abc”:false}
其中Expando稍后再講，先說一下JsonSlurper類，可以看到在初始化對象之后調用了setType方法，這個參數的作用是，允許json字符串存在注釋或者沒有引號的字段，這個是一個非常好的功能，推薦使用這種模式，還有一點就是在定義info時，后面使用了as，這意味著json字符串轉換成類型時，可以定義它的類型
相當于，如果我已經確定這個json字符串對應的實體對象，那么我可以直接使用

def student = parser.parseText(jsonStr) as Student

這樣就可以直接實例化一個student對象；JsonOutput提供了多種類型轉換成json字符串的方法

這里生成的json字符串可以更直觀的看出類的關系，但是這里需要注意的是，中文會被轉換成unicode編碼，在java中Unicode編碼字符串toString()之后會自動轉換成中文，但是這里不行

（5）面向對象
在做groovy開發時，可以查看groovy解釋生成的.class文件
我在同一個文件中定義了三個class，解釋之后會生成3個class文件，首先我們開一下簡單類

class Student {
    String name
    int age
    School school
}

>>生成的class文件
import groovy.lang.GroovyObject;
import groovy.lang.MetaClass;
import org.codehaus.groovy.runtime.ScriptBytecodeAdapter;
import org.codehaus.groovy.runtime.callsite.CallSite;
import org.codehaus.groovy.runtime.typehandling.DefaultTypeTransformation;
import org.codehaus.groovy.runtime.typehandling.ShortTypeHandling;

public class Student implements GroovyObject {
    private String name;
    private int age;
    private School school;

    public Student() {
        CallSite[] var1 = $getCallSiteArray();
        MetaClass var2 = this.$getStaticMetaClass();
        this.metaClass = var2;
    }

    public Student(Object name, Object age, Object school) {
        CallSite[] var4 = $getCallSiteArray();
        MetaClass var5 = this.$getStaticMetaClass();
        this.metaClass = var5;
        this.name = (String)ShortTypeHandling.castToString(name);
        this.age = DefaultTypeTransformation.intUnbox(age);
        this.school = (School)ScriptBytecodeAdapter.castToType(school, School.class);
    }

    public String getName() {
        return this.name;
    }

    public void setName(String var1) {
        this.name = var1;
    }

    public int getAge() {
        return this.age;
    }

    public void setAge(int var1) {
        this.age = var1;
    }

    public School getSchool() {
        return this.school;
    }

    public void setSchool(School var1) {
        this.school = var1;
    }
}

很明顯，groovy把封裝做的很好，屬性私有，對外暴露setter/getter方法，還有，groovy對方法也進行了處理，方法的默認返回值為方法的最后一行代碼，一切的工作都是在努力的減少工作量；
在面向對象中特別值得一提的就是元對象編程，什么意思呢？假如你現在想對一個沒有任何屬性的類，添加屬性并賦值，怎么辦，直接操作肯定是報錯的，groovy在這里提供了一個方法

class Student {
    static void main(String[] args){
        Student.metaClass.name = { -> 'Mr.zou'}
        def stu = new Student()
        println stu.name
    }
}

對于這種模式，相當于在Student類上永久加了這個name屬性，之后初始化都會帶有這個屬性，還有要介紹的兩個類，Expando，ExpandoMetaClass，后者類似于上面的操作，主要說一下Expando，這個東西很好用，比如說我有這樣一個場景，我從接口中收到一個json串，我想不通過反序列化，直接將json轉換成對象并且對這個對象的屬性進行增改組裝，然后調用其他接口，代碼如下

def parser = new JsonSlurper().setType(JsonParserType.LAX)
def jsonResp = parser.parseText(var12) as HashMap //var12為jsonString
def student = new Expando(jsonResp as HashMap)

student.setProperty(propName, propValue);
student.getproperty(propName)

這個是Expando類提供的api和構造函數
在groovy中實現一個GroovyInterceptable類也是可以進行動態賦值的，invokeMethod相當于java反射

 public Object invokeMethod(String name, Object args) {
        return this.getMetaClass().invokeMethod(this, name, args);
    }
    這是源碼，GroovyObjectSupport抽象類繼承自GroovyObject

正在學習，寫的不好歡迎糾正，未完待續……..