2018的年终总结被我活生生拖了这么多天,拖延症已经病入膏肓了.2018年是我工作的第一年,在这一年中我算过得比较顺利,在工作中成长了很多.这篇文章将会对去年做一个总结,并为今年做一些规划.

关于工作

熟悉我的朋友应该都知道我是去年毕业的,虽然没有进入BAT，但是我非常喜欢现在的公司，我所在的团队也很优秀．原谅我不能一一向每个人道谢，总之很感激在自己工作的第一年就能够遇到大伙.在这里真的很感谢我的导师，从我入职的第一天起就很照顾我，帮我迅速熟悉业务，为我讲解遇到的问题，是他让我快速成长，知道自己有哪些方便比较薄弱并知道该如何弥补．

关于技术

工作了才知道自己以前掌握的都是一些皮毛，也才知道业界有很多先进的成熟的方案，在工作的近一年内，团队内引入了很多新的技术方案，我在其中也学到很多，以下列举几项

Kotlin

关于Kotlin，我从今年下半年开始学习，前后看了《Kotlin实战》、《疯狂Kotlin讲义》以及极客时间的《快速手上Kotlin》，一开始学完之后虽然知道他的简介与威力，但却非常不适应，后面实战之后才发现，写了两天之后就再也不想用java了．我现在在项目中也已经大部分使用Kotlin进行编写了，有一些坑还没遇到，接下来我会写一个Kotlin系列的文章与大家一起分享Kotlin的魅力．

组件化

个人开发很少会需要组件化，只有在大的商业项目中才能见其优势．组件化是这两年比较火热的方向，我们团队也完成了组件化的工作，并在内部分享了组件化方案的实现原理以及遇到的坑，我私底下也看了业界目前的几个相对比较成熟的组件化方案，对其有了较深的理解.

Android碎片化适配

做Android开发的遇到最多的问题就是碎片化了,今年是Android全面屏手机百花齐放的一年,年初的刘海屏,到年中的水滴屏,到后面的滑盖屏以及最近的挖孔屏.OEM厂商在推出新机型的同时也给我们开发者增加了适配难度,尤其是手机屏幕宽高比以及异性全面屏还有AndroidP的适配,都非常不容易,我们团队去年上半年做了一轮适配,这不现在适配方案还是不全了,后续还会继续更新适配方案.

Android源码

程序开发远远不能停留在只会用上面,更需要理解背后的原理,那么看源码则是最好的一个方法.在工作中发现自己对Framework层的一些知识不太熟悉,这也导致在平时的工作中遇到一些问题不能自己分辨出来,而是需要通过搜索引擎需求帮助,如果对源码足够熟悉,那么就可以通过堆栈错误信息很快的查找到错误根源,也是沉淀自己技术水平的最佳方式.在源码方面,今年看了两本书:《Android进阶解密》和《深入理解 Android 卷I》,啃完之后发现真的能够有效提高工作效率

短视频&直播

短视频和直播是这两年比较火热的技术,不过技术原理还是在底层,我这种非科班出身的学起来还是比较吃力的,虽然团队内部进行了相关主题的分享,但是要真正掌握好还是需要自身多花时间学习.

关于博客

说起博客真的很惭愧,去年总共才更新了两篇,完全没有达到要求,当然原因也是存在的.今年4月份入职,工作之后才发现很难抽时间静下心来写文章,另一方面因为在工作的时候发现自己还有很多需要学习和进步的,所以周末会花时间在学习上,利用碎片时间学习效率也就没有那么高,也就很难再抽时间写文章.这一点我希望在新的2019年能够得到改善,不要再为没有时间找借口,只要是自己想做的事情,再没有时间也会抽出来的,等到写2019年年终总结的时候希望自己不要打脸.

关于旅游

今年公司的年度旅游去了日本东京和富士山,很幸运第一年入职就能去海外,日本干净的街道和富士山的美景真的很赞,大家有机会真的可以去玩一玩.

富士山

东京塔

关于其他

工作快一年了发现自己的肚子越来越大了,主要是没有太注重运动,为了避免自己太早进入油腻中年的行列中,新的一年希望自己多花点时间在运动上面,也希望大家都能够注意身体!

最后祝大家新的一年心想事成,越来越棒!!!

上一篇文章我们从整体上初步认识了Gradle，也说了Gradle的学习曲线，这篇文章我们就按照顺序来讲解Groovy语言。
需要说明的是这篇文章大部分内容是翻译自Groovy的官方文档，不过中间也有些许内容是我自己学习过程中总结整理的，如果大家英语好的话建议直接看英文文档。

这是一个系列的Gradle文章：

• 一口一口吃掉Gradle（一）：初识Gradle
• 一口一口吃掉Gradle（二）：深入学习Groovy

Groovy是一门什么语言

在Groovy的官网上有对Groovy的一段描述：

1

Groovy tries to be as natural as possible for Java developers. We’ve tried to follow the principle of least surprise when designing Groovy, particularly for developers learning Groovy who’ve come from a Java background.

大意是说Groovy就是为了JAVA程序员“量身定做”的，既然这么说的话，我们学习Groovy应该是比较容易的。当然事实也是如此，不过Groovy作为一门脚本语言，也有它与JAVA的区别之处，例如在JAVA中我们需要每一行都要分号作为结束标志，但是Groovy却可以省略；我们调用JAVA中的方法时需要使用括号，而Groovy中也可以省略。当然还有很多特点使得Groovy相比JAVA来说都是一门更简洁的语言。接下来我们就来了解一番。

搭建Groovy开发环境

尽管Gradle使用了Groovy作为开发语言，但是确切地说Gradle使用的是基于Groovy的领域特定语言(DSL)，也就是说Gradle只是使用了Groovy中的一些语法。所以当我们来了解Groovy时最好还是搭建Groovy的开发环境。

Linux环境下

1
2
3
4
5
6
7
8
9
10
11
12
13

## 到sdkman官网下载对应的安装shell script，然后调用bash解析器去执行
## 在这个过程中最好关闭代理
curl -s get.sdkman.io | bash

## 继续执行下面的命令
source ~/.sdkman/bin/sdkman-init.sh

## 安装Groovy
sdk install groovy

## 查看Groovy版本
groovy -version
Groovy Version: 2.4.14 JVM: 1.8.0_131 Vendor: Oracle Corporation OS: Linux

如果能够成功显示如上的Groovy版本则说明安装成功。

Windows环境下

点击这个连接到Groovy官网下载所需的版本，之后安装并设置环境变量即可。以上步骤完成之后同样在命令行中测试groovy -version，看看能够正确显示Groovy的版本号。

Groovy自带编辑器

使用终端或者命令行执行groovyConsole等待一下即可打开Groovy自带的编辑器，我们可以直接在上面写程序，之后使用快捷键Ctrl+R可以执行代码查看执行结果；使用快捷键Ctrl+W可以清空控制台的输出信息。另外需要了解的一点就是Groovy的代码需要保存在.groovy文件中。

注释

Groovy与JAVA有很多的相同点，在注释上尤为明显，举例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

//单行注释
println "single line comments" //注释可以位于语句后方

/* 多行
   注释 */
println "multiline comments" /*多行注释还可以
这样写*/
println 1 /*还可以写在语句中间*/ +2 /*没错，这样写也是可以的*/

//文档注释与JAVA类似
/**
 * 类说明
 */
class Person {
    /** 变量说明 */
    String name

    /**
     * 说明方法的含义
     *
     * @param 参数含义
     * @return 返回值含义
     */
    String greet(String otherPerson) {
       "Hello ${otherPerson}"
    }
}

//特殊的单行注释，这种注释通常是用来给UNIX系统声明允许脚本运行的类型的
#!/usr/bin/env groovy
println "Hello from the shebang line"

关键字

标识符

普通标识符

标识符以字母，美元符号或下划线开始。不能以一个数字开始。
合法标识符如下：

1
2
3
4

def name
def item3
def with_underscore
def $dollarStart

下面是一些非法标识符：

1
2
3

def 3tier
def a+b
def a#b

特殊一点的就是关键字在.之后的都可以作为合法的标识符：

1
2
3
4
5

foo.as
foo.assert
foo.break
foo.case
foo.catch

引用标识符

引用标识符是指出现在.表达式的后面，例如person.”name”中的name，一般的用法如下：

1
2
3
4
5
6
7

def map = [:]

map."an identifier with a space and double quotes" = "ALLOWED"// 向map添加一个键值对
map.'with-dash-signs-and-single-quotes' = "ALLOWED"// 向map再添加一个键值对

assert map."an identifier with a space and double quotes" == "ALLOWED"
assert map.'with-dash-signs-and-single-quotes' == "ALLOWED"

另外由于Groovy支持多种字符串表达方式(接下来会讲到)，所以以下的表达方式也都是允许的：

1
2
3
4
5
6

map.'single quote'
map."double quote"
map.'''triple single quote'''
map."""triple double quote"""
map./slashy string/
map.$/dollar slashy string/$

此外，由于Groovy提供了自己的String，称之为GString，他是一种有插值的字符串(即可以在字符串中引用其它变量)，所以以下的这些也算是合法的标识符：

1
2
3
4

def firstname = "Homer"
map."Simpson-${firstname}" = "Homer Simpson"

assert map.'Simpson-Homer' == "Homer Simpson"

字符串

Groovy中的字符串有两大类，第一种与JAVA的一样，即java.lang.String，另一种则是Groovy独有的：groovy.lang.GString，后者的作用就是可以在字符串中引用其他变量(即插值)。

单引号字符串

单引号字符串是普通的java.lang.String，不支持插值。

1

'a single quoted string'

三单引号字符串

三单引号字符串同样也是普通的java.lang.String，也是不支持插值。
三单引号字符串是可以跨行和保留所有的缩进：

1
2
3
4
5
6
7

def startingAndEndingWithANewline = '''
line one
line two
line three
'''
assert startingAndEndingWithANewline.startsWith('\n')
assert startingAndEndingWithANewline.endsWith('\n')

上述的字符串中第一行与最后一行都是换行，可见三单引号字符串是保留了所有的换行，而实际上，Groovy将其中的换行解释为\n，将所有的空白字符则是保留原样。
如果我们想要转义字符的话只要在需要转义的字符前方添加反斜杠\，例如我们想要去掉上方字符串的前后两个换行，则可以这样处理

1
2
3
4
5
6
7

def startingAndEndingWithoutANewline = '''\
line one
line two
line three\
'''
assert !startingAndEndingWithoutANewline.startsWith('\n')
assert !startingAndEndingWithoutANewline.endsWith('\n')

双引号字符串

双引号字符串稍微有点特殊，刚才我们说的插值就是在这里使用的，请看下方的例子：

1
2
3
4

def name = "Guillaume" // 普通字符串
def greeting = "Hello ${name}" // 含有插值的字符串

assert greeting.toString() == 'Hello Guillaume'

可以看到没有含有插值的字符串就是普通的JAVA字符串，含有的则是GString，他可以访问其他的变量，表达的方式有两种：${}和$，前者一般用于代替字符串或者表达式，后者则用于A.B的形式中，且也只能适用于这种形式中，如果表达式中含有例如括号，大括号，闭包(稍后讲解)等都是会报错的：

1
2
3
4
5
6
7
8
9
10
11

def sum = "The sum of 2 and 3 equals ${2 + 3}"
assert sum.toString() == 'The sum of 2 and 3 equals 5'

def person = [name: 'Guillaume', age: 36]
assert "$person.name is $person.age years old" == 'Guillaume is 36 years old'

def number = 3.14
shouldFail(MissingPropertyException) {
    // 这样写是会报错的，因为解释器会将其解释为："${number.toString}()"
    println "$number.toString()"
}

如果想要转义$或者${}占位符，只需要加上反斜杠\就行

1

assert '${name}' == "\${name}"

java.lang.String与groovy.lang.GString配合使用也是我们经常遇到的，在下面的例子中，takeString方法需要的参数是String类型的，但是我们传进去的却是GString类型的，此时GSTring的toString()方法会被调用。使得传入时能够保证类型一致。

1
2
3
4
5
6
7
8
9
10
11

String takeString(String message) { 
  assert message instanceof String 
  return message
}

def message = "The message is ${'hello'}" 
assert message instanceof GString 

def result = takeString(message) 
assert result instanceof String
assert result == 'The message is hello'

最后需要注意一点的就是，普通Java字符串是不可变的，而一个GString依赖于插入的值，它的String是可变的。即使有相同的字符串结果，GString和String也没有相同的hashCode，例如：

