rx-java
विषय

वाक्य - विन्यास

• विषय <T, R> विषय = AsyncSubject.create (); // डिफ़ॉल्ट AsyncSubject
• विषय <T, R> विषय = BehaviorSubject.create (); // डिफ़ॉल्ट व्यवहार
• विषय <T, R> विषय = PublishSubject.create (); // डिफॉल्ट पब्लिशसबजेक्ट
• विषय <T, R> विषय = ReplaySubject.create (); // डिफ़ॉल्ट रीप्लेस्बजेक्ट
• mySafeSubject = new SerializedSubject (unSafeSubject); // एक असुरक्षितSubject को सेफसबजेक्ट में कन्वर्ट करें - आम तौर पर मल्टी थ्रेडेड सब्जेक्ट्स के लिए

पैरामीटर

टिप्पणियों

मूल विषय

एक Subject RxJava में एक वर्ग के दोनों एक है Observable और एक Observer । इसका मूल रूप से मतलब है कि यह एक Observable रूप में काम कर सकता है और सब्सक्राइबर को इनपुट दे सकता है और Observer रूप में दूसरे ऑब्जर्वेबल से इनपुट प्राप्त कर सकता है।

Subject<String, String> subject = PublishSubject.create(); 
subject.subscribe(System.out::print);
subject.onNext("Hello, World!"); 

उपरोक्त प्रिंट "हैलो, वर्ल्ड!" Subjects का उपयोग करके सांत्वना देने के लिए।

व्याख्या

1. कोड की पहली पंक्ति PublishSubject नए Subject को परिभाषित करती है

   Subject<String, String> subject = PublishSubject.create();
       |     |       |       |                 |
    subject<input, output>  name   = default publish subject
   

2. दूसरी पंक्ति Observer व्यवहार को दिखाते हुए इस विषय की सदस्यता लेती है।

   subject.subscribe(System.out::print);
   

   यह Subject को एक नियमित ग्राहक की तरह इनपुट लेने में सक्षम बनाता है

3. तीसरी लाइन कॉल onNext विषय की विधि, दिखा Observable व्यवहार।

   subject.onNext("Hello, World!"); 
   

   यह सब सब्स्क्राइबर को इनपुट देने के लिए Subject को सक्षम बनाता है।

प्रकार

एक Subject (RxJava में) इन चार प्रकारों में से किसी एक का हो सकता है:

• AsyncSubject
• BehaviorSubject
• PublishSubject
• ReplaySubject

साथ ही, Subject , SerializedSubject प्रकार का हो सकता है। यह प्रकार सुनिश्चित करता है कि Subject ऑब्जर्वेबल कॉन्ट्रैक्ट का उल्लंघन नहीं करता है (जो यह निर्दिष्ट करता है कि सभी कॉल सीरियल किए जाने चाहिए)

आगे की पढाई:

• डेव सेक्सटन के ब्लॉग से विषय का उपयोग करने या न करने के लिए

PublishSubject

PublishSubject एक करने के लिए उत्सर्जन करता है Observer केवल उन वस्तुओं है कि स्रोत द्वारा उत्सर्जित होती हैं Observable सदस्यता के समय के बाद।

एक साधारण PublishSubject उदाहरण:

Observable<Long> clock = Observable.interval(500, TimeUnit.MILLISECONDS);
Subject<Long, Long> subjectLong = PublishSubject.create();

clock.subscribe(subjectLong);

System.out.println("sub1 subscribing...");
subjectLong.subscribe(l -> System.out.println("sub1 -> " + l));
Thread.sleep(3000);
System.out.println("sub2 subscribing...");
subjectLong.subscribe(l -> System.out.println("sub2 -> " + l));
Thread.sleep(5000);

आउटपुट:

sub1 subscribing...
sub1 -> 0
sub1 -> 1
sub2 subscribing...
sub1 -> 2
sub2 -> 2
sub1 -> 3
sub2 -> 3

उपरोक्त उदाहरण में, एक PublishSubject एक का सदस्य बनता Observable (लांग) प्रत्येक 500 मिली सेकंड जो उत्सर्जन करता है आइटम एक घड़ी की तरह काम करता है, और। के रूप में उत्पादन में देखा, PublishSubject vales यह स्रोत (से हो जाता है पर गुजरता clock ) अपने ग्राहकों (करने के लिए sub1 और sub2 )।

एक PublishSubject किसी भी पर्यवेक्षक के बिना बनाए गए आइटम को PublishSubject शुरू कर सकता है, जो पर्यवेक्षक के डूबने तक एक या एक से अधिक वस्तुओं के खो जाने का जोखिम रखता है।

createClock(); // 3 lines moved for brevity. same as above example

Thread.sleep(5000); // introduces a delay before first subscribe

sub1andsub2(); // 6 lines moved for brevity. same as above example

आउटपुट:

sub1 subscribing...
sub1 -> 10
sub1 -> 11
sub2 subscribing...
sub1 -> 12
sub2 -> 12
sub1 -> 13
sub2 -> 13

ध्यान दें कि sub1 1 10 से शुरू होने वाले मूल्यों का उत्सर्जन करता है। 5 सेकंड की देरी के कारण वस्तुओं का नुकसान हुआ । ये पुन: पेश नहीं किए जा सकते हैं। यह अनिवार्य रूप से PublishSubject को Hot Observable PublishSubject बनाता है।

यह भी ध्यान दें कि यदि कोई PublishSubject को सब्सक्राइब करने के बाद उसके एन आइटम उत्सर्जित करता है, तो इन एन आइटम को इस PublishSubject लिए पुन: प्रस्तुत नहीं किया जा सकता है।

नीचे PublishSubject का संगमरमर आरेख है

PublishSubject सभी आइटम है कि पहले समय की किसी भी बिंदु पर सदस्यता ली है, का उत्सर्जन करता है onCompleted स्रोत का Observable कहा जाता है।

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

उदाहरण
मान लीजिए आप एक एप्लिकेशन बनाना चाहते हैं जो एक निश्चित कंपनी के शेयर की कीमतों की निगरानी करेगा और इसे उन सभी ग्राहकों को अग्रेषित करेगा जो इसके लिए अनुरोध करते हैं।

/* Dummy stock prices */
Observable<Integer> prices = Observable.just(11, 12, 14, 11, 10, 12, 15, 11, 10);

/* Your server */
PublishSubject<Integer> watcher = PublishSubject.create();
/* subscribe to listen to stock price changes and push to observers/clients */
prices.subscribe(watcher);

/* Client application */
stockWatcher = getWatcherInstance(); // gets subject
Subscription steve = stockWatcher.subscribe(i -> System.out.println("steve watching " + i));
Thread.sleep(1000);
System.out.println("steve stops watching");
steve.unsubscribe();

ऊपर के उदाहरण उपयोग के मामले में, PublishSubject अपने सर्वर से सभी ग्राहकों है कि अपने की सदस्यता के लिए मान प्रदान करने के लिए एक सेतु के रूप में कार्य करता है watcher ।

आगे की पढाई:

• PublishSubject javadocs
• थॉमस निल्ड द्वारा ब्लॉग (उन्नत पठन)