示例1 登录并返回用户信息
传统异步方式
使用Retrofit+Handler
1、引入Retrofit依赖
// Retrofit库
implementation "com.squareup.retrofit2:retrofit:2.9.0"
implementation "com.squareup.retrofit2:retrofit-mock:2.7.2"
implementation "com.squareup.retrofit2:converter-gson:2.7.2"
implementation 'com.squareup.okhttp3:logging-interceptor:3.5.0'
implementation "com.squareup.retrofit2:converter-scalars:2.7.2"
implementation "com.squareup.retrofit2:adapter-rxjava2:2.7.2"
2、定义接口
interface WanAndroidApi {
@POST("/user/login")
@FormUrlEncoded
fun loginAction(@Field("username") username: String, @Field("password") password: String):
Call<ResponseWrapper<LoginRegisterResponse>>
}
3、相应数据实体
data class LoginRegisterResponse(
val admin: Boolean,
val chapterTops: List<*>,
val collectIds: List<*>,
val email: String?,
val icon: String?,
val id: String?,
val nickname: String?,
val password: String?,
val publicName: String?,
val token: String?,
val type: Int,
val username: String?
)
4、响应数据包装类
data class ResponseWrapper<T>(val data: T, val errorCode: Int, val errorMsg: String)
5、数据请求Client
class ApiClient {
private object Holder {
val INSTANCE = ApiClient()
}
companion object {
val instance = Holder.INSTANCE
}
fun <T> instanceRetrofit(apiInterface: Class<T>): T {
//OkHttpClient请求服务器
val mOkhttpClient = OkHttpClient().newBuilder().apply {
readTimeout(10000, TimeUnit.SECONDS)//读取超时时间
connectTimeout(10000, TimeUnit.SECONDS)//连接超时时间
writeTimeout(10000, TimeUnit.SECONDS)//写入超时时间
}.build()
val retrofit: Retrofit = Retrofit.Builder().baseUrl("https://www.wanandroid.com")
//请求方
.client(mOkhttpClient)
//响应方
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())//RxJava处理
.addConverterFactory(GsonConverterFactory.create())//Gson解析
.build()
return retrofit.create(apiInterface)
}
}
6、view层请开启子线程发起请求，然后通过Handler切换到主线程更新UI
//第二步：用Handler接收请求结果并更新UI
private val mHandler = Handler(Looper.getMainLooper()) {
val result = it.obj as ResponseWrapper<*>
tv_response.text = result.data.toString()
mProgressDialog?.dismiss()
false
}
//第一步：开启异步线程，请求服务器
thread {
val loginResult = ApiClient.instance.instanceRetrofit(WanAndroidApi::class.java)
.loginAction("Derry-vip", "123456")
val result = loginResult.execute().body()
//切换到主线程更新UI,把请求结果发送给Handler
val msg = mHandler.obtainMessage()
msg.obj = result
mHandler.sendMessage(msg)
}
携程方式
使用Retrofit+协程，数据实体、包装类，请求Client同上。
1、定义接口
interface WanAndroidApi {
@POST("/user/login")
@FormUrlEncoded
suspend fun loginActionCoroutine(
@Field("username") username: String,
@Field("password") password: String
): ResponseWrapper<LoginRegisterResponse>
}
使用suspend关键字修饰，起到一个提示的作用，表示该函数会使用协程挂起，有一个代码颜色规则。用suspend修饰的方法中需要使用协程，比如withContext()，否则suspend关键字没有意义，并且会置灰。而一旦使用了协程，该方法就必须用suspend来修饰。
2、使用协程发起请求
//使用协程登录 同步代码实现异步效果
//GlobalScope.launch()默认为IO线程，需要用GlobalScope.launch(Dispatchers.Main)切换到主线程
GlobalScope.launch(Dispatchers.Main) {
//UI线程
val result = ApiClient.instance.instanceRetrofit(WanAndroidApi::class.java)
.loginActionCoroutine("Derry-vip", "123456")//1、挂起出去执行异步操作 2、操作完成后恢复主线程
//应为{}内为主线程，所以可以直接更新UI
tv_response.text = result.data.toString()
mProgressDialog?.dismiss()
}
注意： GlobalScope.launch()默认为异步(IO)线程，需要用GlobalScope.launch(Dispatchers.Main)切换到主线程，并且实际开发中很少直接用GlobalScope，因为它是作用于全局的，只有在进程被kill的时候才会销毁。实际开发可以使用viewModelScope等。
对比
1、使用传统的异步请求，代码量比较大，很繁琐，使用协程代码非常简洁。
2、使用传统的异步请，请求完数据再反过来发送给Handler去处理代码的逻辑无法按照人类正常的思维认知的顺序去写；而使用协程，用同步代码实现效果，所有逻辑都是从上到下很流畅，符合人类的认知顺序。
示例2 模拟按顺序调用3个接口并返回信息
传统异步方式
1、定义接口回调，回调请求结果
/**
* 模拟请求结果回调
*/
interface ResponseCallBack {
/**
* 服务器请求成功
* @param successInfo 成功回调信息
*/
fun onSuccess(successInfo: String)
/**
* 服务器请求失败
* @param errorInfo 失败回调信息
*/
fun onError(errorInfo: String)
}
2、定义3个接口的请求方法
//第一步 请求用户数据
private fun requestUserInfo(responseCallBack: ResponseCallBack) {
val requestSuccess = true
//开启异步线程，加载服务器数据
thread {
Thread.sleep(2000)
if (requestSuccess) {
responseCallBack.onSuccess("请求用户数据 成功")
} else {
responseCallBack.onError("请求用户数据 失败")
}
}
}
//第二步 请求课程数据
private fun requestLessonInfo(responseCallBack: ResponseCallBack) {
val requestSuccess = true
thread {
Thread.sleep(2000)
if (requestSuccess) {
responseCallBack.onSuccess("请求课程信息 成功")
} else {
responseCallBack.onError("请求课程数据 失败")
}
}
}
//第二步 请求课程详情数据
private fun requestLessonDetailInfo(responseCallBack: ResponseCallBack) {
val requestSuccess = true
thread {
Thread.sleep(2000)
if (requestSuccess) {
responseCallBack.onSuccess("请求课程详情信息 成功")
} else {
responseCallBack.onError("请求课程详情数据 失败")
}
}
}
3、按顺序发起请求，并回调结果更新UI
private fun requestData() {
mProgressDialog = ProgressDialog(this)
mProgressDialog?.setTitle("loading...")
mProgressDialog?.show()
//请求用户信息
requestUserInfo(object : ResponseCallBack {
override fun onSuccess(successInfo: String) {
//用户信息请求成功
val handler = object : Handler(Looper.getMainLooper()) {
override fun handleMessage(msg: Message) {
super.handleMessage(msg)
//更新UI
tv_response.text = successInfo
tv_response.setTextColor(Color.RED)
//请求课程信息
requestLessonInfo(object : ResponseCallBack {
override fun onSuccess(successInfo: String) {
//课程信息请求成功
val handler = object : Handler(Looper.getMainLooper()) {
override fun handleMessage(msg: Message) {
super.handleMessage(msg)
//更新UI
tv_response.text = successInfo
tv_response.setTextColor(Color.BLUE)
//请求课程详情信息
requestLessonDetailInfo(object : ResponseCallBack {
override fun onSuccess(successInfo: String) {
//课程详情信息请求成功
val handler =
object : Handler(Looper.getMainLooper()) {
override fun handleMessage(msg: Message) {
super.handleMessage(msg)
//更新UI
tv_response.text = successInfo
tv_response.setTextColor(Color.GREEN)
mProgressDialog?.dismiss()
}
}
handler.sendEmptyMessage(0)
}
override fun onError(errorInfo: String) {
}
})
}
}
handler.sendEmptyMessage(0)
}
override fun onError(errorInfo: String) {
}
})
}
}
handler.sendEmptyMessage(0)
}
override fun onError(errorInfo: String) {
}
})
}
携程方式
1、定义3个接口的请求方法
//第一步 请求用户数据
//suspend 就是一个提醒作用，提醒用户 当前的函数，是挂起函数，可能会执行异常操作
private suspend fun requestUserInfo(): String {
val requestSuccess = true
withContext(Dispatchers.IO) {
delay(2000L)
}
return if (requestSuccess) "请求用户数据 成功" else "请求用户数据 失败"
}
//第二步 请求课程数据
private suspend fun requestLessonInfo(): String {
val requestSuccess = true
withContext(Dispatchers.IO) {
delay(2000L)
}
return if (requestSuccess) "请求课程信息 成功" else "请求课程数据 失败"
}
//第二步 请求课程详情数据
private suspend fun requestLessonDetailInfo(): String {
val requestSuccess = true
withContext(Dispatchers.IO) {
delay(2000L)
}
return if (requestSuccess) "请求课程详情信息 成功" else "请求课程详情数据 失败"
}
2、使用协程发起请求，并更新UI
private fun requestData() {
val progressDialog = ProgressDialog(this)
progressDialog.setTitle("loading...")
progressDialog.show()
//一般不用GlobalScope GlobalScope是全局的作用于，只有进程被kill的时候才会销毁
GlobalScope.launch(Dispatchers.Main) {
val result1 = requestUserInfo()
tv_response.text = result1
tv_response.setTextColor(Color.RED)
val result2 = requestLessonInfo()
tv_response.text = result2
tv_response.setTextColor(Color.BLUE)
val result3 = requestLessonDetailInfo()
tv_response.text = result3
tv_response.setTextColor(Color.GREEN)
progressDialog.dismiss()
}
}
对比
传统方式代码量很大，还需要进行大量的嵌套，代码阅读困难；携程方式代码极度简洁，很容易阅读。
关注木水小站 (zhangmushui.cn)和微信公众号【木水Code】，及时获取更多最新技术干货。
