Quand faut-il utiliser RxJava Observable et quand un simple rappel sur Android?

Les choses observables sont déjà faites en rénovation, donc le code pourrait être ceci:

api.getUserPhoto(photoId)
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Action1<Photo>() {
         @Override
            public void call(Photo photo) {
                //save photo?
            }
     });

Dans le cas de getUserPhoto () les avantages pour RxJava ne sont pas grands. Mais prenons un autre exemple lorsque vous obtiendrez toutes les photos pour un utilisateur, mais seulement lorsque l'image est PNG, et que vous n'avez pas accès au JSON pour faire le filtrage côté serveur.

api.getUserPhotos(userId)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.flatMap(new Func1<List<Photo>, Observable<Photo>>() {
    @Override
    public Observable<Photo> call(List<Photo> photos) {
         return Observable.from(photos);
    }
})
.filter(new Func1<Photo, Boolean>() {
    @Override
    public Boolean call(Photo photo) {
         return photo.isPNG();
    }
})
.subscribe(
    new Action1<Photo>() {
    @Override
        public void call(Photo photo) {
            // on main thread; callback for each photo, add them to a list or something.
            list.add(photo)
        }
    }, 
    new Action1<Throwable>() {
    @Override
        public void call(Throwable throwable) {
            // on main thread; something went wrong
            System.out.println("Error! " + throwable);
        }
    }, 
    new Action0() {
        @Override
        public void call() {
            // on main thread; all photo's loaded, time to show the list or something.
        }
    });

Maintenant, le JSON renvoie une liste de photos. nous allons les flatMap aux éléments individuels. Ce faisant, nous serons en mesure d'utiliser la méthode de filtre pour ignorer les photos qui ne sont pas PNG. Après cela, nous allons vous abonner et obtenir un rappel pour chaque photo individuelle, un errorHandler et un rappel lorsque toutes les lignes ont été terminées.

TLDR Point ici étant; le rappel ne vous renvoie qu'un rappel pour le succès et l'échec; le RxJava Observable vous permet de faire la carte, réduire, filtrer et bien d'autres choses.

, Avec rxjava vous pouvez faire plus de choses avec moins de code.

Supposons que vous souhaitez implémenter la recherche instantanée dans votre application. Avec les rappels, vous avez peur de vous désabonner de la demande précédente et de vous abonner à la nouvelle, gérez vous-même le changement d'orientation... Je pense que c'est beaucoup de code et trop verbeux.

Avec rxjava est très simple.

public class PhotoModel{
  BehaviorSubject<Observable<Photo>> subject = BehaviorSubject.create(...);

  public void setUserId(String id){
   subject.onNext(Api.getUserPhoto(photoId));
  }

  public Observable<Photo> subscribeToPhoto(){
    return Observable.switchOnNext(subject);
  }
}

Si vous souhaitez implémenter une recherche instantanée, il vous suffit d'écouter TextChangeListener et d'appeler photoModel.setUserId(EditText.getText());

Dans onCreate méthode de Fragment ou d'activité vous vous abonnez à L'Observable qui renvoie photoModel.subscribeToPhoto (), il renvoie une Observable qui émet toujours les éléments émis par la dernière Observable (requête).

AndroidObservable.bindFragment(this, photoModel.subscribeToPhoto())
                 .subscribe(new Action1<Photo>(Photo photo){
      //Here you always receive the response of the latest query to the server.
                  });

En outre, si PhotoModel est un Singleton, par exemple, vous n'avez pas à vous soucier des changements d'orientation, car BehaviorSubject émet la dernière réponse du serveur, quel que soit le moment où vous vous abonnez.

Avec ces lignes de code, nous avons implémenté une recherche instantanée et gérer les changements d'orientation. Pensez-vous que vous pouvez implémenter cela avec des rappels avec moins de code? J'en doute.

On dirait que vous réinventez la roue, ce que vous faites est déjà implémenté dans retrofit.

Pour un exemple, vous pouvez regarder RestAdapterTest de retrofit.java, où ils définir une interface avec Observables comme type de retour, et alors utiliser.

Par les échantillons et les conclusions dans d'autres réponses, je pense qu'il n'y a pas de grande différence pour les tâches simples en une ou deux étapes. Cependant, le rappel est simple et direct. RxJava est plus compliqué et trop grand pour une tâche simple. Il y a la troisième solution par: AbacusUtil . Permettez-moi d'implémenter les cas d'utilisation ci-dessus avec les trois solutions: Callback, RxJava, CompletableFuture (AbacusUtil) avec Retrolambda :

Récupérer la photo du réseau et enregistrer / afficher sur dispositif:

// By Callback
api.getUserPhoto(userId, new Callback<Photo>() {
    @Override
    public void onResponse(Call<Photo> call, Response<Photo> response) {
        save(response.body()); // or update view on UI thread.
    }

    @Override
    public void onFailure(Call<Photo> call, Throwable t) {
        // show error message on UI or do something else.
    }
});

// By RxJava
api.getUserPhoto2(userId) //
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(photo -> {
            save(photo); // or update view on UI thread.
        }, error -> {
            // show error message on UI or do something else.
        });

// By Thread pool executor and CompletableFuture.
TPExecutor.execute(() -> api.getUserPhoto(userId))
        .thenRunOnUI((photo, error) -> {
            if (error != null) {
                // show error message on UI or do something else.
            } else {
                save(photo); // or update view on UI thread.
            }
        });

Charger les détails de l'utilisateur et la photo en parallèle

// By Callback
// ignored because it's little complicated

// By RxJava
Observable.zip(api.getUserDetails2(userId), api.getUserPhoto2(userId), (details, photo) -> Pair.of(details, photo))
        .subscribe(p -> {
            // Do your task.
        });

// By Thread pool executor and CompletableFuture.
TPExecutor.execute(() -> api.getUserDetails(userId))
          .runOnUIAfterBoth(TPExecutor.execute(() -> api.getUserPhoto(userId)), p -> {
    // Do your task
});

Nous allons généralement avec la logique suivante:

1. S'il s'agit d'un simple appel à réponse unique, alors Callback ou Future est meilleur.
2. s'il s'agit d'un appel avec plusieurs réponses (flux), ou lorsqu'il y a une interaction complexe entre différents appels (voir la réponse de @Niels), alors les Observables sont meilleurs.