Wann RxJava in Android und zu verwenden wenn LiveData von Android Architektonischen Komponenten?

Bin ich nicht immer der Grund für die Verwendung RxJava in Android und LiveData von Android Architektonischen Komponenten.Es wäre wirklich hilfreich, wenn die usecases und Unterschiede zwischen den beiden erläutert werden zusammen mit Beispiel in form von code, was erklärt die Unterschiede zwischen den beiden.

  • Haben Sie einen guten Grund, noch? Frage ich mich das gleiche...
InformationsquelleAutor rahul66 | 2017-09-20
  1. 93

    Android LiveData ist eine Variante des original-observer-Muster, mit dem Zusatz von aktiven/inaktiven übergänge. Als solche, es ist sehr restriktiv in seiner Tragweite.

    Am Beispiel beschrieben in Android LiveData, a-Klasse wird erstellt, um zu überwachen, Standort-Daten, und registrieren und aufheben der Registrierung basiert auf den Zustand der Anwendung.

    RxJava bietet dem Betreiber, viel mehr verallgemeinert. Lassen Sie uns annehmen, dass das beobachtbare bieten Standortdaten:

    Observable<LocationData> locationObservable;

    Die Umsetzung des beobachtbaren aufgebaut werden kann, mit Observable.create() Karte der call-back-Operationen. Wenn die beobachtbaren abonniert ist, wird der Anruf wieder registriert ist, und wenn es ist abgemeldet, wird der Anruf wieder nicht registriert ist. Die Implementierung ähnelt sehr der code aus dem Beispiel.

    Lassen Sie uns auch annehmen, dass Sie eine observable, die strahlt true, wenn die Anwendung aktiv:

    Observable<Boolean> isActive;

    Dann können Sie alle Funktionalitäten von LiveData durch die folgenden

    Observable<LocationData> liveLocation =
  isActive
    .switchMap( active -> active ? locationObservable : Observable.never() );

    Den switchMap() Betreiber wird entweder die aktuelle Position im stream, oder gar nichts, wenn die Anwendung nicht aktiv ist. Sobald Sie die liveLocation beobachtbar ist, gibt es eine Menge Dinge, die Sie tun können, mit Hilfe von RxJava Betreiber. Mein Lieblings-Beispiel ist:

    liveLocation.distinctUntilChanged()
  .filter( location -> isLocationInAreaOfInterest( location ) )
  .subscribe( location -> doSomethingWithNewLocation( location ) );

    Wird nur die Aktion ausführen, wenn sich der Ort geändert, und die Lage ist interessant. Sie können erstellen Sie ähnliche Operationen,
    kombinieren Sie Zeit-Operatoren bestimmen die Geschwindigkeit. Noch wichtiger ist, können Sie ausführliche Kontrolle, ob Operationen geschehen in der Haupt-thread, oder einen hintergrund-thread oder mehrere threads, mit RxJava Betreiber.

    Den Punkt RxJava ist, dass Sie kombiniert Steuerung und timing in einem einzigen Universum, mit Operationen zur Verfügung gestellt von der Bibliothek, oder sogar benutzerdefinierte Operationen, die Sie stellen.

    LiveData-Adressen nur ein kleiner Teil des Universums, das entspricht der Aufbau der liveLocation.

    • Danke, die LiveData docs nicht scheinen, verweisen auf ein Standort-Probe mehr. Es gibt weitere interessante Punkte (mit einem Standort-Beispiel) hier: androidkt.com/livedata
    • der link ist nicht mehr verfügbar.
    • Dude ich kann mich nicht erinnern, wtf war auf diesen link 😀 ich mag Mark Allison sample-code für eine live-data: blog.stylingandroid.com/architecture-components-livedata
    • The point of RxJava is that it combines control and timing into a single universe, using operations provided from the library, or even custom operations that you provide. Aber nicht LiveData lifecycle bewusst. Wenn wir Rx, würden wir nicht haben, um die lifecycle-änderungen?
    • bekam den Punkt. RxJava ist nicht lifecycle bewusst. wir haben, um manuell eingeben. wo, wie in LiveData es ist bereits gesorgt-Lebenszyklus.
    • Wir passieren können LiveData einem anderen thread zum Beispiel Netzwerk aufrufen und dann diesen thread kann postValue in der livedata, die der Abonnent hören kann. Außerdem kümmern Lebenszyklus. Ich glaube RxJava sollte nur verwendet werden, wenn Sie mehr komplexe Fälle.

    InformationsquelleAutor Bob Dalgleish
  2. 76

    Bezug auf die ursprüngliche Frage, die beide RxJava und LiveData ergänzen einander wirklich gut.

    LiveData scheint auf den ViewModel-layer, mit dessen enge integration mit Android-Lebenszyklen und ViewModel. RxJava bietet mehr Funktionen bei Transformationen (wie erwähnt von @Bob Dalgleish).

    Momentan sind wir mit RxJava im Datenquellen-und repository-Schichten, und es verwandelt sich in LiveData (mit LiveDataReactiveStreams) in ViewModels (vor Verfügbarmachen von Daten zu Aktivitäten/Fragmente) - sehr zufrieden mit diesem Ansatz.

    • Wenn wir Sie richtig verstanden haben, dann LiveData ist nur nützlich für Android-UI-spezifische Implementierungen. Wenn wir nur den Bau einer generischen app mit Sauberen Architektur, und teilen Sie dieses Architektur mit anderen Plattformen, dann RxJava ist eine bessere Passform als LiveData?
    • welche Sprache/frameworks verwenden Sie für die generische app?
    • Android-unabhängigen APIs und Sauberen Bogen, geschrieben in Java/Kotlin.
    • können Sie schlagen alle arbeiten Beispiel LiveDataReactiveStreams in Ihrer Antwort?
    • z.B. folgende Erweiterung Funktion wandelt Fließfähige in LiveData: LiveDataReactiveStreams.fromPublisher(this.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()))
    • Sie brauchen nicht, dass observeOn, LiveDataReactiveStreams hat, die sowieso durch den Aufruf LiveData.postValue(). Und es gibt keine Garantie, Ihr subscribeOn haben keine Wirkung im Allgemeinen.

    InformationsquelleAutor kzotin
  3. 25

    In der Tat LiveData ist nicht ein grundsätzlich anderes tool RxJava , also warum wurde es eingeführt, als eine Architektur-Komponente, wenn RxJava könnte leicht verwaltet den Lebenszyklus durch die Speicherung alle Anmeldungen, die zu observablen in einem CompositeDispoable Objekt und dann entsorgen Sie Sie in onDestroy() des Activity oder onDestroyView() des Fragment mit nur einer Zeile code?

    Habe ich beantwortet diese Frage vollständig durch den Bau einer Film Suche app einmal mit RxJava und dann mit LiveData hier.

    Aber kurz gesagt, ja, das könnte es, aber das müsste zuerst überschreiben die entsprechenden lifecycle-Methoden neben der basic-lifecycle-wissen. Diese noch nicht sinnvoll für einige, aber die Tatsache ist, dass nach einem der Jetpack-sessions in Google-I/O-2018 viele Entwickler lifecycle management Komplex. Der crash-Fehler aufgrund von nicht handling lifecycle-Abhängigkeit könnte ein weiteres Zeichen dafür, dass einige Entwickler, auch wenn kenntnisreich, lifecycle, vergessen zu kümmern, dass in jeder Activity /Fragment, die Sie in der app. Im großen apps könnte dies zu einem Problem werden, trotz der negativen Auswirkungen könnte es haben auf die Produktivität.

    Die Quintessenz ist, dass durch die Einführung LiveData größere Anzahl von Entwicklern erwartet, um anzunehmen, MVVM, ohne auch nur zu verstehen, lifecycle-management, memory Leck wird und abstürzt. Obwohl ich habe keinen Zweifel, dass LiveData ist nicht vergleichbar mit RxJava in Bezug auf die Fähigkeiten und die Energie, die es gibt Entwickler, reaktive Programmierung und RxJava ist schwer zu verstehen, Konzept und Werkzeug für viele. Auf der anderen Seite, ich glaube nicht, dass LiveData ist dazu gedacht, ein Ersatz für RxJava–es kann einfach nicht–aber ein sehr einfaches Werkzeug für den Umgang mit einem umstrittenen weit verbreitetes Problem erfahren viele Entwickler.

    ** UPDATE **
    Ich habe soeben einen neuen Artikel hier, wo ich erklärt habe, wie missbrauchen LiveData kann zu unerwarteten Ergebnissen führen. RxJava können kommen, um zu retten, die in diesen Situationen

    • "warum wurde es eingeführt, wenn RxJava könnte leicht verwaltet den Lebenszyklus durch die Speicherung alle Abonnements in einem CompositeDispoable und dann entsorgen Sie Sie in onDestroy() der Activity" - LiveData würde entsorgen in onStop eigentlich
    • von meinem verstehen: selbst zu behandeln, das CompositeDispoablewe haben, überschreiben Sie die life-cycle-Methoden. Aber in der Live-Daten gehören in eine einzige Zeile von code. So sparen wir mindestens 20 Zeilen code.
    • Wir definieren eine baseFragment und definieren Einweg[] Abos () - Methode überschrieben werden, die von allen abgeleiteten Fragmente , ruft diese Methode onCreateView und fügen Sie den Rückgabewert in einer CompositeDisposable, entsorgen, dass in onDestroyView, nicht mehr zu vergessen.
    • Es geht nicht nur um die Entsorgung. Mit RxJava, Sie verfügen bei onStop, dann abonnieren Sie wieder in onStart/onResume, Griff Konfigurationsänderungen, und tun eine Menge anderer Dinge. Das ist, warum es so viele Abstürze mit RxJava. LiveData Griffe, aber ist nicht so flexibel wie RxJava.
    InformationsquelleAutor Ali Nem
  4. 21

    Wie Sie vielleicht wissen, in der reaktiven ökosystem haben wir eine Beobachtbaren, dass sendet Daten und eine Beobachter, die abonniert( benachrichtigt werden) dieser Beobachtbaren emission, nichts ungewöhnliches ist, wie funktioniert das so genannte Observer-Muster. Eine Beobachtbare "schreit"etwas, das der Beobachter benachrichtigt werden, dass die Beobachtbaren Schreien, etwas in einem gegebenen moment.

    Denke LiveData als eine Beobachtbare, dass ermöglicht Ihnen zu verwalten, die Beobachter, die in einem active Zustand. In anderen Worten LiveData ist eine einfache Beobachtbare aber auch kümmert sich um die life-cycle.

    Aber mal sehen, die beiden code-Fällen, die Sie verlangen:

    A) Live-Daten

    B) RXJava

    A)Dies ist eine grundlegende Implementierung von LiveData

    1) Sie in der Regel instanziieren LiveData im ViewModel um die Orientierung zu behalten ändern (Sie können LiveData ist nur zu Lesen, oder MutableLiveData, die auch beschreibbar sind, so dass Sie in der Regel aussetzen, die außerhalb von der Klasse LiveData)

    2) in der OnCreate Methode der Main Aktivität(nicht die ViewModel -)
    Sie "abonnieren" ein Beobachter-Objekt (in der Regel eine a-Methode onChanged-Ereignisse)

    3) starten Sie die Methode beobachten, um die Verbindung

    Zuerst die ViewModel (besitzt die business-Logik)

    class ViewModel : ViewModel() { //Point 1

    var liveData: MutableLiveData<Int> = MutableLiveData()

}

    - Und dies ist die MainActivity( so dumm wie möglich)

    class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val ViewModelProvider= ViewModelProviders.of(this).get(ViewModel::class.java)

        ViewModelProvider.observe(this, Observer {//Points 2 and 3
            //what you want to observe
        })


        }
    }
}

    B)Dies ist die grundlegende Implementierung von RXJava

    1) deklarieren Sie eine Beobachtbare

    2) Sie erklären Beobachter

    3) Sie abonnieren die Beobachtbaren mit dem Betrachter

    Observable.just(1, 2, 3, 4, 5, 6) //Point 1

   .subscribe(new Subscriber() {    //Points 2 & 3
       @Override
       public void onCompleted() {
           System.out.println("Complete!");
       }

       @Override
       public void onError(Throwable e) {
       }

       @Override
       public void onNext(Double value) {
           System.out.println("onNext: " + value);
       }
    });

    Insbesondere LiveData mit Lifecycle und oft mit ViewModel(wie wir gesehen haben) - Architektur-Komponenten. In der Tat, wenn LiveData ist kombiniert mit einem ViewModel ermöglicht Ihnen zu halten, die in Echtzeit aktualisiert wird jede änderung in den Betrachter, so, dass die Ereignisse verwaltet werden, in Echtzeit, wo erforderlich ist. Verwenden LiveData wird dringend empfohlen, zu wissen, das Konzept der lifecycle und die relative Objekte LifeCycleOwner/LifeCycle, auch ich würde dir empfehlen, einen Blick auf Transformationen, wenn Sie implementieren möchten LiveData im real life Szenarien. Hier finden Sie einige Anwendungsfälle aus der großen commonsware.

    Zu wickeln im Grunde LiveData ist eine vereinfachte RXJava eine elegante Weise zu beobachten, Veränderungen über mehrere Komponenten, ohne die Schaffung expliziter sogenannten Regeln für Abhängigkeiten zwischen den Komponenten, so dass Sie testen können, viel leichter den code und machen es sehr viel besser lesbar.
    RXJava, können Sie die Dinge tun, die von LiveData und vieles mehr. Aufgrund der erweiterten Funktionalitäten von RXJava, können Sie beide verwenden LiveData für einfache Fälle oder nutzen Sie alle die Kraft des RXJava halten mit Android-Architektur Komponenten wie die ViewModel, das bedeutet natürlich, dass RXJava können weitaus komplexer, man denke nur hat Hunderte von Operatoren statt SwitchMap und Anzeigen von LiveData(im moment).

    RXJava version 2 ist eine Bibliothek, die revolutioniert das objektorientierte Paradigma, indem eine so genannte funktionale Art und Weise zu verwalten den Fluss des Programms.

    InformationsquelleAutor trocchietto
  5. 21

    Gibt es viele Unterschiede zwischen LiveData und RxJava:

    1. LiveData ist nicht ein STREAM während in RxJava alles (buchstäblich alles) ist ein STREAM.
    2. LiveData ist eine beobachtbare Daten, Halter-Klasse. Im Gegensatz zu einem normalen beobachten, LiveData ist lifecycle-bewusst, das heißt, es respektiert den Lebenszyklus von anderen app-Komponenten, wie Aktivitäten, Fragmente oder Dienstleistungen. Dieses Bewusstsein sorgt für LiveData nur updates app-Komponente-Beobachter, die in einer aktiven Lebenszyklus-Status.
    3. LiveData ist synchrone, So Sie können ' T execute ein Stück code (Netzwerk aufrufen, Datenbank-manipulation etc.) asynchron mit nur LiveData, wie Sie mit RxJava.
    4. Beste, was, die Sie tun können, zu nutzen, die die meisten von diesem duo ist die Verwendung RxJava für Ihre business-Logik (Netzwerk, call, data manipulation, etc., alles, was geschieht, in und außerhalb Repository) und verwenden LiveData für Ihre Präsentation. Von dieser erhalten Sie-transformation und stream-Funktionen für Ihre business-Logik und lifecycle-bewusst-Betrieb für die Benutzeroberfläche.
    5. LiveData und RxJava die sich gegenseitig ergänzen wenn Sie zusammen benutzt werden. Was ich meine ist, alles mit RxJava und am Ende, wenn Sie aktualisieren möchten, UI, etwas tun, wie den unten angegebenen code zu ändern, Ihre Beobachtbaren in LiveData. So, Ihre Ansicht (Benutzeroberfläche) beobachtet, um die LiveData im ViewModel, wo Ihre LiveData ist nichts anderes als nicht-änderbarer MutableLiveData (oder MutableLiveData ist veränderlich LiveData).
    6. Also die Frage hier ist, warum sollten Sie auch verwenden, LiveData an die erste Stelle?
      Wie Sie unten sehen können in den code, speichern Sie Ihre Antwort aus RxJava zu MutableLiveData (oder LiveData) und Ihre LiveData ist lifecycle-wissen, so in einer Art und Weise, Ihre Daten-lifecycle-bewusst. Nun, stellen Sie sich nur die Möglichkeit, wenn Sie Ihre Daten selbst wissen, Wann-und wenn-nicht-aktualisieren der Benutzeroberfläche verwendet werden.
    7. LiveData nicht haben eine Geschichte (nur den aktuellen Stand). Daher, sollten Sie nicht verwenden LiveData für ein chat-Programm.
    8. Wenn Sie LiveData mit RxJava Sie brauchen keine Sachen wie MediatorLiveData, SwitchMap etc. Sie sind stream-control-tools und RxJava ist besser durch viele Zeiten.
    9. Finden Sie unter LiveData als Daten-Halter-Ding und sonst nichts. Wir können auch sagen, LiveData ist lifecycle-bewusste Verbraucher.
        public class RegistrationViewModel extends ViewModel {

        private RegistrationRepo registrationRepo;
        private MutableLiveData<RegistrationResponse> modelMutableLiveData =
                new MutableLiveData<>();

        public RegistrationViewModel() {
        }

        public RegistrationViewModel(RegistrationRepo registrationRepo) {
            this.registrationRepo = registrationRepo;
        }

        public void init(RegistrationModel registrationModel) {
            disposable = registrationRepo.loginForUser(registrationModel)
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(new Consumer<Response<RegistrationResponse>>() {
                        @Override
                        public void accept(Response<RegistrationResponse>
                                                   registrationModelResponse) throws Exception {

                            modelMutableLiveData.setValue(registrationModelResponse.body());
                        }
                    });
        }

        public LiveData<RegistrationResponse> getModelLiveData() {
            return modelMutableLiveData;
        }
    }
    • Sehen LiveData als Daten-Halter-Ding und sonst nichts. ==> JA
    • Schönes Beispiel. Sie haben vergessen zu erklären, dass die Einweg-und es wäre schön, Sie zu entfernen, in onCleared.
    • Könnten Sie bitte erklären, wie livedata ist synchron? Soweit ich weiß, senden wir Livedata-Objekt zu einem anderen thread, und dann, der thread kann postvalue, die Beobachter hören können, in den MainThread.
    • Wenn du noch einmal Lesen was ich geschrieben habe, es heißt, Sie können nicht auf einen anderen thread ( JA, ich habe "nur" einmal dort ) mit LiveData wie können Sie tun, mit RxJava
    InformationsquelleAutor Abhishek Kumar
  6. 4

    LiveData ist eine Teilmenge der android-Architektur-Komponenten, die entwickelt wird, indem das android-team.

    Mit live-Daten und andere Architektur-Komponenten, Speicher-Lecks und andere ähnliche Probleme behandelt werden, die von Architektur-Komponenten. Da ist es entwickelt von android-team, es ist das beste für android. Sie bieten auch updates, die mit neuen Versionen von Android.

    Wenn Sie nur wollen, um den Einsatz in Android-app-Entwicklung gehen für die Android-Architektur-Komponenten. Andernfalls, wenn Sie verwenden möchten anderen Java-Anwendung, die wie web-app, desktop-apps, etc., verwenden RxJava

    • Ich habe versucht zu klären deine Antwort. Wenn ich in irgendeiner Weise in Konflikt mit Ihrer ursprünglichen Absicht, fühlen Sie sich frei zu Bearbeiten. Wenn Sie aber tun, bitte versuchen Sie machen es besser als die erste revision. Der Letzte Teil deiner Antwort ehrlich gesagt nicht sinnvoll.
    • ich glaube, meine aktualisierte Antworten ist klar
    InformationsquelleAutor SIVAKUMAR.J
  7. 0

    LiveData als Daten-Halter-Ding und sonst nichts. Wir können auch sagen, LiveData ist Lifecycle bewusst ist Verbraucher. LiveData wird dringend empfohlen, zu wissen, das Konzept des Lebenszyklus und der relativen Objekte LifeCycleOwner/LifeCycle, Sie bekommen Transformations-und stream-Funktionen für Ihre business-Logik und lifecycle-bewusst-Betrieb für die Benutzeroberfläche.

    Rx ist leistungsfähiges Werkzeug, das ermöglicht das lösen von problem in einem eleganten deklarativen Stil. Es behandelt das business-Seite Optionen oder Service-Api-Vorgänge

    InformationsquelleAutor Attif
Schreibe einen Kommentar