RxHttp ，比Retrofit 更优雅的协程体验 ，面试复盘

 .await()

if (response.code == 200) {
//拿到data字段(Student)刷新UI
} else {
//拿到msg字段给出错误提示
}

试想一下，一个项目少说也有30+个这样的接口，如果每个接口读取这么判断，就显得不够优雅，也可以说是灾难，相信也没有人会这么干。而且对于UI来说，只需要data字段即可，错误提示啥的我管不着。

那有没有什么办法，能直接拿到data字段，并且对code做出统一判断呢？有的，直接上代码

val student = RxHttp.get("/service/…")
.toResponse() //调用此方法，直接拿到data字段，也就是Student对象
.await()
//直接开始更新UI

可以看到，这里调用了`toResponse()`方法，就直接拿到了data字段，也就是Student对象。

此时，相信很多人会有疑问，

*   业务code哪里判断的？
    
*   业务code非200时，msg字段怎么拿到？
    

为此，先来回答第一个问题，业务code哪里判断的？

其实`toResponse()`方法并不是RxHttp内部提供的，而是用户通过自定义解析器，并用`@Parser`注解标注，最后由注解处理器`rxhttp-compiler`自动生成的，听不懂？没关系，直接看代码

@Parser(name = “Response”)
open class ResponseParser : AbstractParser {

//以下两个构造方法是必须的
protected constructor() : super()
constructor(type: Type) : super(type)

@Throws(IOException::class)
override fun onParse(response: okhttp3.Response): T {
    val type: Type = ParameterizedTypeImpl[Response::class.java, mType] //获取泛型类型
    val data: Response = convert(response, type)   //获取Response对象
    val t = data.data                             //获取data字段
    if (data.code != 200 || t == null) { //code不等于200，说明数据不正确，抛出异常
        throw ParseException(data.code.toString(), data.msg, response)
    }
    return t
}

}

上面代码只需要关注两点即可，

第一点，我们在类开头使用了`@Parser`注解，并为解析器取名为`Response`，所以就有了`toResponse()`方法（命名方式为：to + Parser注解里设置的名字）；

第二点，我们在`if`语句里，对code做了判断，非200或者data为空时，就抛出异常，并带上了code及msg字段，所以我们在异常回调的地方就能拿到这两个字段

接着回答第二个问题，code非200时，如何拿到msg字段？直接上代码，看一个使用协程发送请求的完整案例

//当前环境在Fragment中
fun getStudent() {
//rxLifeScope在rxLife-coroutine库中，需要单独依赖
rxLifeScope.launch({ //通过launch方法开启一个协程
val student = RxHttp.get("/service/…")
.toResponse()
.await()
}, {
//异常回调，这里的it为Throwable类型
val code = it.code
val msg = it.msg
})
}

**注：RxLifeScope 是 [RxLife-Coroutine]( )库中的类，本文后续会详细介绍**

上面的代码，在异常回调中便可拿到code及msg字段，需要注意的是，`it.code`及`it.msg`是我为Throwable类扩展的两个属性，代码如下：

val Throwable.code: Int
get() {
val errorCode = when (this) {
is HttpStatusCodeException -> this.statusCode //Http状态码异常
is ParseException -> this.errorCode //业务code异常
else -> “-1”
}
return try {
errorCode.toInt()
} catch (e: Exception) {
-1
}
}

val Throwable.msg: String
get() {
return if (this is UnknownHostException) { //网络异常
“当前无网络，请检查你的网络设置”
} else if (
this is SocketTimeoutException //okhttp全局设置超时
|| this is TimeoutException //rxjava中的timeout方法超时
|| this is TimeoutCancellationException //协程超时
) {
“连接超时,请稍后再试”
} else if (this is ConnectException) {
“网络不给力，请稍候重试！”
} else if (this is HttpStatusCodeException) { //请求失败异常
“Http状态码异常”
} else if (this is JsonSyntaxException) { //请求成功，但Json语法异常,导致解析失败
“数据解析失败,请检查数据是否正确”
} else if (this is ParseException) { // ParseException异常表明请求成功，但是数据不正确
this.message ?: errorCode //msg为空，显示code
} else {
“请求失败，请稍后再试”
}
}