1

assert "one: ${1}".hashCode() != "one: 1".hashCode()

所以在选择Map的键值时我们应当避免选择GString，看看下面的例子你就清楚了：

1
2
3
4

def key = "a"
def m = ["${key}": "letter ${key}"]

assert m["a"] == null

其他字符串

Groovy中还有另外三种字符串，分别是：三双引号字符串、斜杠字符串、美元符修饰的斜杠字符串，由于这三种字符串用得比较少，这里就略过了，有兴趣的朋友可以直接到Groovy的官方文档中查阅。

列表List

由于Groovy中没有定义任何集合类，因此List也是沿用了java.util.List，其默认的实现则是java.util.ArrayList，不过我们也可以使用as关键字将其转换。
变量定义：List 变量由[ ]定义，比如：

1

def aList = [5,'string',true] //List 由[]定义，其元素可以是任何对象

变量存取：可以直接通过索引存取，而且不用担心索引越界。如果索引超过当前链表长度，List会自动往该索引添加元素

1
2
3
4
5
6
7
8

assert aList[1] == 'string' 
assert aList[-1] == true  //当索引为-1时表示倒数最后一个
assert aList[-2] == 'string'  //当索引为-2时表示倒数第二个，以此类推
assert aList[5] == null //第 6 个元素为空  
aList[100] = 100  //设置第 101 个元素的值为 100
assert aList[100] == 100
assert aList[0,2] == [5,true] // 一次访问两个元素，并返回一个包含这两个元素的新列表
assert aList[0..2] == [6,'string',true] // 使用范围访问列表中这个范围内的元素，从start到end元素位置

那么，aList 到现在为止有多少个元素呢？

1

println aList.size()  // 结果是 101

现在我们打算将ArrayList转换为其他的具体实现类

1
2
3
4
5
6
7
8

def arrayList = [1, 2, 3]
assert arrayList instanceof java.util.ArrayList // 默认情况下是ArrayLis

def linkedList = [2, 3, 4] as LinkedList // 使用as关键字将其转换为LinkedList
assert linkedList instanceof java.util.LinkedList 

LinkedList otherLinked = [3, 4, 5] // 声明的时候直接指定为LinkedList
assert otherLinked instanceof java.util.LinkedList

数组

数组的声明与List类似，且都是用[ ]来表示的，之所以不能像JAVA一样采用{}来初始化数组，是因为在Groovy中{}会被误解为闭包标志。我们需要通过类型转换或者类型定义来定义数组，与List不同的是，数组中的元素类型需要一致，并且数组的大小不能改变：

1
2
3
4
5
6
7
8
9
10
11
12

String[] arrStr = ['Ananas', 'Banana', 'Kiwi'] //可以在定义的时候直接指定为数组，

assert arrStr instanceof String[] 
assert !(arrStr instanceof List)

def numArr = [1, 2, 3] as int[] // 使用as关键字转换成数组

assert numArr instanceof int[] 
numArr[0] = 3
assert numArr[0] == 3

assert numArr.size() == 3

映射Map

变量定义：Map 变量由[:]定义，比如

1

def aMap = ['key1':'value1','key2':true]

Map 由 [:] 定义，注意其中的冒号。冒号左边是 key，右边是value。在Groovy中key 不一定是字符串，也可以是其他对象，value也可以是任何对象。另外，key 可以用’’或”” 包起来，也可以不用引号包起来。比如：

1
2
3
4
5
6
7
8
9
10
11
12

def aNewMap = [key1:"value",key2:true] //其中的 key1 和 key2 默认被处理成字符串 "key1" 和 "key2" 
assert aNewMap."key1" == "value"
```  


不过 key 要是不使用引号包起来的话，也会带来一定混淆，比如：

```groovy
def key1="wowo"
def aConfusedMap=[key1:"who am i?"]
//aConfuseMap 中的 key1 到底是"key1"还是变量 key1 的值“wowo”？显然，答案是字符串"key1"。如果要是"wowo"的话，则 aConfusedMap 的定义必须设置成：  
def aConfusedMap=[(key1):"who am i?"]

Map 中元素的存取更加方便，它支持多种方法：

1
2
3
4
5
6
7

def aMap = [key1:1,key2:2,key3:3,4:4]
assert aMap.key1 == 1  //这种表达方法好像 key1 就是 aMap 的一个成员变量一样  
assert aMap."key1" ==1   //因为我们将key1看成了字符串，因此也可以直接这样访问
assert aMap['key1'] ==1 //这种表达方法更传统一点  
assert aMap[4] ==4 //对于数字则需要使用这种方式来访问了
aMap.anotherkey = "i am map"  //为 map 添加新元素 
assert aMap == [key1:1, key2:2, key3:3, 4:4, anotherkey:"i am map"]

闭包

闭包的定义

闭包(Closure)是Groovy中一种非常重要的数据类型，他是一段可以执行的代码。定义的格式如下：

1
2

def xxx = {paramters -> code}  //参数可以是0个或者多个，每个参数之间用`,`分隔开；后面的代码可以一行也可以多行
def xxx = {无参数只有 code}  //这种没有参数的情况则不需要->符号

根据上面的格式我们再来看看几个具体的实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

{ item++ }                    //1                      
{ println it }                //2                     
{ it -> println it }          //3                      
{ name -> println name }      //4                       
{ -> item++ }                 //5                       
{ String x, int y ->                                
    println "hey ${x} the value is ${y}"   //6
}
{ String x, int y=6 ->                                
    println "hey ${x} the value is ${y}"   //7
}
{ reader ->                                         
    def line = reader.readLine()            //8
    line.trim()
}

上面的几个例子中：

• 1、闭包中引用了一个item变量，并做自增操作；
• 2、闭包中直接打印it变量，it变量是闭包中默认的参数，他就是第三行代码的缩减形式；
• 3、与上一行其实是一样的，这里只是显示的将it变量标了出来；
• 4、与第三行代码其实是一个道理只是将参数名字改了一下而已；
• 5、这里没有参数只有一个箭头符号与代码，这样写的意思就是闭包中没有任何参数，连默认的参数都没有，所以如果我们调用闭包的时候传入了参数，那么就会报错；
• 6、这个闭包定义了两个指定类型的参数，并在代码中使用插值引用了两个参数的值；
• 7、这个闭包相比上个闭包只是在参数定义上有了区别，在参数定义的时候可以指定默认值；
• 8、这个闭包定义了一个没有指定类型的参数，并且代码块中是可以有多个表达式的。

除此之外闭包也是groovy.lang.Closure类的实例，尽管它是一个代码块，但是它可以赋给一个变量或者一个属性作为其他的变量，请看如下的实例：

1
2
3
4
5
6

def listener = { e -> println "Clicked on $e.source" }   //1   
assert listener instanceof Closure                       
Closure callback = { println 'Done!' }                   //2                      
Closure<Boolean> isTextFile = {                          //3
    File it -> it.name.endsWith('.txt')               //4      
}

上面的几个例子中：

• 1、闭包是可以赋值给一个变量的；
• 2、如果不使用def关键字来声明变量，我们可以把闭包赋值给一个groovy.lang.Closure类型的变量；
• 3、我们可以指定闭包的返回类型，这里的返回类型为Boolean，当然这个是可选的。
• 4、闭包中代码的最后一行就是闭包的返回值，也可以显示的使用return关键字，也可以不写。

闭包的调用

调用闭包有两种方式：

1
2
3
4
5
6
7

def isOdd = { int i-> i%2 == 1 }  //1                      
assert isOdd(3) == true           //2                             
assert isOdd.call(2) == false     //3

def isEven = { it%2 == 0 }        //4                               
assert isEven(3) == false         //5                               
assert isEven.call(2) == true     //6

总结来说就是闭包对象.call(参数)或者直接闭包对象.(参数)，第4行中是省略了闭包参数的写法，直接使用it来代替，所以我们调用的时候需要传入一个参数。
当闭包作为闭包或方法的最后一个参数，可以将闭包从参数圆括号中提取出来只接在最后；如果闭包或者方法有一个参数且该参数为闭包，那么可以直接省略掉闭包或方法的圆括号；又如果闭包或者方法的参数中有多个闭包，并且这些闭包必须都要排在参数列表中的最后，则此时这些闭包可以依次写在圆括号外：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

def testClosure={param,c -> c(c(param))}            //1
def testMethod(a1, b1, closure){                    //2
      closure() //调用闭包  
}

assert testClosure(5){it*3} == 45                   //3
testMethod(1,'test'){println("i am in closure")}    //4

def testClosure2={c -> c()}                         //5
def testMethod2(a1, b1, closure, closure2){         //6
      closure() // 调用闭包1
      closure2() // 调用闭包2
}

assert testClosure2{"i am in testClosure2"} == "i am in testClosure2"         //7
testMethod2(1,'test')
    {println("i am in closure")} 
    {println "i am in closure2"}                    //8

在上面的例子中：

• 1、闭包c是作为闭包testClosure的最后一个参数；
• 2、闭包closure作为方法testMethod的最后一个参数；
• 3、在调用闭包testClosure时，可以将闭包c写在圆括号外，圆括号内只需要填写其他参数即可；
• 4、同样的道理，闭包写在圆括号外面。
• 5、当定义方法或者闭包时只有一个参数，且参数为闭包；
• 6、当定义的方法或者闭包的参数列表中有多个闭包，并且这些闭包需要排列在参数列表的末尾；
• 7、调用testClosure2闭包时可以直接省略闭包的圆括号，这种方式也适用于方法；
• 8、调用testMethod2方法时可以直接将闭包写在圆括号外面，多个闭包以此排列并且不需要使用,将每个闭包分隔开，这种方式也适用于闭包。

闭包的可变参数

闭包可以像其它方法那样声明一个可变的参数列表。当参数列表的最后一个参数的长度是可变的时候（或者是一个数组），那么这个闭包就能接收数量不定的参数，请看下面的实例：

1
2
3
4
5
6
7
8
9

def concat1 = { String... args -> args.join('') }        //1   
assert concat1('abc','def') == 'abcdef'                  //2  
def concat2 = { String[] args -> args.join('') }         //3   
assert concat2('abc', 'def') == 'abcdef'

def multiConcat = { int n, String... args ->             //4   
    args.join('')*n
}
assert multiConcat(2, 'abc','def') == 'abcdefabcdef'

上面的例子中：

• 1、闭包可以接收数量可变的String参数；
• 2、可以在调用时使用任意数量的参数，而且不用被包装成一个数组；
• 3、使用数组也能达到同样的效果；
• 4、只要最后一个参数是一个数组或者可变长度的的参数类型即可。

在GString中使用闭包

之前我们讲到GString与传统的java.lang.String的区别，而在GString中使用闭包一般有两种情形：

1
2
3
4
5
6
7
8
9
10

def x = 1
def gs1 = "x = ${x}"          //1
assert gs1 == 'x = 1'         //2

def gs2 = "x = ${-> x}"       //3
assert gs2 == 'x = 1'         //4

x = 2         //5
assert gs1 == 'x = 1'         //6
assert gs2 == 'x = 2'         //7

上面例子中的第一行以及第三行就是在GString中使用闭包的两种情形，严格意义上来讲，第一行代码中的${}并不是闭包，而只是一个插值的符号。
在注释1与注释3中定义了两个GString之后我们在注释2以及注释4中验证了他们的结果，这个结果也确实与我们预料中的一致。
但是接下来的注释5中，我们修改了变量x的值，将其改为2，现在再来看看两个GString的结果，发现采用${}的结果不变，而使用了闭包${->}的则会更新结果，这究竟是为什么呢？
这个主要是因为Groovy对两种符号的加载方式不一样，前者${}名字叫做eagerGString，它的值在GString被创建时就已经确定了，并且一直指向旧的这个对象，当我们去改变他所引用的x对象时，它是不会更新的；而在后者${->}中，Groovy采用了懒加载(lazy evaluation)的方式，即每次GString转换为String的时候都会再次调用闭包，因此它就可以更新。
下面我们再来看一下两个实例加深一下对两者的理解：

1
2
3
4
5
6
7
8
9
10
11
12
13

class Person {
    String name
    String toString() { name }              
}
def sam = new Person(name:'Sam')           
def lucy = new Person(name:'Lucy')      
def p = sam                //1                 
def gs = "Name: ${p}"                //2           
assert gs == 'Name: Sam'             //3           
p = lucy                //4    
assert gs == 'Name: Sam'             //5        
sam.name = 'Lucy'                    //6    
assert gs == 'Name: Lucy'            //7

