1.依賴庫引入

implementation 'io.reactivex.rxjava2:rxjava:2.1.7'
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'
implementation 'com.squareup.retrofit2:retrofit:2.3.0'
implementation 'com.squareup.retrofit2:converter-gson:2.3.0'
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'
implementation
 
 'com.squareup.okhttp3:logging-interceptor:3.9.1'

2.基類設計

/**
 * 建立一箇中間類用於建立M層和V層之間的連線，其實就是統一一個呼叫的入口，方便維護擴充套件
 */
public class Present<T extends BaseResult>{
    protected BaseObserver mObserver;
    public Present(BaseObserver observer) {
        mObserver = observer;
        //可根據mObserver的擴充套件屬性進行相應的初始化管理
 

    }

    public void execute(Observable<T> observable) {
        if (mObserver.isLoading()) return;
        observable
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                //RxJava中map操作符也可以實現BaseObserver中對於介面規範中基礎資料的處理，自行選擇
 

                /**.map(new Function<BaseResult<T>, T>() {
                            @Override
                            public T apply(BaseResult<T> base){
                                return base.getResult();
                            }
                        })**/
                .subscribe(mObserver);
    }

    public static void execute(Observable observable, BaseObserver observer) {
        observable
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(observer);
    }
}

/**
 * 基礎的觀察者，類似傳統BaseCallBack，處理介面規範的基層響應，該類應保持最基本的功能
 * 繼承該類可擴充套件為與View層互動重新整理頁面，上傳，列表重新整理之類的Observer(ViewObserver)
 */
public abstract class BaseObserver<T extends BaseResult> implements Observer<T> {
    public enum Status {
        SUCCESS, NOT_DATA, FAILURE, NOT_LOGIN,
    }

    protected Disposable mDisposable;
    protected boolean isLoading;

    @Override
    public void onSubscribe(@NonNull Disposable d) {//類似onBefore(),可初始化菊花圈之類...
        Logger.i("onBefore");
        mDisposable = d;
    }

    @Override
    public void onNext(@NonNull T t) { //基礎響應的處理，可根據後端業務調整，不與View耦合
        if(t==null){
           onError(new Throwable("系統異常"));
           return;
        }
        if(t.getCode()==0){
           onResponse(t,SUCCESS);
        }else if(t.getCode()==999){
           onResponse(t,NOT_LOGIN);
        }else{
           onResponse(t,FAILURE);
        }
    }

    protected abstract void onResponse(@NonNull T t, Status status);

    @Override
    public void onError(@NonNull Throwable e) {
        isLoading = false;
    }
    @Override
    public void onComplete() {
        isLoading = false;
    }
    public boolean isLoading() {
        return isLoading;
    }
}


/**
 * 基於與View層互動的Observer，將頁面切換的操作統一封裝在IViewSwitchImp類中
 * IViewSwitchImp程式碼可自行封裝實現,此處只給出IViewSwitch 介面定義
 */
public abstract class ViewObserver<T> extends BaseObserver<BaseResult<T>> {
    protected IViewSwitch mIView;
    public ViewObserver(ViewGroup container) {
        mIView = new IViewSwitchImp(contentView);
    }
    public ViewObserver(IViewSwitch view) {
        mIView= view;
    }
    @Override
    public void onSubscribe(@NonNull Disposable d) {
        mIView.showLoading();
    }
    @Override
    protected void onResponse(BaseResult<T> result, Status status) {
        switch (status) {
            case SUCCESS:
                mIView.showContent();
                onSuccess(result.getResult());
                break;
            case NOT_DATA:
                mIView.showEmpty();
                break;
            case NOT_LOGIN:
                mIView.showLogin(t.getMessage());
                break;
            case FAILURE:
                mIView.showError(result.getMessage());
                break;
        }
    }

    public abstract void onSuccess(T t);

    @Override
    public void onError(@NonNull Throwable e) {
        Logger.d(e.getMessage());
        if (hasLoadDataSuccess) {
            Toaster.show(e.getMessage());
        } else {
            mSwitchViewHelper.showFailure(e);
        }
    }
}

