मेरे पास एक मामला है जब मेरे पास कई अवलोकन योग्य हैं, प्रत्येक अवलोकन योग्य का अपना कार्यान्वयन होता है, वे एक ही प्रकार के साथ हो सकते हैं, या अलग-अलग मैंने अभी तक तय नहीं किया है, लेकिन मान लीजिए कि वे एक ही प्रकार के हैं।

Observable<String> source1;
Observable<String> source2;
Observable<String> source3;
Observable<String> source4;

अब मुझे उनमें से केवल एक को निष्पादित करने की आवश्यकता है, इसलिए स्ट्रीम केवल अगले अवलोकन योग्य पर जाएँ यदि पिछला वाला विफल हो गया हो।

कुछ संभावित समाधान:

  • onErrorResumeNext() जो कि अच्छा हो सकता है यदि वे केवल दो हैं अवलोकन योग्य, लेकिन मेरे मामले में, अगर मुझे निष्पादन के क्रम को बदलने की आवश्यकता है तो प्रत्येक अवलोकन योग्य को अपडेट करना मुश्किल होगा।

  • कॉम्बिनेशन है, लेकिन मुझे नहीं पता कि यह मेरे जैसा व्यवहार करता है या नहीं वर्णित है, या मुझे आवश्यकतानुसार काम करने के लिए किस संशोधन की आवश्यकता है।

इस तरह कुछ कैसे प्राप्त करें और यदि वे विभिन्न प्रकार के हैं, तो मुझे क्या करने की ज़रूरत है?

1
Mohamed Ibrahim 21 नवम्बर 2017, 19:41

2 जवाब

सबसे बढ़िया उत्तर

मुझे नहीं पता कि इसे करने का कोई बेहतर तरीका है या नहीं, लेकिन मैं इसे लचीला बनाने के लिए कुछ तरीकों की मदद से सिर्फ onErrorResumeNext() का उपयोग करूंगा:

Observable<String> buildObservable(Observable<String> obs, Observable<String>... subsequentObservables) {
    Observable<String> observable = obs;
    for (int i = 0; i < subsequentObservables.length; i++) {
        observable = concatErrorObservable(observable, subsequentObservables[i]);
    }

    return observable;
}

जहां concatErrorObservable है:

Observable<String> concatErrorObservable(Observable<String> observable, Observable<String> observable2) {
        return observable.onErrorResumeNext(observable2);
    }

तो आपको बस Observable की सूची buildObservable विधि को प्रदान करने की आवश्यकता है। उदाहरण के लिए:

buildObservable(Observable.error(new Throwable("error!!")), 
    Observable.just("observable2"), 
    Observable.just("observable3"))
.subscribe(s -> Log.d(TAG, "result: " + s));

observable2 प्रिंट करेगा (लॉगकैट में) क्योंकि पहला अवलोकन योग्य त्रुटि फेंकता है।

विभिन्न प्रकारों के बारे में, आपको संभवतः प्रत्येक Observable के लिए एक अलग map की आवश्यकता होगी, क्योंकि मुझे लगता है कि आपका उपभोक्ता (पर्यवेक्षक) केवल एक प्रकार के उत्सर्जित डेटा की अपेक्षा करेगा।

1
GVillani82 2 पद 2017, 15:38

आप इस तरह onErrorResumeNext और reduce का उपयोग करके एक संयुक्त अवलोकन योग्य प्राप्त कर सकते हैं:

Observable<String> buildObservable(List<Observable<String>> observables) {
    return Observable.fromIterable(observables)
            .reduce(Observable::onErrorResumeNext)
            .flatMapObservable(obs -> obs);
}

अद्यतन करें: आगे की व्याख्या करने के लिए, यदि आप एक सूची के साथ विधि को [o1, o2, o3] कहते हैं, तो

  • fromIterable उच्च-स्तर को just(o1, o2, o3) के बराबर अवलोकन योग्य लौटाएगा

  • reduce प्रत्येक तत्व के साथ इस अवलोकन योग्य, क्रमिक रूप से कॉल करने वाले onErrorResumeNext() के तत्वों को इस प्रकार संयोजित करेगा:

    o1 -> o1.onErrorResumeNext(o2) -> o1.onErrorResumeNext(o2).onErrorResumeNext(o3), 
    

    जिसके परिणामस्वरूप एक स्थिर "उच्च स्तर" 1-तत्व देखा जा सकता है जो just(o1.onErrorResumeNext(o2).onErrorResumeNext(o3)) के बराबर है।

  • flatMapObservable() लाइन देखने योग्य इस 1-तत्व को उसके एक और एकमात्र तत्व से बदल देगी, जो कि o1.onErrorResumeNext(o2).onErrorResumeNext(o3) (just() के बिना) है।

यह परिणाम आपके लिए आवश्यक फ़ॉलबैक तंत्र को लागू करता है।

1
Janos Breuer 3 पद 2017, 01:29