上面的代码中：

• 1、首先将对象sam赋值给变量p；
• 2、使用了插值符号来调用对象的toString()方法；
• 3、很显然返回的名字是Sam；
• 4、如果将lucy赋值给p变量；
• 5、其依旧指向p变量之前指向的旧对象而不会因为p所指的对象的改变而改变GString的值；
• 6、但是如果我们只是改变了旧对象的属性；
• 7、那么很显然GString的值还是会更新的。
• 因此如果使用的是${}的形式，那么改变所指的对象是不能更新GString的值，但是改变对象的属性的话是可以的。

1
2
3
4
5
6
7
8
9
10
11
12

class Person {
    String name
    String toString() { name }
}
def sam = new Person(name:'Sam')
def lucy = new Person(name:'Lucy')
def p = sam
// Create a GString with lazy evaluation of "p"
def gs = "Name: ${-> p}"
assert gs == 'Name: Sam'
p = lucy
assert gs == 'Name: Lucy'

同样的例子，如果是选择了${->}的形式，那么改变所指的对象是可以更新GString的值的，这就是两种形式的区别。

方法

方法的声明

Groovy中的方法与JAVA的差别不大，声明方法时可以加上一个返回值的类型，或者直接使用def关键字而无需标注返回值类型，采用这种方法的时候方法的返回值类型的不固定的。方法可以接收任意数量的参数，并且参数的类型可以是无类型的也可以是有类型的还可以是有默认值的。我们在java中使用的一些修饰方法的关键词都是可以用来修饰Groovy中的方法，但是在Groovy中默认情况下不适用任何访问修饰词的情况下是代表public的。
最后需要再说一下的是，Groovy中的方法总是会返回值的，如果方法中没有return语句，那么方法中的最后一行将会是该方法的返回值，具体的可以看下面的例子。

1
2
3
4
5
6
7
8

def someMethod() { 'method called' } //没有参数也没有return关键字并且使用def来声明方法                     
String anotherMethod() { 'another method called' } //方法的返回值确定         
def thirdMethod(param1) { "$param1 passed" } //方法接收参数，并且参数的类型是未确定的         
static String fourthMethod(String param1) { "$param1 passed" } //静态方法，并且参数是有类型的
//方法接收三个参数，第一个是无类型的，第二个是String类型，第三个是int类型并且默认值是6
String fifthMethod(param1,String param2,int param3 = 6) {"$param1,$param2,$param3"}   
assert fifthMethod(1,"111") == "1,111,6" //如果调用的时候不传入默认的那个参数，则返回结果就会继续使用默认值
assert fifthMethod(1,"111",5) == "1,111,5" //如果传入了第三个参数，那么默认值将会被覆盖

可变参数的方法

在讲闭包的时候我们已经讲到了可变参数，方法中的可变参数与闭包的一致，这里就不再赘述，下面讲一下两种特殊情况：

• 当方法接收可变参数时，我们调用方法时传入的参数为null

1
2
3

def foo(Object... args) { args }      //1
assert foo(null) == null              //2
asser foo(null,null) == [null,null]   //3

我们声明的方法foo，他接收一个可变参数，在第二行中我们传入一个null，此时返回的是空，这里的空并不是一个包含null元素的长度为1的数组；但是在第三行中当我们传入了两个null时，却发现返回的确实长度为2的包含两个null元素的数组。这种情况是需要我们在实践中注意的。

• 当可变函数方法遇到重载方法时

1
2
3
4
5

def foo(Object... args) { 1 }
def foo(Object x) { 2 }
assert foo() == 1               //1
assert foo(1) == 2              //2
assert foo(1, 2) == 1           //3

在这里只需要注意注释2即可，在注释2中我们传入的参数只有一个，但是两个重载的函数都符合我们的参数数量，这个时候Groovy会选择最为确切的方法来调用，两个方法中一个是可变参数，一个是接收一个参数，当然是后者更为确切了，所以后者被调用。因此遇到这种情况时，函数数量最符合的函数将会被调用。

变量

Groovy中的变量我们需要分成两类，一类叫做变量(Field)，一类叫做属性(Property)，尽管我们在JAVA中可以认为这两个其实就是一种东西，但是在Groovy中他们还是有稍微的区别的。

变量(Field)

• 变量是可以使用访问修饰符的(如 public，protected，private)
• 可以使用零个或多个修饰符(如 static，final，synchronized)
• 类型是可选的，即可以声明类型也可以声明为无类型

如下面的实例：

1
2
3
4
5
6
7

class Data {
    private int id =1                                
    protected String description                    
    public static final boolean DEBUG = false       
    private mapping                       //最好不要声明为无类型的
    private Map<String,String> mapping1   //最好在声明时加上确切的类型
}

尽管Groovy中支持在变量声明的时候声明为无类型，不过这并不是一个好的编程习惯，Groovy官方推荐我们最好在声明时指定类型。

属性(Property)

属性与变量有些许的区别，区别在于它不可以使用访问权限修饰符(public，protected，private)，它的声明格式应该如下：

1
2
3
4

class Person {
    String name                             
    int age                                 
}

Property与Field的区别在于，前者会默认为属性添加setter和getter方法，例如下面的这个例子就可以看出两者的区别：

1
2
3
4
5
6
7
8
9
10
11

class A {
    public String field             //1

    String property                 //2

    /* 
         private String property
         public void setProperty(String property) { ... }
         public String getProperty() { ... }
    */
}

上面的代码中注释1中创建了一个变量，那它就只是创建了一个变量而已；但是注释2中创建了一个属性，而它的作用则相当于接下来三行注释中的代码，即创建了一个private的同名的变量，以及public的setter与public的getter方法。尽管两种声明的方式原理不一样，但是我们访问这两者的方式却是可以一样的，如下所示:

1
2
3

def a = new A()
println a.field             //1
println a.property        //2

上面的代码中第一行没有疑问，因为field变量是public的，但是第二行中property却是private，那为什么可以这样去访问到它呢？因为实际上当调用a.property时，调用的是a.getProperty()或者是setProperty(String property)。
下面再讲一个特殊的情况，就是使用final关键词来修饰的属性(property)是只读的，也就是说他只有getter方法没有setter方法，来看下面的实例：

1
2
3
4
5
6
7
8
9
10
11
12

class Person {
    final String name                   
    final int age                       
    Person(String name, int age) {
        this.name = name                
        this.age = age                  
    }
}

def p = new Person('TOM',13)
assert p.name == 'TOM'        //1
p.name='TONY'                 //2

上面的代码中注释1处中的p.name实际上是调用了p.getName()函数，但是注释2处却会报groovy.lang.ReadOnlyPropertyException异常，因为被final修饰的属性是不会生成setter方法的，因此当我们要设置这个变量的值时就会报错。

接下来最后一个需要注意的点是Groovy很贴心的一个功能，即只要我们按照Java Bean的规范声明了属性的getter和setter方法，那么我们就不需要再去声明这个变量了，我们就可以直接用对象.属性的方法来访问这个属性了，具体的方法我们看下面的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class PseudoProperties {
    // 属性"name"可读可写
    void setName(String name) {}
    String getName() {'Foo'}

    // 属性"age"只可读
    int getAge() { 42 }

    // 属性"groovy"只可写
    void setGroovy(boolean groovy) {  }
}
def p = new PseudoProperties()
p.name = 'Foo'           //1    
assert p.name == 'Foo'   //2    
assert p.age == 42       //3           
p.groovy = true          //4

上面的代码中其实声明了三个变量，只是这三个变量的访问权限不一样而已，在注释1处我们可以设置name的值，注释2可以访问name的值，但是我们却只能访问age的值并不能设置它的值，同理我们也只能设置groovy的值但是不能访问。

变量的作用域

在Groovy中变量是有作用域的，普通的Groovy类与JAVA类的变量作用域一致，但是有的时候我们也可以直接写Groovy脚本，即不用定义类直接写代码，这个时候的作用域就不太一样了。下面我们来看看实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import groovy.transform.Field   //不导入则无法使用Field注解

String hello = "hello"          //定义变量，作用域是本地域
def world = "world"             //定义变量，作用域是本地域
helloworld = "hello world"      //全局变量，作用域是绑定域
@Field a = 'I am A'             //定义一个全局变量a

void check() {
    println hello                         //1报错
    println world                         //2报错
    assert helloworld == "hello world"                         //3
    assert a == "I am A"                         //4
    
}
check()

解释上面的代码之前我们需要了解一下在Groovy脚本中定义的变量有两种作用域，分别是绑定域(Binding Scope)和本地域(Local Scope)。
本地域
本地域是脚本中使用 def 定义的动态类型变量或用特定类型定义的静态类型变量的作用域。
绑定域
绑定域为没有任何前缀修饰的变量的作用域。
例如在上面的代码中，hello与world变量的作用域就是本地域，而helloworld的作用域为绑定域。
两者的区别是什么呢？因为Groovy脚本会被编译成一个类，类名为文件名，该类继承自groovy.lang.Script类，我们刚才讲到的本地域变量会被声明在该类的run()方法内部作为临时变量，它只能在定义它的代码块中被调用，而不能在其他代码块(其他方法)中被调用；绑定域其实也是被声明在run()方法内部的，但是他会被当做参数传递给调用它的方法，所以实际上的我们就可以理解为我们可以在其他方法中调用绑定域的变量。

通过上面的解释，我们可以清楚的看到上面的代码中注释1处和注释2处之所以会报错就是因为访问不到变量，而注释3则是可以访问到的。
还有最后一个就是注释4，首先a变量定义前先导入了Field注解，并在使用的时候显示的引用注解，这个时候a变量就变成了一个全局变量，这是因为a变量在编译之后被声明在了类的层级中，即我们在JAVA中所说的全局变量，既然是全局变量，那么所有的方法都是可以访问到他的。
这里需要注意的就是使用@Field注解与使用绑定域的结果尽管是一致的但是原理却是不同的，我们可以使用jd-gui这个可以将class字节码转换为java代码的软件查看上述代码编译之后的情况来验证我们上面的说法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

...
public class field_scope extends Script
{
  Object a;

  public field_scope()
  {
    String str = "I am A";
    this.a = str;
  }

  public field_scope(Binding context)
  {
    super(context);
    String str = "I am A";
    this.a = str;
  }

  public static void main(String[] args)
  {
    CallSite[] arrayOfCallSite = $getCallSiteArray();
    arrayOfCallSite[0].call(InvokerHelper.class, field_scope.class, args);
  }

  public Object run()
  {
    CallSite[] arrayOfCallSite = $getCallSiteArray(); 
    String hello = "hello";
    Object world = "world";
    String str1 = "hello world"; 
    ScriptBytecodeAdapter.setGroovyObjectProperty(str1, field_scope.class, this, (String)"helloworld");
    null;

    if ((__$stMC) || (BytecodeInterface8.disabledStandardMetaClass())) 
    { 
      return arrayOfCallSite[1].callCurrent(this); 
    } 
    else 
    { 
      check(); 
      return null; 
    } 
    return null;
  }

  public void check()
  {
    CallSite[] arrayOfCallSite = $getCallSiteArray(); 
    arrayOfCallSite[2].callCurrent(this, arrayOfCallSite[3].callGroovyObjectGetProperty(this));
    arrayOfCallSite[4].callCurrent(this, arrayOfCallSite[5].callGroovyObjectGetProperty(this));
    ValueRecorder localValueRecorder1 = new ValueRecorder();
    try
    {
      Object tmp64_59 = arrayOfCallSite[6].callGroovyObjectGetProperty(this); 
      localValueRecorder1.record(tmp64_59, 8);
      Object tmp73_64 = tmp64_59; 
      localValueRecorder1.record(tmp73_64, 8);
      boolean tmp87_84 = ScriptBytecodeAdapter.compareEqual(tmp73_64, "hello world"); 
      localValueRecorder1.record(Boolean.valueOf(tmp87_84), 19); 
      if (tmp87_84) 
        localValueRecorder1.clear(); 
      else 
        ScriptBytecodeAdapter.assertFailed(AssertionRenderer.render("assert helloworld == \"hello world\"    //3", localValueRecorder1), null);  
    }  

    finally { localValueRecorder1.clear(); throw finally; }
    ValueRecorder localValueRecorder2 = new ValueRecorder();
    try
    {
      Object tmp139_136 = this.a; localValueRecorder2.record(tmp139_136, 8);
      Object tmp148_139 = tmp139_136; localValueRecorder2.record(tmp148_139, 8);
      boolean tmp162_159 = ScriptBytecodeAdapter.compareEqual(tmp148_139, "I am A"); 
      localValueRecorder2.record(Boolean.valueOf(tmp162_159), 10); 
      if (tmp162_159) 
        localValueRecorder2.clear(); 
      else 
        ScriptBytecodeAdapter.assertFailed(AssertionRenderer.render("assert a == \"I am A\"                  //4", localValueRecorder2), null);  
    } 
    finally { localValueRecorder2.clear(); throw finally;}
  }
}

