rx-java Tutorial
Iniziare con rx-java

Osservazioni

Versioni

Installazione o configurazione

rx-java impostato

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. Edera

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

4. Istantanee di JFrog

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

5. Se devi scaricare i vasi invece di usare un sistema di build, crea un file Maven pom come questo con la versione desiderata:

   <?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>
   

Quindi eseguire:

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

Questo comando scarica rxjava-*.jar e le sue dipendenze in ./target/dependency/.

Hai bisogno di Java 6 o versioni successive.

Ciao mondo!

Quanto segue stampa il messaggio Hello, World! per consolare

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);
       }

    });
}

O usando la notazione lambda Java 8

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

Un'introduzione a RxJava

I concetti chiave di RxJava sono i suoi Observables e Subscribers . Un Observable emette oggetti, mentre un Subscriber li consuma.

Osservabile

Observable è una classe che implementa il modello di progettazione reattiva. Questi oggetti osservabili forniscono metodi che consentono ai consumatori di iscriversi alle modifiche degli eventi. Le modifiche all'evento sono innescate dall'osservabile. Non c'è alcuna limitazione al numero di abbonati che può avere un Observable , o il numero di oggetti che un Observable può emettere.

Prendi ad esempio:

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

Qui, un oggetto osservabile chiamato integerObservable e stringObservable vengono creati dal metodo factory just fornito dalla libreria Rx. Si noti che Observable è generico e può quindi emettere qualsiasi oggetto.

abbonato

Un Subscriber è il consumatore. Un Subscriber può sottoscrivere una sola osservabile. The Observable chiama i onNext() , onCompleted() e onError() del 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);
        }
    };

Si noti che Subscriber è anche generico e può supportare qualsiasi oggetto. Un Subscriber deve iscriversi alla osservabile chiamando il subscribe metodo sul osservabile.

integerObservable.subscribe(mSubscriber);

Quanto sopra, quando eseguito, produrrà il seguente risultato:

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

Capire i diagrammi di marmo

Un osservabile può essere pensato come un semplice flusso di eventi. Quando definisci un Observable, hai tre listener: onNext, onComplete e onError. onNext sarà chiamato ogni volta che l'osservabile acquisisce un nuovo valore. onComplete sarà chiamato se il genitore Observable notifica che ha finito di produrre altri valori. onError viene chiamato se viene lanciata un'eccezione in qualsiasi momento durante l'esecuzione della catena Observable. Per mostrare gli operatori in Rx, il diagramma di marmo viene utilizzato per visualizzare ciò che accade con una particolare operazione. Di seguito è riportato un esempio di un operatore osservabile semplice "Giusto".

I diagrammi di marmo hanno un blocco orizzontale che rappresenta l'operazione eseguita, una barra verticale per rappresentare l'evento completato, una X per rappresentare un errore e qualsiasi altra forma rappresenta un valore. Con questo in mente, possiamo vedere che "Just" prenderà semplicemente il nostro valore e fare un onNext e poi terminare con onComplete. Ci sono molte più operazioni quindi solo "Just". Puoi vedere tutte le operazioni che fanno parte del progetto ReactiveX e le implementazioni in RxJava sul sito ReativeX . Ci sono anche diagrammi di marmo interattivi tramite il sito RxMarbles .