到这，业务code统一判断就介绍完毕，上面的代码，大部分人都可以简单修改后，直接用到自己的项目上，如`ResponseParser`解析器，只需要改下`if`语句的判断条件即可

2.4、操作符介绍
---------

### map 转换符号

`map`操作符很好理解，RxJava及协程的Flow都有该操作符，功能都是一样，用于转换对象，如下：

val student = RxHttp.postForm("/service/…")
.toStr()
.map { it.length } //String转Int
.tryAwait() //这里返回 Student? 对象，即有可能为空

### timeout 超时

OkHttp提供了全局的读、写及连接超时，有时我们也需要为某个请求设置不同的超时时长，此时就可以用到RxHttp的`timeout(Long)`方法，如下：

val student = RxHttp.postForm("/service/…")
.toResponse()
.timeout(3000) //超时时长为3s
.await()

### retry 失败重试

OkHttp为我们提供了全局的失败重试机制，然而，这远远不能满足我们的需求，比如，我就部分接口需要失败重试，而不是全局的；我需要根据某些条件来判断是否需要重试；亦或者我需要周期性重试，即间隔几秒后重试等等

如我们需要在网络出现异常时，重试2次，每次间隔1秒，代码如下：

val student = RxHttp.postForm("/service/…")
.toResponse()
.retry(2, 1000) { //重试2次，每次间隔1s
it is ConnectException //如果是网络异常就重试
}
.await()

`retry()`方法共有3个参数，分别是重试次数、重试周期、重试条件，都有默认值，3个参数可以随意搭配，如下：

/**

• 失败重试，该方法仅在使用协程时才有效
• @param times 重试次数, 默认Int.MAX_VALUE 代表不断重试
• @param period 重试周期, 默认为0, 单位: milliseconds
• @param test 重试条件, 默认为true，只要出现异常就重试
  */
  fun retry(
  times: Int = Int.MAX_VALUE,
  period: Long = 0,
  test: suspend (Throwable) -> Boolean = { true }
  )

### filter 过滤操作

如果服务器返回列表数据，则我们可对列表进行过滤操作，如下：

val students = RxHttp.postForm("/service/…")
.toList()
.filter{ it.age > 20 } //过滤年龄大于20岁的学生
.await()

还可以选用`filterTo`操作符，将过滤后的数据添加到指定列表中，如下：

val list = mutableListOf()
val students = RxHttp.postForm("/service/…")
.toList()
.filterTo(list){ it.age > 20 } //过滤年龄大于20岁的学生
.await() //此时返回的列表对象就是我们传入的列表对象

### distinct 去重

该操作符可以对服务器返回的列表，做去重操作，如下：

//根据Student对象的hashCode去重
val students = RxHttp.postForm("/service/…")
.toList()
.distinct()
.await()

//根据Student对象的id去重
val students = RxHttp.postForm("/service/…")
.toList()
.distinctBy { it.id }
.await()

//将去重后的数据添加到指定列表中，并且去重时，会对指定列表数据做判断
val list = mutableListOf()
val students = RxHttp.postForm("/service/…")
.toList()
.distinctTo(list) { it.id }
.await()

### sort 排序

排序有`sortXxx、sortedXxx`两大类型操作符，区别在于`sortXxx`在列表内排序，排序完，返回自身，而`sortedXxx`在列表外排序，排序完，返回新的列表，这里只对`sortXxx`介绍，如下：

//根据id顺序排序
val students = RxHttp.postForm("/service/…")
.toList()
.sortBy { it.id }
.await()

//根据id、age两个字段顺序排序，id优先，其次age
val students = RxHttp.postForm("/service/…")
.toList()
.sortBy({ it.id }, { it.age })
.await()

//返回两个排序对象，自行实现排序规则
val students = RxHttp.postForm("/service/…")
.toList()
.sortWith { student1, student2 ->
student1.id.compareTo(student2.id)
}
.await()

### flowOn 指定上游所在线程

该操作符跟`Flow`里面的`flowOn`操作符一样，用于指定上游所在线程，如下：