类

上面说到Groovy其实是可以不用定义类的，这也符合脚本语言的特性。不过如果是比较复杂的工程，为了能够系统的管理代码，我们还是需要为其定义类。定义类的方法与JAVA类似，但是不需要使用public关键字，因为在Groovy中默认就是public，不仅仅是类，方法与变量也是这样的。我们先用下面的代码来看看Groovy语言的特点。

1
2
3
4
5
6
7
8
9
10
11
12
13

class Language{
    def name
    def difficulty
    
    String toString(){
        "$name,$difficulty"
    }
}

def java_lan =new Language()
java_lan.setName "JAVA"
java_lan.difficulty = 5
println java_lan

上面的代码相信大家现在是可以看得懂的啦，下面我们再讲一下关于Groovy中的类其他需要注意的事项：

• 类中无须定义构造方法

在Groovy的类中，其实有两个默认的构造方法，一个是无参的，一个是带有map参数的构造函数，所以实际上我们有什么函数只需要通过这个带有map参数的函数传递即可，请看下面的实例：

1
2
3
4
5

def java_lan =new Language()
java_lan.setName "JAVA"
java_lan.difficulty = 5

def groovy_lan = new Language(["name":"Groovy","difficulty":5])

• import的用法

import语句与JAVA很相似，但是也增加了一些新的特点

1
2
3
4
5
6
7
8
9
10
11
12
13
14

//包声明
package com.bob.groovy.test

//import语句1
import groovy.json.JsonBuilder
def json1 = new JsonBuilder()

//import语句2
import groovy.json.*
def json2 = new JsonBuilder()

//import语句3，使用as关键字取别名
import static Calendar.getInstance as now
assert now().class == Calendar.getInstance().class

不过要特别注意，Groovy与Java类似，已经帮我们默认导入了一些常用的包，所以在我们使用这些包的类时就不用再像上面那样导入了，如下是自动导入的包列表：

1
2
3
4
5
6
7
8

import java.lang.*
import java.util.*
import java.io.*
import java.net.*
import groovy.lang.*
import groovy.util.*
import java.math.BigInteger
import java.math.BigDecimal

2018年的第一篇文章将会给大家介绍Gradle，这会是一个系列的文章，名字依旧是一口一口吃掉。
相信很多朋友都和我一样从eclipse转到Android Studio时是又爱又恨，爱是因为Android Studio功能强大，UI也很炫酷，当然还有Google爸爸支持；恨是因为从比较熟悉的eclipse一下子转到了Android Studio，本以为速度会快很多，然而现实却给了自己一记大耳光，其次就是Android Studio采用了Gradle来对项目进行编译，但是Gradle是个啥鬼咯，配置文件又看不懂，首次编译还得下载，下载速度贼慢，不fq就gg。
Android Studio现在已经更新到3.0.1.0，如果你对Gradle还不是很熟悉，那这个系列的文章将会帮到你。相信仔细看完整个系列之后你将会对如何在Android开发中使用Gradle得心应手。祝你好运，我们出发吧！

何为Gradle

在了解Gradle之前，我们来讲讲在Gradle之前我们构建Android程序的时候使用的最多的是Ant以及Maven，我们简单看看三者有什么区别。

Ant

Ant是在2000年的时候发布的，因其简单易学的特点很快就成为了十分流行的Java项目的构建工具。
Ant的优点就是：

• 简单、易学，不需要什么特殊准备就能上手
• 基于过程式编程思想使得构建非常灵活

不足之处就是使用XML作为脚本配置格式，如果项目比较大的话，XML文件将会很难管理。

Maven

Maven是在2004年的时候发布的，他的出现在一定程度上解决了Ant的一些缺点。但是Maven同样沿用了Ant的做法：即把XML作为构建配置的文件格式，不过文件结构却有了巨大的变化：

• Ant需要开发者将执行task所需的全部命令都列出来
• 而Maven依靠约定并提供现成的可调用的目标
• 不仅如此，Maven更重要的一个进步是具备从网络上自动下载依赖的能力（当然Ant后来通过Ivy 也具备了这个功能）。

Maven的缺点就是：

• 依赖管理不能很好地处理相同库文件不同版本之间的冲突（Ivy在这方面更好一些）
• XML作为配置文件的格式有严格的结构层次和标准，定制化目标很困难

Gradle

Gradle则是在2012年发布的，它吸收了前两者的优点并极大的改进了他们的缺点，使其成为了Google官方推荐的构建语言。Gradle最大的改进就是摒弃了XML而是使用了一门基于java的Groovy语言作为构建脚本的书写语言，使得原本采用XML、冗杂得难以维护的配置文件变得清爽强大许多。

如果你还想对三者的对比有一个更直观的印象，可以查看这篇文章了解更详细的内容。这篇文章介绍了完成同一任务，三个构建工具的代码如下：
Ant的ivy.xml文件

1
2
3
4
5
6
7

<ivy-module version="2.0">  
    <info organisation="org.apache" module="java-build-tools"/>  
    <dependencies>  
        <dependency org="junit" name="junit" rev="4.11"/>  
        <dependency org="org.hamcrest" name="hamcrest-all" rev="1.3"/>  
    </dependencies>  
</ivy-module>

Ant的build.xml文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

<project xmlns:ivy="antlib:org.apache.ivy.ant" name="java-build-tools" default="jar">  
    <property name="src.dir" value="src"/>  
    <property name="build.dir" value="build"/>  
    <property name="classes.dir" value="${build.dir}/classes"/>  
    <property name="jar.dir" value="${build.dir}/jar"/>  
    <property name="lib.dir" value="lib" />  
    <path id="lib.path.id">  
        <fileset dir="${lib.dir}" />  
    </path>  
   
    <target name="resolve">  
        <ivy:retrieve />  
    </target>  
   
    <target name="clean">  
        <delete dir="${build.dir}"/>  
    </target>  
   
    <target name="compile" depends="resolve">  
        <mkdir dir="${classes.dir}"/>  
        <javac srcdir="${src.dir}" destdir="${classes.dir}" classpathref="lib.path.id"/>  
    </target>  
   
    <target name="jar" depends="compile">  
        <mkdir dir="${jar.dir}"/>  
        <jar destfile="${jar.dir}/${ant.project.name}.jar" basedir="${classes.dir}"/>  
    </target>  
   
</project>

Maven的pom.xml文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

<project xmlns="http://maven.apache.org/POM/4.0.0"  
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">  
    <modelVersion>4.0.0</modelVersion>  
    <groupId>com.technologyconversations</groupId>  
    <artifactId>java-build-tools</artifactId>  
    <packaging>jar</packaging>  
    <version>1.0</version>  
   
    <dependencies>  
        <dependency>  
            <groupId>junit</groupId>  
            <artifactId>junit</artifactId>  
            <version>4.11</version>  
        </dependency>  
        <dependency>  
            <groupId>org.hamcrest</groupId>  
            <artifactId>hamcrest-all</artifactId>  
            <version>1.3</version>  
        </dependency>  
    </dependencies>  
   
    <build>  
        <plugins>  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-compiler-plugin</artifactId>  
                <version>2.3.2</version>  
            </plugin>  
        </plugins>  
    </build>  
   
</project>

Gradle的build.gradle文件则只需要如下代码即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

apply plugin: 'java'  
apply plugin: 'checkstyle'  
apply plugin: 'findbugs'  
apply plugin: 'pmd'  
   
version = '1.0'  
   
repositories {  
    mavenCentral()  
}  
   
dependencies {  
    testCompile group: 'junit', name: 'junit', version: '4.11'  
    testCompile group: 'org.hamcrest', name: 'hamcrest-all', version: '1.3'  
}

单单从代码量上做一个选择的话，相信大家都会选择Gradle吧！

Gradle有啥作用

我们一直在说Gradle是一个构建工具，可是构建(build)究竟是个啥意思呢？我们以Android平台为例，构建就是将我们的代码，资源文件进行打包，编译最后形成一个可以安装运行的apk文件的过程。如果你还不是很了解，那么我们来瞧瞧Google官方给出的Android应用程序构建的完整流程图吧！

典型 Android 应用模块的构建流程

1
2
3
4

将程序中的以及引用的第三方库中的资源文件、代码文件、和aidl文件通过java编译器编译成.class文件，再通过dex工具将.class文件转换为.dex文件。
使用apkbuilder工具将所有未编译的资源（如图片），已编译的资源和.dex文件打包到.apk文件中。
jarsigner工具使用调试密钥或正式发行版本的秘钥将.apk文件签名。
使用zipalign工具对齐.apk包中的文件，以减少其在设备上运行时的内存占用。

以上的每个步骤就是构建工具需要完成的，也就是说这其中的许多事情都是由Gradle来干的。所以说没有Gradle那就需要我们手动一个步骤一个步骤做，有了构建工具，程序员只需要动动手指就可以啦！

搭建Gradle开发环境

工欲善其事,必先利其器，想要了解并且使用Gradle，我们得先把开发环境搭建起来。

下载

下载的方法有很多种，这里介绍的是适用于各个平台的，首先需要到Gradle官网，然后找到你想要的版本下载即可。需要注意的是Gradle官网的服务器在国外，所以下载速度贼慢，最好是能够自备梯子，否则你需要耐心等待一段时间。
在这个页面中你会看到同一个版本号也有几个版本，如：-src对应的是Gradle源代码，这个不是我们需要下载的；-bin对应的是二进制版本，但不包含源代码，文档等，体积相对较小；-all版本是完全版，既包含了编译需要的二进制文件，也包含了源代码和开发文档等。
推荐大家一开始可以下载一个-all版本作为你主要使用的版本，如果你需要使用到其他版本号的，再去下载其他版本号对应的-bin版本，这样可以节省磁盘空间。当然如果你只安装了-bin版本，你可以到这里查看在线的官方文档，在这里查看Gradle的源代码。

解压&配置环境变量

下载完成之后需要解压，以-all版本为例，解压之后的目录结构如下图所示：

gradle-4.1-all目录结构图

1
2
3
4
5

vim /etc/profile
## 将"/usr/local/gradle-4.3"替换为你解压好的gradle的根目录
export GRADLE_HOME=/usr/local/gradle-4.3
PATH=$PATH:$GRADLE_HOME/bin
source /etc/profile

Windows系统下
在环境变量配置页面新增一个系统变量GRADLE_HOME，值为你解压好的gradle的根目录；接着修改Path变量，在最后追加%GRADLE_HOME%\bin;，之后点击应用，确定即可。

配置好之后需要测试一下Gradle的开发环境是否搭建成功，在linux下打开终端，在Windows下则是打开命令行，输入gradle -v然后回车，如果输出的信息与下面类似那就说明Gradle的开发环境已经搭建成功啦！

1
2
3
4
5
6
7
8
9
10
11
12

bob@bob-PC:~$ gradle -v
------------------------------------------------------------
Gradle 4.3
------------------------------------------------------------

Build time:   2017-10-30 15:43:29 UTC
Revision:     c684c202534c4138b51033b52d871939b8d38d72

Groovy:       2.4.12
Ant:          Apache Ant(TM) version 1.9.6 compiled on June 29 2015
JVM:          1.8.0_131 (Oracle Corporation 25.131-b11)
OS:           Linux 4.9.0-deepin4-amd64 amd64

写一个Hello World的小demo

前面我们说到Gradle是基于Groovy的，所以我们还得再学Groovy，下面的这个例子我们就先来领略一下Groovy，具体的语法我们将在下一篇文章继续学习。
首先我们新建一个目录，然后在目录下新建一个build.gradle文件，接着用记事本或者sublime打开，写入如下代码：

1
2
3

task hello{
    println 'Hello World'
}

之后保存，之后打开终端(Windows使用命令行)进入当前目录(Windows可以直接在当前目录下同时按住Shift键和鼠标右键选择命令行或者Powershell打开则可以直接进入当前目录)，输入如下代码：

1

gradle -q hello

