Gradle入門(mén)知識(shí)之Gradle語(yǔ)法2

5.閉包

閉包在我們groovy中起著很大比重，如果想要學(xué)好groovy，閉包一定得掌握好，

在我們build.gradle其實(shí)就有很多閉包使用：

如:

android{
    sourceSets {
        main{
                jniLibs.srcDirs = ['libs']
        }
    }
}

這里面的

android {}

其實(shí)就是一個(gè)閉包結(jié)構(gòu)，其內(nèi)部的sourceSets{}又是閉包中的閉包，可以看到閉包在我們的gradle中無(wú)處不在.

學(xué)好閉包真的很關(guān)鍵

常用閉包方式：

{'abc'}
{ -> 'abc'}
{ -> "abc"+$it}
{ String name -> 'abc'}
{ name -> "abc${name}"}
{ name,age -> "abc${name}"+age}

5.1：閉包的定義及基本方法

• 閉包概念：其實(shí)就是一段代碼段，你把閉包想象為java中的回調(diào)Callback即可，

  閉包在Groovy中是groovy.lang.Closure 的實(shí)例,可以直接賦值給其他變量.

• 閉包的調(diào)用：

def closer = {1234}
closer()
closer.call()

• 閉包參數(shù)：帶參數(shù)的閉包 使用 -> 如果是一個(gè)參數(shù)可以直接使用it代替和kotlin中的lambda類(lèi)型類(lèi)似

def closerParam = { name,age ->
    println "hello groovy:${name}:${age}"
    'return hei'
}
def result = closerParam("lily",123)

• 閉包返回值：閉包返回值 如果沒(méi)有定義return則直接返回最后一句話(huà)的返回值

println result //打印結(jié)果：return hei

5.2：閉包使用詳解

• 5.2.1:與基本類(lèi)型結(jié)合使用：

//upto:實(shí)現(xiàn)階乘
int x= fab_upTo(5)
println(x)
int fab_upTo(int number){
    int result = 1
    1.upto(number,{result*=it})
    return result
}
//downto:實(shí)現(xiàn)階乘
int x1= fab_downTo(5)
println(x1)
int fab_downTo(int number){
    int result = 1
    number.downto(1){result*=it}
    return result
}
//times:實(shí)現(xiàn)累加
int x2 = cal(101)
println(x2)

int cal(int number){
def result = 0;
number.times {
    result+=it
}
return result
}

• 5.2.2:與String結(jié)合使用

String str = "the 2 and 3 is 5"
//each:遍歷查找,返回值是str自己
println str.each {temp ->
        print  temp.multiply(2)
}
//find查找一個(gè)符合條件的
println str.find {
        it.isNumber()
}
//findAll查找所有符合條件的，返回的是一個(gè)集合
println str.findAll {
        it.isNumber()
}
//any表示查找只要存在一個(gè)符合的就是true
println str.any { s ->
        s.isNumber()
}
//every表示全部元素都要符合的就是true
println str.every {
        it.isNumber()
}
//將所有字符進(jìn)行轉(zhuǎn)化后，放到一個(gè)List中返回
def list = str.collect {
        it.toUpperCase()
}
println(list)

• 5.2.3:與數(shù)據(jù)結(jié)構(gòu)結(jié)合使用:

  這部分操作和與String結(jié)合使用類(lèi)似，不再講解

• 5.2.4:與文件結(jié)合使用

  這部分在講解到文件操作的時(shí)候，再進(jìn)行具體講解

5.3：閉包進(jìn)階詳解

• 5.3.1：閉包關(guān)鍵變量:this,owner,delegate

情況1 ：一般情況：

def scriptCloser = {
    println "scriptCloser:this:${this}"
    println "scriptCloser:owner:${owner}"
    println "scriptCloser:delegate:${delegate}"
}
調(diào)用：scriptCloser()
結(jié)果：
scriptCloser:this:variable.Closer@58a63629
scriptCloser:owner:variable.Closer@58a63629
scriptCloser:delegate:variable.Closer@58a63629

可以看到一般情況下：三種都是相等的：都代表當(dāng)前閉包對(duì)象

情況2 ：我們來(lái)看下面的情況：閉包中有閉包

def nestClosure = {
    def innerClosure = {
            println "innerClosure:this:"+this.getClass()
            println "innerClosure:owner:${owner.getClass()}"
            println "innerClosure:delegate:${delegate.getClass()}"
    }
    innerClosure()
}
nestClosure()
結(jié)果：
innerClosure:this:class variable.Closer
innerClosure:owner:class variable.Closer$_run_closure10
innerClosure:delegate:class variable.Closer$_run_closure10

看到在閉包中調(diào)用閉包：

this還是執(zhí)行外部的Closer對(duì)象，而owner和delegate變?yōu)榱?code>Closer的內(nèi)部閉包對(duì)象

情況3 ：最后來(lái)看一種情況：使用delegate委托

class Student{
    def name
    def pretty = {println "my name is ${name}"}
    void showName(){
            pretty.call()
    }
}
class Teacher{
    def name
}
Student stu1 = new Student(name: 'yuhb')
Teacher tea1 = new Teacher(name: 'lily')

