如何避免Java中的回调地狱？

Question

我有一个带有api调用序列的java应用程序(我正在使用改造).目前它看起来像金字塔:

mApi.login(request, new Callback<LoginResponse>() {
  @Override
  public void success(LoginResponse s, Response response) {
     mApi.getRoutes(request, new Callback<RoutesResponse>() {
        @Override
        public void success(RoutesResponses, Response response) {
           ...
        }
        @Override
        public void failure(RetrofitError error) {}
     }
  }

   @Override
   public void failure(RetrofitError error) {}
});

是否有一些图书馆可以避免回调地狱？像在JavaScript中的TwoStep或Q.

Answer 1

使用lambda expressions将摆脱这种回调地狱.但是,由于Callback<T>接口由2个抽象方法组成,你不能直接使用lambdas.这就是RxJava的用武之地.RxJava引入了更多功能方式,使您能够使用功能接口,您可以使用lambda来减少回调地狱.

RxJava是ReactiveX(Reactive Extensions)的Java VM实现:一个通过使用可观察序列来编写异步和基于事件的程序的库...

这里有一些关于RxJava和lambda的资源.

• Grokking RxJava,第1部分:基础知识
• Monads:您的应用程序作为一个功能

Answer 2

只要您仅对 API 调用进行排序，您就可以通过使用 Observables 而不是回调并将它们与 Rx 流支持绑定在一起来使用 Retrofit 的 RxJava 支持。我主要使用 .flatmap() 函数将一个 API 调用的结果转换为另一个 API 调用的结果。在你的情况下，它会喜欢这样的东西：

首先，我将使用可观察版本的调用，而不是带有回调的版本，这将是：

Observable<LoginResponse> login(loginRequest);
Observable<RoutesResponse> getRoutes(routesRequest);

在我们的 API 中拥有这两个函数之后，我们可以将它们与 RxJava 流绑定在一起。这是一个没有错误检查的例子，我正在路上写这个作为一个简单的例子：

public Observable<RoutesResponse> rxGetRoutes(loginRequest, routesRequest) {
  final YourAPI mAPI = YourApiProvider.getInstance();

  return mAPI.login(loginRequest)
    //using flatmap to convert one answer to another answer
    .flatmap( (Func1) LoginResponse -> {
      return mAPI.getRoutes(routesRequest); 
    });
}

在学习了一些 RxJava 之后，您现在可以正常观察并订阅该函数返回的 Observable：

rxGetRoutes(loginReq, routesReq)
   .observeOn(//the thread you want to observe on)
   .subscribe( new Subscriber<RoutesResult>() {
          @Override
          //the functions of Subscriber you need to override
          //where you can also check for errors
          //Check RxJava documentation after your IDE completes this area.
                 });