不出意外的话屏幕上会打印Hello World。

我们再来回顾一下整个过程，首先是新建一个build.gradle文件，有没有很熟悉呢？在Android项目中，也经常会出现build.gradle文件，在工程中他扮演着十分重要的角色，现在只需要知道它是整个项目的入口即可，具体的我们后续再讲。
接着我们再来看看在build.gradle文件中插入的代码是什么意思:

1
2
3

task hello{
    println 'Hello World'
}

首先声明了一个task(任务)，这个任务的名称叫做hello，接着使用{}将该任务的内容包围起来，即花括号里面的内容就是这个hello任务的内容，我们看到他的输出语句与java十分相似，但是也有不同点：

• java中方法的声明和调用需要使用()，但是groovy则可以不用，这样可以更加简洁。
• java使用双引号来表示字符串，但是在groovy中则直接使用了单引号，这是因为在groovy的语法中，字符串的表达方式比较多种，有的需要单引号''，有的需要双引号""，还有的需要三引号''''''，每种符号都有他使用的场景与作用，这个我们也是放到后面再讲。
• java需要使用分号来表示一行语句的结束，而groovy与kotlin一样不需要使用分号来作为语句的结束标志，只需要换行即可。
  最后我们使用命令行输入的gradle -q hello又是代表什么意思呢？
  首先gradle则是命令，它会去查找当前所在目录下的build.gradle文件，因为这个文件就是整个命令的入口，而hello就是我们刚才命名的任务的名称，那么-q又是什么呢？其实这里的-q代表quiet模式，它不会生成 Gradle的日志信息(log messages)，所以用户只能看到tasks的输出，这样可以让输出信息更加清晰。

通过上面的说明大家应该都能够理解。

Gradle Wrapper

相信大家在运行github上的项目时经常会出现导入失败的问题，例如我们将一个项目导入了Android studio，但是由于项目使用的gradle版本与我们本机安装的不一致，尽管我们可以手动更改配置文件使得该项目使用我们本机的gradle，不过不同的gradle版本对应用程序的编译支持又不一样，所以最好就是还得自行下载gradle然后再运行，这就是为什么我们在Android studio倒入一个项目有的时候需要很久的原因。为了应对着一些列复杂的操作，Google推出了gradle wrapper(即gradle包装器)。接下来我们来看看gradle wrapper是如何解决的。

首先程序的开发者需要为工程提供gradle wrapper的支持

我们使用者想要使用gradle wrapper来构建项目，得需要项目的开发者为该工程添加gradle wrapper的支持，这样我们要使用的时候才知道需要哪个版本的gradle来构建项目。为工程添加gradle wrapper其实很简单，一般来说有两种方法。

使用终端(或命令行)添加gradle wrapper

在项目的根目录下打开终端或者命令行并进入到该目录，接着使用如下的命令即可：

1
2
3
4
5

## 将下方4.0换成你需要的gradle版本号，将all换成你需要的版本类型，例如bin
bob@bob-PC:~/workspace/gradle_workspace/how_to_use_gradleWrapper$ gradle wrapper --gradle-version 4.0 --distribution-type all

BUILD SUCCESSFUL in 9s
1 actionable task: 1 executed

如果出现了上方的构建成功的信息则代表已经成功为工程添加了gradle wrapper。

编写文件添加gradle wrapper

我们还可以通过编辑项目根目录的build.gradle文件，为该文件添加如下代码：

1
2
3
4

task wrapper(type: Wrapper) {
    gradleVersion '4.0'
    distributionType 'all'
}

我们可以看到其实就是添加了一个名为wrapper的任务，该任务还接受一个Wrapper类型的参数，然后在任务内部可以定义gradle的版本号，以及版本类型，根据我们的需要自行修改即可。
添加完该任务之后还是打开终端或者命令行进入项目的根目录执行wrapper任务：

1
2
3
4

bob@bob-PC:~/workspace/gradle_workspace/how_to_use_gradleWrapper$ gradle wrapper

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

通过这种方式我们也是可以为项目添加gradle wrapper的。

添加了gradle wrapper之后项目的根目录下添加了如下几个文件：

1
2
3
4
5
6
7
8

.
├── build.gradle
├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew
└── gradlew.bat

新增加的四个文件各有含义：

• gradlew：linux下执行gradle wrapper的脚本
• gradlew.bat：windows下执行gradle wrapper的脚本
• gradle-wrapper.jar：gradle wrapper微类库，包含下载和解包gradle运行时的逻辑
• gradle-wrapper.properties：gradle wrapper元信息，包含已下载gradle运行时的存储位置和原始URL

使用gradle wrapper构建项目

现在我们使用者已经拿到了支持gradle wrapper的项目，我们只需要打开终端或者命令行并导航到项目的根目录然后执行：

1
2
3
4

## linux系统下
./gradlew build
## Windows系统下
gradlew build

即可编译项目。这里的gradlew就是gradle wrapper的缩写了。当我们使用gradlew运行gradle时，他会首先检查wrapper对应的gradle是否可用，如果可用，他会将gradlew的所有参数委托给gradle，然后执行构建，如果gradle包不可用，它就会首先下载对应版本的gradle，然后再构建。

下载很慢怎么办？

如果执行了上述的命令之后发现gradle的下载很慢，那我们可以手动修改gradle-wrapper.properties文件，将其中的distributionUrl更改成下面这样，这样他就会复用我们本地的gradle而不是去服务器下载。

1
2
3
4

## linux系统下：
distributionUrl='file:/home/bob/gradle/gradle-4.0-all.zip'
## Windows系统下：
distributionUrl='file:///D:/grale/gradle-4.0-all.zip'

Gradle该如何学习

通过上面的学习想必大家对gradle应该有了初步的认识了，但是gradle的知识还有很多，那我们要怎么学呢？

• 首先gradle是基于groovy语言的，所以我们需要对groovy的语法有所了解，我们将在下一节与大家一起学习。
• 接着就是深入到Android项目中，来看看gradle的文件结构。
• 随后需要了解的就是gradle的插件，这些插件有的是专门用于Android项目的构建的，所以我们需要结合文档一起来理解。
• 再后面的话我们还得了解如何构建变体，例如我们需要为一个项目编译多个不同应用市场的渠道包。
  当然还有很多，这里只是先给大家一个思路，之后的文章我们一起继续学习。

大家好，不知不觉已经有两个月的时间没有更新文章了，时间真是过得好快啊，转眼间2017也已经来到了最后一天，这篇文章就来记录和总结一下过去的这个2017年吧！
过去的两个月时间里状态不是很好，加上学校大四了还一大堆课，一大堆作业要做。本以为拿了offer就可以轻松看书学习了，想不到这段时间过得比找工作还累。本来计划的文章都没有写，拖延症太重了，不过最主要的原因还是自己的惰性太严重了，希望在接下来的新的一年里能有所改善吧！
2017年对我来说注定是不简单的一个年份，有收获有遗憾，收获的是有了人生中第一份工作、在开源世界上有了自己更多的贡献、阅读了许多经典的书籍让自己的知识的深度和广度上了一个台阶、当然也结识了许多志同道合优秀的朋友、同时趁着自己大学时光的最后一年也出去走走看看；当然遗憾也不少，总感觉时间不够用，也总感觉自己浪费了许多宝贵的年华，每每想到这些心头总是唏嘘不已。

关于实习和工作

今年一共有两次实习的经历，一个较长一个较短，较长的是在博雅，较短的是在CVTE，两家公司的同事和导师们都十分的nice，在这两段实习的时间里真的能够体会到商业项目与个人项目巨大的区别。前一段实习经历我记录在了这篇文章中，后一段实习则因为自己的拖延症迟迟没有写成文章，不过在这短短的一个星期的考核实习中我的导师以及领导对我的帮助确实是巨大的，尤其是在对工程框架、编码规范、设计模式以及性能优化方面，很感谢他们给我提出的意见。当然我觉得在实习中也有一个比较好的建议想与大家一起分享的，其实这对正式工作也是有很大帮助的，那就是在每天早上工作前先列一个任务清单，确定自己一天需要完成的任务，这能够让你对一天的工作量有所准备，同时也让你更有计划性；接着是一天工作完之后最好能花点时间总结一下今天的任务完成的如何，同时记录自己工作过程中的收货以及遇到的困难等等，我觉得这个方法对我这个菜鸟确实帮助挺大的。
关于工作，我之前也写过一篇文章：一个三非渣本的安卓秋招之路 ，不过当初在写文章的时候还没有确定正式签约的公司，最后我选择了珍爱网，希望在这里能够遇见美好。

关于开源

这一年我开始逐步的拥抱开源，在开源世界上吸收了许多前辈们贡献的成果和经验，当然在此基础上我也向开源世界开始贡献我的绵薄之力。

Github

贡献图

上面这张图是我2017年总共的贡献图，实在惭愧，上半年完成的还是可以，但是到了下半年因为要实习还有找工作再加之拖延症一片惨不忍睹的白啊。

repositories

gank

gank

关于博客

2017年1月份开始搭建的独立个人博客，在这一年的时间里网站总访客数：22725，网站总访问量：59067

网站访问量

博客内容归档

掘金

看书

今年看的书不少，下面这张图是我认真看并且觉得不错的书。

books

还有几本书有的借人了，有的放在图书馆没有拿回来没有拍照，列在下面供大家参考。

• Android进阶之光
• Android开发艺术探索
• 高性能Android应用开发
• 网络是怎样连接的
• 算法（第4版）
• 程序员的算法趣题
• Java编程思想（第四版）
• Gradle for Android (PDF)
  其中《鸟哥的私房菜》、《Java编程思想》没有全部看完，只看了其中的一部分。讲真今年买书花了还挺多钱的，但是如果对自己有所帮助还是很愿意投资的，并且也知道作者出书不容易，应该支持正版啦！

朋友

写博客确实认识了许多志同道合的朋友，这里不能一一举例实在抱歉，向大家推荐两个我比较熟悉的大神，两位都还是学生，@Carson_Ho是研究生，@Tonny则跟我一样也是大四，两位大神比我厉害多了，我也经常看他们的博客和开源项目，@Carson_Ho博客的更新频率真的很赞，一个月都有几篇，这一点真的很棒啊，希望以后我也能向他这样。

世界那么大我想去走走

大学最后一年，也想利用着最后的一点时间出去走走看看，于是就去了成都和重庆，讲真我可能是假的广东人，并不觉得四川和重庆的很辣，难道是我吃了假的辣椒？

成都

重庆

遗憾

2017年遗憾的事情还是挺多的，究其原因还是自己有的时候太懒惰了，没有一直坚持下去，无论是写博客还是开源项目，到了下半年都有所松懈。再加之我也很容易被琐碎的事情打扰，也因为如此很多事情都中途而费了，希望来年自己能够在这方面有所改进。

2018年展望

2018年自己将迎来工作的第一个年头，希望自己能够尽快适应新的工作环境，在工作上能够有所建树。当然在技术学习的道路上也应用永无止境，自己也已经开始准备学习人工智能和深度学习方面的内容，技术人唯有不断学习才不会太快被淘汰。2018年博客将会继续更新，接下来将会写一个有关Gradle的系列文章，到后面还会与大家一起分享更多流行的技术；文章的更新频率方面会比今年做的更好，在工作学习之余会抽出更多的时间来更新文章。
最后祝大家2018年新年快乐，新的一年大家都能心想事成！

距离上次更新文章已经过去一个多月了，实在是很抱歉没有按照进度更新博客。最近主要是在忙秋招，前几天也刚刚结束，所以这篇文章就来和大家一起分享我的秋招之路。
或许大部分朋友都是从这篇文章————2017腾讯实习生Android客户端开发面试总结开始认识我的吧，在那篇文章中我也讲到自己是非科班出身，同时学校也是非985非211的普通一本学校，这也就是标题中讲到的“三非”，这篇文章主要是记录一下我的秋招历程，在文章中我也会分享自己准备秋招的一些经验，希望对大家有所帮助。话不多说让我们开始吧！

前言

先来说一下我目前的情况吧，截止到这篇文章发布的时候，我手上是拿到了4个offer，分别是实习的公司，珍爱网，久邦数码，租租车，在等待最终结果的是还有1个。像我这种实力是拿不到大厂offer的啦，请大神们轻喷。
回顾整个秋招，从8月底开始，先后总共投了11份简历，8份过了笔试来到了面试，在这8个中有2个一面挂分别是腾讯和4399，剩下6个都到了终面，最后有1个终面挂，剩下5个就是上面说到的5个。很多朋友会问为什么只投了11份呢？因为个人的关系，我选择在广东省内工作，其实主要就是广州和深圳，再加上本身投递的岗位是Android开发，所以选择的公司就少了很多了，其实我也很羡慕那些能够到外省工作的同学，当然这个是个人自己的选择啦！下面我就来细讲一下这些面试的过程。

