rx-java Samouczek
Rozpoczęcie pracy z rx-java

Uwagi

Wersje

Instalacja lub konfiguracja

konfiguracja 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. Bluszcz

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

4. Migawki z JFrog

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

5. Jeśli zamiast pobierać system kompilacji, musisz pobrać słoiki, utwórz plik pom Maven w żądanej wersji:

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

Następnie wykonaj:

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

To polecenie pobiera rxjava-*.jar i jego zależności do ./target/dependency/.

Potrzebujesz Java 6 lub nowszej.

Witaj świecie!

Poniżej wydrukowano komunikat Hello, World! do konsoli

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

    });
}

Lub używając notacji lambda Java 8

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

Wprowadzenie do RxJava

Te podstawowe koncepcje RxJava są jego Observables i Subscribers . Observable emituje obiekty, podczas gdy Subscriber je pochłania.

Zauważalny

Observable to klasa, która implementuje reaktywny wzorzec projektowy. Te obserwowalne zapewniają metody, które pozwalają konsumentom subskrybować zmiany zdarzeń. Zmiany zdarzeń są wywoływane przez obserwowalne. Nie ma ograniczeń co do liczby subskrybentów, które może mieć Observable , ani liczby obiektów, które Observable może emitować.

Weź na przykład:

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

Tutaj obserwowalny obiekt o nazwie integerObservable i stringObservable są tworzone z metody fabrycznej dostarczonej just przez bibliotekę Rx. Zauważ, że Observable jest ogólny i dlatego może emitować dowolny obiekt.

Abonent

Subscriber jest konsumentem. Subscriber może subskrybować tylko jeden obserwowalny. Observable wywołuje metody onNext() , onCompleted() i 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);
        }
    };

Zauważ, że Subscriber jest również ogólny i może obsługiwać dowolny obiekt. Subscriber musi subskrybować obserwowalne, wywołując metodę subscribe na obserwowalnym.

integerObservable.subscribe(mSubscriber);

Powyższe po uruchomieniu wygeneruje następujące dane wyjściowe:

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

Zrozumienie marmurowych schematów

Obserwowalny można traktować jako strumień wydarzeń. Kiedy definiujesz Observable, masz trzy detektory: onNext, onComplete i onError. onNext będzie wywoływany za każdym razem, gdy obserwowalne uzyska nową wartość. onComplete zostanie wywołany, jeśli element nadrzędny Observable powiadomi, że zakończył tworzenie kolejnych wartości. onError jest wywoływany, jeśli wyjątek zostanie zgłoszony w dowolnym momencie podczas wykonywania obserwowalnego łańcucha. Aby pokazać operatorów w Rx, marmurowy diagram służy do wyświetlenia tego, co dzieje się z określoną operacją. Poniżej znajduje się przykład prostego obserwowalnego operatora „Just”.

Marmurowe diagramy mają poziomy blok reprezentujący wykonywaną operację, pionowy pasek reprezentujący zakończone zdarzenie, X reprezentujący błąd, a każdy inny kształt reprezentuje wartość. Mając to na uwadze, możemy zobaczyć, że „Just” po prostu weźmie naszą wartość i zrobi onNext, a następnie zakończy się z onComplete. Jest o wiele więcej operacji niż tylko „Just”. Możesz zobaczyć wszystkie operacje, które są częścią projektu ReactiveX, a tam implementacje w RxJava na stronie ReativeX . Istnieją również interaktywne diagramy marmurowe za pośrednictwem strony RxMarbles .