[Android] Das erste Kapitel von RxJava

Über RxJava

RxJava ist eine von ReactiveX gestartete asynchrone Operationsbibliothek zur Verwendung in der Java VM-Umgebung. Zusätzlich zur Java-Umgebung startet ReactiveX auch Rx-Bibliotheken für andere Programmiersprachen wie Py, Js, Go usw. Es gibt viele Einführungen und Anwendungen von RxJava im Internet und es gibt auch viele Projekte, die RxJava in der Android-Entwicklung verwenden. Warum also RxJava verwenden? Die Android-Entwicklung bietet Entwicklern auch asynchrone Betriebsmethoden. Ich denke, RxJava ist einfacher und eleganter als Handle und AsyncTask.

1 RxJava verwendet Kettenaufrufe, die in der Programmlogik klar und prägnant sind

2 Verwendet das erweiterte Beobachter-Entwurfsmuster

Dies ist eine Einführung in das Beobachtermuster und andere RxJava Ohne mich zu wiederholen, konzentriert sich der folgende Inhalt hauptsächlich auf die Verwendung von RxJava und RxAndroid. Die offizielle Dokumentation von RxJava wurde ausführlich vorgestellt. Dieser Abschnitt dient hauptsächlich zum Lernen und zur Diskussion. Wenn es Fehler gibt, können Sie diese hoffentlich aufzeigen.

Observable Observable

Mit RxJava müssen Sie ein Observable erstellen, das zur Ausgabe von Daten verwendet wird. Die Erstellungsmethode des folgenden Observable muss ein OnSubscribe übergeben, das von Action1 erbt. Der Abonnent in der Aktion ist der Abonnent.

public static <T> Observable<T> create(OnSubscribe<T> f) { 
    return new Observable<T>(RxJavaHooks.onCreate(f)); 
}

Darüber hinaus muss die Methode create den Schnittstellenaufruf implementieren und das Abonnentenobjekt zurückgeben. Die Aufrufmethode implementiert den Ereignisstrom, der ausgeführt werden soll, nachdem das Observable abonniert wurde. subscriber.onNext gibt Daten aus, und subscriber.onCompleted kann das Ende des Emissionsereignisses anzeigen. Rufen Sie dann die Subscribe-Methode des Observablen auf, um den Ereignisstrom zu implementieren, der nach dem Abonnement ausgeführt wird.

