圖譜：Spark<-Scala<-Gradle<-Groovy

Before you learn, setup your IDE well!!! IDEA is recommanded.

1. Groovy基于JVM；

2.如果把java文件的后綴改成.groovy，能夠編譯通過并運行。但是由于groovy是動態語言，很多行為可能會不一致。尤其涉及繼承、多態的時候。如果調用方使用的是父類，則，java會找一個最上層的基類實現，但是groovy則會使用實際的對象中的方法。例如下面的代碼中，如果是java，則在collection.remove中，實際調用的是Collection的直接子類AbstractCollection的remove方法，嘗試將0轉成Object去刪除，但是Collection中沒有Integer(0)這個對象，所以沒有刪除。Java并不會把0當做index。而對于groovy，即使使用的是collection.remove,groovy也會使用實際對象的類型中的remove，也就是ArrayList的remove，把0當做index。執行這段代碼后，java會剩一個元素，groovy集合為空。

ArrayList<String> list=new ArrayList<>();
Collection<String> collection=list;
list.add("Jim");
list.add("Tom");
collection.remove(0);
list.remove(0);

3. groovy聲明對象時，可以指定類型，但是和java不同，groovy并不在靜態時檢查這個類型，而是在運行時嘗試做強制類型轉換。因此是偽靜態類型。groovy可以使用注解來執行更嚴格的編譯時檢查：

@groovy.transform.TypeChecked
def shout(String str){
    str.notExistMethod();
}

4. 動態語言沒有編譯時類型檢查，甚至連方法、屬性是否存在也不能確定，也不能幫助發現一些拼寫錯誤。為了保障程序的功能能夠正常實現，應該采用完整的ut來驗證功能。動態語言對ut的要求更加嚴格。

5. 可以使用@CompileStatic讓groovy執行靜態編譯，但是會失去元編程的能力，這主要是出于性能考慮。groovy動態編譯可能導致損失10%的性能，但是靜態編譯可以產生和java相媲美的性能。

6. 閉包

def each(n, block){
    for(int i=0;i<n;++i){
        block(i)
    }
}

each(10, { it -> println it }) <=> each(10, { println it }) <=> each(10){ println it }

def examine(closure){
    println closure.maximumNumberOfParameters
}
examine(){} // closure.maximumNumberOfParameters = 1
examine(){it} // closure.maximumNumberOfParameters = 1
examine(){->} // closure.maximumNumberOfParameters = 0

7. 科里化(咖喱化，哈哈)

add3 = { x, y, z = x + y + z }
add2 = add3.curry(1)
add = add2.curry(2)
addr = add3.rcurry(5) // <=> add3(x, y, 5)
addn = add3.ncurry(1, 9) // <=> add3(x, 9, z)
add3.call(4, 5, 6) <=> add3(4, 5, 6)
add(3) //6

8. GDK

Groovy 給java.lang.Object增加了一些方法。還有更多，例如use,mixin 等都在 DefaultGroovyMethods 中定義。

obj.dump()
obj.inspect();

list=[]; list.add(3); list.add(4) <=> list=[]; list.with(add(3);add(4));

9. 一個簡單的DSL， 放在Counter.groovy中可以直接運行。以get set開頭的方法是定義了類的屬性訪問器。

value = 10

def getClear() {
    value = 0
}

def getTotal() {
    println "Total count is ${value}"
}

def add(int n) {
    value += n
}

clear
add 3
total
add 4
total
clear
total

10. this, delegate和owner

this 指閉包本身；owner指定義閉包的外層閉包；默認delegate和owner相等，但是delegate可以被修改。

List.metaClass.myeach={delegate.each{println it}}

11. MOP(MetaObject Protocol) 和元編程

Groovy對象分為三種：

POJO普通java對象

POGO使用Groovy編寫的對象，擴展了java.lang.Object 對象，同時實現了groovy.lang.GroovyObject接口。一旦一個類被加載到JVM中，我們就不能修改它的元對象Class了，但是我們可以通過setMetaClass修改它的MetaClass，造成一種對象運行時類被修改了的感覺。

package groovy.lang;
public interface GroovyObject {
    Object invokeMethod(String var1, Object var2);
    Object getProperty(String var1);
    void setProperty(String var1, Object var2);
    MetaClass getMetaClass();
    void setMetaClass(MetaClass var1);
}

Groovy攔截器 是擴展了GroovyInterceptable接口的Groovy對象。不管對象存在的還是不存在的方法調用，都會被它的invokeMethod攔截。對于一般的groovy對象時只有當方法不存在時，才會調用的invokeMethod方法，除非在對象的MetaClass上實現了InvokeMethod方法

