Unlimited Plugins, WordPress themes, videos & courses! Unlimited asset downloads! From $16.50/m
Advertisement
  1. Code
  2. Android SDK
Code

Erste Schritte mit RxJava 2 für Android

by
Difficulty:BeginnerLength:LongLanguages:

German (Deutsch) translation by Katharina Nevolina (you can also view the original English article)

Wenn Sie ein Android-Entwickler sind, haben Sie vielleicht gute Dinge über RxJava gehört, eine beliebte Open-Source-Implementierung der ReactiveX-Bibliothek, die reaktive Programmierung auf die Java Virtual Machine (JVM) bringt.

RxJava wurde entwickelt, um die Arbeit mit asynchronen Datenströmen zu vereinfachen. Wie Sie sehen werden, ist die Definition von "Daten" in RxJava jedoch ziemlich weit gefasst. Da RxJava eine JVM-vereinbare Bibliothek ist, können Sie sie auf einer Vielzahl von Plattformen verwenden. In dieser Serie werde ich Ihnen jedoch zeigen, wie Sie RxJava 2 für die Android-Entwicklung verwenden.

Am Ende dieser Serie haben Sie alle wichtigen Funktionen von RxJava 2 beherrscht, sodass Sie hochreaktive Apps erstellen können, die eine Vielzahl von synchronen und asynchronen Daten verarbeiten können - alles unter Verwendung von Code, der präziser und verwaltbarer ist als normalerweise allein mit Java zu erreichen.

Wenn Sie ein RxJava 1-Veteran sind, der den Sprung zu RxJava 2 schaffen möchte, bietet diese Serie nicht nur eine Einführung für RxJava-Neulinge, sondern trägt auch dazu bei, diesen Übergang so reibungslos wie möglich zu gestalten. Während eine Aktualisierung auf die neueste Version einer Bibliothek möglicherweise keine große Sache ist, ist RxJava 2 keine typische Aktualisierung - es ist eine vollständige Neufassung von RxJava. Bei so vielen Änderungen kann es leicht zu Verwirrung kommen. Wenn Sie sich also etwas Zeit nehmen, um sich mit RxJava 2 aus Anfängersicht vertraut zu machen, können Sie auf lange Sicht viel Zeit und Frust sparen.

In diesem ersten Beitrag werde ich erläutern, was RxJava ist und welche Hauptvorteile es Android-Entwicklern bietet. Wir werden uns auch eingehend mit den Kernkomponenten eines RxJava-Projekts befassen: Observers, Observables und Abonnements. Am Ende dieses Tutorials haben Sie eine einfache Anwendung im "Hallo Welt"-Stil erstellt, die alle diese Kernkomponenten enthält.

Die anderen Hauptbausteine von RxJava sind Operatoren. In Teil 2 werde ich die verschiedenen Möglichkeiten untersuchen, wie Sie Operatoren zum Transformieren, Kombinieren, Filtern und Bearbeiten der Daten Ihrer Anwendung verwenden können.

In der letzten Ausgabe gehen wir über die RxJava-Kernbibliothek hinaus und werfen einen Blick auf RxAndroid, eine gesamte Bibliothek mit allen Android-spezifischen Erweiterungen, die Sie benötigen, um das volle Potenzial der reaktiven Programmierung für Android auszuschöpfen.

Wir haben viel zu besprechen, also fangen wir mit dem Wesentlichen an:

Was ist RxJava überhaupt?

RxJava ist eine Bibliothek, mit der Sie Anwendungen im reaktiven Programmierstil erstellen können. Im Kern bietet die reaktive Programmierung eine saubere und effiziente Möglichkeit, Echtzeitdatenströme, einschließlich Daten mit dynamischen Werten, zu verarbeiten und darauf zu reagieren.

Diese Datenströme müssen nicht unbedingt die Form traditionelle Datentypen haben, da RxJava so ziemlich alles als Datenstrom behandelt - von Variablen über Eigenschaften, Caches bis hin zu Benutzereingabeereignissen wie Klicks und Wischen.