Observable<String> observable = Observable 
                .create(new Observable.OnSubscribe<String>() { 
 
            @Override 
            public void call(Subscriber<? super String> subscriber) { 
                subscriber.onNext("1"); 
                subscriber.onNext("2"); 
                subscriber.onNext("3"); 
                subscriber.onNext("4"); 
                subscriber.onNext("5"); 
            } 
}); 
Subscriber<String> subscriber = new  Subscriber<String>() { 
            @Override 
            public void onCompleted() { 
 
            } 
 
            @Override 
            public void onError(Throwable e) { 
 
            } 
 
            @Override 
            public void onNext(String s) { 
                System.out.print(s + &#39;\n&#39;); 
            } 
}; 
observable.subscribe(subscriber); 
//输出结果 print： 
//1 
//2 
//3 
//4 
//5

Zusätzlich zur Verwendung der Methode „create“ zum Erstellen eines Observable können Sie auch „from“ oder „nur“ verwenden, um den ausgegebenen Ereignisstrom schnell einzurichten und so die Erstellungsschritte zu vereinfachen.

Observable<String> o = Observable.from("a", "b", "c");

Observable<String> o = Observable.just("one object");

Der asynchrone Betrieb besagt

RxJava-Threads werden von Schedulern gesteuert. Verwenden Sie es um den Thread zu steuern, in dem bestimmte Vorgänge ausgeführt werden.

Schedulers.immediate() Im aktuellen Thread ausführen

Schedulers.newThread() Einen Thread für jede auszuführende Aufgabe erstellen

Schedulers.computation() Den Thread berechnen in dem die Aufgabe ausgeführt wird

Schedulers.io() Der Thread, in dem E/A-Aufgaben ausgeführt werden....

AndroidSchedulers.mainThread() Der Android-Hauptthread wird ausgeführt

Die Thread-Steuerung erfolgt hauptsächlich ausgeführt durch subscribeOn() und observOn() werden durch zwei Methoden gesteuert:

subscribeOn steuert den Thread, in dem sich Observable.OnSubscribe befindet, was dem Thread entspricht, in dem sich Observable create, just und from befinden.

observeOn steuert den Thread des Abonnenten, der auch als Thread bezeichnet werden kann, in dem das Steuerereignis ausgeführt wird.

Observable 
        .just(1,2,3) 
        .subscribeOn(Schedulers.io()) 
        .observeOn(AndroidSchedulers.mainThread()) 
        .subscribe(new Subscriber<Integer>() { 
            @Override 
            public void onCompleted() { 
 
            } 
 
            @Override 
            public void onError(Throwable e) { 
 
            } 
 
            @Override 
            public void onNext(Integer integer) { 
                 System.out.print(integer + &#39;\n&#39;);                        
            } 
}); 
//输出结果 print： 
//1 
//2 
//3

Schreiben Sie den RxJava-Kettenaufrufcode oben auf. Denken Sie, dass er viel erfrischender ist als die asynchronen Aufrufe, die Sie zuvor verwendet haben?

Operatoren

ReactiveX bietet viele Operatoren, jeder Operator hat unterschiedliche Funktionen, aber der Zweck besteht darin, den ausgegebenen Ereignisstrom zwischen Observable und Subscribe zu transformieren und zu ändern. In diesem Abschnitt werden mehrere gängige und einfache Operatoren vorgestellt. Wenn ich später Gelegenheit habe, werde ich einen weiteren Abschnitt über Operatoren schreiben, um die Rolle jedes Operators im Detail zu erläutern. Anhand der offiziellen Betreiberdokumentation erfahren Sie, wie viele es sind.

Map()

public final <R> Observable<R> map(Func1<? super T, ? extends R> func) { 
        return create(new OnSubscribeMap<T, R>(this, func)); 
    }

Führen Sie zunächst eine Operatorkarte ein, die die Func1-Schnittstelle implementiert, um Daten vom Typ T in Daten vom Typ R umzuwandeln und R zurückzugeben Geben Sie Daten ein. Beispielsweise wird eine Ereigniswarteschlange vom Typ „Integer“ übergeben und nach der Kartenverarbeitung als String-Typ zurückgegeben.

Observable 
                .just(1,2,3) 
                .subscribeOn(Schedulers.io()) 
                .observeOn(AndroidSchedulers.mainThread()) 
                .map(new Func1<Integer, String>() { 
                    @Override 
                    public String call(Integer integer) { 
                        return integer + ""; 
                    } 
                }) 
                .subscribe(new Subscriber<String>() { 
                    ...... 
                    @Override 
                    public void onNext(String str) { 
                        System.out.print(str + &#39;\n&#39;); 
                    } 
                }); 
//输出结果 print： 
//1 
//2 
//3

Filter()

public final Observable<T> filter(Func1<? super T, Boolean> predicate) { 
       return create(new OnSubscribeFilter<T>(this, predicate)); 
   }

filter implementiert die Func1-Schnittstelle wie eine Karte, aber sein konvertierter Typ ist boolesch, für ausgegebene Ereignisse Der Stream gefiltert wird. Wenn der transformierte boolesche Wert wahr ist, kann der Abonnent das Ereignis empfangen, das die Filterung besteht. Beispielsweise erfordert die Ereignisstromfilterung, dass der int-Wert durch 2 teilbar sein kann, bevor er weiter übermittelt werden kann. Die letzten Ereignisse, die der Abonnent konsumieren kann, sind also 2, 4, 6, 8 und 10.

Observable 
                .just(1,2,3,4,5,6,7,8,9,10) 
                .subscribeOn(Schedulers.io()) 
                .observeOn(AndroidSchedulers.mainThread()) 
                .filter(new Func1<Integer, Boolean>() { 
                    @Override 
                    public Boolean call(Integer integer) { 
                        return integer % 2 == 0; 
                    } 
                }) 
                .map(new Func1<Integer, String>() { 
                    @Override 
                    public String call(Integer integer) { 
                        return integer + ""; 
                    } 
                }) 
                .subscribe(new Subscriber<String>() { 
                   ...... 
                    @Override 
                    public void onNext(String str) { 
                        System.out.print(str + &#39;\n&#39;); 
                        Log.i("subscribe", str); 
                    } 
                }); 
//输出结果 print： 
//2 
//3 
//4 
//6 
//8 
//10

Skip()

public final Observable<T> skip(int count) { 
        return lift(new OperatorSkip<T>(count)); 
    }

Der Skip-Operator bedeutet, die ersten paar Ereignisse zu überspringen und ab einem bestimmten Ereignis (Index) mit der Ausgabe von Ereignissen zu beginnen Beginnen Sie bei 0.

Observable 
                .just(1,2,3,4,5,6,7,8,9,10) 
                .subscribeOn(Schedulers.io()) 
                .observeOn(AndroidSchedulers.mainThread()) 
                .skip(3) 
                .map(new Func1<Integer, String>() { 
                    @Override 
                    public String call(Integer integer) { 
                        return integer + ""; 
                    } 
                }) 
                .subscribe(new Subscriber<String>() { 
                    ...... 
                    @Override 
                    public void onNext(String s) { 
                        System.out.print(s + &#39;\n&#39;); 
                        Log.i("subscribe", s); 
                    } 
                }); 
//输出结果 print： 
//4 
//5 
//6 
//7 
//8 
//9 
//10

Range()

public static Observable<Integer> range(int start, int count) { 
        if (count < 0) { 
            throw new IllegalArgumentException("Count can not be negative"); 
        } 
        if (count == 0) { 
            return Observable.empty(); 
        } 
        if (start > Integer.MAX_VALUE - count + 1) { 
            throw new IllegalArgumentException("start + count can not exceed Integer.MAX_VALUE"); 
        } 
        if(count == 1) { 
            return Observable.just(start); 
        } 
        return Observable.create(new OnSubscribeRange(start, start + (count - 1))); 
    }

Der Bereichsoperator kann einfach so verstanden werden, dass from ein kontinuierliches int-Typ-Array übergibt, das ausgegeben werden soll, n ist der int-Startwert, m ist Count. Beispielsweise ist das Array n = 1, m = 5 int {1, 2, 3, 4, 5}

End

Dies habe ich zuerst in diesem Abschnitt gelernt, der als vorläufiges Verständnis und Erlernen von RxJava gilt. Tatsächlich basiert die Verwendung von RxJava hauptsächlich auf der Verwendung von Operatoren. Die zuvor eingeführten Operatoren sind die einfachsten und grundlegendsten, und es gibt viele besonders nützliche Operatoren, die noch nicht eingeführt wurden. Wir werden später weiterhin einige Operatoren vorstellen. RxJava ist aufgrund seiner Leistungsfähigkeit in der Android-Entwicklung sehr beliebt. Gleichzeitig kann RxJava in Kombination mit Retrofit verwendet werden, um die Rückgabewerte von Netzwerkanforderungen effizienter zu verarbeiten. Darüber hinaus verfügt die Android-Architektur auf GitHub GoogleSample auch über TODO-Projekte, die das RxJava-Framework verwenden. Sie können einen Blick darauf werfen und die praktische Anwendung von RxJava im Projekt verstehen.