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

Kotlin Reaktive Programmierung mit RxJava und RxKotlin

by
Difficulty:IntermediateLength:LongLanguages:

German (Deutsch) translation by Władysław Łucyszyn (you can also view the original English article)

Seitdem Kotlin eine offiziell unterstützte Sprache für die Android-Entwicklung geworden ist, erfreut es sich bei Android-Entwicklern immer größerer Beliebtheit. Google meldeteinen 6-fachen Anstieg der mit Kotlin erstellten Anwendungen.

Wenn Sie zuvor RxJava oder RxAndroid verwendet haben und zu Kotlin wechseln oder eine reaktive Programmierung mit Kotlin starten möchten, ist dieses Tutorial genau das Richtige für Sie. Wir werden uns mit den Grundlagen der Erstellung von RxJava 2.0 Observers, Observables und Datenströmen in Kotlin befassen, bevor wir uns ansehen, wie Sie eine Tonne Boilerplate-Code aus Ihren Projekten entfernen können, indem Sie RxJava mit Kotlin-Erweiterungsfunktionen kombinieren.

Die Verwendung von RxJava mit Kotlin kann Ihnen dabei helfen, hochreaktive Apps in weniger Code zu erstellen, aber keine Programmiersprache ist perfekt. Daher werde ich auch eine Problemumgehung für das SAM-Konvertierungsproblem vorstellen, auf das viele Entwickler stoßen, wenn sie RxJava 2.0 zum ersten Mal mit Kotlin verwenden.

Zum Abschluss erstellen wir eine Anwendung, die zeigt, wie Sie RxJava verwenden können, um einige der Probleme zu lösen, die in realen Android-Projekten auftreten.

Wenn dies Ihr erster Eindruck von RxJava ist, werde ich auf dem Weg auch alle Hintergrundinformationen bereitstellen, die Sie zum Verständnis der wichtigsten RxJava-Konzepte benötigen. Selbst wenn Sie noch nie zuvor mit RxJava experimentiert haben, haben Sie am Ende dieses Artikels ein solides Verständnis für die Verwendung dieser Bibliothek in Ihren Projekten und haben mehrere funktionierende Apps mit RxJava, RxKotlin, RxAndroid erstellt und RxBinding.

Was ist RxJava überhaupt?

RxJava ist eine Open-Source-Implementierung der ReactiveX-Bibliothek, mit der Sie Anwendungen im reaktiven Programmierstil erstellen können. Obwohl RxJava für die Verarbeitung synchroner und asynchroner Datenströme ausgelegt ist, ist es nicht auf "traditionelle" Datentypen beschränkt. RxJavas Definition von "data" ist ziemlich weit gefasst und umfasst Dinge wie Caches, Variablen, Eigenschaften und sogar Benutzereingabeereignisse wie Klicks und Wischen. Nur weil Ihre Anwendung keine großen Zahlen verarbeitet oder keine komplexen Datentransformationen durchführt, bedeutet dies nicht, dass sie nicht von RxJava profitieren kann!

Für ein wenig Hintergrundwissen über die Verwendung von RxJava für Android-Apps können Sie einige meiner anderen Beiträge hier auf Envato Tuts+ lesen.

Wie funktioniert RxJava?

RxJava erweitert das Entwurfsmuster der Observer-Software, das auf dem Konzept von Observers and Observables basiert. Um eine grundlegende RxJava-Datenpipeline zu erstellen, müssen Sie:

  • Erstellen Sie ein Observable.
  • Geben Sie dem Observable einige Daten zum Ausgeben.
  • Erstellen Sie einen Observer.
  • Abonnieren Sie den Observer für das Observable.

Sobald das Observable mindestens einen Observer hat, werden Daten ausgegeben. Jedes Mal, wenn das Observable ein Datenelement ausgibt, benachrichtigt es seinen zugewiesenen Observer durch Aufrufen der onNext() -Methode, und der Observer führt dann normalerweise eine Aktion als Reaktion auf diese Datenemission aus. Sobald das Observable die Datenausgabe beendet hat, benachrichtigt es den Observer durch Aufrufen von onComplete(). Das Observable wird dann beendet und der Datenstrom wird beendet.

Wenn eine Ausnahme auftritt, wird onError() aufgerufen und Observable wird sofort beendet, ohne dass weitere Daten ausgegeben oder onComplete() aufgerufen werden.

Bei RxJava geht es jedoch nicht nur darum, Daten von einem Observable an einen Observer zu übergeben! RxJava verfügt über eine große Sammlung von Operatoren, mit denen Sie diese Daten filtern, zusammenführen und transformieren können. Stellen Sie sich beispielsweise vor, Ihre App verfügt über eine Schaltfläche "Jetzt bezahlen", die onClick-Ereignisse erkennt, und Sie befürchten, dass ein ungeduldiger Benutzer mehrmals auf die Schaltfläche tippt und Ihre App mehrere Zahlungen verarbeitet.

