it-swarm.com.de

Wann wird RxJava in Android und wann LiveData von Android Architectural Components verwendet?

Ich bekomme nicht den Grund, RxJava in Android und LiveData von Android Architectural Components zu verwenden. Es wäre wirklich hilfreich, wenn die Verwendungsmöglichkeiten und Unterschiede zwischen den beiden zusammen mit Beispielbeispielen in Form von Code erläutert werden, der die Unterschiede zwischen den beiden erklärt.

98
rahul66

Android LiveData ist eine Variante des ursprünglichen Beobachtermusters, wobei aktive/inaktive Übergänge hinzugefügt werden. Als solches ist es in seinem Umfang sehr restriktiv.

Mit dem in Android LiveData beschriebenen Beispiel wird eine Klasse zum Überwachen von Standortdaten und zum Registrieren und Aufheben der Registrierung basierend auf dem Anwendungsstatus erstellt.

RxJava bietet Operatoren, die viel allgemeiner sind. Nehmen wir an, dass dieses Observable Standortdaten liefert:

Observable<LocationData> locationObservable;

Die Implementierung des Observable kann mithilfe von Observable.create() aufgebaut werden, um die Rückrufoperationen abzubilden. Wenn das Observable abonniert ist, wird der Rückruf registriert, und wenn es abbestellt wird, wird der Rückruf nicht registriert. Die Implementierung sieht dem im Beispiel bereitgestellten Code sehr ähnlich.

Nehmen wir auch an, dass Sie über ein Observable verfügen, das wahr ist, wenn die Anwendung aktiv ist:

Observable<Boolean> isActive;

Dann können Sie alle Funktionen von LiveData folgendermaßen bereitstellen

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

Der switchMap()-Operator stellt entweder den aktuellen Standort als Stream bereit oder nichts, wenn die Anwendung nicht aktiv ist. Sobald Sie die Variable liveLocation haben, können Sie mit den RxJava-Operatoren eine Menge tun. Mein Lieblingsbeispiel ist:

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

Dadurch wird die Aktion nur ausgeführt, wenn sich der Standort geändert hat und der Standort interessant ist. Sie können ähnliche Vorgänge erstellen, die Zeitoperatoren kombinieren, um die Geschwindigkeit zu bestimmen. Noch wichtiger ist, Sie können mit RxJava-Operatoren detailliert steuern, ob Vorgänge im Haupt- oder Hintergrundthread oder mehrere Threads ausgeführt werden.

Der Sinn von RxJava besteht darin, dass Steuerelement und Timing in einem einzigen Universum kombiniert werden, indem aus der Bibliothek bereitgestellte Operationen oder sogar benutzerdefinierte Operationen verwendet werden, die Sie bereitstellen.

LiveData adressiert nur einen kleinen Teil dieses Universums, das Äquivalent zum Erstellen der liveLocation.

79
Bob Dalgleish

In der ursprünglichen Frage ergänzen sich sowohl RxJava als auch LiveData sehr gut.

LiveData glänzt auf der ViewModel-Ebene mit ihrer engen Integration mit Android-Lebenszyklen und ViewModel. RxJava bietet mehr Funktionen für Transformationen (wie von @Bob Dalgleish erwähnt). 

Derzeit verwenden wir RxJava in Datenquellen- und Repository-Layern, und es wird in ViewModels in LiveData (mit LiveDataReactiveStreams) umgewandelt (bevor Daten für Aktivitäten/Fragmente verfügbar gemacht werden) - mit diesem Ansatz sehr zufrieden.

66
kzotin

Wie Sie vielleicht im reaktiven Ökosystem wissen, haben wir ein Observable , das Daten aussendet, und ein Observer dass diese Observable Emission abonniert (benachrichtigt wird), ist nichts Seltsames, wie das sogenannte Observer Pattern funktioniert. Ein Observable "schreit" etwas, der Observer wird benachrichtigt, dass Observable in einem bestimmten Moment etwas schreit.

Stellen Sie sich LiveData als Observable vor, mit dem Sie die Observer verwalten können, die sich im Zustand active befinden. Mit anderen Worten ist LiveData eine einfache Observable , die sich aber auch um den Lebenszyklus kümmert.

Aber sehen wir uns die beiden von Ihnen angeforderten Codefälle an:

A) Live-Daten

B) RXJava

A) Dies ist eine grundlegende Implementierung von LiveData

1) Normalerweise instanziieren Sie LiveData im ViewModel, um die Änderung der Ausrichtung beizubehalten (Sie können LiveData schreibgeschützt oder MutableLiveData schreibgeschützt haben, sodass Sie normalerweise außerhalb der Klasse LiveData verfügbar machen).