val students = RxHttp.postForm("/service/…")
.toList()
.sortBy { it.id } //IO线程执行
.flowOn(Dispatchers.IO)
.distinctBy { it.id } //Default线程执行
.flowOn(Dispatchers.Default)
.filter{ it.age > 20 } //IO线程执行
.flowOn(Dispatchers.IO)
.flowOn(Dispatchers.Default)
.await()

### asFlow 转Flow对象

如果你喜欢kotlin的`flow`流，那么`asFlow` 就派上用场了，如下：

RxHttp.postForm("/service/…")
.toList()
.asFlow()
.collect {
//这里拿到List对象
}

注意：使用`asFlow`操作符后，需要使用`collect`替代`await`操作符

### subList、take 截取列表

`subList`用于截取某段列表，截取范围越界，则抛出越界异常；`take`用于从0开始，取n个数据，不足n个时，返回全部，如下：

val students = RxHttp.postForm("/service/…")
.toList()
.subList(1，10) //截取9个数据
.take(5) //从9个中取前5个
.await()

### async 异步操作

如果我们由两个请求需要并行时，就可以使用该操作符，如下：

//同时获取两个学生信息
suspend void initData() {
val asyncStudent1 = RxHttp.postForm("/service/…")
.toResponse()
.async(this) //this为CoroutineScope对象，这里会返回Deferred

val asyncStudent2 = RxHttp.postForm("/service/…")
.toResponse()
.async(this) //this为CoroutineScope对象，这里会返回Deferred

//随后调用await方法获取对象
val student1 = asyncStudent1.await()
val student2 = asyncStudent2.await()
}

### delay、startDelay 延迟

`delay`操作符是请求结束后，延迟一段时间返回；而`startDelay`操作符则是延迟一段时间后再发送请求，如下：

val student = RxHttp.postForm("/service/…")
.toResponse()
.delay(1000) //请求回来后，延迟1s返回
.await()

val student = RxHttp.postForm("/service/…")
.toResponse()
.startDelay(1000) //延迟1s后再发送请求
.await()

### onErrorReturn、onErrorReturnItem异常默认值

有些情况，我们不希望请求出现异常时，直接走异常回调，此时我们就可以通过两个操作符，给出默认的值，如下：

//根据异常给出默认值
val student = RxHttp.postForm("/service/…")
.toResponse()
.timeout(100) //超时时长为100毫秒
.onErrorReturn {
//如果时超时异常，就给出默认值，否则，抛出原异常
return@onErrorReturn if (it is TimeoutCancellationException)
Student()
else
throw it
}
.await()

//只要出现异常，就返回默认值
val student = RxHttp.postForm("/service/…")
.toResponse()
.timeout(100) //超时时长为100毫秒
.onErrorReturnItem(Student())
.await()

### awaitResult 返回kotlin.Result

这个就直接看代码吧

val result: Result = RxHttp
.postForm("/service/…")
.toClass()
.awaitResult {
//请求成功，通过it拿到Student对象
}.onFailure {
//请求异常，通过it拿到Throwable对象
}

拿到`kotlin.Result`对象后，随后成功/失败处理相关逻辑

### tryAwait 异常返回null

`tryAwait`会在异常出现时，返回null，如下：

val student = RxHttp.postForm("/service/…")
.toResponse()
.timeout(100) //超时时长为100毫秒
.tryAwait() //这里返回 Student? 对象，如果出现异常，那它就是null

### 自定义操作符

RxHttp内置了一系列强大又好用的操作符，然而肯定满足不了所有的业务场景，此时我们就可以考虑自定义操作符

**自定义takeLast操作符**

如我们有这样一个需求，自定义需要在列表尾部取n条数据，不足n条，返回全部

前面我们介绍了`take`操作符，它是从0开始，取n条数据，如果不足n条，则全部返回，来看看源码

fun IAwait.take(
count: Int
): IAwait = newAwait {
await().take(count)
}

代码解读，

1、`IAwait`是一个接口，如下：

interface IAwait {

suspend fun await(): T

}

该接口仅有一个`await()`方法，返回声明的`T`

2、`newAwait`操作符，只是创建了一个`IAwait`接口的实现而已，如下：