Die von jedem Strom ausgegebenen Daten können entweder ein Wert, ein Fehler oder ein "abgeschlossenes" Signal sein, obwohl Sie die letzten beiden nicht unbedingt implementieren müssen. Sobald Sie Ihre datenemittierenden Ströme erstellt haben, kombinieren Sie sie mit reaktiven Objekten, die diese Daten verbrauchen und dann darauf reagieren. Je nachdem, was der Strom emittiert hat, führen Sie unterschiedliche Aktionen aus. RxJava enthält eine ganze Reihe nützlicher Operatoren für die Arbeit mit Ströme, die das Filtern, Zuordnen, Verzögern, Zählen und vieles mehr vereinfachen.

An Observable and an operation

Um diesen Arbeitsablauf aus Datenströmen und Objekten zu erstellen, die darauf reagieren, erweitert RxJava das Entwurfsmuster der Observer-Software. Im Wesentlichen haben Sie in RxJava Observable-Objekte, die einen Datenstrom ausgeben und dann beenden, und Observer-Objekte, die Observables abonnieren. Ein Observer erhält jedes Mal eine Benachrichtigung, wenn sein zugewiesenes Observable einen Wert, einen Fehler oder ein abgeschlossenes Signal ausgibt.

Auf sehr hohem Niveau dreht sich bei RxJava alles um:

  • Observable erstellen.
  • Geben Sie diesem Observable einige Daten zum Ausgeben.
  • Observer erstellen.
  • Zuweisen desObserver zu einem Observable
  • Geben Sie Observer Aufgaben, die er ausführen muss, wenn er eine Emission von seinem zugewiesenen Observable erhält.

Warum RxJava?

Das Erlernen neuer Technologien erfordert Zeit und Mühe. Als datenorientierte Bibliothek ist RxJava nicht immer die am einfachsten zu handhabende API.

Lassen Sie uns einige der wichtigsten Vorteile des Hinzufügens der RxJava-Bibliothek zu Ihren Android-Projekten untersuchen, um zu entscheiden, ob das Erlernen von RxJava die anfängliche Investition wert ist.

Prägnanter, lesbarer Code

Code, der komplex, ausführlich und schwer zu lesen ist, ist immer eine schlechte Nachricht. Unordentlicher Code ist anfälliger für Fehler und andere Ineffizienzen. Wenn Fehler auftreten, wird es viel schwieriger, die Ursache dieser Fehler zu ermitteln, wenn Ihr Code ein Schlamassel ist.

Selbst wenn Ihr Projekt fehlerfrei erstellt wird, kann komplexer Code Sie immer noch verfolgen - normalerweise, wenn Sie ein paar Monate später ein Update für Ihre App veröffentlichen, Ihr Projekt starten und sofort mit einer Wand von verwirrtem, verwirrendem Code konfrontiert werden!

RxJava vereinfacht den Code, der für die Verarbeitung von Daten und Ereignissen erforderlich ist, indem Sie beschreiben können, was Sie erreichen möchten, anstatt eine Liste mit Anweisungen für Ihre App zu erstellen. RxJava bietet auch einen Standard-Arbeitsablauf, mit dem Sie alle Daten und Ereignisse in Ihrer Anwendung verarbeiten können: erstellen Sie ein Observable, erstellen Sie einen Observer, weisen Sie das Observable diesem Observer zu, spülen Sie es aus und wiederholen Sie es. Dieser formelhafte Ansatz ermöglicht einen sehr einfachen, für Menschen lesbaren Code.

Multithreading leicht gemacht

Moderne Android-Anwendungen müssen Multitasking-fähig sein. Zumindest erwarten Ihre Benutzer, dass sie weiterhin mit der Benutzeroberfläche Ihrer App interagieren können, während Ihre Anwendung im Hintergrund einige Arbeiten ausführt, z. B. das Verwalten einer Netzwerkverbindung, das Herunterladen einer Datei oder das Abspielen von Musik. Das Problem ist, dass Android standardmäßig Single-Threaded ist. Wenn Ihre App also jemals erfolgreich mehrere Aufgaben ausführen kann, müssen Sie einige zusätzliche Threads erstellen.

Standardmäßig bietet Android eine Reihe von Möglichkeiten zum Erstellen zusätzlicher Threads, z. B. Dienste und IntentServices. Keine dieser Lösungen ist jedoch besonders einfach zu implementieren und kann schnell zu komplexem, ausführlichem Code führen, der fehleranfällig ist.

