Lorsque vous utilisez la carte vs flatMap dans RxJava?

FlatMap se comporte comme une carte, la différence est que la fonction à laquelle elle s'applique renvoie une observable lui-même, il est donc parfaitement adapté à la carte sur les opérations asynchrones.

Dans le sens pratique, la fonction Map applique tout simplement une transformation en chaîne de réponse (pas de renvoi d'un Observable); tandis que la fonction FlatMap s'applique retourne un Observable<T>, c'est pourquoi FlatMap est recommandé si vous envisagez de faire un appel asynchrone à l'intérieur de la méthode.

Résumé:

• Carte retourne un objet de type T
• FlatMap renvoie une Observable.

Un exemple peut être vu ici: http://blog.couchbase.com/why-couchbase-chose-rxjava-new-java-sdk .

Couchbase Java 2.X Client utilise Rx à fournir des appels asynchrones de façon pratique. Depuis qu'il utilise Rx, il a les méthodes carte et FlatMap, l'explication dans leur documentation pourrait être utile pour comprendre le concept général.

Pour gérer les erreurs, remplacer onError sur votre 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) { }
};

Il peut être utile de regarder ce document: http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/

Une bonne source sur la façon de gérer les erreurs avec la RX peut être trouvé à: https://gist.github.com/daschl/db9fcc9d2b932115b679

La façon dont je pense à ce sujet est que vous utilisez flatMap lorsque la fonction que vous vouliez mettre à l'intérieur de map() retourne un Observable. Dans ce cas, vous pourriez toujours essayer de l'utiliser map() mais il serait judicieux. Laissez-moi vous expliquer pourquoi.

Si dans de tels cas, vous avez décidé de rester avec map, vous obtiendrez une Observable<Observable<Something>>. Par exemple, dans votre cas, si nous avons utilisé un imaginaire RxGson de la bibliothèque, qui a retourné une Observable<String> de toJson() méthode (au lieu de simplement retourner un String), il devrait ressembler à ceci:

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

À ce stade, il serait assez difficile de subscribe() à une telle observable. A l'intérieur, vous obtiendrez une Observable<String> à qui vous auriez encore besoin de subscribe() pour obtenir de la valeur. Ce qui n'est pas pratique et agréable à regarder.

Afin de la rendre utile une idée est "d'aplatir" ce observables des observables (vous pourriez commencer à voir où le nom _flat_Map vient). RxJava fournit un peu de moyens pour aplatir observables et par souci de simplicité, supposons fusion est ce que nous voulons. Fusion prend essentiellement en un tas de phénomènes observables et émet à chaque fois que l'un d'eux émet. (Beaucoup de gens diraient commutateur serait une meilleure défaut. Mais si vous êtes émet juste une seule valeur, il n'a pas d'importance de toute façon.)

Donc à la modification de notre fragment de code précédent, nous aurions:

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

C'est beaucoup plus utile, parce que souscrire à cette (ou de cartographie, de filtrage ou de...), vous obtenez juste le String valeur. (Aussi, vous l'esprit, une telle variante de merge() n'existe pas dans RxJava, mais si vous comprenez l'idée de fusionner alors j'espère que vous comprenez comment cela pourrait fonctionner.)

Donc, fondamentalement, parce que de telles merge() devrait probablement toujours être utile lorsqu'il réussit un map() retour d'un observable et donc vous n'avez pas à taper encore et encore, flatMap() a été créé comme une abréviation. Il applique la fonction de mappage juste normal map() serait, mais plus tard, au lieu d'émettre les valeurs renvoyées il a également "aplatit" (ou de fusion) entre eux.

C'est le grand cas d'utilisation. Il est le plus utile dans une base de code qui utilise Rx allover l'endroit et vous avez de nombreuses méthodes de retour observables, qui vous voulez à la chaîne avec d'autres méthodes retournant observables.

Dans votre cas d'utilisation, il arrive à être utile, parce que map() ne peut transformer une valeur émise dans onNext() en une autre valeur émise dans onNext(). Mais il ne peut pas la transformer en de multiples valeurs, aucune valeur ou une erreur. Et comme akarnokd a écrit dans sa réponse (et vous l'esprit qu'il est beaucoup plus intelligent que moi, sans doute en général, mais au moins quand il s'agit de RxJava) vous ne devriez pas lancer des exceptions à partir de votre map(). Donc, au lieu de cela, vous pouvez utiliser flatMap() et

return Observable.just(value);

quand tout va bien, mais

return Observable.error(exception);

quand quelque chose tombe en panne.

Voir sa réponse complète pour un extrait: https://stackoverflow.com/a/30330772/1402641

La question est de le faire Lorsque vous utilisez la carte vs flatMap dans RxJava?. Et je pense qu'une simple démo est plus spécifique.

Où vous voulez convertir un élément émis à un autre type , dans votre cas, la conversion du fichier à Chaîne, d'une carte et flatMap peut à la fois travailler. Mais je préfère la carte de l'opérateur, car il est plus clairement.

Toutefois, dans certains endroit, flatMap peut faire de la magie de travail mais map ne le peuvent pas. Par exemple, je souhaite obtenir des informations pour un utilisateur, mais je dois d'abord obtenir sa carte d'identité lors de la connexion de l'utilisateur dans. Évidemment, j'ai besoin de deux demandes et ils sont dans l'ordre.

Nous allons commencer.

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

Observable<UserInfo> fetchUserInfo(String userId);

Voici deux méthodes, l'une pour la connexion retourné Response, et un autre pour récupérer les infos de l'utilisateur.

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

Comme vous le voyez, en fonction flatMap s'applique, j'ai d'abord obtenir l'id d'utilisateur à partir Response de récupérer les infos de l'utilisateur. Lorsque deux demandes sont finis, nous pouvons faire notre travail comme la mise à jour de l'INTERFACE utilisateur ou des données de sauvegarde dans la base de données.

Toutefois, si vous utilisez map vous ne pouvez pas écrire de telles nice code. En un mot, flatMap peut nous aider à sérialiser les demandes.

Dans ce scénario, l'utilisation de la carte, vous n'avez pas besoin d'un nouveau Observables pour elle.

vous devriez utiliser les Exceptions.propager, ce qui est un wrapper de sorte que vous pouvez envoyer ces checked exceptions à la rx mécanisme

Observable<String> obs = Observable.from(jsonFile).map(new Func1<File, String>() { 
@Override public String call(File file) {
    try { 
        return new Gson().toJson(new FileReader(file), Object.class);
    } catch (FileNotFoundException e) {
        throw Exceptions.propagate(t); /will propagate it as error
    } 
} 
});

Vous devrez alors gérer cette erreur dans l'abonné

obs.subscribe(new Subscriber<String>() {
    @Override 
    public void onNext(String s) { //valid result }

    @Override 
    public void onCompleted() { } 

    @Override 
    public void onError(Throwable e) { //e might be the FileNotFoundException you got }
};); 

Il y a un super post pour elle: http://blog.danlew.net/2015/12/08/error-handling-in-rxjava/