//改變委托delegate
stu1.pretty.delegate = tea1
stu1.showName()
//設(shè)置委托策略
stu1.pretty.resolveStrategy = Closure.DELEGATE_FIRST
stu1.showName()


結(jié)果：
my name is yuhb
my name is lily

通過(guò)上面三種情況：

總結(jié)出：

• this：指向最外部的Closer對(duì)象
• owner：執(zhí)行當(dāng)前閉包的Closer對(duì)象，特指當(dāng)前，所以對(duì)閉包中的閉包，指向內(nèi)部的閉包
• delegate：這個(gè)是閉包的代理對(duì)象，如果有單獨(dú)配置這個(gè)delegate，且設(shè)置了委托策略 =DELEGATE_FIRST， 則閉包中的所有內(nèi)部屬性都會(huì)優(yōu)先使用delegate中的對(duì)象

下面我們就來(lái)講解閉包的委托策略

• 5.3.2：閉包委托策略

閉包中給我提供了以下策略：

//優(yōu)先使用ower中的屬性
public static final int OWNER_FIRST = 0;
//優(yōu)先使用delegate中的屬性
public static final int DELEGATE_FIRST = 1;
//只是有owner中的屬性
public static final int OWNER_ONLY = 2;
//只是有delegate中的屬性
public static final int DELEGATE_ONLY = 3;
//使用this中的屬性
public static final int TO_SELF = 4;

通過(guò)5.3.1中的例子，我們也可以看出Groovy默認(rèn)使用的是OWNER_FIRST的委托策略

6.文件

groovy文件操作完全兼容java的文件操作，但groovy集成了自己的高階使用方式

• 讀文件：withReader

def file = new File('../../hello_groovy.iml')
def buf1 = file.withReader {reader ->
        char[] buf = new char[100]
        reader.read(buf)
        buf
}
println buf1

• 寫(xiě)文件：withWriter

//寫(xiě)文件：withWriter：實(shí)現(xiàn)文件拷貝操作
def result = copy('../../hello_groovy1.iml','../../hello_groovy.iml')    
println result
def copy(String desFilePath,String srcFilePath){
try {
    File desFile = new File(desFilePath)
    if(!desFile.exists()){
        desFile.createNewFile()
    }
    File srcFile = new File(srcFilePath)
    if(!srcFile.exists()){
        return false
    }else{
        srcFile.withReader {reader ->
            def lines = reader.readLines()
            desFile.withWriter {writer ->
                    lines.each {line ->
                            writer.write(line+'\\r\\n')
                    }
            }
            return true
        }
    }
}catch(Exception e){
    return false
}

}

• 讀對(duì)象：withObjectInputStream readObject

Groovy不僅可以寫(xiě)文件，還可以寫(xiě)入和讀取對(duì)象操作

//讀對(duì)象
def ob1 = readObject('../../person.bin')
println ob1
def readObject(String srcFilePath){
    try {
        File desFile = new File(srcFilePath)
        if(!desFile.exists()){
            return false
        }
        desFile.withObjectInputStream {
            def person = it.readObject()
            println person.name
        }
        return true
    }catch(Exception e){
            return false
    }
}

• 寫(xiě)對(duì)象：withObjectOutputStream writeObject

//寫(xiě)對(duì)象：
Person person = new Person(name: 'uihb',age: 32)
saveObject(person,'../../person.bin')

def saveObject(Object obj,String desFilePath){
    try {
        File desFile = new File(desFilePath)
        if(!desFile.exists()){
            desFile.createNewFile()
        }
        if(obj != null){
            desFile.withObjectOutputStream {
                    it.writeObject(obj)
            }
        }
    }catch(Exception e){
            return false
    }
}

7.Json

• 7.1：Object轉(zhuǎn)Json字符串轉(zhuǎn)

//1.Object 轉(zhuǎn)JSon
def personList = [
        new Person(name: 'lily',age: 12),
        new Person(name: 'lucy',age: 14),
        new Person(name: 'kare',age: 18)
]

def jsonPerson =  JsonOutput.toJson(personList)
println JsonOutput.prettyPrint(jsonPerson)

• 7.2：Json字符串轉(zhuǎn)Object

//2.JSon轉(zhuǎn)Object

def jsonSlurper = new JsonSlurper()
def obj = jsonSlurper.parseText(jsonPerson)
println(obj[0].name)

從網(wǎng)絡(luò)獲取Json數(shù)據(jù)操作：

這里引入OkHttp

def getNetWork(String url){
    OkHttpClient client = new OkHttpClient();
    Request request = new Request.Builder()
            .url(url)
            .get()
            .build();
    Call call = client.newCall(request)
    call.enqueue(new Callback() {
        @Override
        void onFailure(Request _request, IOException e) {

        }

        @Override
        void onResponse(Response response) throws IOException {
            def res = new String(response.body().bytes())
            println res
            JsonSlurper jsonSlurper1 = new JsonSlurper()
            Version objetres = (Version)jsonSlurper1.parseText(res)
            println  objetres.ecode
        }
    })
    sleep(10000)
}

class Version{
    int ecode
    String emsg
    CurrentVersion data
}
class CurrentVersion{
    String currentVersion
}