Gradle入门到实战(一) — 全面了解Gradle

本文目录

一、前言

从本篇起我们来系统学习一下Gradle相关知识，为什么要写本系列呢？因为我发现在平时工作中大部分开发同学只是仅仅会简单的配置Gradle，说白了就是用的时候配置一下，出问题查找一下然后配置上就完了，至于Gradle基本的工作流程完全不理解，其实我本人刚用AS开发的时候也是对Gradle完全不理解，甚至厌恶，为什么非要用这玩意？还要我花时间学习额外的玩意，但是当我慢慢熟悉Gradle之后就慢慢对其"刮目相看"了，简单，可扩展等方面非常友好，项目的构建我们可以编写一些自己的插件来完成一些重复无意义的操作。

本系列我会从最基本的groovy语言开始慢慢学习，直到最后编写我们自己的多渠道打包插件（美团也有同样功能的开源解决方案），图片压缩转换插件（jpg,png转换webp, 不能转换则进一步压缩），相信最后你一定会有所收获。

二、学习Gradle的基础—Groovy语言的学习

学习Geadle我们需要先来学习一下Groovy，很多同学估计听说过Groovy语言，有的也许没听说过，其实我们每天在配置Gradle的时候就是在跟Groovy接触了。

Groovy是一门jvm语言，最终编译成class文件然后在jvm上执行，Java语言的特性Groovy都支持，我们可以混写Java和Groovy，就是在同一文件中可以混写， 注意，这里与Java和Kotlin可不一样，Java和Kotlin是可以互相调用，而不能在同一文件混写 。

Groovy的优势是什么呢？Groovy增强了Java的很多功能。比如解析xml文件，文件读写等，Groovy只需要几行代码就能搞定，而如果用Java则需要几十行代码，简单说就是使用Groovy实现某些功能比Java要少些很多代码。

好了，说了那么多"废话"，下面就具体来了解一下Groovy语言，我们只需要了解其中核心的一些使用就可以了，没必要完全了解，作为一门语言Groovy也算比较复杂的，但是我们学习Groovy是为了编写Gradle插件那就只需要了解其核心部分就可以了，其实从我的经验来说学习Groovy更多是为了写更少的代码来实现一些功能，否则我直接用Java写不就完了。

关于Groovy环境的配置很简单，自己查询配置一下就可以了，使用自带的编辑器学习即可。

Groovy的变量和方法声明

Groovy使用def来声明变量，声明变量可以不加类型，运行的时候可以自动推断出变量类型，并且声明语句可以不加分号结尾，如下：

def  i = 10
def  str = "hello groovy"
def  d = 1.25

def同样用来定义函数，Groovy中函数返回值可以是无类型的：

//定义函数
def showName(){
    "wang lei" //最后一行执行结果默认作为函数返回值，可以不加return
}

如果我们指定了函数的返回值类型，那么可以不加def关键字：

//定义函数
String showName(){
    "wang lei" //最后一行执行结果默认作为函数返回值
}

Groovy的字符串

Groovy中字符串分为三种，我们一个个来看。
单引号字符串，单引号字符串不会对$号进行转义，原样输出，如下：

def i = 10
def str1 = 'i am $i yuan'//单引号不会转义
println str1 //输出  i am $i yuan

双引号字符串，双引号字符串会对$号进行转义，如下：

def i = 10
def str2 = "i am $i yuan"//双引号会转义
println str2 //输出  i am 10 yuan

三引号字符串，三引号字符串支持换行，原样输出，如下：

//三个引号原样输出
def str3 = '''
    public static void main(){
        println "miss you"
    }
'''
println str3

输出:

    public static void main(){
        println "miss you"
    }

Groovy的数据类型

Groovy数据类型主要包括以下三种：

• Java中基本数据类型
• 增强的List,Map,Range容器类
• 闭包

我们分别看一下

Groovy中的所有事物都是对象。int，double等Java中的基本数据类型，在Groovy中对应的是它们的包装数据类型。比如int对应为Integer。比如：

def x = 23
println x.getClass().getCanonicalName()//java.lang.Integer

def f = true
println f.getClass().getCanonicalName()//java.lang.Boolean