inline fun IAwait.newAwait(
crossinline block: suspend IAwait.() -> R
): IAwait = object : IAwait {

override suspend fun await(): R {
    return [email protected]()
}

}

3、由于我们是为`IAwait>`对象扩展的`take`方法，故在内部，我们调用`await()`方法它返回`Iterable`对象，最后就执行`Iterable`对象的扩展方法`take(Int)`获取从0开是的n条数据，`take(Int)`是系统提供的方法，源码如下：

public fun Iterable.take(n: Int): List {
require(n >= 0) { “Requested element count $n is less than zero.” }
if (n == 0) return emptyList()
if (this is Collection) {
if (n >= size) return toList()
if (n == 1) return listOf(first())
}
var count = 0
val list = ArrayList(n)
for (item in this) {
list.add(item)
if (++count == n)
break
}
return list.optimizeReadOnlyList()
}

ok，回到前面的话题，如何自定义一个操作，实现在列表尾部取n条数据，不足n条，返回全部

看了上面的`take(int)`源码，我们就可以很轻松的写出如下代码：

fun IAwait.takeLast(
count: Int
): IAwait = newAwait {
await().takeLast(count)
}

首先，我们对`IAwait>`扩展了`takeLast(Int)`方法，随后调用`newAwait`创建了`IAwait`接口的实例对象，接着调用`await()`方法返回`List`对象，最后调用系统为`List`扩展的`takeLast(Int)`方法

定义好了，我们就可直接使用，如下：

val students = RxHttp.postForm("/service/…")
.toList()
.takeLast(5) //取列表尾部5条数据，不足时，全部返回
.await()

### 以上操作符随意搭配

以上操作符，可随意搭配使用，但调用顺序的不同，产生的效果也不一样，这里先告诉大家，以上操作符仅会对上游代码产生影响。

如`timeout及retry`：

val student = RxHttp.postForm("/service/…")
.toResponse()
.timeout(50)
.retry(2, 1000) { it is TimeoutCancellationException }
.await()

以上代码，只要出现超时，就会重试，并且最多重试两次。

但如果`timeout`、`retry`互换下位置，就不一样了，如下：

val student = RxHttp.postForm("/service/…")
.toResponse()
.retry(2, 1000) { it is TimeoutCancellationException }
.timeout(50)
.await()

此时，如果50毫秒内请求没有完成，就会触发超时异常，并且直接走异常回调，不会重试。为什么会这样？原因很简单，`timeout及retry`操作符，仅对上游代码生效。如retry操作符，下游的异常是捕获不到的，这就是为什么timeout在retry下，超时时，重试机制没有触发的原因。

在看`timeout`和`startDelay`操作符

val student = RxHttp.postForm("/service/…")
.toResponse()
.startDelay(2000)
.timeout(1000)
.await()

以上代码，必定会触发超时异常，因为startDelay，延迟了2000毫秒，而超时时长只有1000毫秒，所以必定触发超时。 但互换下位置，又不一样了，如下：

val student = RxHttp.postForm("/service/…")
.toResponse()
.timeout(1000)
.startDelay(2000)
.await()

以上代码正常情况下，都能正确拿到返回值，为什么？原因很简单，上面说过，操作符只会对上游产生影响，下游的`startDelay`延迟，它是不管的，也管不到。

3、上传/下载
=======

RxHttp对文件的优雅操作是与生俱来的，在协程的环境下，依然如此，没有什么比代码更具有说服力，直接上代码

3.1、文件上传
--------

val result = RxHttp.postForm("/service/…")
.addFile(“file”, File(“xxx/1.png”)) //添加单个文件
.addFile(“fileList”, ArrayList()) //添加多个文件
.toResponse()
.await()

只需要通过`addFile`系列方法添加File对象即可，就是这么简单粗暴，想监听上传进度？简单，再加一个`upload`操作符即可，如下：

val result = RxHttp.postForm("/service/…")
.addFile(“file”, File(“xxx/1.png”))
.addFile(“fileList”, ArrayList())
.upload(this) { //此this为CoroutineScope对象，即当前协程对象
//it为Progress对象
val process = it.progress //已上传进度 0-100
val currentSize = it.currentSize //已上传size，单位：byte
val totalSize = it.totalSize //要上传的总size 单位：byte
}
.toResponse()
.await()

