Wann benutzt du map vs flatMap in RxJava?

FlatMap verhält sich sehr viel wie Karte, der Unterschied ist, dass die Funktion, die es gilt gibt es eine erkennbare selbst, so ist es perfekt geeignet, um anzeigen über asynchrone Vorgänge.

Im praktischen Sinn, die Funktion Map wendet die macht gerade eine transformation im Laufe der verketteten Reaktion (nicht wieder eine Beobachtbare); während die Funktion FlatMap gilt gibt ein Observable<T>, deshalb FlatMap ist empfehlenswert, wenn Sie planen, einen asynchronen Aufruf innerhalb der Methode.

Zusammenfassung:

• Karte gibt ein Objekt vom Typ T
• FlatMap gibt es eine erkennbare.

Ein deutliches Beispiel können hier eingesehen werden: http://blog.couchbase.com/why-couchbase-chose-rxjava-new-java-sdk .

Couchbase Java 2.X-Client verwendet Rx zu stellen asynchrone Aufrufe in einer bequemen Art und Weise. Seit es nutzt die Rx, es hat die Methoden map und FlatMap, die Erklärung in Ihrer Dokumentation könnte hilfreich sein, zu verstehen, das Allgemeine Konzept.

Fehler zu behandeln, überschreiben onError auf Ihre susbcriber.

Subscriber<String> mySubscriber = new Subscriber<String>() {
    @Override
    public void onNext(String s) { System.out.println(s); }

    @Override
    public void onCompleted() { }

    @Override
    public void onError(Throwable e) { }
};

Könnte es helfen, dieses Dokument anzusehen: http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/

Eine gute Quelle über den Umgang mit Fehlern im RX finden Sie unter: https://gist.github.com/daschl/db9fcc9d2b932115b679

InformationsquelleAutor der Antwort 1vand1ng0

So denke ich über es ist, dass Sie flatMap wenn die Funktion, die Sie wollte in der map() gibt ein Observable. In dem Fall kann man immer noch versuchen, zu verwenden map() aber es wäre unpraktisch. Lassen Sie mich versuchen zu erklären, warum.

Wenn in einem solchen Fall, dass Sie beschlossen, stick mit map, erhalten Sie eine Observable<Observable<Something>>. Zum Beispiel in deinem Fall, wenn wir eine imaginäre RxGson Bibliothek, zurückgegeben ein Observable<String> aus toJson() - Methode (anstelle der Rücksendung eine String) würde es so Aussehen:

Observable.from(jsonFile).map(new Func1<File, Observable<String>>() {
    @Override public Observable<String>> call(File file) {
        return new RxGson().toJson(new FileReader(file), Object.class);
    }
}); //you get Observable<Observable<String>> here

In diesem Punkt wäre es ziemlich schwierig zu subscribe() so zu beobachten. Darin erhalten Sie eine Observable<String> zu, die Sie wieder brauchen, um subscribe() um den Wert. Das ist nicht praktisch oder schön anzusehen.

So ist es nützlich eine Idee ist, zu "glätten" das beobachten von observablen (Sie könnten beginnen zu sehen, wo der name _flat_Map kommt). RxJava bietet ein paar Möglichkeiten, Sie zu glätten observablen und aus Gründen der Einfachheit nehmen wir an Zusammenführen ist, was wir wollen. Merge im Grunde nimmt eine Reihe von observablen und strahlt immer, wenn einer von Ihnen strahlt. (Viele Leute würden argumentieren, Schalter wäre ein besserer Standard. Aber wenn Sie emittiert nur ein Wert, ist es eigentlich auch egal.)

Also die änderung unserer vorherigen Codeausschnitt wir würden erhalten:

Observable.from(jsonFile).map(new Func1<File, Observable<String>>() {
    @Override public Observable<String>> call(File file) {
        return new RxGson().toJson(new FileReader(file), Object.class);
    }
}).merge(); //you get Observable<String> here

Dies ist viel mehr nützlich, da die Anmeldung zu, dass (oder Zuordnung oder filtern, oder...) bekommst du nur die String Wert. (Auch, wohlgemerkt, solche Variante der merge() existiert nicht in RxJava, aber wenn Sie verstehen, die Idee der merge-dann hoffe ich, dass Sie auch verstehen, wie das funktionieren würde.)