2) In der OnCreate -Methode der Hauptaktivität (nicht des ViewModel) "abonnieren" Sie ein Observer-Objekt (normalerweise ein onChanged-Objekt) Methode)

3) Sie starten die Methode beobachten, um die Verbindung herzustellen

Zuerst das ViewModel (besitzt die Geschäftslogik)

class ViewModel : ViewModel() { //Point 1

    var liveData: MutableLiveData<Int> = MutableLiveData()

}

Und das ist der 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) Sie erklären eine Observable

2) Sie erklären einen Beobachter

3) Sie abonnieren das Observable beim Observer

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 wird LiveData mit Lifecycle und häufig mit ViewModel (wie wir gesehen haben) Architekturkomponenten verwendet. Wenn LiveData mit einem ViewModel kombiniert wird, können Sie jede Änderung im Observer in Echtzeit aktualisieren , damit die Ereignisse angezeigt werden werden in Echtzeit verwaltet, wo es nötig ist. Für die Verwendung von LiveData wird dringend empfohlen, das Konzept von Lebenszyklus und die relativen Objekte LifeCycleOwner/LifeCycle zu kennen. Transformationen , wenn Sie LiveData in realen Szenarien implementieren möchten. Hier finden Sie einige Anwendungsfälle aus der großen Commonsware .

Zum AbschlussLiveData ist im Grunde genommen eine vereinfachte RXJava, eine elegante Art und Weise Sie können Änderungen über mehrere Komponenten hinweg beobachten, ohne explizite sogenannte Abhängigkeitsregeln zwischen den Komponenten zu erstellen, damit Sie den Code viel einfacher testen und besser lesbar machen können. Mit RXJava können Sie die Dinge von LiveData erledigen und vieles mehr. Aufgrund der erweiterten Funktionen von RXJava können Sie sowohl LiveData für einfache Fälle verwenden als auch die gesamte Leistungsfähigkeit von RXJava nutzen, indem Sie Android Architekturkomponenten als ViewModel verwenden Dies bedeutet, dass RXJava sehr viel komplexer sein kann. Denken Sie nur an Hunderte von Operatoren anstelle von SwitchMap und Map of LiveData (derzeit).

RXJava Version 2 ist eine Bibliothek, die das objektorientierte Paradigma revolutionierte und eine sogenannte funktionale Methode zur Verwaltung des Programmflusses hinzufügte.

23
trocchietto

Tatsächlich ist LiveData kein grundlegend anderes Werkzeug als RxJava. Warum wurde es als Architekturkomponente eingeführt, wenn RxJava den Lebenszyklus leicht verwalten konnte, indem alle Subskriptionen von Observables in einem CompositeDispoable-Objekt gespeichert und dann in onDestroy() der Activity abgelegt werden oder onDestroyView() der Fragment mit nur einer Codezeile?

Ich habe diese Frage vollständig beantwortet, indem ich einmal eine Filmsuch-App mit RxJava und dann LiveData here erstellt habe.

Kurz gesagt, ja, das könnte es, aber dazu müssten zunächst die relevanten Lebenszyklusmethoden außer Kraft gesetzt werden, und zwar nicht nur über das grundlegende Lebenszykluswissen. Dies mag für einige immer noch nicht sinnvoll sein, aber Tatsache ist, dass laut einer der Jetpack-Sitzungen in Google I/O 2018 viele Entwickler das Lifecycle-Management komplex finden. Die Absturzfehler, die sich aus der Nichtbehandlung der Lebenszyklusabhängigkeit ergeben, könnten ein weiteres Zeichen dafür sein, dass einige Entwickler, selbst wenn sie sich mit dem Lebenszyklus auskennen, vergessen, dies in jeder Aktivität/jedem Fragment zu berücksichtigen, die sie in ihrer App verwenden. In großen Apps kann dies trotz der negativen Auswirkungen auf die Produktivität zum Problem werden.

Unter dem Strich wird durch die Einführung von LiveData erwartet, dass eine größere Anzahl von Entwicklern MVVM übernimmt, ohne das Lifecycle-Management, Speicherleck und Absturz verstehen zu müssen. Auch wenn ich keinen Zweifel habe, dass LiveData nicht mit RxJava vergleichbar ist, was die Fähigkeiten und die Möglichkeiten an Entwickler betrifft, reaktive Programmierung und RxJava sind für viele ein schwer verständliches Konzept und Werkzeug. Auf der anderen Seite denke ich nicht, dass LiveData ein Ersatz für RxJava sein soll - es kann einfach nicht -, sondern ein sehr einfaches Werkzeug, um ein kontrovers diskutiertes, weit verbreitetes Problem zu lösen, das von vielen Entwicklern vorgefunden wird.