我们来看下`upload`方法的完整签名，如下：

/**

• 调用此方法监听上传进度
• @param coroutine CoroutineScope对象，用于开启协程，回调进度，进度回调所在线程取决于协程所在线程
• @param progress 进度回调
• 注意：此方法仅在协程环境下才生效
  */
  fun RxHttpFormParam.upload(
  coroutine: CoroutineScope? = null,
  progress: (Progress) -> Unit
  ):RxHttpFormParam

3.2、文件下载
--------

接着再来看看下载，直接贴代码

val localPath = “sdcard//android/data/…/1.apk”
val student = RxHttp.get("/service/…")
.toDownload(localPath) //下载需要传入本地文件路径
.await()

下载调用`toDownload(String)`方法，传入本地文件路径即可，要监听下载进度？也简单，如下：

val localPath = “sdcard//android/data/…/1.apk”
val student = RxHttp.get("/service/…")
.toDownload(localPath, Dispatchers.Main) {
//it为Progress对象
val process = it.progress //已下载进度 0-100
val currentSize = it.currentSize //已下载size，单位：byte
val totalSize = it.totalSize //要下载的总size 单位：byte
}
.await()

看下`toDownload`方法完整签名

/**

• @param destPath 本地存储路径
• @param context CoroutineContext 指定进度/成功/失败回调所在线程
• @param progress 进度回调
  */
  fun IRxHttp.toDownload(
  destPath: String,
  context: CoroutineContext? = null,
  progress: (suspend (ProgressT) -> Unit)? = null
  ): IAwait

如果你需要断点下载，用`toAppendDownload`方法替换`toDownload`方法即可，如下：

val localPath = “sdcard//android/data/…/1.apk”
val student = RxHttp.get("/service/…")
.toAppendDownload(localPath, Dispatchers.Main) {
//it为Progress对象
val process = it.progress //已下载进度 0-100
val currentSize = it.currentSize //已下size，单位：byte
val totalSize = it.totalSize //要下的总size 单位：byte
}
.await()

到这，RxHttp协程的基础Api基本介绍完毕，那么问题了，以上介绍的Api都依赖与协程环境，那我这么开启协程呢？亦或者说，我对协程不是很懂，你只要保证安全的前提下，告诉怎么用就行了，ok，那下面如何安全的开启一个协程，做到自动异常捕获，且页面销毁时，自动关闭协程及请求

4、协程开启及关闭
=========

对于协程的开启，Jetpack库里提供了`lifecycle-runtime-ktx`、`lifecycle-viewmodel-ktx`这两个框架，可以非常方便的开启协程，并在页面销毁时，自动关闭协程，想了解的同学，自行查找相关资料。

这里介绍本人开源的另一个库[RxLife-Coroutine]( )，用于开启/关闭协程，并自动异常捕获，依赖如下：

implementation ‘com.ljx.rxlife:rxlife-coroutine:2.0.1’

本文在介绍业务code统一处理的时候，我们用到rxLifeScope属性开启协程，那这个是什么类型呢？看代码

val ViewModel.rxLifeScope: RxLifeScope
get() {
val scope: RxLifeScope? = this.getTag(JOB_KEY)
if (scope != null) {
return scope
}
return setTagIfAbsent(JOB_KEY, RxLifeScope())
}

val LifecycleOwner.rxLifeScope: RxLifeScope
get() = lifecycle.rxLifeScope

可以看到，我们为`ViewModel`及`LifecycleOwner`都扩展了一个名为`rxLifeScope`的属性，类型为`RxLifeScope`，ViewModel相信大家都知道了，这里就简单讲一下LifecycleOwner接口，我们的Fragment及FragmentActivity都实现了`LifecycleOwner`接口，而我们的Activity一般继承于AppCompatActivity，而AppCompatActivity继承于FragmentActivity，所以我们在`FragmentActivity/Fragment/ViewModel`环境下，可以直接使用`rxLifeScope`开启协程，如下：