RxJava zielt darauf ab, die Erstellung von Multithread-Android-Apps zu vereinfachen, indem spezielle Planer und Operatoren bereitgestellt werden. Auf diese Weise können Sie auf einfache Weise den Thread angeben, in dem die Arbeit ausgeführt werden soll, und den Thread, in dem die Ergebnisse dieser Arbeit veröffentlicht werden sollen. RxJava 2.0 enthält standardmäßig eine Reihe von Planer, einschließlich Schedulers.newThread, was besonders nützlich ist, wenn ein neuer Thread erstellt wird.

Um den Thread zu ändern, in dem die Arbeit ausgeführt wird, müssen Sie nur mit dem Operator subscribeOn ändern, wo ein Observer eine Observable abonniert. Hier erstellen wir beispielsweise einen neuen Thread und legen fest, dass die Arbeit an diesem neuen Thread ausgeführt werden soll:

Ein weiteres seit langem bestehendes Problem beim Multithreading unter Android ist, dass Sie die Benutzeroberfläche Ihrer App nur über den Hauptthread aktualisieren können. Wenn Sie die Ergebnisse einiger Hintergrundarbeiten auf der Benutzeroberfläche Ihrer App veröffentlichen müssen, müssen Sie in der Regel einen dedizierten Handler erstellen.

Wieder einmal hat RxJava eine viel einfachere Lösung. Mit dem observOn-Operator können Sie festlegen, dass ein Observable seine Benachrichtigungen mit einem anderen Scheduler senden soll. Auf diese Weise können Sie die Daten Ihres Observable im Wesentlichen an den Thread Ihrer Wahl senden, einschließlich des Haupt-UI-Threads.

Das bedeutet, dass Sie mit nur zwei Codezeilen einen neuen Thread erstellen und die Ergebnisse der an diesem Thread durchgeführten Arbeiten an den Haupt-UI-Thread von Android senden können:

Gut, technisch gesehen betrügen wir hier ein wenig, da AndroidSchedulers.mainThread nur als Teil der RxAndroid-Bibliothek verfügbar ist, die wir erst im dritten Teil betrachten werden. Dieses Beispiel gibt Ihnen jedoch einen Einblick in die Möglichkeiten von RxJava und RxAndroid, einen Bereich der Android-Entwicklung zu vereinfachen, der dafür bekannt ist, dass er zu kompliziert ist.

Erhöhte Flexibilität

Observables geben ihre Daten auf eine Weise aus, die die Art und Weise, wie Daten erstellt wurden, vollständig verbirgt. Da Ihre Observers nicht einmal sehen können, wie die Daten erstellt wurden, können Sie Ihre Observables beliebig implementieren.

Sobald Sie Ihre Observables implementiert haben, bietet RxJava eine Vielzahl von Operatoren, mit denen Sie die von diesen Observables ausgegebenen Daten filtern, zusammenführen und transformieren können. Sie können sogar immer mehr Operatoren miteinander verketten, bis Sie genau den Datenstrom erstellt haben, den Ihre Anwendung benötigt.

Sie können beispielsweise Daten aus mehreren Ströme kombinieren, den neu zusammengeführten Strom filtern und die resultierenden Daten dann als Eingabe für einen nachfolgenden Datenstrom verwenden. Und denken Sie daran, dass in RxJava so ziemlich alles als Datenstrom behandelt wird, sodass Sie diese Operatoren sogar auf nicht traditionelle "Daten" wie Klickereignisse anwenden können.

Erstellen Sie ansprechbare Apps

Vorbei sind die Zeiten, in denen eine App möglicherweise keine Inhaltsseite mehr lädt und dann darauf wartet, dass der Benutzer auf die Schaltfläche Weiter tippt. Heutzutage muss Ihre typische mobile App in der Lage sein, auf eine ständig wachsende Vielfalt von Ereignissen und Daten zu reagieren, idealerweise in Echtzeit. Beispielsweise muss Ihre typische Social-Networking-App ständig auf eingehende Likes, Kommentare und Freundschaftsanfragen warten, während Sie im Hintergrund eine Netzwerkverbindung verwalten und sofort reagieren, wenn der Benutzer auf den Bildschirm tippt oder darüber wischt.

Die RxJava-Bibliothek wurde entwickelt, um eine Vielzahl von Daten und Ereignissen gleichzeitig und in Echtzeit verwalten zu können. Das macht sie zu einem leistungsstarken Werkzeug für die Erstellung von Anwendungen, die moderne mobile Benutzer erwarten.

