2019-04-30

Android-gradle

VS maven ant

gradle 是基于groovy的编程语言，比maven，ant强大很多。

groovy

基本概念

属于领域特定语言（eg： matlab（计算） html（网页））解决特定问题的语言；

基于jvm，可以将groovy编译成.class在jvm上执行，也可以直接解释执行（js）；

结合了python，ruby等脚本语言的特性；

可以跟java完美结合，可以使用java库；

支持动态类型，闭包；

支持面向对象，也支持面向过程（写脚本）；

环境搭建

官网下载groovy—sdk；

安装jdk；

安装idea；

新建项目

idea中new project，选择groovy，指定groovy sdk即可；

语法

基本语法

变量类型：跟java一致，没有基本类型，自动装箱；

变量定义：def + 强定义自己用的话使用def，提供给外界用的话，使用强定义

int x = 10
println x.class

def y = 2.3
println y.class

def name = "name"
println name.class


结果：
class java.lang.Integer
class java.math.BigDecimal
class java.lang.String

package variable;
/***********字符串定义**********/

//三引号
def s = '''\
line one
line two
line three '''
println s
//可扩展字符串 GString
def s_1 = "this is a common String"

def temp = "temp"
def s_2 = "hello: ${temp}"

println s_1.class
println s_2.class

def sum2 = "2+3=${2 + 3}"
println sum2
//不需要强转
def result1 = echo(sum2)
println result1

String echo(String msg) {
    return msg
}

/**********字符串方法*************/
def str = "groovy"
println str.center(8, 'a')
println str.padLeft(8, 'a')

def str2 = 'vy'
println str > str2

println str[2]
println str2[0..1]

println str.minus(str2)
println str-str2

println str.reverse()

println str.capitalize()

def str3="1"
println str3.isInteger()
println str3.toInteger()

/**********swith case***********/
def x = 1.23
def result
switch (x) {
    case "foo":
        result = 'found foo'
        break;
    case [4, 5, '123']:
        result = 'list'
        break
    case 1..4:
        result = 'range'
        break
    case Integer:
        result = 'integer'
        break
    case BigDecimal:
        result = 'big decimal'
        break
    default:
        result = 'default'
        break;
}
println result

/**********for ***********/
def sum = 0
for (i in 0..9) {
    sum += i
}
println sum

for (i in [1, 2, 3]) {
    sum += i
}

println sum

for (i in ['lili': 1, 'zs': 3]) {
    sum += i.value
}

println sum

闭包

package variable
/**
 * 闭包
 */
/***************基础****************/
//箭头前面是参数，后面是方法体
def clouser = { String params, int age ->
    println "hello ${params} , ${age}"
}
clouser.call('clousure', 3)
clouser('clousure', 7)

def it = {
    println "hello ${it}"
}
it(1)

def re = { String name ->
    return "hello ${name}"
}
println re("clousure")

/**************进阶********************/
//求10的阶乘

int fab(int number) {
    int result = 1
    1.upto(number, { num -> result *= num })
    return result
}

println fab(5)

int fab2(int number) {
    int result = 1
    number.downto(1) {
        num ->
            result *= num
    }
    return result
}

println fab2(5)

//累加
int cal(int number) {
    int result = 0
    number.times {
        num -> result += num
    }
    return result
}

println cal(5)


def tes = "a.b.c"
println tes.substring(tes.lastIndexOf("."))
/***********字符串跟clousure结合**************/
String wzq = "wzq and zpy 1"
wzq.each {
    String temp ->
        print temp
}
println()

println wzq.find {
    String temp ->
        (temp == "d")
}

println wzq.findAll {
    String temp ->
        temp == "z"
}

println wzq.any {
    String s -> s.isNumber()
}

println wzq.every {
    String s -> s.isNumber()
}