增强的List,Map,Range容器类

List
List：链表，其底层对应Java中的List接口，一般用ArrayList作为真正的实现 类。
使用如下：

def myList = [5,'werw',true]//看到了吧，可以放任意数据，就是那么任性
myList.add(34)
//myList.add(12,55)//这样会报角标越界异常
myList[6] = true
println myList.size()
//遍历
myList.each{
    println "item: $it"
}
myList.eachWithIndex {
    it, i -> // `it` is the current element,`i` is the index
    println "$i: $it"
}
println myList.getClass().getCanonicalName()

打印信息如下：

7
item: 5
item: werw
item: true
item: 34
item: null
item: null
item: true
0: 5
1: werw
2: true
3: 34
4: null
5: null
6: true
java.util.ArrayList

看到了吧，Groovy中List用起来方便多了，扩展了Java中的一些功能。

单独说明一下，List还有一种方式可以加入元素：<<操作。如下：

myList << 34//这样也是加入元素

刚接触是不是感觉很别扭，慢慢来，习惯就好了，对于<<文档描述如下：

一定要学会查文档来学习，而不是遇见问题就查询，向这种<< 只有文档才说的最明白，况且我这篇文章也只是写出来最核心的一些资料，如果你想实现一些功能而我没写出来就需要自己去查文档。

文档地址：The Groovy Development Kit 与 groovy 2.5.6 API

建议还是浏览一下文档，里面有很多好玩的东西

Map
直接看示例：

//Map类
def map = ['key1':true,name:"str1",3:"str3",4:"str4"]
println map.name // 相当于 map.get('name')
println map.get(4)
map.age = 14 //加入 age:14 数据项
println map.age //输出14
println map.getClass().getCanonicalName()
//遍历
map.each{
    key,value -> 
       println key +"--"+ value
    }
    
map.each{
    it -> 
       println "$it.key ::: $it.value"
    }
// `entry` is a map entry, `i` the index in the map
map.eachWithIndex { entry, i ->
    println "$i - Name: $entry.key Age: $entry.value"
}

// Key, value and i as the index in the map
map.eachWithIndex { key, value, i ->
    println "$i - Name: $key Age: $value"
}
    
println map.containsKey('key1')  //判断map中是否包含给定的key
println map.containsValue(1)  //判断map中是否包含给定的value
//返回所有
println map.findAll{
    entry ->
         entry.value instanceof String//value是String类型的
}
//返回第一个符合要求的
println map.find{
    entry ->
        entry.key instanceof Integer && entry.key > 1
} //返回符合条件一个entry

//清空
map.clear()

println map.size()

Ranges
关于Ranges文档描述如下：

简单来说Ranges就是对List的扩展，用…或者…<来定义，具体使用如下：

//Range
def Range1 = 1..10//包括10
println Range1.contains(10)
println Range1.from +"__"+Range1.to
def Range2 = 1..<10//不包括10
println Range2.contains(10)
println Range2.from +"__"+Range2.to
//遍历
for (i in 1..10) {
    println "for ${i}"
}

(1..10).each { i ->
    println "each ${i}"
}
def years = 23
def interestRate
switch (years) {
    case 1..10: interestRate = 0.076; break;
    case 11..25: interestRate = 0.052; break;
    default: interestRate = 0.037;
}
println interestRate//0.052

好了，以上就是Groovy中的容器类，最核心的我已经列出来了，如果想继续查看其余功能请自己查看文档，当初看完这部分我的感觉就是这尼玛不就是kotlin吗（学习Groovy之前已经看了Kotlin），二者其实都是对Java的扩展，使用起来都更加简单，功能更加强大，好了，学习Gradle，掌握以上就已经基本够用了。

Groovy中的闭包

闭包Closure一开始接触的时候真是有点蒙圈的感觉，这是什么玩意，Kotlin中也有这玩意，接触多了也就慢慢习惯了，其实就是一段可执行的代码，我们可以像定义变量一样定义可执行的代码。

闭包一般定义如下：

def xxx = {
	paramters -> 
		code
}

比如，我们定义一下闭包：

def mClosure = {
    p1,p2 ->
         println p1 +"..."+p2
}