Este artigo apresenta uma explicação detalhada da embalagem simples de Kotlin + Retrofit + Rxjava. É compartilhado com você. Os detalhes são os seguintes:
Instanciar a retrofit
Objeto retrofitutil {val Connect_time_out = 30 // Duração do tempo limite da conexão x segundos val Val read_time_out = 30 // Leia o tempo limite de dados Duração x segundos val write_time_out = 30 // grava o tempo limite de dados x segundos) retrofit: retrofit por lazy {LOG.DOF ("retrofitItil", "Retrofit LAZY" .baseUrl("http://gank.io/api/") //This article uses GitHub API as an example.addConverterFactory(GsonConverterFactory.create()) .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) .client(getOkHttpClient()) .build() } private fun getOkhttpClient (): okhttpclient {val construtor = okhttpclient.builder () builder.connecttimeout (Connect_time_out.tolong (), timeunit.seconds) .writEtimeout (write_time_out.tolong (), timeUnit.Seconds). TimeUnit.Seconds) if (BuildConfig.debug) {Builder.addintercept (httPloggingIntercept (). Cabeçalho Builder.addinterceptor {Chain -> Val Time = (System.CurrentTimemillis () / 1000) .ToString () + "" Val RequestBuilder = Chain.Request (). NewBuilder () requestBuilder.addHeader ("Time) Chain.ilerDeed.Builder (). Retornar ao encapsulamento de dados
classe Response <t> {var erro: boolean = false var Resultados: t? = nulo}A API de desenvolvimento do Gank.io foi usada na demonstração. O formato de retorno do projeto geral anterior foi o código + mensagem + T formato.
Erro da interface da API/Exceção de manuseio unificado Classe
classe apiException: exceção {var código: int = 0 // código de erro var msg: string? = NULL // ERROT MENSEGRIRTOR (jogável: jogável, código: int): super (throwable) {this.code = code} construtor (code: int, msg: string) {this.code = code this.msg = msg}}Definir ExceptionFunction lida com o OnErrorReSumeNext:
Classe ExceptionFunction <T>: FUNÇÃO <Throwable, observável <T>> {Substitua Fun Aplicar (@Nonnull Throwable: Throwable): Observável <T> {log.e ("ExceptionFunction", Throwable.Message) Return observable.error (ExceptionEngine (). error analtic_server_data_error = 1001 // paste (servidor) erro de dados vale connect_error = 1002 // erro de conexão de rede val time_out_error = 1003 // tempo limite de rede hidrômexception (e: shrowxex): handlexex): handlexex): hanSex): houset {srort byrt byrt) {APIException {val ex: apiexception if (e é apiexception) {/) // error http ex "Erro de análise" retorna ex} else if (e é ConnectException) {// Conecte o erro de rede Ex = apIexception (e, Connect_error) ex.MSG = "Falha na conexão" retorna ex} else if (e é sockettimeoutException) {// Rede Timeout Ex = APIEXCOPTH (E, Timeout_Orror) Ex.MS) Apiexception (e, un_known_error) ex.msg = e.message return ex}}} Processamento de solicitação de encapsulamento
Objeto rx { / *** rxlifecycycle Lifecycle de vida* / diversão <t, e> get (observável: observável <resposta <t>>, LifeCycleProvider: LifeCycleProvider <E>): observar o ponteiro de LIFET {// Solicitar o ciclo de vida para impedir o vazamento de memória e o retorno do Null Pointer causado pela página que se deve ser o que o de retorno do Null { RxAppCompatActivity) { val rxAppCompatActivity = lifecycleProvider as RxAppCompatActivity observable.compose(rxAppCompatActivity.bindUntilEvent(ActivityEvent.DESTROY)) } else if (lifecycleProvider is RxFragment) { val rxFragment = lifecycleProvider as RxFragment obsertable.compose (rxfragment.binduntilevent (fragmentEvent.destroy))} retornar observável .compor (handleResult ()) .ONERRRORRESUMENEXT (ExceptionFunction ())} / *** solicitações parciais de fundo* / diversão <T. Get (observable: observável <t> .ONERRORRORESUMENEXT (ExceptionFunction ())} Classe privada HandleResult <T>: ObservableTransformer <Response <T>, t> {Substitua Fun Apply (upstream: observável <resposta <t>>): SpotablesOrce <T> {Return upstream.flatmap {resposta -> CeREArSult (resposta). .unsubscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) } } private fun <T> createResult(response: Response<T>): Observable<T> { return Observable.create({ subscriber -> if (response.error) throw ApiException(-1, "Server Exception") // Generally speaking, your own server exception will return the corresponding code and Mensagem else Response.Results? .Let {Subscrint.onnext (Response.Results !!)}?: Subscrint.onComplete ()})}} Definir httpobserver de retorno de processamento unificado
Classe abstrata httpobserver <t>: observer <t> { / *** tag é um caso especial* / privado Var ResultNull: boolean = True Substitua Fun Oncomplete () {// Caso especial: OnExt será ignorado quando a solicitação for bem -sucedida, mas t == null e ainda é que é necessário (resulte -se (resulte), quando a solicitação é que a solicitação é que a solicitação, mas a SoldnUll), que é fúneira, quando a SoldNeln), quando a solicitação), que é fuml). Descartável) {// A caixa de diálogo pode ser adicionada aqui} Substituir o Fun OnError (e: throwable) {if (e é apiException) {OnError (e.code, e.msg)} else {OnError (0, E.Message)}} Substitua Fun OnNext (t: t) {resultadonull = false onSuct)}}} t) t) t) t) (resultado? O processamento unificado falhou, como falha de login, etc. * @param code * @param msg */ open divertido oror (código: int, msg: string?) {}} API
Resultado da classe {var _id: string? = null var criateat: string? = NULL VAR Desc: String? = null var publledat: string? = NULL VAR Fonte: String? = NULL VAR TIPO: String? = null var url: string = "" var isUsuse: boolean = false var who: string? = imagens nulas var: list <string>? = null/*** imagem pequena da garota*/diversão meizismallurl (): string {val meizi = url return meizi.replace ("grande", "small")}} interface apiservice {@get ("dados/{type}/10/ @ @ @) fun getGank (" "tipo") Observável <Resposta <LIST <LIST <SILLD>>>} Objeto API {Val ApiseService: Apiservice por Lazy {Log.d ("API", "Apiservice Create Lazy") Retrofitutil.retofit.create (APISERVICE :: Class.java)}}}}}}}}}} usar
Substitua Fun loadData () {rx.get (api.apiseService.getGank (getType (), mintpage), this) .SubScribe (objeto: httpobServer <list <cost >> () {substituir diversão onsuccess (t: list <trist>?) String?) {Super.onerror (código, msg) // getDataFailed ()}})}O ciclo de vida de ligação ao ciclo RXLIFECLO é usado para lidar com possíveis vazamentos de memória. Fragmento e atividade precisam herdar a classe base correspondente de Rx.
Programa de prática
Cliente meizikt gank.io Android, usando kotlin + retrofit2 + rxjava
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.