面试总结

体验最好的面试————CVTE

CVTE是我第一个去面试的公司，三轮面试下来总共是两天，不过两天不连续，这两天的面试都是到地铁站附近等候公司的班车过来，然后坐班车前往公司面试，一面二面安排在同一天，从等待面试的人数就可以看出CVTE很受欢迎。当天我是早上11点到的公司，然后工作人员安排我们到电影院稍作休息，等候面试通知，从公司的基础设施以及环境就可以看出CVTE还是挺有钱的，工作人员也十分的热情，整个面试流程也是尽然有序。

CVTE一面

一面的时候是两个面试官同时面试我，一个问问题的时候另一个做记录，另外一个问问题再由另一个做记录，这轮面试总共40分钟，面完之后感觉快要虚脱，因为面试节奏很快，如果脑袋不够用就可能当场gg，不过问的问题都是很基础的知识，只要基础够扎实基本没问题。下面是我被问到的一些问题：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

从ActivityA跳转到ActivityB的生命周期调用顺序？
Activity的四种启动方式？
Android多线程的通信方式有什么？做简要介绍。
Android中的消息机制？
HandlerThread的原理？
Window的工作原理和作用？
自定义View的流程以及需要注意哪些地方？
自定义View的时候如何实现wrap_content属性？
View事件分发机制？
滑动冲突的解决方法有哪些？子View如何通知父View去拦截某事件？
Volley原理？
retrofit原理？
JAVA的四种元注解是什么？主要作用有哪些？
okhttp原理？
老年代与新生代的区别？
JVM中的复制算法是什么？
java加锁机制有哪些方法？原理分别是什么？
wait()和sleep()的区别是什么？
synchronized关键字的四种用法和区别？
onCopyWriteArrayList的原理？
Hashmap实现原理？
concurrentHashmap原理？
反射机制原理？
动态代理原理？
单例模式有哪些实现方法？
手写算法题————字符串反转的有哪些方法？

一面大概历时40分钟，时间也来到12点多，结束之后就等待二面，因为怕面试官通知面试所以就没去吃午饭，话说CVTE的零食和饭堂都是挺不错的，可惜没有去尝一下。差不多一点多的时候就是二面。

CVTE二面

二面应该是总监面，问题主要偏向项目，有一些问题已经忘记了，只能列出一些还记得的：

1
2
3
4
5
6
7
8
9
10
11
12

做了哪些项目？详细说一下项目。
讲一下RXJava原理；subscribeOn()与observeOn()哪一个方法多次切换线程只有第一次有效？为什么？
Volley原理？
Retrofit原理？
Volley与Retrofit缓存机制有哪些区别？
简单工厂，工厂方法，抽象工厂三种设计模式的优缺点？
什么是内存泄露，什么是内存溢出？
平常使用什么分析工具来优化APP的性能？
手写算法题————实现一个栈
Java的集合类包括哪些？各自有什么特点？
为什么写博客？
今后想要往哪些方面发展？

二面其实发挥得不好，尤其是讲到RxJava的时候，因为没有仔细看RxJava源码，后续会写关于这个开源库源码解析的文章。
过了几天之后面试状态变成了终面，然后就前往CVTE的第二产业园进行HR面，一般是两个面试官同时面三个同学，不过因为我面的那一批人数不够，所以只是2对2。不得不说CVTE的HR真的很专业，把我从小到大的事情都扒出来了，问的问题大体如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

对自己两轮面试打一下分
都面试了哪些公司，拿到哪些offer？
小时候印象最深刻的一件？
说说自己的家庭情况？
说说对自己影响最大的人？
父母的性格都是怎么样的？
从小什么事情对自己的影响最大？
期望的工作地点，每天期望的工作时间？一周期望工作多久？
有什么理由会让你拒绝CVTE的offer？
说说你对薪资的要求？
觉得什么是自己不喜欢的？
说一下自己的优点和缺点？
梦想是什么？
有什么问题想问我？

全程还是挺严肃的，大概30分钟，不过因为之前对一些问题做了准备，所以没有遇到太大的难题。HR面之后过了几天官网显示已经通过终面，不过终面过了并不表示能够顺利拿到offer啦，按照CVTE的惯例，顺利通过终面的学生一般是需要经历一周的考核，考核的项目完成之后会进行再一轮的HR面，最后才会给结果。也就在前两天我刚刚结束了为期一周的实习，实习期间我的导师，同事，老大都很nice，有什么问题都可以向这些同事们请教，他们都会很耐心的帮忙解答，更重要的是CVTE给实习生的待遇很好，除了很好吃的一日三餐以及宵夜之外还会安排公司的公寓式酒店给实习生入住，相信去实习的同学对这点应该都很清楚。说了这么多好的那也该说一下不是特别好的地方，首先就是工作强度会稍微有点大，不过因为我是短期实习生，同时也要这3~4天内完成一个项目，所以压力相对大，每天几乎都是8点半左右上班工作到晚上9点多，中午12点多吃午饭，下午两点上班，如果你觉得这样的工作强度适应的了的话那来CVTE肯定是很好的选择，最后再说一下项目考核之后的HR面吧：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

实习的这一周有什么不适的吗？
对公司的安排有什么意见吗？
觉得哪方面还没有达到你的预期？
跟家里人说了来实习的情况了吗？家里人都说了些什么？
父母对你未来的期望是什么？
未来对父母有什么打算？
家里情况怎么样？
父母对你的影响是什么？
从小到大对你造成的负面影响最大的事情是什么？
哪一段时间是自己压力最大的时候？
给自己的实习考核打个分？
觉得自己能不能够通过此次的考核？为什么？
期望的薪资是多少？最低的薪资要求是多少？
如果考核评估觉得你无法达到这样的薪资水平你该怎么办？
如果没有通过CVTE的考核你该怎么办？
手里都拿到哪些Offer了？薪资水平都怎么样？
都拿到这么多offer了为什么还来实习？
为什么会选择CVTE？
有什么理由让你拒绝CVTE的offer？
什么情况下你会从CVTE离职？
还想对我们说什么？用一句话表达。

讲真，经历了这么多次面试，CVTE的HR面给我的印象是最深刻的，当然这次的面试压力也是最大的，跟我一起面试的另一个小伙伴也顶着很大的压力，我们两个面试结束之后都大口的舒了口气，这次的HR是相对比较高层的，经验可以说相当丰富啊，对每个问题都会挖得很深直击要害，如果没有提前做好充分的准备可能会被问哭。总之这个星期的实习确实是个非常不错的经历。

体验最糟的面试————4399

其实这样黑4399也不是很好，那就当成是我个人的片面之见吧，写出来只是与大家分享而已，完全没有恶意。4399的面试是在华工中心酒店，去之前就听说今年的面试有点水，一面似乎都是20分钟草草而过，听去面试的同学讲起问的技术问题不多，主要聊人生。本来也不是很想去的，因为同时间也赶着去另外一家公司面试，不过为了给自己多一次机会，所以也来到现场。话说4399的人气不是盖的，会议室里坐满了人，到了现场不到3分钟就被叫去一面。

4399一面

1
2
3
4
5
6
7
8
9

自我介绍
问了一下项目
说说ListView与RecyclerView的区别
说说以后的发展方向
为什么写博客
用过什么设计模式？问说需不需要详细说一下面试官说不用。
有优点和缺点？
觉得自己什么情况下会离职？
怎么学习Android的？

大概就这些问题了，面完之后面试官叫我出去等一下，然后前台的工作人员过了一阵子叫我先回去等消息，接着另一个工作人员叫我稍等一下，然后在电脑上处理了3分钟左右，接着另外一个工作人员又叫我去面二面，不过刚才那个工作人员说他在处理我的，又过了2分钟他叫我回去等消息了。听到这个回复就知道gg了。
总体评价一下这次的面试，感觉4399确实很多人想去，不过不知道今年是不是不怎么招人，感觉面试都很水，也有可能面试官觉得我很渣，然后随便问问过一下流程吧！不过我一直觉得面试是一个互相了解的过程，双方都应该尊重彼此，不然怎么体现这个公司的形象呢？

最轻松幽默的面试————珍爱网

珍爱网简历是在8月份就投了，10月13号的时候在华工进行了现场笔试，最后HR面的时候面试官跟我说其实我的笔试成绩有点低(尴尬脸)，当初做的时候觉得除了算法题之外都答得挺好的呀，可能有些题目考虑的不是很全面吧。现在想想觉得自己还是挺幸运的。当天就收到一面的短信，一面面试官给我留下的印象十分深刻，无论是开口的第一句话：“我们不用搞得那么严肃，轻松点就行(哈哈)”，还是面试过程中对我回答的不好的问题耐心的纠正，到最后离开的时候站起来跟我握手。整体给面试者的印象都十分深刻，相信有面过珍爱网Android的同学都会倍感亲切和轻松吧！

珍爱网一面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

介绍一下做过的项目，面试官问我手机上有没有安装做过的APP，自己的APP当然得装在手机上啦，于是面试过程基本都是围绕着这个项目展开的。
介绍一下RecyclerView的原理以及优点。
为什么会选用Material Design？
Android 5.0之后的版本和之前的版本有什么区别？
DVM与ART的区别？(回答得不好)
为什么要写博客？
怎么学习Android的？
项目中遇到过哪些困难？如何去解决的？
MVP与MVC有什么区别？
Custom-Tabs-Client是什么？(因为在项目中用到这个开源库)作用是什么？
Handler机制？Looper原理？
如果在主线程中同时创建10个Handler，会发生什么事？(回答得不好)
HandlerThread实现原理？
Activity的启动流程？
ActivityThread的main方法主要做了哪些操作？
对团队有什么要求吗？
有哪些问题要问他的？(去面试之前使用了珍爱网的APP，发现有一个页面有点卡顿，然后使用AS的dump View Hierarchy for UI automator观察了这个Activity的实现组件是webview，但不是传统的webview，而是基于腾讯的X5内核，同时注意到这个页面需要连接网络，如果没有网络连接的话就无法显示内容，后来通过使用分析知道这个页面的卡顿有一部分原因是网络连接造成的。基于这个问题与面试官进行了一番讨论。)
还有什么问题要问他的吗？(请教了一下面试官在珍爱网工作最大的收获是什么)

面试结束之后面试官主动站起来跟我握手，我都有点受宠若惊了。分析了一下这次面试，觉得自己的技术问题上大部分答得都还行，不过有两个问题基本属于知识盲区，所以回答的不好。能过一面我觉得除了运气好之外，可能是我问的两个问题也加了不少分，第一个问题主要是我有去使用他们的产品，并且对其中的问题有自己的思考和深入的了解，这可能是面试官更加看中的吧；第二个问题能够体现出我很想去珍爱网的热情。

珍爱网二面

二面应该是总监面或者总裁面吧，面试官懂技术，会问一些技术问题，估计是CTO之类的高管。主要的问题记录如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

介绍一下项目，面试官同样也拿着我的手机看项目。
项目中有没有做一下性能的优化？优化工具有哪些？
了解过哪些设计模式？分别详细说一下优缺点？
什么情况下使用单例模式？
java中的加锁有哪些方法？
说一下网络连接的状态码的含义？
说一下长连接的优点和缺点？
如何看待Android未来的发展？
为什么会选择学习Android？
如何学习Android？
自己有什么优势？
为什么写博客？
项目中遇到过哪些困难？如何去解决的？
遇到过最大的坎是什么？
有什么问题要问他的？(面试前看了一下珍爱网的官网，注意到对应届生有一个培养计划————纯珍计划，于是就向面试官提问)

二面感觉发挥还可以，个人还是觉得问的问题还是比较重要的，要让面试官觉得你是一个有心的人，觉得你很想来公司工作，所以从官网了解公司是最直接的啦！二面紧接着就是HR面了，HR小姐姐很有趣，这一轮问的问题就是对一些基本问题的了解了，如实回答即可。过几天之后就收到offer通知了。

最真诚的面试————租租车