Hinzufügen von RxJava zu Android Studio

Wenn Sie entschieden haben, dass RxJava Ihrer Android-Entwicklungspraxis etwas zu bieten hat, besteht der erste Schritt, um ein RxJava-Master zu werden, darin, die Bibliothek zu Ihrem Projekt hinzuzufügen.

Erstellen Sie ein neues Android Studio-Projekt mit den Einstellungen Ihrer Wahl, öffnen Sie dann die Datei build.gradle auf Modulebene und fügen Sie die neueste Version von io.reactivex.rxjava2:rxjava als Abhängigkeit hinzu.

Zum Zeitpunkt des Schreibens war RxJava 2.0.5 die neueste Version, daher sieht meine build.gradle-Datei folgendermaßen aus:

Wenn Sie dazu aufgefordert werden, klicken Sie auf Jetzt synchronisieren.

Öffnen Sie als Nächstes Ihre MainActivity-Datei und fügen Sie die Importe hinzu, die Sie benötigen, um mit den wichtigsten RxJava-Funktionen zu arbeiten:

Wenn Sie von RxJava 1 migrieren, entsprechen diese Importe möglicherweise nicht Ihren Erwartungen, da RxJava 1 einen völlig anderen Paketnamen verwendet (genauer gesagt rx).

Das ist jedoch keine willkürliche Namensänderung: Die verschiedenen Paketnamen bieten Ihnen die Möglichkeit, RxJava 1 und RxJava 2 nebeneinander im selben Projekt zu verwenden. Wenn Sie sich in der Mitte eines Projekts befinden, das RxJava 1 verwendet, können Sie die RxJava 2-Bibliothek hinzufügen und die aktualisierten 2 Funktionen sofort verwenden, ohne Ihren RxJava 1-Code zu beschädigen.

Wenn Sie Ihre RxJava-Reise mit Version 2 beginnen, beachten Sie nur, dass dies RxJava 1-Code ist und wahrscheinlich nicht mit der Version 2-Bibliothek kompatibel ist, wenn Sie auf RxJava-Tutorials oder -Code mit dem des rx-Paket-Namens stoßen.

Die Bausteine von RxJava

Bisher haben wir uns RxJava nur auf sehr hohem Niveau angesehen. Es ist an der Zeit, genauer zu werden und zwei der wichtigsten Komponenten, die während Ihrer RxJava-Arbeit immer wieder auftauchen, genauer zu betrachten: Observers und Observabls.

Am Ende dieses Abschnitts haben Sie nicht nur ein solides Verständnis für diese beiden Kernkomponenten, sondern Sie haben auch eine voll funktionsfähige Anwendung erstellt, die aus einem Observable besteht, das Daten ausgibt, und einem Observer, der auf diese Emissionen reagiert.

Erstellen Sie ein Observable

Ein Observable ähnelt einem Iterable darin, dass es bei einer bestimmten Sequenz diese Sequenz durchläuft und jedes Element ausgibt, obwohl Observables normalerweise erst dann mit der Ausgabe von Daten beginnen, wenn ein Observer sie abonniert.

Jedes Mal, wenn ein Observable ein Element ausgibt, benachrichtigt es seinen zugewiesenen mithilfe Observer der onNext() -Methode. Sobald ein Observable alle seine Werte übertragen hat, wird es durch Aufrufen von:

  • onComplete: Wird aufgerufen, wenn die Operation erfolgreich war.
  • onError: Wird aufgerufen, wenn eine Exception ausgelöst wurde.

Schauen wir uns ein Beispiel an. Hier erstellen wir ein Observable, das die Nummern 1, 2, 3 und 4 ausgibt und dann endet.

Beachten Sie, dass ich in diesem Beispiel genau darlege, was gerade passiert. Lassen Sie sich also nicht von der Menge an Code abschrecken! Das ist viel mehr Code, als Sie normalerweise zum Erstellen von Observables in Ihren realen RxJava-Projekten verwenden.

Erstellen Sie einen Observer

Observers sind Objekte, die Sie mit dem subscribe()-Operator einem Observable zuweisen. Sobald ein Observer ein Observable abonniert hat, reagiert er immer dann, wenn sein Observer eine der folgenden Aktionen ausgibt:

  • onNext: Das Observable hat einen Wert ausgegeben.
  • onError: Ein Fehler ist aufgetreten.
  • onComplete: Das Observable hat alle seine Werte ausgegeben.