Mit RxJava können Sie diese onClick-Ereignisse in einen Datenstrom umwandeln, den Sie dann mit den verschiedenen Operatoren von RxJava bearbeiten können. In diesem Beispiel können Sie den Operator debounce() verwenden, um Datenemissionen zu filtern, die schnell hintereinander auftreten. Selbst wenn der Benutzer auf die Schaltfläche "Jetzt bezahlen" klopft, registriert Ihre App immer nur eine einzige Zahlung.

Was sind die Vorteile von RxJava?

Wir haben gesehen, wie RxJava Ihnen bei der Lösung eines bestimmten Problems in einer bestimmten Anwendung helfen kann. Was bietet es Android-Projekten im Allgemeinen?

RxJava kann Ihnen dabei helfen, Ihren Code zu vereinfachen, indem es Ihnen die Möglichkeit gibt, das zu schreiben, was Sie erreichen möchten, anstatt eine Liste von Anweisungen zu schreiben, die Ihre Anwendung verarbeiten muss. Wenn Sie beispielsweise alle Datenemissionen ignorieren möchten, die innerhalb derselben 500-Millisekunden-Periode auftreten, schreiben Sie:

Da RxJava fast alles als Daten behandelt, bietet es eine Vorlage, die Sie auf eine Vielzahl von Ereignissen anwenden können: Erstellen Sie eine Observable, erstellen Sie einen Observer, abonnieren Sie die Observable, spülen Sie sie und wiederholen Sie sie. Dieser formelhafte Ansatz führt zu einem viel einfacheren, für Menschen lesbaren Code.

Der andere große Vorteil für Android-Entwickler ist, dass RxJava das Multithreading unter Android erheblich entlasten kann. Heutige mobile Benutzer erwarten von ihren Anwendungen Multitasking, auch wenn dies so einfach ist wie das Herunterladen von Daten im Hintergrund, während sie auf Benutzereingaben reagieren.

Android verfügt über mehrere integrierte Lösungen zum Erstellen und Verwalten mehrerer Threads. Keine dieser Lösungen ist jedoch besonders einfach zu implementieren und kann schnell zu komplexem, ausführlichem Code führen, der schwer zu lesen und fehleranfällig ist.

In RxJava erstellen und verwalten Sie zusätzliche Threads mithilfe einer Kombination aus Operatoren und Schedulern. Sie können den Thread, in dem die Arbeit ausgeführt wird, einfach ändern, indem Sie den Operator subscribeOn und einen Scheduler verwenden. Hier planen wir beispielsweise die Arbeit an einem neuen Thread:

Mit dem Operator observeOn können Sie festlegen, wo die Ergebnisse dieser Arbeit veröffentlicht werden sollen. Hier veröffentlichen wir die Ergebnisse mithilfe des AndroidSchedulers.mainThread-Schedulers, der als Teil der RxAndroid-Bibliothek verfügbar ist, im wichtigsten Haupt-UI-Thread von Android:

Im Vergleich zu den in Android integrierten Multithreading-Lösungen ist der Ansatz von RxJava viel präziser und verständlicher.

Weitere Informationen zur Funktionsweise von RxJava und zu den Vorteilen des Hinzufügens dieser Bibliothek zu Ihrem Projekt finden Sie in meinem Artikel Erste Schritte mit RxJava 2 für Android.

Sollte ich RxJava oder RxKotlin verwenden?

Da Kotlin zu 100% mit Java interoperabel ist, können Sie die meisten Java-Bibliotheken in Ihren Kotlin-Projekten problemlos verwenden - und die RxJava-Bibliothek ist keine Ausnahme.

Es gibt eine dedizierte RxKotlin-Bibliothek, bei der es sich um einen Kotlin-Verpackung um die reguläre RxJava-Bibliothek handelt. Dieser Verpackung bietet Erweiterungen, die RxJava für die Kotlin-Umgebung optimieren und die Menge an Boilerplate-Code, die Sie schreiben müssen, weiter reduzieren können.

Da Sie RxJava in Kotlin verwenden können, ohne jemals RxKotlin zu benötigen, werden wir in diesem Artikel RxJava verwenden, sofern nicht anders angegeben.

Erstellen einfacher Observers und Observablen in Kotlin

Observer und Observables sind die Bausteine von RxJava. Beginnen wir also mit der Erstellung von:

  • Ein einfaches Observable, das als Reaktion auf ein Schaltflächenklickereignis einen kurzen Datenstrom ausgibt.
  • Ein Observable, das auf diese Daten reagiert, indem es verschiedene Nachrichten an Logcat von Android Studio druckt.

Erstellen Sie ein neues Projekt mit den Einstellungen Ihrer Wahl. Stellen Sie jedoch sicher, dass Sie das Kontrollkästchen Kotlin-Unterstützung einschließen aktivieren, wenn Sie dazu aufgefordert werden. Öffnen Sie als Nächstes die Datei build.gradle Ihres Projekts und fügen Sie die RxJava-Bibliothek als Projektabhängigkeit hinzu:

