最近把RxJava2和Retrofit2學習了一下，並做了一個簡單的封裝，算是對學習的總結,以及以後的做專案時可以，可以拿來及用。

注意：本篇不說RxJava2 和 Retrofit2的基礎使用，只梳理一下封裝的步驟，所以適合對RxJava2 和 Retrofit2有一定的瞭解的 Coder.

先上封裝後使用網路請求的程式碼：

ServiceFactory.getService(LoginService.class)
                .login()
                .compose(RxSchedulers.<BaseEntity<User>>ioMain(context))
                .subscribe(new BaseObserver<User>(context) {
                    @Override
                    public void onSuccess(User user) {
                        Log.e(TAG, "User: " + user);
                    }
                });
 

前言：一個網路請求，一般而言，大概有以下步驟：

1.建立網路連結。

2.請求前的預處理（如：統一處理請求格式、網路判斷、ProgressDialog）。

3.取消請求。

4.請求結果預處理，拿到想要的結果。

一般我們響應的資料格式如：

{
      "code":1,
      "msg":"success",
      "data":{}
  }

封裝步驟：

一、建立連結：

建立Service：寫一個ServiceFactory建立Service。主要程式碼如下：

public class ServiceFactory {
    public static <T> T getService(String url ,final  Class<T> service) {
        return RetrofitHelper.getRetrofit(url).create(service);
    }

    public static <T> T getService(final  Class<T> service) {
        return RetrofitHelper.getRetrofit().create(service);
    }
}
 

OkHttpClient 和 Retrofit的建立請看底部連結 Demo。

二、請求前的預處理：

我是寫了一個執行緒轉換類，並在裡面做的請求預處理，如下：

public class RxSchedulers {
    private static ProgressDialog dialog;

    /**
     * @param: [context]
     * @return: io.reactivex.ObservableTransformer<T,T>
     * @description: Thread Scheduling. The default is show dialog.
     */
    public static <T> ObservableTransformer<T, T> ioMain(final Context context) {
        return ioMain(context,true);
    }

    /**
     * @param: [context, isShow] [context，Whether or not show dialog.]
     * @return: io.reactivex.ObservableTransformer<T,T>
     * @description: Thread Scheduling.
     */
    public static <T> ObservableTransformer<T, T> ioMain(final Context context, final boolean isShow) {
        return new ObservableTransformer<T, T>() {
            @Override
            public ObservableSource<T> apply(Observable<T> observable) {
                if (isShow && dialog == null) {
                    dialog = new ProgressDialog(context);
                    dialog.setCancelable(true);
                    dialog.setMessage("載入中...");
                }
                return observable
                        .subscribeOn(Schedulers.io())
                        .doOnSubscribe(new Consumer<Disposable>() {
                            @Override
                            public void accept(final Disposable disposable) throws Exception {
                                LogUtil.d("doOnSubscribe -- Determine if there is a network and dialog.");

                                if (!NetWorkUtils.isConnectedByState(context)) {
                                    disposable.dispose();
                                    LogUtil.d("doOnSubscribe -- There's no network link.");
                                    Toast.makeText(context, R.string.toast_network_error, Toast.LENGTH_SHORT).show();
                                } else {
                                    LogUtil.d("doOnSubscribe -- There's a network link.");
                                    if (isShow && dialog != null && !dialog.isShowing()) {
                                        dialog.show();
                                        dialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
                                            @Override
                                            public void onCancel(DialogInterface dialog) {
                                                LogUtil.i("Dialog Cancel and interrupt network request!");
                                                disposable.dispose();
                                            }
                                        });
                                    }

                                }
                            }
                        })
                        .doFinally(new Action() {
                            @Override
                            public void run() throws Exception {
                                if (dialog != null && dialog.isShowing())
                                    dialog.dismiss();
                            }
                        })
                        .observeOn(AndroidSchedulers.mainThread());
            }
        };
    }


}
 

三、結果預處理：

建立一個BaseObserver類，基礎Observer，如下：

public abstract class BaseObserver<T> implements Observer<BaseEntity<T>> {

    private static final String TAG = "BaseObserver";
    public static final int SUCCESS_CODE = 1;
    private Context mContext;

    protected BaseObserver(Context context) {
        this.mContext = context.getApplicationContext();
    }

    @Override
    public void onSubscribe(@NonNull Disposable d) {

    }

    @Override
    public void onNext(@NonNull BaseEntity<T> tBaseEntity) {
        LogUtil.d(TAG,"onNext");
        if (SUCCESS_CODE == tBaseEntity.getCode()) {
            T t = tBaseEntity.getData();
            onSuccess(t);
        } else {
            onFail(tBaseEntity.getMsg());
        }

    }

    @Override
    public void onError(@NonNull Throwable e) {
        LogUtil.d(TAG,"onError");
    }

    @Override
    public void onComplete() {
        LogUtil.d(TAG,"onComplete");

    }

    public abstract void onSuccess(T t);

    public void onFail(String msg) {
        Toast.makeText(mContext, msg, Toast.LENGTH_SHORT).show();
    }
}

BaseEntity:

public class BaseEntity<T> {
    private int code;
    private String msg;
    private T data;

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "HttpResult{" +
                "code=" + code +
                ", msg='" + msg + '\'' +
                ", data=" + data +
                '}';
    }
}

大概基本的思路就這樣。

好了，不寫了，還有其他事先撤了，希望對您有些許幫助。

再次宣告：本篇部落格適合有Rxjava2 和 Retrofit2有一定基礎的Coder.

拜拜啦！！！真不寫了。