** UPDATE ** Ich habe einen neuen Artikel here hinzugefügt, in dem ich erklärt habe, wie der Missbrauch von LiveData zu unerwarteten Ergebnissen führen kann. RxJava kann in solchen Situationen zur Rettung kommen


21
Ali Nem

Es gibt viele Unterschiede zwischen LiveData und RxJava

  1. LiveData ist keinSTREAM, während in Rxjava alles (wörtlich alles) einSTREAMist. 
  2. LiveData ist synchronous . Sie können also keinen Codeabschnitt (nework-Aufruf, Datenbankmanipulation n ol) asynchron ausführen, indem Sie LiveData wie bei Rxjava verwenden.
  3. Um das Beste aus diesem Duo am besten zu nutzen, können Sie Rxjava für Ihre Geschäftslogik (Netzwerkanruf, Datenmanipulation usw., alles, was innerhalb und außerhalb von Repository geschieht) und LiveData für Ihre Präsentationsschicht verwenden. Auf diese Weise erhalten Sie Transformations- und Streaming-Funktionen für Ihre Geschäftslogik und den Lebenszyklus für Ihre Benutzeroberfläche.
  4. LiveData und Rxjava ergänzen sich wenn sie zusammen verwendet werden. Was ich damit meine, ist, alles mit RxJava zu erledigen und am Ende, wenn Sie die Benutzeroberfläche aktualisieren möchten, etwas wie den unten angegebenen Code tun, um Ihr Observable in Livedata zu ändern. Ihre Ansicht (UI) berücksichtigt also die Livedata in ViewModel, wobei Ihre LiveData nichts anderes ist als nicht veränderliche MutableLiveData (oder MutableLiveData ist veränderliche LiveData).
  5. Die Frage ist also, warum sollten Sie überhaupt LiveData verwenden? Wie Sie unten im Code sehen können, speichern Sie Ihre Antwort von Rxjava in MutableLiveData (oder LiveData) und Ihre LiveData ist Lifecycle-fähig, so dass Ihre Daten in gewisser Weise den Lebenszyklus-Sensibilisierungsprozess unterstützen. Stellen Sie sich jetzt die Möglichkeit vor, wenn Ihre Daten selbst wissen, wann und wann die Benutzeroberfläche nicht aktualisiert wird.

  6. LiveData hat keine Historie (nur den aktuellen Status). Daher sollten Sie LiveData nicht für eine Chat-Anwendung verwenden.

  7. Wenn Sie LiveData mit RxJava verwenden, benötigen Sie keine Dinge wie MediatorLiveData , SwitchMap usw. Sie sind Stream-Steuerungs-Tools und RxJava ist um ein Vielfaches besser.
  8. Sehen Sie LiveData als Dateninhabersache und sonst nichts. Wir können auch sagen, dass LiveData ein Lifecycle-fähiger Verbraucher ist.

     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;
             }
    }
    
5
Abhishek Kumar

LiveData ist eine Teilmenge der Android-Architekturkomponenten, die vom Android-Team entwickelt wurde. Mit den Live-Daten und anderen Architekturkomponenten (Am besten für Android geeignet. Gedächtnislecks usw. werden von Architekturkomponenten gehandhabt. Da es von Android-Team entwickelt wird. Also, es passt am besten zu Android. Sie bieten Updates mit neuen Versionen von Android usw.). Wir können das tun, was wir mit RxJava erreichen können.
Wenn Sie nur unter Android verwenden möchten, gehen Sie zu den Komponenten der Android-Architektur. Wenn Sie das Ur-Modul für Android und andere verwenden möchten (Java-App usw.), gehen Sie zu RxJava (native reagieren).

3
SIVAKUMAR.J

LiveData als Dateninhabersache und sonst nichts. Wir können auch sagen, dass LiveData ein lebenszyklusbewusster Verbraucher ist. LiveData wird dringend empfohlen, um das Konzept des Lebenszyklus und die relativen Objekte LifeCycleOwner/LifeCycle zu kennen. Sie erhalten Transformations- und Stream-Funktionen für Ihre Geschäftslogik und einen für den Lebenszyklus relevanten Vorgang für Ihre Benutzeroberfläche.

Rx ist ein leistungsfähiges Werkzeug, das es ermöglicht, Probleme in einem eleganten deklarativen Stil zu lösen. Es behandelt geschäftliche Optionen oder Service Api-Vorgänge

0
Attif