经过委派模式包装一个RxJavaCallAdapterFactory

经过委派模式包装一个RxJavaCallAdapterFactory

标签（空格分隔）： RxJava Retrofit CallAdapter

---

实现是厌倦了写不少重复的代码了。

最近项目使用RxJava（RxAndroid）和Retrofit搭配作网络请求。有一段代码常常重复，

service.XXX()
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(
        httpResp -> {
            ... 这里是一些处理结果前的常规操做
            
            ... 这里处理结果
            
            ... 这里是一些处理结果后的常规操做
        },
        throwable -> {
            ... 这里是一些处理错误前的常规操做
            
            ... 这里处理错误
            
            ... 这里是一些处理错误后的常规操做
        }
    );

其实上面的代码中，重要的就只有server.XXX()和“处理结果”、“处理错误”两个三行。其余的都是一些常规性的代码，在其余地方也重复的写着。由于以前没有想到很好的组织方式，就一直放着没有整理。可是，写得多的时候就烦了，因而就写了下面一个类。

public class MyRxJavaCallAdapterFactory implements CallAdapter.Factory {
  private RxJavaCallAdapterFactory mFactory;
  private MyRxJavaCallAdapterFactory() {
    mFactory = RxJavaCallAdapterFactory.create();
  }

  public static MyRxJavaCallAdapterFactory create() {
    return new MyRxJavaCallAdapterFactory();
  }


  @Override
  public CallAdapter<?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    CallAdapter<?> a = mFactory.get(returnType, annotations, retrofit);
    if (a == null) {
      return null;
    } else {
      CallAdapter<Observable<?>> adapter = (CallAdapter<Observable<?>>) a;
      return new MyCallAdapter(adapter);
    }
  }

    private class MyCallAdapter implements CallAdapter<Observable<?>> {

        private CallAdapter<Observable<?>> mAdapter;

        MyCallAdapter(CallAdapter<Observable<?>> adapter) {
            this.mAdapter = adapter;
        }

        @Override
        public Type responseType() {
            return mAdapter.responseType();
        }

        @Override
        public <R> Observable<?> adapt(Call<R> call) {
            Observable<?> observable = mAdapter.adapt(call);

            return observable
                    .compose(o -> {
                        // 有点尴尬，不少状况下，网络请求是在onCreate的时候就建立了。
                        // 而load事件的监听倒是在onResume。
                        EventBus.getInstance().send(new LoadingStartEvent());
                        return o;
                    })
                    .lift(subscriber -> {
                        Subscriber temp = new Subscriber() {
                            @Override
                            public void onCompleted() {
                                subscriber.onCompleted();
                            }

                            @Override
                            public void onError(Throwable e) {
                                subscriber.onError(e);
                                EventBus.getInstance().send(new LoadingStopEvent());
                            }

                            @Override
                            public void onNext(Object o) {
                                subscriber.onNext(o);
                                EventBus.getInstance().send(new LoadingStopEvent());
                            }
                        };
                        return temp;
                    })
                    // 下面两句先不要开放，由于有些地方须要同步请求。
//                    .subscribeOn(Schedulers.io())
//                    .observeOn(AndroidSchedulers.mainThread())
                    ;
        }
    }


}

好困，不想排版了。睡觉去。