閉包概述

閉包就是一個特殊的匿名程式碼塊，可以傳遞引數，有返回值，還能作為方法的引數進行傳遞。

閉包格式

1. 閉包的格式定義如下：

   { [closureParameters -> ] statements }

   示例：

   { item++ }                                          
   
   { -> item++ }                                       
   
   { println it }                                      
   
   { it -> println it
    
    }                                
   
   { name -> println name }                            
   
   { String x, int y ->                                
       println "hey ${x} the value is ${y}"
   }
   
   { reader ->                                         
       def line = reader.readLine()
       line.trim()
   }

2. closureParameters ：閉包引數是非必需的，與方法的引數十分類似，區別是：如果存在閉包引數，閉包引數與閉包語句之間需要使用箭頭（->）的分割。

3. 注意：如果沒有指定引數，則預設存在一個it的引數，代表的是閉包本身。如下例子：

   def obj = {
       println(it)
   }
   obj('hello')

4. statements：同樣，閉包語句則可以類比於方法體，功能也相同。

5. 變數可作為閉包的載體，原因是：閉包其實是Groovy中的Closure類的例項。如下三種示例：

   def listener = { e -> println "Clicked on $e.source" }      
   
   //指明為Closure型別例項
   Closure callback = { println 'Done!' }                      
   
   //指明為Closure型別例項，並指定返回型別 
    
   
   Closure<Boolean> isTextFile = {
       File it -> it.name.endsWith('.txt')                     
   }

6. 執行閉包有兩種方式：一是直接呼叫；二是通過呼叫Closure的call方法。如下程式碼：

   def obj = {
       def item = 10
       return ++item
   }
   // 直接呼叫
   println(obj())
   
   //call呼叫
   println(obj.call())

7. 從位元組碼來看上述兩種方式的區別：兩種方式完全等效，都是通過call來完成

   public Object test() {
       CallSite[] var1 = $getCallSiteArray();
       class _test_closure1 extends Closure implements GeneratedClosure {
           public _test_closure1(Object _thisObject) {
               CallSite[] var3 = $getCallSiteArray();
               super(Closures.this, _thisObject);
           }
   
           public Object doCall(Object it) {
               CallSite[] var2 = $getCallSiteArray();
               Object item = Integer.valueOf(10);
               return var2[0].call(item);
           }
   
           public Object doCall() {
               CallSite[] var1 = $getCallSiteArray();
               return this.doCall((Object)null);
           }
       }
   
       Object obj = new _test_closure1(this);
       var1[2].callCurrent(this, var1[3].call(obj));
       return var1[4].callCurrent(this, var1[5].call(obj));
   }

代理策略

1. 代理在groovy的閉包中是非常重要的概念，與之相關的是this、owner和delegate這三種概念。

2. this：指的是定義閉包所在的直接的外圍類，具體有如下兩種方式獲取：

   class Test {
       void run() {
           // 方式一：使用getThisObject
           def enclosingThisObject = { getThisObject() }
           // 方式二：this操作符
           def enclosingThis = { this }
   
           def testThis = this
           def print = "enclosingThisObject=${enclosingThisObject()},enclosingThis=${enclosingThis()},testThis=$testThis"
           println(print)
      }
   }
   def test = new Test()
   test.run()

   執行結果：

   enclosingThisObject=com.demo.test.cl.Test@4f209819,
   enclosingThis=com.demo.test.cl.Test@4f209819,
   testThis=com.demo.test.cl.Test@4f209819

   從位元組碼也可看出兩種方式是等效的，因為this方式也會呼叫getThisObject，如下：

   public void run() {
       CallSite[] var1 = $getCallSiteArray();
       class _run_closure1 extends Closure implements GeneratedClosure {
           public _run_closure1(Object _thisObject) {
               CallSite[] var3 = $getCallSiteArray();
               super(Test.this, _thisObject);
           }
   
           public Object doCall(Object it) {
               CallSite[] var2 = $getCallSiteArray();
               return var2[0].callCurrent(this);
           }
   
           public Object doCall() {
               CallSite[] var1 = $getCallSiteArray();
               return this.doCall((Object)null);
           }
       }
   
       Object enclosingThisObject = new _run_closure1(this);
       class _run_closure2 extends Closure implements GeneratedClosure {
           public _run_closure2(Object _thisObject) {
               CallSite[] var3 = $getCallSiteArray();
               super(Test.this, _thisObject);
           }
   
           public Object doCall(Object it) {
               CallSite[] var2 = $getCallSiteArray();
               // this方式呼叫getThisObject方法
               return this.getThisObject();
           }
   
           public Object doCall() {
               CallSite[] var1 = $getCallSiteArray();
               return this.doCall((Object)null);
           }
       }
   
       Object enclosingThis = new _run_closure2(this);
       Object print = new GStringImpl(new Object[]{var1[0].call(enclosingThisObject), var1[1].call(enclosingThis), this}, new String[]{"enclosingThisObject=", ",enclosingThis=", ",testThis=", ""});
       var1[2].callCurrent(this, print);
   }

   注意：在內部類中定義閉包，那麼this指的是這個內部類；同樣，巢狀的閉包定義，this指的是外層閉包所在的類。如下例項：

   class EnclosedInInnerClass {
       class Inner {
           Closure cl = { this }
       }
   
       void run() {
           def inner = new Inner()
           assert inner.cl() == inner
       }
   }
   
   class NestedClosures {
       void run() {
           def nestedClosures = {
               def cl = { this }
               cl()
           }
           assert nestedClosures() == this
       }
   }

   小結：閉包需要依附於某個類中，不能單獨存在；this其實是閉包與所在外部類的通訊橋樑。

