मैंने अपने प्रोजेक्ट में कोरजाइंस के साथ RxJava को कैसे प्रतिस्थापित किया और आपको शायद ऐसा क्यों करना चाहिए

नमस्कार, हेब्र! मैं आपको अपने एंड्रॉइड प्रोजेक्ट्स में RxJava के बजाय कोटलिन कॉरआउट्स के उपयोग पर पाउलो सातो के एक लेख का अनुवाद प्रस्तुत करता हूं।

RxJava एक bazooka के रूप में, अधिकांश अनुप्रयोग इसकी मारक क्षमता का आधा भी उपयोग नहीं करते हैं। लेख में चर्चा की जाएगी कि इसे कोटलिन कोरटाइन्स (कोरटाइन) के साथ कैसे प्रतिस्थापित किया जाए।

मैं कई वर्षों से RxJava के साथ काम कर रहा हूं। यह निश्चित रूप से किसी भी एंड्रॉइड प्रोजेक्ट के लिए सर्वश्रेष्ठ पुस्तकालयों में से एक है, जो आज भी सदमे में है, खासकर यदि आप जावा में प्रोग्रामिंग कर रहे हैं। यदि आप कोटलिन का उपयोग करते हैं, तो हम कह सकते हैं कि शहर में एक नया शेरिफ है।

ज्यादातर RxJava का उपयोग केवल थ्रेड्स को नियंत्रित करने के लिए और कॉलबैक नरक को रोकने के लिए किया जाता है (यदि आप नहीं जानते कि यह क्या है, तो अपने आप को भाग्यशाली और ऐसा क्यों मानें)। तथ्य यह है कि हमें यह ध्यान रखना चाहिए कि RxJava की वास्तविक शक्ति प्रतिक्रियाशील प्रोग्रामिंग और बैकस्पेस है। यदि आप अतुल्यकालिक अनुरोधों को नियंत्रित करने के लिए इसका उपयोग करते हैं, तो आप मकड़ी को मारने के लिए बाज़ूका का उपयोग करते हैं। वह अपना काम करेगी, लेकिन यह ओवरकिल है।

RxJava की एक उल्लेखनीय कमी तरीकों की संख्या है। यह बहुत बड़ा है और पूरे कोड में फैल जाता है। कोटलिन में, आप RxJava का उपयोग करके आपके द्वारा पहले बनाए गए व्यवहार को लागू करने के लिए कोरटाइन का उपयोग कर सकते हैं।

लेकिन ... कोरटाइन क्या हैं?

Corutin एक सूत्र में प्रतिस्पर्धी कार्यों को संभालने का एक तरीका है। थ्रेड तब तक काम करेगा जब तक इसे रोका नहीं जाता है और एक नया थ्रेड बनाए बिना संदर्भ प्रत्येक कोरटाइन के लिए बदल जाएगा।
कोटलिन में अभी भी प्रायोगिक प्रायोगिक हैं, लेकिन वे कोटलिन 1.3 में शामिल हैं, इसलिए मैंने एक नया यूसेज कैशे (स्वच्छ वास्तुकला के लिए) क्लास के नीचे लिखा था जो उनका उपयोग करता है। इस उदाहरण में, एक coroutine कॉल किसी एकल फ़ाइल में एनकैप्सुलेटेड है। इस प्रकार, अन्य परतें, निष्पादित किए जा रहे कोराउट पर निर्भर नहीं होंगी, और अधिक डिस्कनेक्टेड आर्किटेक्चर प्रदान करेंगी।