package groovy.lang;
public interface GroovyInterceptable extends GroovyObject {
}

Groovy對調用方法的路由：

1)如果是POJO對象，先從MetaClassRegistry中取出MetaClass，并將方法代理給它。因此在MetaClass上定義的任何方法都先于POJO自己定義的方法

2)如果是POGO對象，且實現了GroovyInterceptable接口，所有的調用都會被路由到invokeMethod方法，在這個攔截器內，調用正確的方法，使得AOP成為可能。

3)如果是POGO對象，沒有實現GroovyInterceptable，則會先查找MetaClass中定義的方法，如果沒有找到，就調用POGO本身的方法。如果POGO沒有這樣的方法，會查找POGO的屬性或者字段。如果屬性或者字段是Closure類型，則調用它以代替方法調用。接下來會嘗試調用methodMissing方法，否則調用invokeMethod方法。invokeMethod的默認實現是拋出MethodMissingException。其中invokeMethod和methodMissing必須有嚴格的prototype聲明。一下還給出了調用默認實現的一個invokeMethod的實現。

def invokeMethod(String method, Object args){
    metaClass.getMetaMethod(method, args).invoke(this, args)
    //metaClass.invokeMethod(this, method, args);
}

查看某個方法能否被相應

String.metaClass.respondsTo(str,"compareTo","test") // true

12. MOP 方法注入的三種方式

1) 分類。背后的原理是調用GroovyCategorySupport.use(categoryClass, closure)方法，創建臨時作用域，將新方法附在目標對象的MetaClass上。一旦閉包結束，則丟棄所有加入的新方法。也可以使用@Category注解來實現。

class StringUtil {
    def static dup(str) {
        str + str
    }
}

use(StringUtil) {
    println "hello,".dup()
}

2) ExpandoMetaClass

向類的MetaClass添加新方法，這樣會將累的MetaClass從MetaClassImpl變成ExpandoMetaClass。可以通過<< 添加新的構造函數。改變某個對象的MetaClass而不是整個類。這個像極了js

def jack = new Person()
def emc = new ExpandoMetaClass(Person)
emc.sing = {-> "Sing..."}
emc.initialize()
jack.metaClass = emc
println jack.sing()
jack.metaClass=null //去除添加在metaClass上的方法

3) Mixin

class Friend{
    def sayHello(){
        println "Hello, $name!"
    }
}
/**************************************/
@Mixin(Friend)
class Person{
    def name
    Person(){
        name="Jim"
    }
}

new Person().sayHello()
/**************************************/
Person.mix Friend
new Person().sayHello()
/**************************************/
def person = new Person()
person.metaClass.mix Friend
person.sayHello()

13. 動態創建類：Expando，這個仍然像極了js

def car = new Expando(mile: 300, turn:{dir -> println "turning $dir"})
car.color = "green"

14. 在java/groovy中使用java類，groovy類和groovy腳本

1) 運行groovy腳本

groovy script.groogy //run directly

groovyc script.groovy // compile first, generate script.class
groovy -cp . script // run the groovy class

2) groovy中使用java

groovyc -j Animal.java useAnimal.groovy // outputs Animal.class, useAnimal.class
groovy -cp . useAnimal

也可以使用javac自行對java文件進行編譯生成class文件，將生成的class文件加入到groovy的classpath中即可。畢竟groovy的類中包含POJO，POGO，Interceptable，groovy可以正確處理POJO。

3)java中使用groovy靜態方法

// Function.groovy
class Function{
    def apply(v,closure){
        closure(v)
    }
}

//Main.java
public class Main{
    public static void main(String[] args){
        System.out.println(new Function().apply(3, new Object(){
            public int call(int v){
                return v * 2;
            }
        }));
    }
}

groovyc -j Main.java Function.groovy // compile
java -cp groovy-3.0.0-alpha-3/lib/groovy-3.0.0-alpha-3.jar: Main // run

4) Java中使用groovy的動態方法

只需要將產生的對象賦值給 groovy.lang.GroovyObject，然后調用該對象的invokeMethod方法即可。

5) Groovy中使用groovy腳本 需要使用GroovyShell，使用Binding傳遞參數，使用run來傳遞命令行參數

6) Java 中使用Groovy腳本 需要使用javax.script.ScriptEngineManager和ScriptEngine

 

Questions

1. Groovy中callsite的概念。腳本會被轉化成Call site，機制是什么？

2. Groovy可以修改metaClass，這個是如何存儲的？這部分可能需要明白JVM的編譯和反編譯機制。