rxLifeScope.lanuch({
//协程代码块，运行在UI线程
}, {
//异常回调，协程代码块出现任何异常，都会直接走这里
})

通过这种方式开启的协程，会在页面销毁时，会自动关闭协程，当然，如果你的协程代码块里还有RxHttp请求的代码，协程关闭的同时，也是关闭请求，所以在这种情况下，只需要知道如何开启协程就行，其它一律不管。

现在，我们来看下`rxLifeScope.lanuch`方法的完整签名

/**

• @param block 协程代码块，运行在UI线程
• @param onError 异常回调，运行在UI线程
• @param onStart 协程开始回调，运行在UI线程
• @param onFinally 协程结束回调，不管成功/失败，都会回调，运行在UI线程
  */
  fun launch(
  block: suspend CoroutineScope.() -> Unit,
  onError: ((Throwable) -> Unit)? = null,
  onStart: (() -> Unit)? = null,
  onFinally: (() -> Unit)? = null
  ): Job

可以看到，不仅有失败回调，还有开始及结束回调，这对于我们发请求来说，真的非常方便，如下：

rxLifeScope.launch({
//协程代码块
val students = RxHttp.postJson("/service/…")
.toResponse()
.await()
//可以直接更新UI
}, {
//异常回调，这里可以拿到Throwable对象
}, {
//开始回调，可以开启等待弹窗
}, {
//结束回调，可以销毁等待弹窗
})

以上代码均运行在UI线程中，请求回来后，便可直接更新UI

也许你还有疑问，我在非`FragmentActivity/Fragment/ViewModel`环境下，如何开启协程，又如何关闭，其实也很简单，如下：

val job = RxLifeScope().launch({
val students = RxHttp.postJson("/service/…")
.toResponse()
.await()
}, {
//异常回调，这里可以拿到Throwable对象
}, {
//开始回调，可以开启等待弹窗
}, {
//结束回调，可以销毁等待弹窗
})
job.cancel() //关闭协程

以上代码，需要注意两点，第一，我们需要手动创建`RxLifeScope()`对象，随后开启协程；第二，开启协程后，可以拿到`Job`对象，我们需要通过该对象手动关闭协程。其它就没啥区别了。

5、协程多任务处理
=========

我们知道，协程最大的优势就是：`能以看起来同步的代码，写出异步的逻辑`，这使得我们可以非常优雅的实现多任务场景，比如多请求的并行/串行

5.1、协程串行多个请求
------------

假设，我们有这么一种场景，首先获取Student对象，随后通过studentId获取学生的家庭成员列表，后者依赖于前者，这是典型的串行场景

看看通过协程如何解决这个问题，如下：

class MainActivity : AppCompatActivity() {
//启动协程，发送请求
fun sendRequest() {
rxLifeScope.launch({
//当前运行在协程中，且在主线程运行
val student = getStudent()
val personList = getFamilyPersons(student.id) //通过学生Id，查询家庭成员信息
//拿到相关信息后，便可直接更新UI，如：
tvName.text = student.name
}, {
//出现异常，就会到这里，这里的it为Throwable类型
it.show(“发送失败,请稍后再试!”) //show方法是在Demo中扩展的方法
})
}

//挂断方法，获取学生信息
suspend fun getStudent(): Student {
    return RxHttp.get("/service/...")
        .add("key", "value")
        .addHeader("headKey", "headValue")
        .toClass()
        .await()
}

//挂断方法，获取家庭成员信息
suspend fun getFamilyPersons(studentId: Int): List {
    return RxHttp.get("/service/...")
        .add("studentId", "10000")
        .toClass>()
        .await()
}

}

我们重点看下协程代码块，首先通过第一个请求拿到Student对象，随后拿到studentId，发送第二个请求获取学习家庭成员列表，拿到后，便可以直接更新UI，怎么样，是不是看起来同步的代码，写出了异步的逻辑。

串行请求中，只要其中一个请求出现异常，协程便会关闭（同时也会关闭请求），停止执行剩下的代码，接着走异常回调

5.2、协程并行多个请求
------------

请求并行，在现实开发中，也是家常便饭，在一个Activity中，我们往往需要拿到多种数据来展示给用户，而这些数据，都是不同接口下发的。