Also im Grunde, weil solche merge() sollte wohl immer nur nützlich sein, wenn es gelingt, eine map() Rückkehr eine beobachtbare und damit Sie nicht haben, um diese Art immer und immer wieder flatMap() entstand als eine Kurzform. Es gilt die mapping-Funktion genauso wie eine normale map() würde, aber später anstelle der Aussendung der zurückgegebenen Werte es ebenfalls "verflacht" (oder fusioniert).

Dass die Allgemeinen Anwendungsfall. Es ist sehr nützlich, in eine Codebasis verwendet Rx auf dem gesamten Platz und Sie haben viele Methoden, die Rückkehr observablen, die Sie wollen, um die Kette mit anderen Methoden zurückgeben observablen.

Verwenden, falls es passiert, um nützlich zu sein als gut, weil map() können nur verwandeln ein Wert ausgegeben, dass onNext() in einem anderen Wert ausgegeben onNext(). Aber es kann nicht die Umwandlung in mehrere Werte, kein Wert oder ein Fehler. Und wie akarnokd schrieb in seiner Antwort (und wohlgemerkt, er ist viel schlauer als ich, wohl im Allgemeinen, aber zumindest wenn es um RxJava) sollten Sie nicht throw Ausnahmen von Ihrem map(). Also anstatt die Sie verwenden können flatMap() und

return Observable.just(value);

wenn alles gut geht, aber

return Observable.error(exception);

wenn etwas ausfällt.

Siehe seine Antwort für eine komplette snippet: https://stackoverflow.com/a/30330772/1402641

InformationsquelleAutor der Antwort Marcin Koziński

Ich wollte nur hinzufügen, dass mit flatMap Sie nicht wirklich brauchen, um verwenden Sie Ihre eigenen benutzerdefinierten Beobachtbaren innerhalb der Funktion und verlassen Sie sich auf standard-factory-Methoden/Operatoren:

Observable.from(jsonFile).flatMap(new Func1<File, Observable<String>>() {
    @Override public Observable<String> call(final File file) {
        try {
            String json = new Gson().toJson(new FileReader(file), Object.class);
            return Observable.just(json);
        } catch (FileNotFoundException ex) {
            return Observable.<String>error(ex);
        }
    }
});

In der Regel sollten Sie es vermeiden, werfen (Runtime-) exceptions von onXXX-Methoden und callbacks, wenn möglich, auch wenn wir so viele Sicherheitsmaßnahmen wie wir konnten in RxJava.

InformationsquelleAutor der Antwort akarnokd

Die Frage ist Wann nutzen Sie die Karte vs flatMap in RxJava?. Und ich denke, eine einfache demo-spezifischer ist.

Wenn Sie möchten, konvertieren Element emittiert, um einen anderen Typ , in deinem Fall die Umwandlung Datei, String, map und flatMap können beide arbeiten. Aber ich bevorzuge map-operator, denn es ist mehr klar.

Jedoch in einen Ort, flatMap kann zaubern arbeiten, aber map nicht. Ich zum Beispiel möchte ein Benutzer die info, aber ich habe zuerst seine id beim user-login. Offensichtlich brauche ich zwei Anfragen, und Sie sind in Ordnung.

Lassen Sie uns beginnen.

Observable<LoginResponse> login(String email, String password);

Observable<UserInfo> fetchUserInfo(String userId);

Hier sind zwei Methoden, eine für die Anmeldung zurückgegeben Response, und ein weiteres für die Benutzer-info Holen.

login(email, password)
        .flatMap(response ->
                fetchUserInfo(response.id))
        .subscribe(userInfo -> {
            //get user info and you update ui now
        });

Wie Sie sehen, in Funktion flatMap gilt, bei der ersten bekomme ich die Benutzer-id aus Response dann fetch Benutzer-info. Wenn zwei Anfragen fertig sind, können wir unsere Arbeit wie die Aktualisierung von UI oder speichern von Daten in die Datenbank ein.

Allerdings, wenn Sie verwenden map Sie können nicht schreiben, wie schön-code. In einem Wort, ist flatMap uns helfen kann, serialisieren Anfragen.

InformationsquelleAutor der Antwort CoXier