这里说的最真诚当然不是说我自己啦，我对待每次面试都是十分真诚的啦，这里的真诚就是指租租车的面试官们，因为公司已经经过了B+融资，今年应该是首次校招，不过从规模上来看招聘会办的十分好，招的人数也不少。一面的面试官挺负责任的，在面试之前先浏览了我的博客，以下是面试的一些问题。

租租车一面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

自我介绍
介绍一下项目
说一下Retrofit原理
说一下java中4种元注解？
说一下@Retention元注解的三个取值的使用范围和场景分别是什么？
说一下Volley的原理
说一下Retrofit与Volley的区别和使用场景
说一下Android中的多线程通信机制
说一下Android中的Binder机制原理
自定义View的流程
MeasureSpec是什么？
View事件的分发机制
Android如何实现图片的高效加载
java中的四种引用以及使用场景
项目中有做过性能优化吗？如何优化的?
JVM的内存模型？
java有什么垃圾回收算法？分别是怎么实现的？
java多线程的三个特性？原理分别是什么？
java多线程的锁机制有什么实现方式？原理分别是什么？
说说java中的集合类？
写一下单例模式？
为什么静态内部类不会造成内存泄漏？
说一下TCP与UDP的区别？
说一下网络连接的三次握手和四次挥手？
为什么写博客？
写博客给你带来什么成长？
有什么问题想问我的吗？(面试前使用了公司的APP，发现有一个页面出现了bug，然后就基于这个问题与面试官展开了讨论。)

租租车二面

租租车的二面是HR面，问的问题基本和其他的HR面相同，下面就列举一些还记得的

1
2
3
4
5
6
7
8
9
10

家是哪里的啊？父母对未来的工作有什么要求啊？
有什么优缺点吗？
为什么想要写博客呢？
觉得自己性格怎么样？
对未来的团队有什么要求吗？
拿到哪些Offer了吗？
对薪资方面有什么要求吗？
对自己未来几年的打算是什么？
学校什么时候发三方啊？
还有什么问题要问我吗？

租租车的工作环境是我比较喜欢的，地点在天河大厦，办公楼虽然只是一栋三四层的写字楼但都是自己的，而且装修十分讲究，从门外往里看就能明显感受到与其他公司的差别。两次面试加上一开始的笔试体验都挺不错的，去刚刚起步的初创公司确实能够学到很多当然对自己也是一种历练，更让我喜欢的一点则是公司员工大部分都是年轻人，跟他们工作会相对的轻松些。当然最后还是很开心能够顺利拿到租租车的offer啦！

Android秋招如何准备？

其实每个人都有自己特有的学习方法，我们都需要寻找到最适合自己的，在这里我只是列举出我复习的技巧，大家只需要选择适合自己的就行。

书籍和网站

我觉得看书真的是十分的重要，每一本书都有自己的知识体系，但是好书确实不多，需要经历一番挑选；关于网站则是对一些体系较小的知识进行汇总，这里推荐的是设计模式。以下我列举一些个人觉得不错的一些书籍和网站：

• Android 相关

• 《Android开发艺术探索》
• 《深入理解Android虚拟机》
• 《Android源码设计模式解析与实战》

• Java相关

• 《Java编程思想》
• 《深入理解Java虚拟机》
• 《图解Java多线程设计模式》

• 网络相关

• 《计算机网络》(谢希仁 编著)
• 《网络是怎么连接的》

• 数据结构与算法相关

• 《算法导论》
• 《算法》(第4版)

• 设计模式相关

• 图说设计模式
• 设计模式Java版

• 练习相关

• 牛客网在线笔试题(多练练编程题)
• LeetCode

知识总结

看了这么多书籍和网站之后需要对这些知识做一个比较系统的整理，这里推荐使用思维导图工具，不过市面上的这类工具已经足够多了，有的收费有的免(po)费(jie)，大家可以根据自己的使用习惯自行选择，我个人使用的是mindjet，下图则是我总结的Android复习体系图，完整的版本大家可以点击这里下载。

Android面试知识体系

面试技巧

1
2
3

面试前需要对自己总结的知识重新回顾一遍，以便在被问及时能够快速并且全面的回答问题。
面试前对该公司稍做了解，可以从官网或者从产品等方面了解，如果有产品的话还可以使用，看看有没有存在一些bug，当面试官要你提问题的时候可以跟他一起讨论。
面试完之后做稍做记录，记下自己回答的不好的问题，方便查漏补缺。

关于简历

我觉得简历真的十分重要，如果你的学历和能力都不是很有优势的情况下那么简历很可能就决定了你是否有面试的机会了。当然我的简历做得也不是很好，在这里只是与大家一起分享我在准备简历过程中的一些收获，下面一一与大家分享。

为每个公司准备一份简历

如果你不是去一些大型招聘会，不知道都有哪些企业过来招人，那么你大可以用一份普遍适用的简历投递出去，但如果你已经明确知道今天要去哪家公司面试了，那最好能够为这个企业准备一份专属的简历。最基本的就是在简历的页眉部分加上这个公司的logo，其次简历的文字主题色与logo相呼应，例如给腾讯的简历大概长这样

人丑不露相

要不要放照片？

首先需要声明的是技术岗一般不看颜值，如果你能力棒棒哒同时颜值高高哒，那基本上就稳了，但如果你跟我一样都是屌丝，那得分两种情况讨论咯。首先如果你愿意花钱的话，可以到靠谱点儿的相馆拍张好的证件照，记得跟老板要电子版哦；如果你不愿意花钱的话，那我建议你还是不要放照片吧。

简历最好要彩印

其实我在简历上还是很舍得花钱的，今年学校换了打印店，彩印一面需要两块钱，每次打印心里都在流血啊，不过想到要给面试官留下一个好的印象，还是忍下心了。对了打印一定要用比较硬一点的纸，不要像普通A4纸那样软哦，这样手感才好哟！还有最好还是单面彩印，如果你的简历不止一面那就打几张用订书机钉起来！

推荐一些实用的工具和网站

这里并不是推荐大家什么简历模板，讲真我也没用过这些，对于技术岗的同学简历不需要花哨，只要条理清晰版面整洁即可，基本都是可以用我的(word)哥做。这里推荐的是一款获取图片颜色的工具，还记得刚才我说简历的文字主题色最好与logo相呼应，那就得知道logo的RGB属性值了，使用这款GetRGB工具则可以让你轻松获取图片的RGB参数。使用方式见下图哦！

如何使用GetRGB

图标示例

后记

作为一个Android本科渣渣，在秋招中虽然也经历过失利与彷徨，但对最终的结果还是很满意的。这段时间很感谢身边人对我的帮助，感谢我实习的领导给我的意见和帮助，感谢面试过程中遇到的所有面试官以及结识的朋友们，也感谢我的老师同学朋友一直以来对我的帮助，当然也要感谢我爸妈对我的培养，最后的感谢留给自己，感谢自己学习Android一路来的坚持和努力。希望这篇文章对你有用，同时也祝大家能够实现自己的目标找到心仪的工作！

今天是九月的第四天了，学校也正式开学，趁着大学最后一年的这大好时光，抓紧时间赶快学习新知识吧！今天想要与大家一起分享的是Retrofit，由于网上已经有许多讲解Retrofit使用的文章了，本篇文章只会给一个小小的示例，以这个示例作为入口分析其源码，同样也会贴上流程图，以免迷路。话不多说，我们开始吧！！！

关于Retrofit

简介

Retrofit是近来十分火热的一个网络请求开源库，Android开发者使用的网络请求开源库从最早的HttpClient与HttpURLConnection到2013年Google官方推出的Volley，接着就到了现在很火的OKHttp，最后才到了Retrofit。网络请求开源库的演变也正是移动互联网下用户对网络需求的真实写照。有哪个用户不想使用APP的时候网络加载速度更快，更省流量，更加安全呢？也就是基于用户的这些需求，才有了许多开源库的不断迭代，而Retrofit可以说正是当下最适合开发者使用的网络请求开源库之一。
何出此言呢？首先它是由大名鼎鼎的square公司出品的，或许你不知道square公司，但你应该认识Jake Wharton，不过他最近已经到谷歌去了，倘若你连他都不知道，那你应该使用过他开发的这些开源库：OkHttp,picasso,butterknife,RxAndroid等等，可以说Retrofit是由一个十分厉害的公司开发和维护的，所以你大可以放心地在你的项目中使用。

什么场景下适合使用呢？

尽管Retrofit十分强大，但是他却不一定适合所有场景，正所谓术业有专攻，我们也不必大材小用，如果是一些频繁但是访问量很小的网络请求，那么Volley就足以对付了，接下来我列举一下Retrofit普遍的使用场景。

• 服务器后台遵循RESTful API的设计风格。如果你对这种风格不熟悉，建议你看看阮一峰大神的这篇文章，或者向你的后台小伙伴请教一番。
• 项目中使用了RxJava。如果你的项目中使用了RxJava，那么使用Retrofit绝对会让你的开发效率翻倍。
• 项目中的网络数据请求量比较大。如果你的应用经常会有数据量比较大的网络请求，那么使用Retrofit也会很有效，因为Retrofit底层的实现是使用OKHttp，而OKHttp就是适用于这种场景的。

如果你符合以上三种情况，当然是选择Retrofit啦！

Retrofit绿

一个简单的栗子

说了这么多，我们就通过下面这个栗子来看看他究竟好在哪里？
需要说明的是：这个例子是用来获取干货集中营API上面的数据
1、首先定义一个常量用来描述要访问的服务器主机的地址

1
2
3

public class GankConfig {
    public static final String HOST = "http://gank.io/api/";
}

2、定义返回数据的bean类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class GankData {
    public List<String> category;
    public Result results;

    public class Result{
            @SerializedName("Android")
            public List<Gank> androidList;
            @SerializedName("休息视频")
            public List<Gank> restVideoList;
            @SerializedName("iOS")
            public List<Gank> iosList;
            @SerializedName("福利")
            public List<Gank> meiZiList;
            @SerializedName("拓展资源")
            public List<Gank> extendResourceList;
            @SerializedName("瞎推荐")
            public List<Gank> suggestionList;
            @SerializedName("App")
            public List<Gank> appList;
            @SerializedName("前端")
            public List<Gank> webList;
    }
}

3、定义要访问的接口

1
2
3
4
5
6
7

public interface GankRetrofit {

    //这里以获取指定日期的内容为例子
    @GET("day/{year}/{month}/{day}")
    GankData getDailyData(@Path("year") int year, @Path("month") int month, @Path("day") int day);

}

4、用单例模式创建一个Retrofit客户端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public class GankRetrofitClient {
        private volatile static GankRetrofit gankRetrofit;
        private static Retrofit retrofit;

        private GankRetrofitClient(){}

        static{
                Gson date_gson = new GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").create();
                retrofit = new Retrofit.Builder()
                        .baseUrl(GankConfig.HOST)
                        .addConverterFactory(GsonConverterFactory.create(date_gson))//添加一个转换器，将gson数据转换为bean类
                        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())//添加一个适配器，与RxJava配合使用
                        .build();
        }

        public static GankRetrofit getGankRetrofitInstance() {
                if (gankRetrofit==null){
                        synchronized (GankRetrofitClient.class){
                                if (gankRetrofit==null){
                                        gankRetrofit=retrofit.create(GankRetrofit.class);
                                }
                        }
                }
                return gankRetrofit;
        }
}

5、使用Retrofit进行网络请求

1

GankData data= GankRetrofitClient.getGankRetrofitInstance().getDailyData(2017, 9, 1);

源码解析

从Builder模式创建实例开始看起

首先我们先从上面的第4步开始解析源码，有下面这段代码：

1
2
3
4
5

retrofit = new Retrofit.Builder()
            .baseUrl(GankConfig.HOST)
            .addConverterFactory(GsonConverterFactory.create(date_gson))//添加一个转换器，将gson数据转换为bean类
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())//添加一个适配器，与RxJava配合使用
            .build();

很明显这个是使用了Builder模式，接下来我们一步一步来看里面做了什么？首先是Builder()。

1
2
3
4
5
6
7
8
9

public Builder() {
      this(Platform.get());
}

Builder(Platform platform) {
      this.platform = platform;
      //添加转换器，请见下面关于addConverterFactory()的讲解
      converterFactories.add(new BuiltInConverters());
    }

构造方法中的参数是Platform的静态方法get()，接下来就看看get()。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

private static final Platform PLATFORM = findPlatform();

  static Platform get() {
    return PLATFORM;
  }

  private static Platform findPlatform() {
    try {
      Class.forName("android.os.Build");
      if (Build.VERSION.SDK_INT != 0) {
        return new Android();
      }
    } catch (ClassNotFoundException ignored) {
    }
    try {
      Class.forName("java.util.Optional");
      return new Java8();
    } catch (ClassNotFoundException ignored) {
    }
    return new Platform();
  }

