खोज…
एक ऑब्जर्वेबल बनाएं
RxJava में एक ऑब्जर्वेबल बनाने के कई तरीके हैं। सबसे शक्तिशाली तरीका है Observable.create पद्धति का उपयोग करना। लेकिन यह सबसे जटिल तरीका भी है । इसलिए आपको इसका अधिक से अधिक उपयोग करने से बचना चाहिए।
बाहर निकलने का मूल्य
यदि आपके पास पहले से ही एक मूल्य है, तो आप अपने मूल्य का उत्सर्जन करने के लिए Observable.just का उपयोग कर सकते हैं।
Observable.just("Hello World").subscribe(System.out::println);
एक मूल्य का उत्सर्जन जो गणना किया जाना चाहिए
यदि आप किसी ऐसे मूल्य का उत्सर्जन करना चाहते हैं जो पहले से ही संगणित नहीं है, या जिसे गणना करने में लंबा समय लग सकता है, तो आप अपने अगले मूल्य का उत्सर्जन करने के लिए Observable.fromCallable का उपयोग कर सकते हैं।
Observable.fromCallable(() -> longComputation()).subscribe(System.out::println);
longComputation() केवल बुलाया जाएगा जब आप अपने की सदस्यता Observable । इस तरह, गणना आलसी हो जाएगी।
एक मूल्य का उत्सर्जन करने का वैकल्पिक तरीका जिसे गणना की जानी चाहिए
Observable.defer एक बनाता है Observable की तरह सिर्फ Observable.fromCallable लेकिन यह प्रयोग किया जाता है जब आप एक वापस जाने के लिए की जरूरत है Observable एक मूल्य के बजाय। यह उपयोगी है जब आप अपने कॉल में त्रुटियों का प्रबंधन करना चाहते हैं।
Observable.defer(() -> {
try {
return Observable.just(longComputation());
} catch(SpecificException e) {
return Observable.error(e);
}).subscribe(System.out::println);
हॉट एंड कोल्ड ऑब्जर्वर
वेधशालाओं को मोटे तौर पर उनके उत्सर्जन व्यवहार के आधार पर Hot या Cold रूप में वर्गीकृत किया जाता है।
एक Cold Observable वह होता है जो अनुरोध (सदस्यता) पर Cold Observable शुरू कर देता है, जबकि एक Hot Observable वह होता है, जो सदस्यता के बावजूद उत्सर्जन करता है।
शीत अवलोकनीय
/* Demonstration of a Cold Observable */
Observable<Long> cold = Observable.interval(500, TimeUnit.MILLISECONDS); // emits a long every 500 milli seconds
cold.subscribe(l -> System.out.println("sub1, " + l)); // subscriber1
Thread.sleep(1000); // interval between the two subscribes
cold.subscribe(l -> System.out.println("sub2, " + l)); // subscriber2
उपरोक्त कोड का आउटपुट जैसा दिखता है (भिन्न हो सकता है):
sub1, 0 -> subscriber1 starts
sub1, 1
sub1, 2
sub2, 0 -> subscriber2 starts
sub1, 3
sub2, 1
sub1, 4
sub2, 2
सूचना है कि भले ही sub2 देर से शुरू होता है, यह शुरू से ही मान प्राप्त करता है। निष्कर्ष निकालने के लिए, एक Cold Observable केवल उन वस्तुओं का उत्सर्जन करता है, Cold Observable लिए अनुरोध किया जाता है। एकाधिक अनुरोध कई पाइपलाइन शुरू करते हैं।
हॉट ऑब्जर्वेबल
नोट: गर्म वेधशालाएँ व्यक्तिगत ग्राहकी से स्वतंत्र मूल्यों का उत्सर्जन करती हैं। उनकी अपनी समयावधि होती है और घटनाएं घटती हैं कि कोई सुन रहा है या नहीं। एक Cold Observale को एक साधारण publish साथ Hot Observable Cold Observale जा सकता है।
Observable.interval(500, TimeUnit.MILLISECONDS)
.publish(); // publish converts cold to hot
एक ConnectableObservable रिटर्न publish करता है, जो अवलोकन से कनेक्ट करने और डिस्कनेक्ट करने के लिए कार्यक्षमता जोड़ता है।
ConnectableObservable<Long> hot = Observable
.interval(500, TimeUnit.MILLISECONDS)
.publish(); // returns ConnectableObservable
hot.connect(); // connect to subscribe
hot.subscribe(l -> System.out.println("sub1, " + l));
Thread.sleep(1000);
hot.subscribe(l -> System.out.println("sub2, " + l));
उपरोक्त पैदावार:
sub1, 0 -> subscriber1 starts
sub1, 1
sub1, 2
sub2, 2 -> subscriber2 starts
sub1, 3
sub2, 3
सूचना भले ही उस sub2 शुरू होता है देर से देख रहा है, यह साथ सिंक में है sub1 ।
डिस्कनेक्ट थोड़ा अधिक जटिल है! डिस्कनेक्ट Subscription पर होता है न कि Observable ।
ConnectableObservable<Long> hot = Observable
.interval(500, TimeUnit.MILLISECONDS)
.publish(); // same as above
Subscription subscription = hot.connect(); // connect returns a subscription object, which we store for further use
hot.subscribe(l -> System.out.println("sub1, " + l));
Thread.sleep(1000);
hot.subscribe(l -> System.out.println("sub2, " + l));
Thread.sleep(1000);
subscription.unsubscribe(); // disconnect, or unsubscribe from subscription
System.out.println("reconnecting");
/* reconnect and redo */
subscription = hot.connect();
hot.subscribe(l -> System.out.println("sub1, " + l));
Thread.sleep(1000);
hot.subscribe(l -> System.out.println("sub2, " + l));
Thread.sleep(1000);
subscription.unsubscribe();
उपरोक्त उत्पादन:
sub1, 0 -> subscriber1 starts
sub1, 1
sub1, 2
sub2, 2 -> subscriber2 starts
sub1, 3
sub2, 3
reconnecting -> reconnect after unsubscribe
sub1, 0
...
डिस्कनेक्ट करने पर, Observable अनिवार्य रूप से "समाप्त" हो जाता है और एक नई सदस्यता जुड़ने पर फिर से शुरू होता है।
EventBus बनाने के लिए Hot Observable EventBus उपयोग किया जा सकता है। ऐसे EventBuse आमतौर पर हल्के और सुपर फास्ट होते हैं। RxBus का एकमात्र नकारात्मक पक्ष यह है कि सभी घटनाओं को मैन्युअल रूप से लागू किया जाना चाहिए और बस में जाना चाहिए।