最近大半年都在做java后台和flutter的相关开发，对老本行Android原生开发难免变得生疏，更是没机会用kotlin练练手，于是想将之前用java实现过的retrofit2自定义转换器使用kotlin重写一遍练练手，再稍微熟悉下retrofit2源码。
P.S.平时看别人写文章没觉得，自己写起来感觉好难。如有纰漏，还请海涵。
源码地址：https://github.com/YXLCN/Retrofit2-Converter
，有需要的可以下载demo看看
最终实现效果如下图，成功时在 Consumer onNext 直接返回接口定义的泛型对象，失败则直接触发 Consumer onError 的回调。
@GET("/api/picture")
fun getWallPaperList(@Query("page") page: Int): CustomFlowable
本文的自定义converter是根据 RxJava2CallAdapterFactory 及 GsonConverterFactory 进行的依葫芦画瓢，原理比较简单，如果有地方写的不清楚可以参考下源码。
1、自定义Flowable
自定义Flowable的目的在于方便在converter里根据返回类型进行拦截判断，非必须的步骤，但是如果不使用自定义的Flowable或Observable，偶尔想正常使用Flowable或者Observable进行数据解析时需要进行特殊处理。所以最好自定义一个简单的Flowable。
class CustomFlowable<T> {
var flowable: Flowable<T>
constructor(flowable: Flowable<T>) {
this.flowable = flowable
}
}
2、自定义AdapterFactory及CallAdapter
重写AdapterFactory及CallAdapter的目的是修改 retrofit.create(xxx.class) 的方法返回的Observable
而在retrofit.create方法中，在loadServiceMethod方法中对ServiceMethod进行了缓存。所以对同一adapter和converter只会分配一次，后续从缓存中读取。
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;
}
AdapterFactory 继承于 CallAdapter.Factory，只需重写其中的 get 方法，根据返回类型判断是否返回CallAdapter。
由于之前接口定义的返回值类型为CustomFlowable<WallPaperModel>，是一个参数化类型。所以在调用getRawType获得最外层的类型后，判断为CustomFlowable则进行adapter的分配。
并根据 getParameterUpperBound 获取到泛型类型后传递给CallAdapter进行解析使用。
代码如下：
class RespAdapterFactory<T> : CallAdapter.Factory() {
override fun get(
returnType: Type,
annotations: Array<Annotation>,
retrofit: Retrofit
): CallAdapter<*, *>? {
val rawType = getRawType(returnType)
// 对返回类型非 CustomFlowable 的请求不分发 adapter
if (rawType != CustomFlowable::class.java) {
return null
}
val observableType = getParameterUpperBound(0, returnType as ParameterizedType)
return CustomCallAdapter<BaseModel<T>>(observableType)
}
}
自定义CallAdapter继承自Retrofit2的CallAdapter，只需重写其中的adapter方法。
在RxJava2CallAdapter的adapt方法中根据是否异步，存在CallExecuteObservable和CallEnqueueObservable两种方式，由于两者都是final类，直接复制一个出来即可，不需进行额外操作。我这里选择的非异步的方式。
class CustomCallAdapter<R>: CallAdapter<R, Any> {
private var type: Type
constructor(type: Type) {
this.type = type
}
override fun adapt(call: Call<R>): Any {
val observable = CallExecuteObservable(call) as Observable<Response<BaseModel<R>>>
val bodyObservable = CustomBodyObservable(observable)
// 由于接口定义的返回值为CustomFlowable，所以这里用 CustomFlowable 进行装饰
return CustomFlowable(bodyObservable.toFlowable(BackpressureStrategy.LATEST))
}
override fun responseType(): Type {
return type
}
}
在CustomBodyObservable继承于Observable，配合继承于Observer的BodyObserver，在onNext方法中进行接口状态码的判断，进行统一的错误处理，请求的状态码异常时直接抛出错误，交由Consumer onError进行处理。
class CustomBodyObservable<T> : Observable<T> {
private val responseObservable: Observable<Response<BaseModel<T>>>
constructor(upstream: Observable<Response<BaseModel<T>>>) : super() {
responseObservable = upstream
}
override fun subscribeActual(observer: Observer<in T>) {
// 用 BodyObserver 装饰了原本的 observer，用于对异常情况进行统一处理
responseObservable.subscribe(BodyObserver(observer))
}
private class BodyObserver<R> internal constructor(private val observer: Observer<in R>) :
Observer<Response<BaseModel<R>>> {
private var terminated = false
override fun onSubscribe(disposable: Disposable) {
observer.onSubscribe(disposable)
}
override fun onNext(response: Response<BaseModel<R>>) {
Logger.i("BodyObserver onNext : ")
val body = response.body()
if (response.isSuccessful && body != null) {
// 对异常情况进行统一处理
if (body.mCode == 0) {
// 成功
Logger.i("onNext 请求成功, body.mResult : \n${body.mData}")
observer.onNext(body.mData!!)
} else {
val apiErrorCode: Int = body.mCode
val apiErrorMessage: String? = body.mMessage
//业务失败
val t = DadaThrowable(apiErrorCode, apiErrorMessage)
try {
observer.onError(t)
} catch (inner: Throwable) {
Exceptions.throwIfFatal(inner)
RxJavaPlugins.onError(CompositeException(t, inner))
}
}
} else {
terminated = true
val t: Throwable = HttpException(response)
try {
observer.onError(t)
} catch (inner: Throwable) {
Exceptions.throwIfFatal(inner)
RxJavaPlugins.onError(CompositeException(t, inner))
}
}
}
override fun onComplete() {
if (!terminated) {
observer.onComplete()
}
}
override fun onError(throwable: Throwable) {
if (!terminated) {
observer.onError(throwable)
} else {
// This should never happen! onNext handles and forwards errors automatically.
val broken: Throwable = AssertionError(
"This should never happen! Report as a bug with the full stacktrace."
)
broken.initCause(throwable)
RxJavaPlugins.onError(broken)
}
}
}
class DadaThrowable(val apiErrorCode: Int = -1, val apiErrorMessage: String? = "unknown error") :
Throwable() {
override val message: String
get() = "$apiErrorCode, 错误原因 : $apiErrorMessage"
}
}
3、自定义ConverterFactory及Converter
ConverterFactory和Converter都很简单，重写对应的方法，根据Retrofit的接口的返回类型对converter进行分配就行。Converter如下
class CustomBodyConverter<T>(private val type: Type) : Converter<ResponseBody, BaseModel<T>> {
override fun convert(value: ResponseBody): BaseModel<T> {
try {
val respString = value.string()
// Logger.i("convert ---> respString : $respString")
val model = BaseModel<T>()
val jsonObject = JSONObject(respString)
model.mMessage = jsonObject.getString("message")
model.mCode = jsonObject.getInt("code")
val result = jsonObject.getString("data")
if (!TextUtils.isEmpty(result) && !"null".equals(result, true)) {
when (type) {
JsonObject::class.java,
JSONObject::class.java -> {
Logger.i("convert ---> JSONObject ")
model.mData = JSONObject(result) as T
}
JsonArray::class.java -> {
Logger.i("convert ---> JsonArray ")
}
else -> {
model.mData = Gson().fromJson(result, this.type)
}
}
} else {
val rawType: Class<*> = TypeUtil.getRawType(type)
if (rawType == String.javaClass) {
model.mData = "" as T
} else {
model.mData = Gson().fromJson<T>("{}", type)
}
}
Logger.i("convert ---> model : $model")
return model
} catch (e: Exception) {
e.printStackTrace()
return BaseModel.unknownError(e)!!
}
}
}
至此，自定义converter基本完毕，retrofit2的源码不算太难，还支持高度定制，可以满足Android开发的各种需求了。