def collect = wzq.collect {
    it.toUpperCase()
}
println collect.toListString()
/************进阶2*************/
//this owner delegate
def wzqClouser = {
    println this
    println owner
    println delegate
}
wzqClouser.call()

class Person {
    def  pClousure = {
        println this
        println owner
        println delegate
    }

    def  say() {
        def pClousure = {
            println this
            println owner
            println delegate
        }
        pClousure.call()
    }
}

def person = new Person()
person.pClousure.call()
person.say()

def outClousure={
    def innerClousure={
        println this //clousure
        println owner  //outClousure
        println delegate //outClousure
    }
    innerClousure.call()
}
outClousure.call()
//委托策略

class Student{
    String name
    def pretty ={"My name is ${name}"}

    String toString(){
        pretty.call()
    }
}

class Teacher{
    String name
}

def stu=new Student(name: "wzq")
def tea=new Teacher(name: "zpy")
stu.pretty.delegate=tea
stu.pretty.resolveStrategy=Closure.DELEGATE_FIRST
println stu.toString()

数据结构

List:

package variable

//定义list
def list = [1, 2, 3]
//定义数组
def array = [1, 2, 3] as int[]
int[] array2 = [1, 2]

//排序
def sortList=[2,4,1,-3]
Comparator mc={
    a,b->
        a==b?0:Math.abs(a)<Math.abs(b)?-1:1
}

Collections.sort(sortList,mc)
println(sortList)

sortList.sort {
    a,b->
        a==b?0:Math.abs(a)<Math.abs(b)?-1:1
}
println(sortList)

def stringList=["w","wa","f","fdaf",""]
stringList.sort{
    it.size()
}
println stringList


//查找
def findList=[-1,2,5,1,6,5]
def find = findList.find { a ->
    a > 3
}
println find
def all = findList.findAll {
    it > 2
}
println all.toListString()

def any = findList.any {
    it > 7
}
println any

def min = findList.min()
println min

def count = findList.count {
    it > 4
}
println(count)

Map:

package variable
//映射
def colors=[red:"ff0000",green:"00ff00"]

println colors['red']
println colors.green
colors.yellow="ffff00"
colors.temp=[a:1,b:2]
println colors.toMapString()
println colors.getClass()


//遍历
def students=[1:[name:'wzq',age:18],
            2:[name:'zpy',age:17],
            3:[name:'wrr',age: 20]]

students.each {key,value->
    println "${key}->${value}"
}
students.eachWithIndex{ entry, int i ->
    println "${i}->${entry.key}->${entry.value}"
}
//查找
def find = students.find { student ->
    return student.value.age > 17
}
println(find)

def all = students.findAll { student ->
    return student.value.age > 10
}
println(all.toMapString())

def collect = students.findAll { student ->
    return student.value.age > 10
}.collect { student ->
    return student.value.name
}
println(collect.toListString())

def by = students.groupBy { student ->
    return student.value.age > 17 ? "good" : "bad"
}
println(by.toMapString())
//排序
def sort = students.sort {
    student1, student2 ->
        return student1.value.age == student2.value.age ? 0 : student1.value.age < student2.value.age ? -1 : 1
}
println(sort.toMapString())

range：

package variable
//定义
def range= 1..10

println range[0]
//遍历
range.each {
    print(it)
}
println()
//swith-case
println(test(10))
def test(Number number){
    def result
    switch (number){
        case 0..<60:
            result="不及格"
            break
        case 60..100:
            result="及格"
            break
        default:
            break
    }
    return result
}

面向对象

package variable.clazz.study

/**
 @author kb_jay
 @time 2019/4/18
  * */
class Person implements Action {
    String name;
    int age;

    def sayHello() {
        println("${name}->${age} say hello")
    }

    @Override
    void play() {

    }

    @Override
    void eat() {

    }

    //运行时 1
    @Override
    Object invokeMethod(String s, Object o) {
        return "method->${s},args->${o}"
    }
}

//类的使用！！！！！！！
package variable.clazz.study