3. owner： 指的是定義閉包的直接外圍物件，可以是類或者閉包。與this相似，區別在於巢狀閉包，如下例項：

   class NestedClosures {
       void runOwner() {
           def nestedClosures = {
               def cl = { owner }
               cl()
           }
           assert nestedClosures() == nestedClosures
       }
   
       void runThis() {
           def nestedClosures = {
               def cl = { this }
               cl()
           }
           assert nestedClosures() == this
       }
   }

   巢狀閉包中this與owner的區別：this是外圍類的例項，而owner則是外層閉包例項。

   小結：閉包中的this側重於直接外圍類，而owner則偏向於閉包的宿主物件，它們都是閉包與外部環境的通訊橋樑。

4. delegate：獲取閉包的delegate有如下兩種方式，其返回的預設值是owner。

   // 方式一：呼叫getDelegate()方法
   def obj1 = { getDelegate() }
   // 方式二：delegate關鍵字
   def obj2 = { delegate }
   // delegate預設值是owner
   println(obj1() == obj2.owner)
   // 巢狀閉包delegate預設值也是owner
   def enclosed = {
         { -> delegate }.call()
       }
   assert enclosed() == enclosed

   如下通過不同的代理物件，閉包的行為是不同的：

   class Person {
       String name
   }
   
   class Thing {
       String name
   }
   
   def p = new Person(name: 'Norman')
   def t = new Thing(name: 'Teapot')
   
   def upperCasedName = { delegate.name.toUpperCase() }
   upperCasedName.delegate = p
   println(upperCasedName())//Norman
   
   upperCasedName.delegate = t
   println(upperCasedName())//Teapot

5. 代理策略：上述例子中的閉包能正常執行，是因為閉包的代理策略影響了編譯閉包程式碼時的解析策略。分為如下幾種策略：

   • Closure.OWNER_FIRST：OWNER優先策略，也是預設策略，優先從owner中尋找屬性或方法，找不到再從delegete中尋找。
   • Closure.DELEGATE_FIRST：與OWNER_FIRST相反。
   • Closure.OWNER_ONLY： 只在owner中尋找屬性或方法。
   • Closure.DELEGATE_ONLY： 只在delegate中尋找屬性或方法。
   • Closure.TO_SELF： 前提是使用者需要實現的Closure的子類，只會在閉包自身中尋找屬性或方法。

   class Person {
       String name
       int age
       def fetchAge = { age }
   }
   
   class Thing {
       String name
   }
   
   def p = new Person(name: 'Jessica', age: 42)
   def t = new Thing(name: 'Printer')
   def cl = p.fetchAge
   // 注意：cl的預設代理物件就是p，可以省略
   // cl.delegate = p
   println(cl())//42
   
   cl.delegate = t
   println(cl())//42
   
   //修改代理策略
   cl.resolveStrategy = Closure.DELEGATE_ONLY
   cl.delegate = p
   println(cl())//42
   
   cl.delegate = t
   try {
       cl()
       assert false
   } catch (MissingPropertyException ex) {
       // "age" is not defined on the delegate
   }