Retrofit+Moshi+Kotlin 如何网络请求中的业务异常_retrofit moshi

Moshi是square开源的一款JSON解析工具，有文章分析其和kotlin很搭且性能非常优秀，但对此我们并没有很深刻的理解，但是其API的易用性还是很不错的，用Gson作为解析工具的时候，一直有一个问题，如果json字符串中有一个字段类型匹配不上就会报错，这个时候如果想知道具体的结果就得手动解析，为什么不能在匹配不上的时候给默认值呢？Moshi则可以传入Adapter来自定义默认值，这对我们统一处理业务异常挺有用的。

先贴一下用法

这是创建Retrofit的地方，关键类是DefaultOnDataMismatchAdapter

fun factory(): Retrofit {
        return Retrofit.Builder()
            .baseUrl(HttpConfig.baseUrl)
            .client(okHttpClientBuilder.build())
            .addConverterFactory(
                MoshiConverterFactory.create(
                    Moshi.Builder()
                        .add(DefaultOnDataMismatchAdapter.newFactory())
                        .build()
                )
            )
            .build()
    }

这是DefaultOnDataMismatchAdapter的实现

 
class DefaultOnDataMismatchAdapter<T>(val delegate: JsonAdapter<T>) : JsonAdapter<T>() {
    @Throws(IOException::class)
    override fun fromJson(reader: JsonReader): T? {
        val peeked = reader.peekJson()
        val result: T?
        try {
            var errorCode = -1
            var errorMsg = ""
            var errorCodeInit = false
            var errorMsgInit = false
            peeked.beginObject()
            while (peeked.hasNext()) {
                val nextName = peeked.nextName() ?: continue
                when (nextName) {
                    "errcode" -> {
                        errorCode = peeked.nextInt()
                        errorCodeInit = true
                    }
                    "errmsg" -> {
                        errorMsg = peeked.nextString()
                        errorMsgInit = true
                    }
                }
                if (errorCodeInit && errorMsgInit) {
                    if (errorCode != 0) {
                        //解析到errorCode不是0，业务返回异常，抛出异常让外界处理
                    
                        throw CustomerException(errorCode, errorMsg)
                    }
 
                    break
                }
            }
            result = delegate.fromJson(reader)
        } catch (e: JsonDataException) {
            throw e
        } finally {
            peeked.close()
        }
        reader.skipValue()
        return result
    }
 
 
    @Throws(IOException::class)
    override fun toJson(writer: JsonWriter, value: T?) {
        delegate.toJson(writer, value)
    }
 
    class CustomerException(val errorCode: Int, val errorMsg: String) : IOException()
 
    companion object {
        fun newFactory(): Factory {
            return object : Factory {
                override fun create(
                    requestedType: Type, annotations: Set<Annotation?>?, moshi: Moshi
                ): JsonAdapter<*>? {
                    //nextAdapter是系统提供的默认解析器，自定义的解析器最终也是用这个来解析的
                    val delegate: JsonAdapter<Any?> =
                        moshi.nextAdapter(this, requestedType, annotations)
                    return if (requestedType.toString().contains("ApiResponse")) {
                        //如果发现要解析ApiResponse，就用我们自己的Adapter
                        DefaultOnDataMismatchAdapter(delegate)
                    } else {
                        //返回null 表示这个Factory不处理该类型的解析
                        null
                    }
 
                }
            }
        }
    }
}

retrofit+Gson也有自己处理业务异常的方式，但是因为Gson的Api不兼容默认类型，所以是在ConvertorFactory中做处理的，相对而言，Moshi这种用Adapter的方式去处理更加灵活且优雅一些