public interface IViewSwitch{
    void showContent();
    void showEmpty();
    void showLoading();
    void showError(String msg);
}

3.Retrofit的封裝

public class RetrofitFactory {

    private static final java.lang.Object Object = new Object();
    /**
     * 快取機制
     * 在響應請求之後在 data/data/<包名>/cache 下建立一個response 資料夾，保持快取資料。
     * 這樣我們就可以在請求的時候，如果判斷到沒有網路，自動讀取快取的資料。
     * 同樣這也可以實現，在我們沒有網路的情況下，重新開啟App可以瀏覽的之前顯示過的內容。
     * 也就是：判斷網路，有網路，則從網路獲取，並儲存到快取中，無網路，則從快取中獲取。
     * https://werb.github.io/2016/07/29/%E4%BD%BF%E7%94%A8Retrofit2+OkHttp3%E5%AE%9E%E7%8E%B0%E7%BC%93%E5%AD%98%E5%A4%84%E7%90%86/
     */
    private static final Interceptor cacheControlInterceptor = new Interceptor() {

        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            if (!NetWorkUtil.isNetworkConnected(MyApplication.AppContext)) {
                request = request.newBuilder().cacheControl(CacheControl.FORCE_CACHE).build();
            }

            Response originalResponse = chain.proceed(request);
            if (NetWorkUtil.isNetworkConnected(MyApplication.AppContext)) {
                // 有網路時 設定快取為預設值
                String cacheControl = request.cacheControl().toString();
                return originalResponse.newBuilder()
                        .header("Cache-Control", cacheControl)
                        .removeHeader("Pragma")
                        .build();
            } else {
                // 無網路時 設定超時為1周
                int maxStale = 60 * 60 * 24 * 7;
                return originalResponse.newBuilder()
                        .header("Cache-Control", "public, only-if-cached, max-stale=" + maxStale)
                        .removeHeader("Pragma")
                        .build();
            }
        }
    };
    private volatile static Retrofit retrofit;

    @NonNull
    public static Retrofit getRetrofit() {
        synchronized (Object) {
            if (retrofit == null) {
                // 指定快取路徑,快取大小 50Mb
                Cache cache = new Cache(new File(MyApplication.AppContext.getCacheDir(), "HttpCache"),
                        1024 * 1024 * 50);

//                // Cookie 持久化
//                ClearableCookieJar cookieJar =
//                        new PersistentCookieJar(new SetCookieCache(), new SharedPrefsCookiePersistor(InitApp.AppContext));

                OkHttpClient.Builder builder = new OkHttpClient.Builder()
//                        .cookieJar(cookieJar)
                        .cache(cache)
                        .addInterceptor(cacheControlInterceptor)
                        .connectTimeout(10, TimeUnit.SECONDS)
                        .readTimeout(15, TimeUnit.SECONDS)
                        .writeTimeout(15, TimeUnit.SECONDS)
                        .retryOnConnectionFailure(true);

                // Log 攔截器
                if (BuildConfig.DEBUG) {
                    builder = HttpBuilderWrapper.initInterceptor(builder);
                }

                retrofit = new Retrofit.Builder()
                        .baseUrl(ApiConstant.HOST)
                        .client(builder.build())
                        .addConverterFactory(GsonConverterFactory.create())
                        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                        .build();
            }
            return retrofit;
        }
    }
}

public interface IHomeApi {
    @FormUrlEncoded
    @POST("/goods/guessyoulikes/v2")
    Observable<BaseResult<HomeBean>> getContentList( @Field("userId")int userId);

}

4.呼叫

Observable<BaseResult<HomeBean>> observable = RetrofitFactory.getRetrofit().create(IHomeApi.class).getContentList(9527);

Present present = new Present(new ViewObserver<HomeBean>(new IViewSwitch()){
    @Override
    public void onSuccess(HomeBean bean){

    }
});
present.excute(observable);

Emmm… 寫完發現並沒有什麼卵用，用Rxjava自帶的鏈式呼叫似乎更簡潔，這樣做的好處在於，將網路的異常響應統一封裝在一個可擴充套件的BaseObserver中並通過IViewSwitch展現給使用者，僅此而已，做個記錄