def person = new Person(name: "wzq", age: 18)

println(person.name)

person.sayHello()

//metaClass
def cry = person.cry()
println(cry)

//为类动态添加属性
Person.metaClass.sex='male'

def person1 = new Person(name: "wzq", age: 18)
println(person1.sex)

//动态添加方法
Person.metaClass.newMethod={return "${name}"}

println(person1.newMethod())
//动态添加静态方法
Person.metaClass.static.newStaticMethod={String name,int age->
    new Person(name:name,age:age)
}

def person2=Person.newStaticMethod("zpy",17)
println person2.name

进阶语法

json文件操作

package variable

import groovy.json.JsonOutput
import groovy.json.JsonParser
import groovy.json.JsonSlurper

//object -> jsonString
def list = [new Test(name: "wzq", age: 16), new Test(name: "zpy", age: 15)]

def json = JsonOutput.toJson(list)
def print = JsonOutput.prettyPrint(json)
println(print)


class Test {
    String name;
    int age;
}

//jsonString 2 object
def slurper = new JsonSlurper()
def text = slurper.parseText(json)
println text[0].name

//call net
def response=callNet('http://yuexibo.top/yxApp/course_detail.json')
println response.data.head.name 

def callNet(String path) {
    def connection = new URL(path).openConnection()
    connection.setRequestMethod("GET")
    connection.connect()

    def response = connection.content.text

    def slurper = new JsonSlurper()
    return slurper.parseText(response)
}

文件操作

package variable

//copy文件

def file = new File('../../HelloGroovy.iml')

def b = copy('../../HelloGroovy.iml', '../../HelloGroovy1.iml')
println(b)

def copy(String sourcePath, String desPath) {
    //    check des
    def destFile = new File(desPath)
    if (!destFile.exists()) {
        destFile.createNewFile()
    }
    // copy
    try {
        def sourceFile = new File(sourcePath)
        sourceFile.withReader { reader ->
            def lines = reader.readLines();
            destFile.withWriter { writer ->
                lines.each { line ->
                    writer.writeLine(line)
                }
            }
        }
        return true
    } catch (Exception e) {
    }
    return false
}

//copy Object

def saveObj(Object o, String desPath) {
    //    check des
    def destFile = new File(desPath)
    if (!destFile.exists()) {
        destFile.createNewFile()
    }
    //copy
    try {
        destFile.withObjectOutputStream { oos ->
            oos.writeObject(o)
        }
        return true
    } catch (Exception e) {
    }
    return false
}

def readObj(String path) {
    def obj = null;
    def destFile = new File(path)
    if (!destFile.exists()) {
        return null
    }
    try {
        destFile.withObjectInputStream { ois ->
            obj = ois.readObject();
        }
    } catch (Exception e) {
        println(e.getMessage())
    }
    return obj
}

def obj = new ObTest(name: "wzq", age: 18)
def save = saveObj(obj, '../../obj.bin')
println("save${save}")

def test = readObj('../../obj.bin')
println "${test.name}->${test.age}"

class ObTest implements Serializable {
    String name;
    int age;
}

Gradle

生命周期

初始化（init）：解析project，生成project对象
配置（config）：解析project的task，构建task的拓扑图
执行（exec）：执行task以及依赖的task

Project

根project跟module都是project，执行

1	./gradlew projects

属性

Task

Task 定义跟配置
Task执行
Task依赖跟执行顺序
Task的类型
挂接到生命周期
Task实战

Settings

SourceSet

 //修改jnilib->lib
sourceSets {
    main {
        jniLibs.srcDirs = ['libs']
    }
}
//资源分模块    
sourceSets {
    main{
        res.srcDirs = ['src/main/res',
                       'src/main/res-ad',
                       'src/main/res-player']
    }
}

自定义plugin

源码地址：https://github.com/kbjay/Kj_ReleasInfoPlugin