/** * (C) Copyright 2018 Paulo Vitor Sato Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ package com.psato.devcamp.interactor.usecase import android.util.Log import kotlinx.coroutines.experimental.* import kotlinx.coroutines.experimental.android.UI import kotlin.coroutines.experimental.CoroutineContext /** * Abstract class for a Use Case (Interactor in terms of Clean Architecture). * This interface represents a execution unit for different use cases (this means any use case * in the application should implement this contract). * <p> * By convention each UseCase implementation will return the result using a coroutine * that will execute its job in a background thread and will post the result in the UI thread. */ abstract class UseCase<T> { protected var parentJob: Job = Job() //var backgroundContext: CoroutineContext = IO var backgroundContext: CoroutineContext = CommonPool var foregroundContext: CoroutineContext = UI protected abstract suspend fun executeOnBackground(): T fun execute(onComplete: (T) -> Unit, onError: (Throwable) -> Unit) { parentJob.cancel() parentJob = Job() launch(foregroundContext, parent = parentJob) { try { val result = withContext(backgroundContext) { executeOnBackground() } onComplete.invoke(result) } catch (e: CancellationException) { Log.d("UseCase", "canceled by user") } catch (e: Exception) { onError(e) } } } protected suspend fun <X> background(context: CoroutineContext = backgroundContext, block: suspend () -> X): Deferred<X> { return async(context, parent = parentJob) { block.invoke() } } fun unsubscribe() { parentJob.cancel() } } 

सबसे पहले, मैंने एक मूल कार्य बनाया। यह उन सभी कोरआउटों को पूर्ववत् करने की कुंजी है जो UseCase क्लास में बनाए गए थे। जब हम निष्पादन को कहते हैं, तो यह महत्वपूर्ण है कि पुराने कार्यों को रद्द कर दिया जाए ताकि हम एक भी कोरटाइन को याद न करें (यह तब भी होगा जब हम इस UseCase से सदस्यता समाप्त करेंगे)।

इसके अलावा, मैं स्टार्टअप (यूआई) का आह्वान करता हूं। इसका मतलब है कि मैं कोरटाइन बनाना चाहता हूं जिसे यूआई थ्रेड में निष्पादित किया जाएगा। उसके बाद, मैं बैकग्राउंड मेथड को कॉल करता हूं जो कॉमनपूल में एसिंक्स बनाता है (यह दृष्टिकोण वास्तव में खराब प्रदर्शन होगा)। बदले में, Async वापस आ जाएगा, और फिर, मैं इसकी प्रतीक्षा विधि कहूंगा। वह पृष्ठभूमि के कोरआउट के पूरा होने की प्रतीक्षा करता है, जो एक परिणाम या त्रुटि लाएगा।

इसका उपयोग हम RxJava के साथ किए गए अधिकांश चीजों को लागू करने के लिए कर सकते हैं। नीचे कुछ उदाहरण दिए गए हैं।

नक्शा

मैंने खोज शो परिणामों को डाउनलोड किया और उन्हें पहले शो का नाम वापस करने के लिए बदल दिया।
RxJava कोड:

 public class SearchShows extends UseCase { private ShowRepository showRepository; private ResourceRepository resourceRepository; private String query; @Inject public SearchShows(ShowRepository showRepository, ResourceRepository resourceRepository) { this.showRepository = showRepository; this.resourceRepository = resourceRepository; } public void setQuery(String query) { this.query = query; } @Override protected Single<String> buildUseCaseObservable() { return showRepository.searchShow(query).map(showInfos -> { if (showInfos != null && !showInfos.isEmpty() && showInfos.get(0).getShow() != null) { return showInfos.get(0).getShow().getTitle(); } else { return resourceRepository.getNotFoundShow(); } }); } } 

Coroutine कोड:

 class SearchShows @Inject constructor(private val showRepository: ShowRepository, private val resourceRepository: ResourceRepository) : UseCase<String>() { var query: String? = null override suspend fun executeOnBackground(): String { query?.let { val showsInfo = showRepository.searchShow(it) val showName: String? = showsInfo?.getOrNull(0)?.show?.title return showName ?: resourceRepository.notFoundShow } return "" } } 

ज़िप

जिप प्रेक्षक से दो उत्सर्जन लेगा और उन्हें एक नए उत्सर्जन में एक साथ रखेगा। ध्यान दें कि RxJava के साथ आपको प्रत्येक सिंगल में सबऑनऑन का उपयोग करके समानांतर में एक कॉल करना होगा। हम एक ही समय में दोनों को प्राप्त करना चाहते हैं और उन्हें एक साथ वापस करना चाहते हैं।

RxJava कोड:

 public class ShowDetail extends UseCase { private ShowRepository showRepository; private String id; @Inject public SearchShows(ShowRepository showRepository) { this.showRepository = showRepository; } public void setId(String id) { this.id = id; } @Override protected Single<Show> buildUseCaseObservable() { Single<ShowDetail> singleDetail = showRepository.showDetail(id).subscribeOn(Schedulers.io()); Single<ShowBanner> singleBanner = showRepository.showBanner(id).subscribeOn(Schedulers.io()); return Single.zip(singleDetail, singleBanner, (detail, banner) -> new Show(detail,banner)); } 

Coroutine कोड:

 class SearchShows @Inject constructor(private val showRepository: ShowRepository, private val resourceRepository: ResourceRepository) : UseCase<Show>() { var id: String? = null override suspend fun executeOnBackground(): Show { id?.let { val showDetail = background{ showRepository.showDetail(it) } val showBanner = background{ showRepository.showBanner(it) } return Show(showDetail.await(), showBanner.await()) } return Show() } } 

FlatMap

इस मामले में, मैं ऐसे शो की तलाश कर रहा हूं जिनमें क्वेरी स्ट्रिंग है और प्रत्येक परिणाम (200 परिणामों तक सीमित) के लिए, मुझे शो की रेटिंग भी मिलती है। अंत में, मैं संबंधित रेटिंग वाले शो की सूची लौटाता हूं।

RxJava कोड:

 public class SearchShows extends UseCase { private ShowRepository showRepository; private String query; @Inject public SearchShows(ShowRepository showRepository) { this.showRepository = showRepository; } public void setQuery(String query) { this.query = query; } @Override protected Single<List<ShowResponse>> buildUseCaseObservable() { return showRepository.searchShow(query).flatMapPublisher( (Function<List<ShowInfo>, Flowable<ShowInfo>>) Flowable::fromIterable) .flatMapSingle((Function<ShowInfo, SingleSource<ShowResponse>>) showInfo -> showRepository.showRating(showInfo.getShow().getIds().getTrakt()) .map(rating -> new ShowResponse(showInfo.getShow().getTitle(), rating .getRating())).subscribeOn(Schedulers.io()), false, 4).toList(); } } 

Coroutine कोड:

 class SearchShows @Inject constructor(private val showRepository: ShowRepository) : UseCase<List<ShowResponse>>() { var query: String? = null override suspend fun executeOnBackground(): List<ShowResponse> { query?.let { query -> return showRepository.searchShow(query).map { background { val rating: Rating = showRepository.showRating(it.show!!.ids!!.trakt!!) ShowResponse(it.show.title!!, rating.rating) } }.map { it.await() } } return arrayListOf() } } 

मुझे समझाने की। RxJava का उपयोग करते हुए, मेरी रिपॉजिटरी सूची का एक एकल उत्सर्जन लौटाती है, इसलिए मुझे कई उत्सर्जन की आवश्यकता है, प्रत्येक ShowInfo के लिए। ऐसा करने के लिए, मैंने फ्लैटपाइप पब्लिशर को बुलाया। प्रत्येक मुद्दे के लिए, मुझे ShowResponse को उजागर करना होगा, और अंत में उन सभी को एक सूची में इकट्ठा करना होगा।

हम इस निर्माण के साथ समाप्त होते हैं: सूची foreach → (ShowInfo → ShowRating → ShowResponse) → सूची।

Coroutines के साथ, मैंने प्रत्येक सूची तत्व के लिए एक सूची <Deffered> में परिवर्तित करने के लिए एक नक्शा बनाया।

जैसा कि आप देख सकते हैं, हमने RxJava के साथ जो किया, उसमें से अधिकांश को सिंक्रोनस कॉल के साथ लागू करना आसान है। Coroutines भी फ्लैटपाइप संभाल सकता है, जो, मेरा मानना ​​है कि RxJava में सबसे जटिल कार्यों में से एक है।

यह सर्वविदित है कि कोरटाइन हल्के हो सकते हैं ( यहां एक उदाहरण है), लेकिन परिणामों ने मुझे हैरान कर दिया। इस उदाहरण में, RxJava ने लगभग 3.1 सेकंड में शुरुआत की, जबकि कॉरटीन ने कॉमनपूल पर चलने में लगभग 5.8 सेकंड का समय लिया।

इन परिणामों ने मेरे सामने सवाल उठाया कि उनमें कुछ अनुचित हो सकता है। बाद में, मैंने यह पाया। मैंने रेट्रोफिट कॉल का उपयोग किया, जिससे प्रवाह अवरुद्ध हो गया।

इस त्रुटि को ठीक करने के दो तरीके हैं, चुनाव इस बात पर निर्भर करता है कि आप एंड्रॉइड स्टूडियो के किस संस्करण का उपयोग कर रहे हैं। एंड्रॉइड स्टूडियो 3.1 में, हमें यह सुनिश्चित करने की आवश्यकता है कि हम पृष्ठभूमि थ्रेड को रोक नहीं रहे हैं। इसके लिए, मैंने इस लाइब्रेरी का उपयोग किया:

कार्यान्वयन 'ru.gildor.coroutines: kotlin-coroutines-retrofit: 0.12.0'

यह कोड स्ट्रीम को रोकने के लिए रेट्रोफ़िट कॉल फ़ंक्शन का एक एक्सटेंशन बनाता है:

 public suspend fun <T : Any> Call<T>.await(): T { return suspendCancellableCoroutine { continuation -> enqueue(object : Callback<T> { override fun onResponse(call: Call<T>?, response: Response<T?>) { if (response.isSuccessful) { val body = response.body() if (body == null) { continuation.resumeWithException( NullPointerException("Response body is null: $response") ) } else { continuation.resume(body) } } else { continuation.resumeWithException(HttpException(response)) } } override fun onFailure(call: Call<T>, t: Throwable) { // Don't bother with resuming the continuation if it is already cancelled. if (continuation.isCancelled) return continuation.resumeWithException(t) } }) registerOnCompletion(continuation) } } 

एंड्रॉइड स्टूडियो 3.2 में, आप कोरटिन लाइब्रेरी को 0.25.0 संस्करण में अपडेट कर सकते हैं। इस संस्करण में CoroutineContext IO है (आप मेरे UseCase वर्ग में संबंधित टिप्पणी देख सकते हैं)।

कॉमनपूल पर बिना ब्लॉकिंग कॉल के चलने में 2.3 सेकंड और 2.4 सेकंड में IO और ब्लॉकिंग कॉल्स लगे।



मुझे उम्मीद है कि यह लेख आपको आरएक्सजैवा के लिए कॉरटीन, एक लाइटर और शायद तेज विकल्प का उपयोग करने के लिए प्रेरित करेगा, यह समझना थोड़ा आसान है कि आप सिंक्रनाइज़ किए गए कोड लिख रहे हैं जो अतुल्यकालिक रूप से चलता है।