Cet article présente une explication détaillée de l'emballage simple de Kotlin + Retrofit + Rxjava. Il est partagé avec vous. Les détails sont les suivants:
Modification instancielle
Retrofitutil d'objet {val connect_time_out = 30 // Durée de délai de connexion x secondes Val Read_time_out = 30 // Read Data Timeout Durée x secondes Val write_time_out = 30 // Write Data Timeout Durée x Seconds Val Retrofit: Retrofit ") Retrofit {log.d (" RetrofitUtil "," rétrofit initrofit ") Retrofit.builder () .baseurl ("http://gank.io/api/") // Cet article utilise l'API GitHub comme exemple.addConverterFactory (gsonConverterFactory.create ()) .AddCalladapterFactory (rxjava2CalladapterFactory.Create ()) .Client (GetokhTTPclient ()). Private Fun GetokHTTPClient (): okhttpClient {val builder = okhttpclient.builder () builder.connectTimeout (connect_time_out.tolong (), timeunit.seconds) .writeTimeout (write_time_out.tolong (), timeunit.seconds) .Readtimeout (read_time_out.Tinet.seconds) .Readtimeout (read_time_out. TimeUnit.seconds) if (buildConfig.debug) {builder.addinterceptor (httploggingInterceptor (). Setlevel (httploggingInterceptor.level.body))} else {builder.addinterceptor (httploggingInterceptor (). Setlevel (httplagging Demande d'en-tête Builder.AddInterceptor {chaîne -> Val Time = (System.Currenttimemillis () / 1000) .toString () + "" Val requestBuilder = chain.request (). newBuilder () requestBuilder.Addheder ("Time", Time) chain.proed (requestBuilder.build ())) }} Retour à l'encapsulation des données
Response de classe <T> {Var Error: Boolean = False Var Résultats: T? = null}L'API de développement de Gank.io a été utilisée dans la démo. Le format de retour du projet général précédent était le code + le message + T.
Erreur d'interface API / Exception Classe de manutention unifiée
CLASSE APIEXception: Exception {Var Code: int = 0 // Code d'erreur var msg: chaîne? = NULL // Message d'erreur Constructeur (Throwable: Throwable, Code: int): super (throwable) {this.code = code} constructeur (code: int, msg: string) {this.code = code this.msg = msg}}Définir les gestionnaires de Fonctionnement ONERRORRESUMENEXT:
Classe exceptionfonction <T>: fonction <lansage, observable <T>> {override fun appliquez (@Nonnull Throwable: Thrownable): RETOURABLABLE <T> {Log.e ("exceptionfunction", throwable.message) 1000 // Erreur inconnue Val analytique_server_data_error = 1001 // Paste (serveur) Erreur de données Val connect_error = 1002 // Erreur de connexion réseau Val Time_out_error = 1003 // Network Connection Timeout Fun HandleException (E: Throwable): APIEXCECTION {Val Ex: APIEXception if (e est apiexception) {// Erreur renvoyée par le serveur Retour E} Httpexception) {// Erreur http ex = apiexception (e, e.code ()) ex.msg = "Erreur de réseau:" + ex.code return ex} else if (e is JsonParseException || e est jSonexception || e est parseException || e est malformedjsonexception) {// l'erreur de données de la comparaison Ex = apiexception (e, e, e, e, e, e, e, e, e, are Analytique_server_data_error) ex.msg = "erreur de parse" return ex} else if (e is connexception) {// connector error ex = apiexception (e, connect_error) ex.msg = "connection a échoué" return ex} else if (e is sockettimeoutexception) {// nework timeout ex = apiexception (e, time_error) ex.m Ex} else {// Erreur inconnue ex = apiexception (e, un_known_error) ex.msg = e.Message return ex}}} Traitement de la demande d'encapsulation
Objet RX {/ ** * Rxlifecycle Binding Lifecycle de liaison * / FUN <T, E> GET (observable: observable <réponse <T>>, LifecycleProvider: LifecycycleProvider <e>): observable <T> {// Demande le cycle de vie de liaison pour prévenir la fuite de la mémoire, et retourner l'erreur du pointeur nul causé par la page RxappCompatActivity) {val rxAppCompatActivity = lifecycleProvider en tant que rxappCompatActivity observable.compose (rxappCompatActivity.bintuntilevent (activitéevent.destroy))} else if (LifecycleProvider est rxfragment) {val rxfragment = lifecycleprovider en tant que RXFragment) observable.composer (rxfragment.bintuntilevent (fragmentEvent.destroy))} return observable .compose (handlerresult ()) .onerrorResumeNext (exceptionFunction ())} / ** * demandes de fond partiels * / fun <T> get (observable: observable <t>>): observable <T> {return observable. .onerrorResumeNext (exceptionFunction ())} HandlereResult de classe privée <T>: observableTransformrer <Sponse <T>, t> {override fun appliquer (UpStream: observable <pon réponse <t>>): observableSource <T> {return upstream.flatmap {réponse -> Createresult (réponse)}. .UNSubScribeon (Schedulers.io ()) .ObServeOn (AndRoidschedulers.Mainthread ())}} Private Fun <T> Creareesult ({Associbert -> If (Réponse.Rerror) Lancez le code de correspondance (-1, "Server Exception") // Message else Response.Results? .let {abonné.onnext (Response.Results !!)}? Définir le retour de traitement unifié httpobserver
Résumé Classe HttpObServer <T>: Observer <T> {/ ** * La balise est un cas spécial * / privé var ResultNull: booléen = True Override Fun OnComplete () {// Case spéciale: onnext sera ignoré lorsque la demande est réussie, mais t == null, et il doit encore être traité pour être traité si (résultat) sur surcasse OnSubscribe (d: jetable) {// Dialogue peut être ajouté ici} Override Fun ONERROR (E: Throwable) {if (e est apiexception) {onerror (e.code, e.msg)} else {Onerror (0, e.Message)}} priver ONSUCCESS (T: T?) / ** * Le traitement unifié a échoué, tel que la défaillance de la connexion, etc. * @param code * @param msg * / ouvrir fun onError (code: int, msg: string?) {}} API
Class Result {var _id: String? = NULL VAR CREATEDAT: String? = null var desc: chaîne? = null var publié: chaîne? = null var source: chaîne? = NULL VAR Type: String? = null var url: string = "" var isUSED: boolean = false var qui: chaîne? = null var images: list <string>? = null / ** * petite image de la fille * / fun meizismallurl (): string {val meizi = url return meizi.replace ("grand", "small")}} interface apiservice {@get ("data / {type} / 10 / {page}") fun getGank (@path ("type") type: string, string, @path ("page") Page: int): Observable <Response <List <Result >>>} Object API {Val ApiService: APISERVICE par paresseux {log.d ("api", "apivice crée paresseux") rétrofitul.retrofit.create (apiservice :: class.java)}} utiliser
Remplacez Fun LoadData () {rx.get (api.apiservice.getgank (getType (), MintPage), this) .SubScribe (objet: httpobserver <list <sult>> () {override fun onSuccess (t: list <sult>?) {// GetDatasuccesss (t)} fun fun inerror (Code: MSG: MSGE: String?) {Super.onerror (code, msg) // getDatafailed ()}})}Le cycle de vie de liaison Rxlifecycle est utilisé pour faire face aux éventuelles fuites de mémoire. Le fragment et l'activité doivent hériter de la classe de base correspondante de Rx.
Programme de pratique
Client Android Meizikt Gank.io, en utilisant Kotlin + Retrofit2 + Rxjava
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.