rx-java ट्यूटोरियल
आरएक्स-जावा के साथ शुरुआत करना

टिप्पणियों

संस्करण

स्थापना या सेटअप

आरएक्स-जावा सेट अप

1. Gradle

   compile 'io.reactivex:rxjava2:rxjava:2.1.1'
   

2. Maven

   <dependency>
       <groupId>io.reactivex.rxjava2</groupId>
       <artifactId>rxjava</artifactId>
       <version>2.1.1</version>
   </dependency>
   

3. आइवी लता

   <dependency org="io.reactivex.rxjava2" name="rxjava" rev="2.1.1" />
   

4. JFrog से स्नैपशॉट

   repositories {
   maven { url 'https://oss.jfrog.org/libs-snapshot' }
   }
   
   dependencies {
       compile 'io.reactivex:rxjava:2.0.0-SNAPSHOT'
   }
   

5. यदि आपको बिल्ड सिस्टम का उपयोग करने के बजाय जार को डाउनलोड करने की आवश्यकता है, तो वांछित संस्करण के साथ इस तरह मावेन pom फ़ाइल बनाएं:

   <?xml version="1.0"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0" 
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <groupId>com.netflix.rxjava.download</groupId>
       <artifactId>rxjava-download</artifactId>
       <version>1.0-SNAPSHOT</version>
       <name>Simple POM to download rxjava and dependencies</name>
       <url>http://github.com/ReactiveX/RxJava</url>
       <dependencies>
           <dependency>
               <groupId>io.reactivex</groupId>
               <artifactId>rxjava</artifactId>
               <version>2.0.0</version>
               <scope/>
           </dependency>
       </dependencies>
   </project>
   

फिर निष्पादित करें:

$ mvn -f download-rxjava-pom.xml dependency:copy-dependencies

यह कमांड rxjava-*.jar और उसकी निर्भरता को ./target/dependency/. dependency/ में ./target/dependency/.

आपको जावा 6 या बाद के संस्करण की आवश्यकता है।

नमस्ते दुनिया!

निम्नलिखित संदेश Hello, World! प्रिंट करता है Hello, World! सांत्वना देने

public void hello() {
  Observable.just("Hello, World!") // create new observable
    .subscribe(new Action1<String>() { // subscribe and perform action

       @Override
       public void call(String st) {
         System.out.println(st);
       }

    });
}

या जावा 8 लैम्ब्डा नोटेशन का उपयोग करना

public void hello() {
      Observable.just("Hello, World!") // create new observable
        .subscribe(onNext -> { // subscribe and perform action
             System.out.println(onNext);   
        });
}

RxJava के लिए एक परिचय

RxJava के मूल अवधारणाओं इसकी हैं Observables और Subscribers । एक Observable वस्तुओं का उत्सर्जन करता है, जबकि एक Subscriber उनका उपभोग करता है।

नमूदार

Observable एक ऐसा वर्ग है जो प्रतिक्रियाशील डिजाइन पैटर्न को लागू करता है। ये वेधशालाएं ऐसे तरीके प्रदान करती हैं जो उपभोक्ताओं को घटना परिवर्तनों की सदस्यता लेने की अनुमति देते हैं। घटना के परिवर्तन देखने योग्य द्वारा ट्रिगर किए जाते हैं। एक Observable पास जितने ग्राहक हो सकते हैं, या उन वस्तुओं की संख्या पर कोई प्रतिबंध नहीं है जो एक Observable का उत्सर्जन कर सकता है।

उदाहरण के लिए:

Observable<Integer> integerObservable = Observable.just(1, 2, 3); // Integer observable
Observable<String> stringObservable = Observable.just("Hello, ", "World", "!"); // String observable

इधर, एक नमूदार बुलाया वस्तु integerObservable और stringObservable कारखाने विधि से बनाई गई हैं just आरएक्स पुस्तकालय द्वारा प्रदान की। गौर करें कि Observable जेनेरिक है और इस प्रकार किसी भी वस्तु का उत्सर्जन कर सकता है।

ग्राहक

एक Subscriber उपभोक्ता है। एक Subscriber केवल एक ही अवलोकन के लिए सदस्यता ले सकता है। Observable कॉल onNext() , onCompleted() , और onError() के तरीकों Subscriber ।

Subscriber<Integer> mSubscriber = new Subscriber<Integer>() {
        // NOTE THAT ALL THESE ARE CALLED BY THE OBSERVABLE
        @Override
        public void onCompleted() {
            // called when all objects are emitted
            System.out.println("onCompleted called!");
        }

        @Override
        public void onError(Throwable throwable) {
            // called when an error occurs during emitting objects
            System.out.println("onError called!");
        }

        @Override
        public void onNext(Integer integer) {
            // called for each object that is emitted
            System.out.println("onNext called with: " + integer);
        }
    };

ध्यान दें कि Subscriber भी सामान्य है और किसी भी वस्तु का समर्थन कर सकता है। एक Subscriber को ऑब्जर्वेबल पर subscribe मेथड को कॉल करके ऑब्जर्व करने योग्य होना चाहिए।

integerObservable.subscribe(mSubscriber);

उपरोक्त, जब चलाया जाता है, तो निम्न आउटपुट उत्पन्न करेगा:

onNext called with: 1
onNext called with: 2
onNext called with: 3
onCompleted called!

मार्बल आरेखों को समझना

एक अवलोकनीय को घटनाओं की एक धारा के रूप में सोचा जा सकता है। जब आप एक अवलोकन को परिभाषित करते हैं, तो आपके पास तीन श्रोता होते हैं: onNext, onComplete और onError। onNext को हर बार कहा जाएगा जब अवलोकन योग्य एक नया मान प्राप्त करता है। यदि माता-पिता अवलोकनीय सूचित करते हैं कि यह किसी भी अधिक मूल्य का उत्पादन समाप्त कर देता है, तो ऑनकाले को बुलाया जाएगा। ऑनर्र को कहा जाता है, यदि अवलोकन श्रृंखला के निष्पादन के दौरान किसी अपवाद को किसी भी समय फेंक दिया जाता है। आरएक्स में ऑपरेटरों को दिखाने के लिए, संगमरमर आरेख का उपयोग यह प्रदर्शित करने के लिए किया जाता है कि किसी विशेष ऑपरेशन के साथ क्या होता है। नीचे एक साधारण वेधशाला ऑपरेटर का उदाहरण है "बस।"

संगमरमर आरेख में एक क्षैतिज ब्लॉक होता है जो प्रदर्शन किए जाने वाले ऑपरेशन का प्रतिनिधित्व करता है, पूर्ण घटना का प्रतिनिधित्व करने के लिए एक ऊर्ध्वाधर बार, एक त्रुटि का प्रतिनिधित्व करने के लिए एक एक्स, और किसी भी अन्य आकार में एक मूल्य का प्रतिनिधित्व करता है। इसे ध्यान में रखते हुए, हम देख सकते हैं कि "बस" हमारा मूल्य लेगा और एक onNext करेगा और उसके बाद onComplete के साथ समाप्त होगा। अभी और बहुत सारे ऑपरेशन हैं "बस।" आप उन सभी कार्यों को देख सकते हैं जो रिएक्टिवएक्स प्रोजेक्ट का हिस्सा हैं और ReatJX साइट पर RxJava में कार्यान्वयन हैं। RxMarbles साइट के माध्यम से इंटरेक्टिव मार्बल आरेख भी हैं।