Erstellen wir einen Observer, der unser 1, 2, 3, 4 Observable abonniert hat. Um die Dinge einfach zu halten, reagiert dieser Observer auf onNext, onError und onComplete, indem er eine Nachricht auf den Logcat-Monitor von Android Studio druckt:

Öffnen Sie den Logcat-Monitor von Android Studio, indem Sie unten im Android Studio-Fenster die Registerkarte Android-Monitor auswählen (wo sich der Cursor im folgenden Screenshot befindet) und dann die Registerkarte Logcat auswählen.

Reactive Programming Logcat

Um diesen Code zu testen, schließen Sie entweder Ihr physisches Android-Gerät an Ihren Entwicklungscomputer an oder führen Sie Ihr Projekt auf einer kompatiblen AVD aus. Sobald Ihre App auf dem Bildschirm angezeigt wird, sollten die von Ihrem Observable ausgegebenen Daten angezeigt werden.

Reactive Programming Observer Observable

Erstellen eines Observable mit weniger Code

Obwohl unser Projekt erfolgreich Daten ausgibt, ist der von uns verwendete Code nicht genau - insbesondere der Code, den wir zum Erstellen unseres Observable verwenden.

Zum Glück bietet RxJava eine Reihe von praktischen Methoden, mit denen Sie ein Observable mit viel weniger Code erstellen können:

1. Observable.just()

Mit dem Operator .just() können Sie jedes Objekt in ein Observable konvertieren. Das Ergebnis Observable gibt dann das ursprüngliche Objekt aus und vervollständigt es.

Zum Beispiel erstellen wir hier ein Observable, das eine einzelne Zeichenfolge an alle seine Observers ausgibt:

2. Observable.from()

Mit dem Operator .from() können Sie eine Sammlung von Objekten in einen beobachtbaren Stream konvertieren. Sie können ein Array mit Observable.fromArray in ein Observable, Callable in ein Obserable mit Observable.fromCallable und Iterable mit Observable.fromIterable in ein Observable konvertieren.

3. Observable.range()

Mit dem Operator .range() können Sie eine Reihe aufeinanderfolgender Ganzzahlen ausgeben. Die erste von Ihnen angegebene Ganzzahl ist der Anfangswert und die zweite die Anzahl der Ganzzahlen, die Sie ausgeben möchten. Zum Beispiel:

4. Observable.interval()

Dieser Operator erstellt eine Observable, die eine unendliche Folge aufsteigender Ganzzahlen ausgibt, wobei jede Emission durch ein von Ihnen ausgewähltes Zeitintervall getrennt ist. Zum Beispiel:

5. Observable.empty()

Der Operator empty() erstellt ein Observable, das keine Elemente ausgibt, aber normal beendet wird. Das kann hilfreich sein, wenn Sie zu Testzwecken schnell ein Observable erstellen müssen.

Schlussfolgerung

In diesem Artikel haben wir die Grundbausteine von RxJava behandelt.

An diesem Punkt wissen Sie, wie Sie Observers und Observables erstellen und damit arbeiten und wie Sie ein Abonnement erstellen, damit Ihre Observables Daten ausgeben können. Wir haben uns auch kurz einige Operatoren angesehen, mit denen Sie eine Reihe verschiedener Observables mit viel weniger Code erstellen können.

Operatoren sind jedoch nicht nur eine praktische Möglichkeit, die Menge an Code zu reduzieren, die Sie schreiben müssen! Das Erstellen eines Observer und eines Observable ist einfach genug, aber in Operatoren können Sie wirklich erkennen, was mit RxJava möglich ist.

Im nächsten Beitrag werden wir einige der leistungsstärksten Operatoren von RxJava untersuchen, einschließlich Operatoren, die das Multithreading unter Android endlich zu einem schmerzfreien Erlebnis machen können. Bleiben Sie auf dem Laufenden, um die wahre Leistungsfähigkeit der RxJava-Bibliothek kennenzulernen.

In der Zwischenzeit können Sie einige unserer anderen Beiträge und Kurse zur Android-Entwicklung hier auf Envato Tuts+ lesen!

Observable Datenflussdiagramme stammen aus der ReactiveX-Dokumentation und sind unter der Creative Commons Attribution 3.0-Lizenz lizenziert.

Advertisement
Advertisement
Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.