如我们有这样一个页面，顶部是横向滚动的Banner条，Banner条下面展示学习列表，此时就有两个接口，一个获取Banner条列表，一个获取学习列表，它们两个互不依赖，便可以并行执行，如下：

class MainActivity : AppCompatActivity() {
//启动协程，发送请求
fun sendRequest() {
rxLifeScope.launch({
//当前运行在协程中，且在主线程运行
val asyncBanner = getBanners(this) //这里返回Deferred对象
val asyncPersons = getStudents(this) //这里返回Deferred对象
val banners = asyncBanner.await() //这里返回List对象
val students = asyncPersons.await() //这里返回List对象
//开始更新UI

    }, {
            //出现异常，就会到这里，这里的it为Throwable类型
        it.show("发送失败,请稍后再试!") //show方法是在Demo中扩展的方法
    })
}

面试复习路线，梳理知识，提升储备

自己的知识准备得怎么样，这直接决定了你能否顺利通过一面和二面，所以在面试前来一个知识梳理，看需不需要提升自己的知识储备是很有必要的。

关于知识梳理，这里再分享一下我面试这段时间的复习路线：（以下体系的复习资料是我从各路大佬收集整理好的）

CodeChina开源项目：《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》

• 架构师筑基必备技能
• Android高级UI与FrameWork源码
• 360°全方面性能调优
• 解读开源框架设计思想
• NDK模块开发
• 微信小程序
• Hybrid 开发与Flutter

知识梳理完之后，就需要进行查漏补缺，所以针对这些知识点，我手头上也准备了不少的电子书和笔记，这些笔记将各个知识点进行了完美的总结：

《960全网最全Android开发笔记》

《379页Android开发面试宝典》

历时半年，我们整理了这份市面上最全面的安卓面试题解析大全
包含了腾讯、百度、小米、阿里、乐视、美团、58、猎豹、360、新浪、搜狐等一线互联网公司面试被问到的题目。熟悉本文中列出的知识点会大大增加通过前两轮技术面试的几率。

如何使用它？

1.可以通过目录索引直接翻看需要的知识点，查漏补缺。
2.五角星数表示面试问到的频率，代表重要推荐指数

《507页Android开发相关源码解析》

只要是程序员，不管是Java还是Android，如果不去阅读源码，只看API文档，那就只是停留于皮毛，这对我们知识体系的建立和完备以及实战技术的提升都是不利的。

deChina开源项目：《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》](https://codechina.csdn.net/m0_60958482/android_p7)**

• 架构师筑基必备技能
• Android高级UI与FrameWork源码
• 360°全方面性能调优
• 解读开源框架设计思想
• NDK模块开发
• 微信小程序
• Hybrid 开发与Flutter

[外链图片转存中…(img-vGNDfQQJ-1630585590084)]

知识梳理完之后，就需要进行查漏补缺，所以针对这些知识点，我手头上也准备了不少的电子书和笔记，这些笔记将各个知识点进行了完美的总结：

[外链图片转存中…(img-1KXnVyhI-1630585590086)]

《960全网最全Android开发笔记》

[外链图片转存中…(img-tunhUf36-1630585590087)]

《379页Android开发面试宝典》

历时半年，我们整理了这份市面上最全面的安卓面试题解析大全
包含了腾讯、百度、小米、阿里、乐视、美团、58、猎豹、360、新浪、搜狐等一线互联网公司面试被问到的题目。熟悉本文中列出的知识点会大大增加通过前两轮技术面试的几率。

如何使用它？

1.可以通过目录索引直接翻看需要的知识点，查漏补缺。
2.五角星数表示面试问到的频率，代表重要推荐指数

[外链图片转存中…(img-lZjWAx4U-1630585590089)]

《507页Android开发相关源码解析》

只要是程序员，不管是Java还是Android，如果不去阅读源码，只看API文档，那就只是停留于皮毛，这对我们知识体系的建立和完备以及实战技术的提升都是不利的。

真正最能锻炼能力的便是直接去阅读源码，不仅限于阅读各大系统源码，还包括各种优秀的开源库。