Este artículo presenta una explicación detallada del empaque simple de Kotlin + Retrofit + RxJava. Se comparte contigo. Los detalles son los siguientes:
Instancia de modernización
Objeto RetrofitUtil {Val Connect_time_out = 30 // Duración de tiempo de espera de conexión x segundos val read_time_out = 30 // Lea la duración del tiempo de espera de datos x segundos Val Write_Time_out = 30 // Escribir Tiempo de espera de datos Duración x Seconds Val Retrofit: Retrofit by Lazy {log.d ("RetrofiTil", "Retrofit Init Init Lazy .baseurl ("http://gank.io/api/") // Este artículo usa la API de GitHub como ejemplo.AddConverterFactory (gsonConverterFactory.create ()) .addcalladapterFactory (rxJava2CallApTactory.create () .client (getOkhtpClient ().)).) getokhttpClient (): okhttpClient {val builder = okhttpclient.builder () builder.connecttimeout (conecte_time_out.tolong (), timeUnit.seconds) .writeTimeOut (write_time_out.tolong (), timeUnit.seconds) .Readtimeout (read_time_out.tolong (),),). TimeUnit.Seconds) if (buildConfig.deBug) {builder.addinterceptore (httPloggingInterceptor (). SetLevel (httPlogginginterceptor.Level.Body))} más {builder.addinterceptor (htttttintercepeptor (). SetLevel (httpploggingginginterceptor.leNELEL) Header Builder.addinterceptor {Chain -> Val Time = (System.CurrentTimEmillis () / 1000) .ToString () + "" Val requestBuilder = Chain.Request (). NewBuilder () requestBuilder.addheader ("Time", Time) Chain.Proceed (requestbuild.build ())} regreso Builder Builder Builder ()})})} Volver a la encapsulación de datos
Respuesta de clase <T> {Error de var: boolean = falso var resultados: t? = nulo}La API de desarrollo de Gank.io se utilizó en la demostración. El formato de retorno del proyecto general anterior fue el formato Code + Message + T.
Error de interfaz API/Excepción Clase de manejo unificado
clase ApiException: Exception {var Code: int = 0 // Código de error var msg: string? = NULL // Error Message Constructor (Showable: Throwable, Code: int): Super (showable) {this.code = code} constructor (código: int, msg: string) {this.code = code this.msg = msg}}Definir las manejas de excepción de la Función OnerrorResumEnext:
Class ExceptionFunction <T>: function <Throwable, Observable <T>> {anular diversión aplicar (@nonnull showable: showable): observable <t> {log.e ("excepcionFunction", showable 1000 // Error desconocido Val Analytic_server_data_error = 1001 // Pegar (servidor) Error de datos Val Connect_Error = 1002 // Error de conexión de red Val Time_out_error = 1003 // Conexión de red Tiempo de espera de la red HandleException (e: Showable): ApiException {val ex: apiException si (e es apiException) {// error devuelto por el retorno e} el servidor e » {// http error ex = apiexception (e, e.code ()) ex.msg = "Error de red:" + ex.code return ex} else if (e is jsonparseException || e es jsonexception || e es parseException || e es malformedjSonexception) {// error de datos de parte ex = apiexception (e, analic_server_server) = "Error de Parse" return ex} else if (e is ConnectException) {// Connect Network Error ex = apiexception (e, conect_error) ex.msg = "Connection fallado" return ex} else if (e es socketTimeoutException) {// network timeOut ex = apiexception (e, time_error) ex.msg = "network timeout" el más} el más} el más}}}}}} {///////////////////1sct. Apiexception (e, un_know_error) ex.msg = e.message return ex}}} Procesamiento de solicitudes de encapsulación
Object rx { / *** rxlifecycle Lifecycle de vida* / diversión <t, e> get (observable: observable <respuesta <t>>, lifecycleProvider: lifecycleProvider <E>): observable <t> {// solicitar el ciclo de vida de enlace para la fuga de memoria y el retorno de la puntuación null RxAppCompatactivity) {val rxAppCompatactivity = lifecycleProvider como rxAppCompatActivity observable.compe (rxAppCompatActivity.BindUnTileVent (ActivityEvent.DestrOY))} de lo contrario (LifeCycleProvider es rxfragment) {val rxfragment = lifeCclePravider As rxfragment como rxfragment observable.comPose (rxFragment.BindUnTileVent (FragmentEvent.DestrOY)))} return observable .Compose (handLaterSult ()) .onerRorResUmExt (excepcionFunction ())} / *** Solicitudes de fondo parcial* / diversión <t> get (observable: observable < -t>>): observable <T> {return observable .ComeTere. .onerrorResumEnext (excepcionFunction ())} privado HandleLerSult <T>: ObservableTransformer <Respuesta <T>, t> {anular diversión Aplicar (Upstream: Observable <Respuesta <T>>): ObservableSource <T> {return upstream.flatmap {Respuesta -> CreaterSult (Respuesta)} .subscribeon (sched) .unsubScribeon (schedulers.io ()) .Observeon (androidSchedulers.Mainthread ())}} diversión privada <t> crereaterSult (respuesta: respuesta <t>): observable <t> {return observable.create ({subscriber -> si (respuesta.error) droga apiexception (-1, "excepción del servidor en general"). Mensaje más Respuesta.Results? Definir retorno de procesamiento unificado httpobserver
clase abstracta httpobserver <t>: observador <t> { / *** La etiqueta es un caso especial* / private var de resultados: boolean = true anulación divertir oncomplete () {// caso especial: OnNext se irá cuando la solicitud sea exitosa, pero t == null, y aún debe procesarse con éxito si (resultnull) Onsucss (nulle es exitosa, pero es exitosa, y se debe procesar con éxito si (resultado) en onSubScribe (d: desechable) {// El diálogo se puede agregar aquí} anular diversión oneRorRor (e: showable) {if (e is apiException) {onErRor (e.code, e.msg)} else {onErRor (0, e.message)}}} anular diversión oneNext (t) OnSuccess (t: t?) / ** * Falló el procesamiento unificado, como falla de inicio de sesión, etc. * @param * @param msg * / abrir diversión onderror (código: int, msg: string?) {}} API
Resultado de clase {var _id: string? = nulo var createdat: string? = NULL var desc: string? = nulo var publicadoat: string? = NULL var Fuente: String? = Tipo de var nulo: String? = NULL var url: string = "" var está usado: boolean = falso var quién: cadena? = Imágenes VAR NULL: List <String>? = NULL/*** La imagen pequeña de la niña*/divertida meizsmallurl (): string {val meizi = url return meizi.replace ("grande", "pequeño")}} interface apiservice {@get ("data/{type}/10/{página}") Fun getGank (@path ("tipo") tipo: string, @path ("página") Observable <Respuesta <Lista <Result>>>} API de objeto {val apiservice: apiservice por perezoso {log.d ("API", "Apiservice Crear perezoso") retrofitUtil.recrofit.create (apiservice :: class.java)}} usar
anular diverse loadData () {rx.get (api.apiservice.getGank (getType (), mintPage), this) .subscribe (objeto: httpobserver <list <sult> () {anular diversión de diversión (t: list <sult>?) {// getDataSucess (t) Cadena?) {Super.onerror (código, msg) // getDatafailed ()}})}El ciclo de vida de unión a rxlifecycle se usa para lidiar con posibles fugas de memoria. El fragmento y la actividad deben heredar la clase base correspondiente de RX.
Programa de práctica
Meizikt Gank.io Android Client, usando Kotlin + Retrofit2 + Rxjava
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.