在Android上什么时候应该使用RxJava Observable和什么时候简单回调？

Question

@GET("/user/{id}/photo")
void getUserPhoto(@Path("id") int id, Callback<Photo> cb);

@GET("/user/{id}/photo")
Observable<Photo> getUserPhoto(@Path("id") int id);

而使用简单的回调实现则类似于如下所示：

api.getUserPhoto(photoId, new Callback<Photo>() {
    @Override
    public void onSuccess() {
    }
});

这是非常简单和直接的。使用observable，它很快就变得冗长和复杂。

public Observable<Photo> getUserPhoto(final int photoId) {
    return Observable.create(new Observable.OnSubscribeFunc<Photo>() {
        @Override
        public Subscription onSubscribe(Observer<? super Photo> observer) {
            try {
                observer.onNext(api.getUserPhoto(photoId));
                observer.onCompleted();
            } catch (Exception e) {
                observer.onError(e);
            }

            return Subscriptions.empty();
        }
    }).subscribeOn(Schedulers.threadPoolForIO());
}

但事实并非如此。你还是要做这样的事情：

Observable.from(photoIdArray)
        .mapMany(new Func1<String, Observable<Photo>>() {
            @Override
            public Observable<Photo> call(Integer s) {
                return getUserPhoto(s);
            }
        })
        .subscribeOn(Schedulers.threadPoolForIO())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Action1<Photo>() {
            @Override
            public void call(Photo photo) {
                //save photo?
            }
        });

我是不是漏了什么？还是使用observables是一个错误的情况？什么时候/应该更喜欢observable而不是简单回调？

正如@Niels在他的答案中或在Jake Wharton的示例项目U2020中所示，使用改型比上面的示例简单得多。但本质上，问题是一样的--什么时候该用这样或那样的方法？

Answer 1

对于简单的网络材料，RxJava相对于回调的优势非常有限。简单的getUserPhoto示例：

RXJava：

api.getUserPhoto(photoId)
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Action1<Photo>() {
            @Override
            public void call(Photo photo) {
               // do some stuff with your photo 
            }
     });

回调：

api.getUserPhoto(photoId, new Callback<Photo>() {
    @Override
    public void onSuccess(Photo photo, Response response) {
    }
});

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) {
            list.add(photo)
        }
    });

api.getUserPhotos(userId, new Callback<List<Photo>>() {
    @Override
    public void onSuccess(List<Photo> photos, Response response) {
        List<Photo> filteredPhotos = new ArrayList<Photo>();
        for(Photo photo: photos) {
            if(photo.isPNG()) {
                filteredList.add(photo);
            }
        }
    }
});

第一个结论

当您加载一个简单的JSON时，它不会使您的代码库变小，因为您准备了正确的格式。

现在，让我们把事情变得更有趣一些。假设您不仅想要检索userPhoto，而且有一个Instagram-克隆，并且想要检索2个JSONs:1。getUserDetails()2。getUserPhotos（）

您希望并行加载这两个JSON，当这两个JSONs都加载时，应该会显示页面。回调变体会变得更难一点：你要创建2个回调，将数据存储在活动中，如果加载了所有数据，就显示页面：

回调：

api.getUserDetails(userId, new Callback<UserDetails>() {
    @Override
    public void onSuccess(UserDetails details, Response response) {
        this.details = details;
        if(this.photos != null) {
            displayPage();
        }
    }
});

api.getUserPhotos(userId, new Callback<List<Photo>>() {
    @Override
    public void onSuccess(List<Photo> photos, Response response) {
        this.photos = photos;
        if(this.details != null) {
            displayPage();
        }
    }
});

RXJava：

private class Combined {
    UserDetails details;
    List<Photo> photos;
}


Observable.zip(api.getUserDetails(userId), api.getUserPhotos(userId), new Func2<UserDetails, List<Photo>, Combined>() {
            @Override
            public Combined call(UserDetails details, List<Photo> photos) {
                Combined r = new Combined();
                r.details = details;
                r.photos = photos;
                return r;
            }
        }).subscribe(new Action1<Combined>() {
            @Override
            public void call(Combined combined) {
            }
        });

我们有进展了！RxJava的代码现在和回调选项一样大。RxJava代码更健壮；想想如果我们需要加载第三个JSON（比如最新的视频）会发生什么？RxJava只需要一个微小的调整，而回调变量需要在多个地方进行调整（在每次回调时，我们需要检查是否检索到了所有数据）。

inputObservable.debounce(1, TimeUnit.SECONDS).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                // use Retrofit to create autocompletedata
            }
        });

我不会创建回调变量，但您会明白这是更多的工作。

结论：当数据以流形式发送时，RxJava表现得特别好。可观察的改型同时将所有元素推到流上。与回调相比，这本身并不是特别有用。但是，当流上有多个元素和不同的时间被推送，并且您需要做与时间相关的事情时，RxJava使代码的可维护性大大提高。