Когда следует использовать RxJava Observable и когда простой обратный вызов на Android?

наблюдаемый материал уже сделан в модификации, поэтому код может быть таким:

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

в случае getUserPhoto() преимущества для RxJava не велики. Но давайте возьмем другой пример, когда вы получите все фотографии для пользователя, но только когда изображение PNG, и у вас нет доступа к JSON, чтобы сделать фильтрацию на стороне сервера.

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.
        }
    });

теперь в JSON возвращает список фотографий. Мы с помощью flatMap их отдельных элементов. Таким образом, мы сможем использовать метод фильтра, чтобы игнорировать фотографии, которые не являются PNG. После этого мы подпишемся и получим обратный вызов для каждой отдельной фотографии, errorHandler и обратного вызова, когда все строки были завершены.

TLDR Точка здесь; обратный вызов только возвращает вам обратный вызов для успеха и неудачи; RxJava Observable позволяет вам делать карту, уменьшать, фильтровать и многое другое.

С rxjava вы можете делать больше вещей с меньшим кодом.

предположим, что вы хотите реализовать мгновенный поиск в своем приложении. С обратными вызовами вы беспокоились об отмене подписки на предыдущий запрос и подписаться на новый, обрабатывать изменение ориентации самостоятельно... Я думаю, что это много кода и слишком многословно.

С rxjava очень просто.

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);
  }
}

Если вы хотите реализовать мгновенный поиск, вам нужно только прослушать TextChangeListener и позвонить к photoModel.setUserId(EditText.getText());

в методе onCreate фрагмента или активности вы подписываетесь на Observable, который возвращает фотомодель.subscribeToPhoto (), он возвращает наблюдаемый, который всегда испускает элементы, испускаемые последним наблюдаемым(запросом).

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

кроме того, если PhotoModel является Одноэлементным, например, вам не нужно беспокоиться об изменениях ориентации, потому что BehaviorSubject выдает последний ответ сервера, независимо от того, когда вы подписываетесь.

С этой линии код мы реализовали мгновенный поиск и обрабатываем изменения ориентации. Как вы думаете, что вы можете реализовать это с обратными вызовами с меньшим количеством кода? Я сомневаюсь в этом.

похоже, вы изобретаете колесо, то, что вы делаете, уже реализовано в модернизации.

, вы могли бы взглянуть на ретрофит это RestAdapterTest.java, где они определить интерфейс С Observable как возвращаемый тип, а затем использовать.

по образцам и выводам в других ответах, я думаю, что нет большой разницы для простых одно-или двухэтапных задач. Однако обратный вызов прост и понятен. RxJava является более сложным и слишком большим для простой задачи. Существует третье решение: AbacusUtil. Позвольте мне реализовать выше примеры использования со всеми тремя решениями: Callback, RxJava, CompletableFuture (AbacusUtil) с Retrolambda:

Fetch фото из сети и сохранение / отображение на устройстве:

// 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.
            }
        });

загрузите данные пользователя и фотографию параллельно

// 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
});

мы обычно идем со следующей логикой:

1. Если это простой вызов с одним ответом, то обратный вызов или будущее лучше.
2. если это вызов с несколькими ответами (поток), или когда есть сложное взаимодействие между различными вызовами (см. @Niels'ответ), то наблюдаемые лучше.