可以看到，Retrofit支持多平台，包括Android与JAVA8，它会根据不同的平台设置不同的线程池。
先来看看到目前为止我们分析到哪里了

接下来看一下baseUrl()方法。

1
2
3
4
5
6
7
8

public Builder baseUrl(String baseUrl) {
      checkNotNull(baseUrl, "baseUrl == null");
      HttpUrl httpUrl = HttpUrl.parse(baseUrl);
      if (httpUrl == null) {
        throw new IllegalArgumentException("Illegal URL: " + baseUrl);
      }
      return baseUrl(httpUrl);
    }

很容易理解，baseUrl()是配置服务器的地址的，如果为空，那么就会抛出异常。

接着是addConverterFactory()

1
2
3
4
5
6

private final List<Converter.Factory> converterFactories = new ArrayList<>(); 

public Builder addConverterFactory(Converter.Factory factory) {
      converterFactories.add(checkNotNull(factory, "factory == null"));
      return this;
}

大家是不是还记得刚才在Builder()方法初始化的时候，有这样一行代码：

1

converterFactories.add(new BuiltInConverters());

可以看到，converterFactories在初始化的时候就已经添加了一个默认的Converter，那我们手动添加的这个GsonConverter是干什么用的呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public final class GsonConverterFactory extends Converter.Factory {
 
  public static GsonConverterFactory create() {
    return create(new Gson());
  }

  
  public static GsonConverterFactory create(Gson gson) {
    return new GsonConverterFactory(gson);
  }

  private final Gson gson;

  private GsonConverterFactory(Gson gson) {
    if (gson == null) throw new NullPointerException("gson == null");
    this.gson = gson;
  }

  @Override
  public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
      Retrofit retrofit) {
    TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
    return new GsonResponseBodyConverter<>(gson, adapter);
  }

  @Override
  public Converter<?, RequestBody> requestBodyConverter(Type type,
      Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
    TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
    return new GsonRequestBodyConverter<>(gson, adapter);
  }
}

其实这个Converter主要的作用就是将HTTP返回的数据解析成Java对象，我们常见的网络传输数据有Xml、Gson、protobuf等等，而GsonConverter就是将Gson数据转换为我们的Java对象，而不用我们重新去解析这些Gson数据。

接着看addCallAdapterFactory()

1
2
3
4
5
6

private final List<CallAdapter.Factory> adapterFactories = new ArrayList<>();

public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
      adapterFactories.add(checkNotNull(factory, "factory == null"));
      return this;
}

可以看到，CallAdapter同样也被一个List维护，也就是说用户可以添加多个CallAdapter，那Retrofit总得有一个默认的吧，默认的是什么呢？请看接下来的build()。

最后看一下build()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public Retrofit build() {
  //检验baseUrl
  if (baseUrl == null) {
    throw new IllegalStateException("Base URL required.");
  }

  //创建一个call，默认情况下使用okhttp作为网络请求器
  okhttp3.Call.Factory callFactory = this.callFactory;
  if (callFactory == null) {
    callFactory = new OkHttpClient();
  }

  Executor callbackExecutor = this.callbackExecutor;
  if (callbackExecutor == null) {
    callbackExecutor = platform.defaultCallbackExecutor();
  }

  List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
  //添加一个默认的callAdapter
  adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

  List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);

  return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
      callbackExecutor, validateEagerly);
    }

首先Retrofit会新建一个call，其实质就是OKHttp，作用就是网络请求器；接着在上一点中我们困惑的callAdapter也已经能够得到解决了，首先Retrofit有一个默认的callAdapter，请看下面这段代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
    if (callbackExecutor != null) {
      return new ExecutorCallAdapterFactory(callbackExecutor);
    }
    return DefaultCallAdapterFactory.INSTANCE;
  }

final class ExecutorCallAdapterFactory extends CallAdapter.Factory {
  final Executor callbackExecutor;

  ExecutorCallAdapterFactory(Executor callbackExecutor) {
    this.callbackExecutor = callbackExecutor;
  }

  @Override
  public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    if (getRawType(returnType) != Call.class) {
      return null;
    }
    final Type responseType = Utils.getCallResponseType(returnType);
    return new CallAdapter<Object, Call<?>>() {
      @Override public Type responseType() {
        return responseType;
      }

      @Override public Call<Object> adapt(Call<Object> call) {
        return new ExecutorCallbackCall<>(callbackExecutor, call);
      }
    };
  }

  static final class ExecutorCallbackCall<T> implements Call<T> {
    final Executor callbackExecutor;
    final Call<T> delegate;

    ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {
      this.callbackExecutor = callbackExecutor;
      this.delegate = delegate;
    }

    @Override public void enqueue(final Callback<T> callback) {
      if (callback == null) throw new NullPointerException("callback == null");

      delegate.enqueue(new Callback<T>() {
        @Override public void onResponse(Call<T> call, final Response<T> response) {
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              if (delegate.isCanceled()) {
                // Emulate OkHttp's behavior of throwing/delivering an IOException on cancellation.
                callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
              } else {
                callback.onResponse(ExecutorCallbackCall.this, response);
              }
            }
          });
        }

        @Override public void onFailure(Call<T> call, final Throwable t) {
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              callback.onFailure(ExecutorCallbackCall.this, t);
            }
          });
        }
      });
    }

    @Override public boolean isExecuted() {
      return delegate.isExecuted();
    }

    @Override public Response<T> execute() throws IOException {
      return delegate.execute();
    }

    @Override public void cancel() {
      delegate.cancel();
    }

    @Override public boolean isCanceled() {
      return delegate.isCanceled();
    }

    @SuppressWarnings("CloneDoesntCallSuperClone") // Performing deep clone.
    @Override public Call<T> clone() {
      return new ExecutorCallbackCall<>(callbackExecutor, delegate.clone());
    }

    @Override public Request request() {
      return delegate.request();
    }
  }
}

可以看到默认的callAdapter是ExecutorCallAdapterFactory。callAdapter其实也是运用了适配器模式，其实质就是网络请求器Call的适配器，而在Retrofit中Call就是指OKHttp，那么CallAdapter就是用来将OKHttp适配给不同的平台的，在Retrofit中提供了四种CallAdapter，分别如下：

• ExecutorCallAdapterFactory（默认使用）
• GuavaCallAdapterFactory
• Java8CallAdapterFactory
• RxJavaCallAdapterFactory

为什么要提供如此多的适配器呢？首先是易于扩展，例如用户习惯使用什么适配器，只需要添加即可使用；再者RxJava如此火热，因为其切换线程十分的方便，不需要手动使用handler切换线程，而Retrofit使用了支持RxJava的适配器之后，功能也会更加强大。

综上我们已经将使用Builder模式创建出来的Retrofit实例分析完毕了，我们只需要对相关的功能进行配置即可，Retrofit负责接收我们配置的功能然后进行对象的初始化，这个也就是Builder模式屏蔽掉创建对象的复杂过程的好处。现在我们再次用流程图来梳理一下刚才的思路。

网络请求接口的创建

我最初使用Retrofit的时候觉得有一个地方十分神奇，如下：

1
2

GankRetrofit gankRetrofit=retrofit.create(GankRetrofit.class);
GankData data= gankRetrofit.getDailyData(2017, 9, 1);

要想解惑，首先得对动态代理有所了解，如果你对动态代理还不是很清楚，请点击这里了解动态代理的原理，之后再接着往下看。

前方高能预警

我们就以这里为切入点开始分析吧！首先是create()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public <T> T create(final Class<T> service) {
    Utils.validateServiceInterface(service);
    if (validateEagerly) {
      eagerlyValidateMethods(service);
    }
    //重点看这里
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
        new InvocationHandler() {
          private final Platform platform = Platform.get();

          @Override public Object invoke(Object proxy, Method method, Object[] args)
              throws Throwable {
            // If the method is a method from Object then defer to normal invocation.
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            //下面就会讲到哦
            ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);

            //下一小节讲到哦
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            
            //下两个小节讲哦
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }

我们主要看Proxy.newProxyInstance方法，它接收三个参数，第一个是一个类加载器，其实哪个类的加载器都无所谓，这里为了方便就选择了我们所定义的借口的类加载器;第二个参数是我们定义的接口的class对象，第三个则是一个InvocationHandler匿名内部类。
那大家应该会有疑问了，这个newProxyInstance到底有什么用呢？其实他就是通过动态代理生成了网络请求接口的代理类，代理类生成之后，接下来我们就可以使用ankRetrofit.getDailyData(2017, 9, 1);这样的语句去调用getDailyData方法，当我们调用这个方法的时候就会被动态代理拦截，直接进入InvocationHandler的invoke方法。下面就来讲讲它。

invoke方法
它接收三个参数，第一个是动态代理，第二个是我们要调用的方法，这里就是指getDailyData，第三个是一个参数数组，同样的这里就是指2017, 9, 1，收到方法名和参数之后，紧接着会调用loadServiceMethod方法来生产过一个ServiceMethod对象，这里的一个ServiceMethod对象就对应我们在网络接口里定义的一个方法，相当于做了一层封装。接下来重点来看loadServiceMethod方法。

loadServiceMethod方法

1
2
3
4
5
6
7
8
9
10
11
12
13

ServiceMethod<?, ?> loadServiceMethod(Method method) {
  ServiceMethod<?, ?> result = serviceMethodCache.get(method);
  if (result != null) return result;

  synchronized (serviceMethodCache) {
    result = serviceMethodCache.get(method);
    if (result == null) {
      result = new ServiceMethod.Builder<>(this, method).build();
      serviceMethodCache.put(method, result);
    }
  }
  return result;
}

它调用了ServiceMethod类，而ServiceMethod也使用了Builder模式，直接先看Builder方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Builder(Retrofit retrofit, Method method) {
  this.retrofit = retrofit;
  //获取接口中的方法名
  this.method = method;

  //获取方法里的注解
  this.methodAnnotations = method.getAnnotations();

  //获取方法里的参数类型 
  this.parameterTypes = method.getGenericParameterTypes();

  //获取接口方法里的注解内容 
  this.parameterAnnotationsArray = method.getParameterAnnotations();
}

再来看build方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

public ServiceMethod build() {
      callAdapter = createCallAdapter();
      responseType = callAdapter.responseType();
      if (responseType == Response.class || responseType == okhttp3.Response.class) {
        throw methodError("'"
            + Utils.getRawType(responseType).getName()
            + "' is not a valid response body type. Did you mean ResponseBody?");
      }
      responseConverter = createResponseConverter();

      for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
      }

      if (httpMethod == null) {
        throw methodError("HTTP method annotation is required (e.g., @GET, @POST, etc.).");
      }

      if (!hasBody) {
        if (isMultipart) {
          throw methodError(
              "Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
        }
        if (isFormEncoded) {
          throw methodError("FormUrlEncoded can only be specified on HTTP methods with "
              + "request body (e.g., @POST).");
        }
      }

      int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler<?>[parameterCount];
      for (int p = 0; p < parameterCount; p++) {
        Type parameterType = parameterTypes[p];
        if (Utils.hasUnresolvableType(parameterType)) {
          throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
              parameterType);
        }

        Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
        if (parameterAnnotations == null) {
          throw parameterError(p, "No Retrofit annotation found.");
        }

        parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
      }

      if (relativeUrl == null && !gotUrl) {
        throw methodError("Missing either @%s URL or @Url parameter.", httpMethod);
      }
      if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
        throw methodError("Non-body HTTP method cannot contain @Body.");
      }
      if (isFormEncoded && !gotField) {
        throw methodError("Form-encoded method must contain at least one @Field.");
      }
      if (isMultipart && !gotPart) {
        throw methodError("Multipart method must contain at least one @Part.");
      }

      return new ServiceMethod<>(this);
    }

代码稍微有点长，但是思路很清晰，主要的工作有
1、首先对注解的合法性进行检验，例如，HTTP的请求方法是GET还是POST，如果不是就会抛出异常；
2、根据方法的返回值类型和方法注解从Retrofit对象的的callAdapter列表和Converter列表中分别获取到该方法对应的callAdapter和Converter；
3、将传递进来的参数与注解封装在parameterHandlers中，为后面的网络请求做准备。

先用流程图梳理一下刚才的思路：

使用OkHttpCall进行网络请求