[JAVA] Ich habe einen Adapter für den Kommunikationsunterricht mit Retrofit2 + Rx2 erstellt

Einführung

Es ist immer noch nur ein Memo, daher denke ich, dass es viele Dinge gibt, die schwer zu verstehen sind. Ich würde mich freuen, wenn Sie eine entsprechende Bearbeitungsanfrage stellen könnten.

Gemeinsamer Schreibstil

Es ist eine Voraussetzung, dass Sie über allgemeine Kenntnisse in Retrofit und Rx verfügen. Wenn Sie darüber wissen möchten, wird dieser Artikel usw. sehr hilfreich sein API-Client schnell mit Retrofit und Rx in Kotlin implementieren

class MyApiDatasore {
   fun <T> createService(service: Class<T>) =
                Retrofit.Builder()
                        .baseUrl("url")
                        .addConverterFactory(JacksonConverterFactory.create(ObjectMapper()))
                        .addCallAdapterFactory(RxCallAdapterFactory.create())
                        .build()
                        .create(service)!!
}

interface MyApiService {
    @Get("hogehoge")
    fun fetchHogeHoge()

}

Anrufer

MyApiDatastore().createService(MyApiService::class.java)
                    .fetchHogeHoge()
                    .subscribeOn(Schedulers.newThread())       //In einem Hintergrund-Thread ausführen
                    .observeOn(AndroidSchedulers.mainThread()) //Benachrichtigen Sie den Haupt-Thread
                    .subscribe({
                        // onSuccess
                    }) { e ->
                        // onError

                    }

Problem

Es ist ärgerlich, dies jedes Mal zu schreiben.

  ...
  .subscribeOn(Schedulers.newThread())
  .observeOn(AndroidSchedulers.mainThread())

Lass es uns zusammenstellen

Lesen Sie Artikel hier oder lesen Sie die Dokumentation und erstellen Sie Ihren eigenen benutzerdefinierten Adapter, der jedes Mal die oben genannten Schritte ausführt. erstellt.

**
 * RxJava adapter for Retrofit.
 * Always `subscribeOn(Schedulers.newThread())`
 *        `observeOn(AndroidSchedulers.mainThread())`
 */
private class RxThreadingCallAdapterFactory : CallAdapter.Factory() {

    companion object {
        fun create(): CallAdapter.Factory = RxThreadingCallAdapterFactory()
    }

    //Führen Sie immer einen neuen Thread aus
    private val original: RxJava2CallAdapterFactory = RxJava2CallAdapterFactory.createWithScheduler(Schedulers.newThread())

    override fun get(returnType: Type, annotations: Array<Annotation>, retrofit: Retrofit): CallAdapter<*, *> {
        // `original.get() == null` -> Retrofit throws IllegalArgumentException.
        return RxCallAdapterWrapper(original.get(returnType, annotations, retrofit)!!)
    }

    private class RxCallAdapterWrapper<R>(private val wrapped: CallAdapter<R, *>) : CallAdapter<R, Any> {
        override fun responseType(): Type = wrapped.responseType()

        //Benachrichtigen Sie immer den Haupt-Thread
        override fun adapt(call: Call<R>) = wrapped.adapt(call)
                .let {
                    when (it) {
                        is Completable -> {
                            it.observeOn(AndroidSchedulers.mainThread())
                        }
                        is Observable<*> -> {
                            it.observeOn(AndroidSchedulers.mainThread())
                        }
                        is Single<*> -> {
                            it.observeOn(AndroidSchedulers.mainThread())
                        }
                        is Flowable<*> -> {
                            it.observeOn(AndroidSchedulers.mainThread())
                        }
                        is Maybe<*> -> {
                            it.observeOn(AndroidSchedulers.mainThread())
                        }
                        else -> errorIfDebug()
                    }
                }!!
    }
}

Wie benutzt man

Wenn Sie den Nachrüstdienst wie unten gezeigt verwenden, können Sie den Prozess so implementieren, dass er im Hintergrund ausgeführt wird, und den Hauptthread benachrichtigen, indem Sie jedes Mal ".subscribe" schreiben.

      Retrofit.Builder()
              .baseUrl("url")
              .addConverterFactory(JacksonConverterFactory.create(ObjectMapper()))
              .addCallAdapterFactory(RxThreadingCallAdapterFactory.create()) //Verwenden Sie hier einen benutzerdefinierten Adapter
              .build()
              .create(service)!!