Öffnen Sie dann die Datei activity_main.xml Ihres Projekts und fügen Sie die Schaltfläche hinzu, mit der der Datenstrom gestartet wird:

Es gibt verschiedene Möglichkeiten, ein Observable zu erstellen. Am einfachsten ist es jedoch, mit dem Operator just() ein Objekt oder eine Liste von Objekten in ein Observable zu konvertieren.

Im folgenden Code erstellen wir ein Observable (myObservable) und geben ihm die Elemente 1, 2, 3, 4 und 5 zum Ausgeben. Außerdem erstellen wir einen Observer (myObserver), abonnieren ihn bei myObservable und weisen ihn an, bei jedem Empfang einer neuen Emission eine Nachricht an Logcat zu drucken.

Sie können diese Anwendung jetzt testen:

  • Installieren Sie Ihr Projekt auf einem physischen Android-Smartphone oder -Tablet oder einem virtuellen Android-Gerät (AVD).
  • Klicken Sie auf die Schaltfläche RxJava-Stream starten.
  • Öffnen Sie den Logcat-Monitor von Android Studio, indem Sie die Registerkarte Android-Monitor (wobei sich der Cursor im folgenden Screenshot befindet) auswählen und dann die Registerkarte Logcat auswählen.

Zu diesem Zeitpunkt gibt das Observable seine Daten aus und der Observer druckt seine Nachrichten an Logcat. Ihre Logcat-Ausgabe sollte ungefähr so aussehen:

Check Android Studios Logcat Monitor

Sie können dieses Projekt von GitHub herunterladen, wenn Sie es selbst ausprobieren möchten.

Kotlin-Erweiterungen für RxJava

Nachdem wir nun gesehen haben, wie eine einfache RxJava-Pipeline in Kotlin eingerichtet wird, wollen wir uns ansehen, wie Sie dies mit weniger Code mithilfe der Erweiterungsfunktionen von RxKotlin erreichen können.

Um die RxKotlin-Bibliothek zu verwenden, müssen Sie sie als Projektabhängigkeit hinzufügen:

Im folgenden Beispiel verwenden wir die toObservable() - Erweiterungsfunktion von RxKotlin, um eine List in eine Observable umzuwandeln. Wir verwenden auch die Erweiterungsfunktion subscribeBy(), mit der wir einen Observer mit benannten Argumenten erstellen können, was zu klarerem Code führt.

Hier ist die Ausgabe, die Sie sehen sollten:

Every time onNext is called the data emission is printed to Android Studios Logcat

Lösen des SAM-Mehrdeutigkeitsproblems von RxJava

RxKotlin bietet auch eine wichtige Problemumgehung für das SAM-Konvertierungsproblem, das auftreten kann, wenn eine bestimmte Java-Methode mehrere SAM-Parameterüberladungen aufweist. Diese SAM-Mehrdeutigkeit verwirrt den Kotlin-Compiler, da er nicht herausfinden kann, welche Schnittstelle er konvertieren soll, und Ihr Projekt daher nicht kompiliert werden kann.

Diese SAM-Mehrdeutigkeit ist ein besonderes Problem bei der Verwendung von RxJava 2.0 mit Kotlin, da viele der RxJava-Operatoren mehrere SAM-kompatible Typen verwenden.

Schauen wir uns das SAM-Konvertierungsproblem in Aktion an. Im folgenden Code verwenden wir den Operator zip(), um die Ausgabe von zwei Observables zu kombinieren:

Dies führt dazu, dass der Kotlin-Compiler einen Typinferenzfehler auslöst. RxKotlin bietet jedoch Hilfsmethoden und Erweiterungsfunktionen für die betroffenen Operatoren, einschließlich Observables.zip(), die wir im folgenden Code verwenden:

Hier ist die Ausgabe dieses Codes:

Switch to the Observableszip operator and the Kotlin compiler will no longer throw a type inference error

Abschluss

In diesem Tutorial habe ich Ihnen gezeigt, wie Sie die RxJava-Bibliothek in Ihren Kotlin-Projekten verwenden können, einschließlich der Verwendung einer Reihe zusätzlicher unterstützender Bibliotheken wie RxKotlin und RxBinding. Wir haben uns angesehen, wie Sie einfache Observer und Observablen in Kotlin erstellen können, bis hin zur Optimierung von RxJava für die Kotlin-Plattform mithilfe von Erweiterungsfunktionen.

Bisher haben wir RxJava verwendet, um einfache Observables zu erstellen, die Daten ausgeben, und Observer, die diese Daten in Logcat von Android Studio drucken. In der realen Welt wird RxJava jedoch nicht so verwendet!

Im nächsten Beitrag werden wir uns ansehen, wie RxJava bei der Lösung realer Probleme helfen kann, die bei der Entwicklung von Android-Anwendungen auftreten. Wir werden RxJava mit Kotlin verwenden, um einen klassischen Anmeldebildschirm zu erstellen.

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.