一步步搭建Retrofit+RxJava+MVP網絡請求框架（二），我的認爲此次封裝比較強大了

時間 2019-11-12

標籤步步搭建 retrofit+rxjava+mvp retrofit rxjava mvp 網絡請求框架我的認爲此次封裝比較強大欄目 Java 简体版

原文原文鏈接

在前面已經初步封裝了一個MVP的網絡請求框架，那只是個雛形，還有不少功能不完善，如今進一步進行封裝。添加了網絡請求時的等待框，retrofit中添加了日誌打印攔截器，添加了token攔截器，而且對DataManager類進行了擴展，真正體現它的做用，而且對大量的重複代碼作了必定封裝，減小代碼的冗餘。java

下面結合上篇文章，進行下一步的封裝。android

一、首先完善Result.java這個類。後端

一般在咱們寫API接口文檔的時候，後端返回的數據格式都是api

"code":1 //1：成功安全

//-1：token驗證失敗網絡

「msg」:」success」, //返回的消息提示app

「token驗證失敗」框架

「data」: //數據ide

{ui

「username」:」 xdw」 , //用戶名

"age":30 //年齡

}

具體的Result.java的代碼以下，裏面還加入了一個對返回碼的判斷方法

package com.xdw.retrofitrxmvpdemo.model;

import com.xdw.retrofitrxmvpdemo.constant.Constant;

/**
 * Created by 夏德旺 on 2017/12/8.
 */

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

    public Result(int code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }
    //添加對返回狀態成功的判斷
    public boolean isSuccess() {
        return code == Constant.SUCCESS;
    }

    public int getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }

    public T getData() {
        return data;
    }

}

二、添加ProgressDialogHandler和ProgressCancelListener，用來處理網絡請求等待框。代碼以下

ProgressCancelListener：

package com.xdw.retrofitrxmvpdemo.model;

/**
 * Created by 夏德旺 on 2017/12/8.
 */
public interface ProgressCancelListener {
    void onCancelProgress();
}

ProgressDialogHandler：

package com.xdw.retrofitrxmvpdemo.http;

import android.app.ProgressDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.os.Handler;
import android.os.Message;

/**
 * Created by 夏德旺 on 2017/12/8.
 */
public class ProgressDialogHandler extends Handler {

    public static final int SHOW_PROGRESS_DIALOG = 1;
    public static final int DISMISS_PROGRESS_DIALOG = 2;

    private ProgressDialog pd;

    private Context context;
    private boolean cancelable;
    private boolean show;
    private ProgressCancelListener mProgressCancelListener;

    public ProgressDialogHandler(Context context, ProgressCancelListener mProgressCancelListener,
                                 boolean cancelable,boolean show) {
        super();
        this.context = context;
        this.mProgressCancelListener = mProgressCancelListener;
        this.cancelable = cancelable;
        this.show = show;
    }

    private void initProgressDialog(){
        if (pd == null) {
            pd = new ProgressDialog(context);

            pd.setCancelable(cancelable);

            if (cancelable) {
                pd.setOnCancelListener(new DialogInterface.OnCancelListener() {
                    @Override
                    public void onCancel(DialogInterface dialogInterface) {
                        mProgressCancelListener.onCancelProgress();
                    }
                });
            }

            if (!pd.isShowing()&&show) {
                pd.show();
            }
        }
    }

    private void dismissProgressDialog(){
        if (pd != null) {
            pd.dismiss();
            pd = null;
        }
    }

    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case SHOW_PROGRESS_DIALOG:
                initProgressDialog();
                break;
            case DISMISS_PROGRESS_DIALOG:
                dismissProgressDialog();
                break;
        }
    }

}

三、改寫RetrofitApiService，將返回結果由原來的UserInfo改成Result<UserInfo>。

public interface RetrofitApiService {

    @GET("user")
    Observable<Result<UserInfo>> getUserInfo(@Query("uid") int uid);

}

四、完善以前的RetrofitUtil，加入日誌與token攔截器，token這段我註釋掉了，根據本身的實際項目進行添加

package com.xdw.retrofitrxmvpdemo.http;

import android.content.Context;

import com.google.gson.GsonBuilder;
import com.xdw.retrofitrxmvpdemo.BuildConfig;
import com.xdw.retrofitrxmvpdemo.constant.UrlConstant;

import java.io.IOException;

import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava.RxJavaCallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;

/**
 * Created by 夏德旺 on 2017/12/8.
 */

public class RetrofitUtil {
    private Context mCntext;
    //聲明Retrofit對象
    private Retrofit mRetrofit;
    //聲明RetrofitApiService對象
    private RetrofitApiService retrofitApiService;
    GsonConverterFactory factory = GsonConverterFactory.create(new GsonBuilder().create());
    //因爲該對象會被頻繁調用，採用單例模式，下面是一種線程安全模式的單例寫法
    private volatile static RetrofitUtil instance;

    public static RetrofitUtil getInstance(Context context){
        if (instance == null) {
            synchronized (RetrofitUtil.class) {
                if (instance == null) {
                    instance = new RetrofitUtil(context);
                }
            }
        }
        return instance;
    }
    private RetrofitUtil(Context mContext){
        mCntext = mContext;
        init();
    }

    //初始化Retrofit
    private void init() {

        //添加token攔截
/*        final String token = AppSPUtils.getValueFromPrefrences(AppConstants.SP_TOKEN, "");
        final int uid = AppSPUtils.getValueFromPrefrences(AppConstants.SP_USERID, 0);
        Interceptor mTokenInterceptor = new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                Request authorised = chain.request().newBuilder()
                        .addHeader("userId", String.valueOf(uid))
                        .addHeader("token", token)
                        .build();
                return chain.proceed(authorised);
            }
        };*/
        //打印請求log日誌
        OkHttpClient httpClient = new OkHttpClient();
        if (BuildConfig.DEBUG) {
            HttpLoggingInterceptor httpLoggingInterceptor = new HttpLoggingInterceptor();
            httpLoggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
            httpClient = new OkHttpClient.Builder()
                    .addInterceptor(httpLoggingInterceptor)
//                    .addInterceptor(mTokenInterceptor)
                    .build();
        }
        mRetrofit = new Retrofit.Builder()
                .baseUrl(UrlConstant.BASE_URL)
                .client(httpClient)
                .addConverterFactory(factory)
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .build();
        retrofitApiService = mRetrofit.create(RetrofitApiService.class);
    }

    public RetrofitApiService getRetrofitApiService(){
        return retrofitApiService;
    }
}

五、重要的地方來了，完善以前的DataManager。以前這個類你們能夠以爲很是雞肋，由於它什麼也沒幹，就是把RetrofitApiService和RetrofitUtil 該乾的活移動到了這類中，非但沒有減輕任務量，反而要多寫一大堆重複代碼。等如今封裝以後就能夠發現它的大做用了。

咱們如今在RetrofitApiService中的getUserInfo方法的返回值變成了Result<UserInfo>，可是實際上最後咱們要的數據僅僅是UserInfo，這時能夠對以前的DataManager中的getUserInfo方法修改下，以下

    public Observable<UserInfo>  getUserInfo(int uid){
        return mRetrofitService.getUserInfo(uid).map(new ResultFunc<UserInfo>() );
    }

這裏使用了rxjava中的map這個關鍵方法將數據進行了剝離出來，不懂這個方法的請本身去查閱rxjava的資料。

在DataManager中同時定義了一個內部類，以下

 public class ResultFunc<T> implements Func1<Result<T>, T> {
        @Override
        public T call(Result<T> result) {
            //在這裏對對服務端返回的resultCode進行判斷，若是返回碼不是成功，
            // 則拋出自定義的API異常，好比token登錄失敗時。拋出異常的異常能夠統一
            // 在Subscriber的子類ProgressSubscriber中進行處理，這樣就不用到
            // 每一個Activity中再來進行處理
            if (!result.isSuccess()) {
                throw new APIException(result.getCode(), result.getMsg());
            }
            return result.getData();
        }
    }

這裏補充本身定義的一個異常類APIException的代碼，以下

package com.xdw.retrofitrxmvpdemo.util;

/**
 * 自定義異常
 * Created by 夏德旺 on 2017/12/8.
 */
public class APIException extends RuntimeException{
    public int code;
    public String message;

    public APIException(int code, String message) {
        this.code = code;
        this.message = message;
    }

    @Override
    public String getMessage() {
        return message;
    }

    public int getCode() {
        return code;
    }
}

DataManager的封裝到此完成，具體它的應用請看後面的UserInfoPresenter中的調用

六、在BasePresenter中添加一個addSubscription方法，這個是對每次的訂閱進行封裝，簡化重複代碼量

    //將每次的訂閱操做進行封裝，簡化重複代碼量
    public <T> void addSubscription(Observable<T> o, Subscriber<T> s) {
        mCompositeSubscription.add(o.unsubscribeOn(Schedulers.io())
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(s));

    }

七、再來看看具體處理業務邏輯的UserInfoPresenter的代碼是否是會清爽不少

package com.xdw.retrofitrxmvpdemo.presenter;

import android.content.Context;
import android.util.Log;

import com.xdw.retrofitrxmvpdemo.http.ProgressSubscriber;
import com.xdw.retrofitrxmvpdemo.manager.DataManager;
import com.xdw.retrofitrxmvpdemo.model.Result;
import com.xdw.retrofitrxmvpdemo.model.UserInfo;
import com.xdw.retrofitrxmvpdemo.pv.PresentView;
import com.xdw.retrofitrxmvpdemo.pv.UserInfoPv;

import rx.Observable;
import rx.Observer;
import rx.Subscriber;
import rx.android.schedulers.AndroidSchedulers;
import rx.functions.Func1;
import rx.schedulers.Schedulers;

/**
 * Created by 夏德旺 on 2017/12/8.
 */

//該類是具體業務presenter，如需增長另外一個業務，好比Order
//則能夠再建立一個OrderPresenter
public class UserInfoPresenter extends BasePresenter {
    private Context mContext;
    private UserInfoPv mUserInfoPv;
    private UserInfo mUserInfo;

    public UserInfoPresenter(Context context) {
        this.mContext = context;
    }

    @Override
    public void BindPresentView(PresentView presentView) {
        mUserInfoPv = (UserInfoPv) presentView;
    }

    //在presenter中實現業務邏輯，此處會調用前面封裝好的retrofit的東西
    //將處理結果綁定到對應的PresentView實例，這樣Activity和PresentView實例綁定好以後，
    //Activity->PresentView->Presenter->retrofit的關係就打通了
    public void getUserInfo(int uid) {
        Observable<UserInfo> observable = DataManager.getInstance(mContext).getUserInfo(uid);
        addSubscription(observable,new ProgressSubscriber<UserInfo>(mUserInfoPv, mContext, true) {
            @Override
            public void onNext(UserInfo userInfo) {
                super.onNext(userInfo);
                mUserInfoPv.onSuccess(userInfo);
            }
        } );
    }
}

這個getUserInfo是否是清爽了不少，首先經過DataManager的封裝，能夠很方便的獲取剝離出了核心數據的observable，而後調用父類中的addSubscription來處理具體的業務。你們看到這裏會發現業務邏輯中的onCompleted與onError這2個核心方法怎麼不見了。這些咱們都統一封裝到了ProgressSubscriber中。繼續往下看

八、封裝ProgressSubscriber，它繼承Subscriber類，而且實現ProgressCancelListener接口。在該類中統一對報錯（而且包括自定義的API異常）和網絡對話框的出現與消失作了處理。這樣就簡化了咱們大量的操做，不用再到每一個界面中單獨對其進行判斷處理。具體代碼以下

package com.xdw.retrofitrxmvpdemo.http;
import android.content.Context;
import android.util.Log;
import android.widget.Toast;

import com.xdw.retrofitrxmvpdemo.pv.PresentView;
import com.xdw.retrofitrxmvpdemo.util.APIException;

import java.net.ConnectException;
import java.net.SocketTimeoutException;

import rx.Subscriber;

/**
 * 用於在Http請求開始時，自動顯示一個ProgressDialog
 * 在Http請求結束時，關閉ProgressDialog
 * 調用者本身對請求數據進行處理
 * Created by 夏德旺 on 2017/12/8.
 */
public class ProgressSubscriber<T> extends Subscriber<T> implements ProgressCancelListener{

    private PresentView mPresentView;
    private ProgressDialogHandler mProgressDialogHandler;

    private Context context;

    public ProgressSubscriber(PresentView mPresentView, Context context, boolean show) {
        this.mPresentView = mPresentView;
        this.context = context;
        mProgressDialogHandler = new ProgressDialogHandler(context, this, true,show);
    }
    public ProgressSubscriber(Context context,boolean show) {
        this.context = context;
        mProgressDialogHandler = new ProgressDialogHandler(context, this, true,show);
    }

    private void showProgressDialog(){
        if (mProgressDialogHandler != null) {
            mProgressDialogHandler.obtainMessage(ProgressDialogHandler.SHOW_PROGRESS_DIALOG).sendToTarget();
        }
    }

    private void dismissProgressDialog(){
        if (mProgressDialogHandler != null) {
            mProgressDialogHandler.obtainMessage(ProgressDialogHandler.DISMISS_PROGRESS_DIALOG).sendToTarget();
            mProgressDialogHandler = null;
        }
    }

    /**
     * 訂閱開始時調用
     * 顯示ProgressDialog
     */
    @Override
    public void onStart() {
        showProgressDialog();
    }

    /**
     * 完成，隱藏ProgressDialog
     */
    @Override
    public void onCompleted() {
        dismissProgressDialog();
    }

    /**
     * 對錯誤進行統一處理
     * 隱藏ProgressDialog
     * @param e
     */
    @Override
    public void onError(Throwable e) {
        if (e instanceof SocketTimeoutException) {
            Toast.makeText(context,"網絡中斷，請檢查您的網絡狀態",Toast.LENGTH_SHORT).show();
        } else if (e instanceof ConnectException) {
            Toast.makeText(context,"網絡中斷，請檢查您的網絡狀態",Toast.LENGTH_SHORT).show();
        } else if(e instanceof APIException){
            Toast.makeText(context,e.getMessage(),Toast.LENGTH_SHORT).show();
            Log.e("xdw","apiCode="+((APIException) e).getCode());
        }else{
            Toast.makeText(context,"未知異常",Toast.LENGTH_SHORT).show();
            Log.e("xdw","apiCode="+((APIException) e).getCode());
        }
        dismissProgressDialog();

    }

    /**
     * 將onNext方法中的返回結果交給Activity或Fragment本身處理
     *
     * @param t 建立Subscriber時的泛型類型
     */
    @Override
    public void onNext(T t) {

    }

    /**
     * 取消ProgressDialog的時候，取消對observable的訂閱，同時也取消了http請求
     */
    @Override
    public void onCancelProgress() {
        if (!this.isUnsubscribed()) {
            this.unsubscribe();
        }
    }
}

九、因爲已經對錯誤進行了統一處理，那麼這裏在PresentView接口中去掉了以前定義的onError方法。

package com.xdw.retrofitrxmvpdemo.pv;

/**
 * Created by 夏德旺 on 2017/12/8.
 */

public interface PresentView{
    //定義一個最基礎的接口，裏面就包含一個出錯信息的回調
    //由於大多數時候報錯的時候都是採用一條信息提示
    //若是須要負責的報錯接口，請重載onError，是重載不是重寫
    //通過後面加入第二次封裝以後，這裏的onError刪除了，統一封裝到了ProgressSubscriber中
    //若是須要特定的具體要到每一個Activity中去重寫報錯信息的，能夠在此再添加一個onError處理
}

十、最後咱們來看看MainActivity中的處理，基本和以前沒什麼變化，就是少了個onError的方法

package com.xdw.retrofitrxmvpdemo.activity;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import com.xdw.retrofitrxmvpdemo.R;
import com.xdw.retrofitrxmvpdemo.model.UserInfo;
import com.xdw.retrofitrxmvpdemo.presenter.UserInfoPresenter;
import com.xdw.retrofitrxmvpdemo.pv.UserInfoPv;

public class MainActivity extends AppCompatActivity {
    private TextView text;
    private Button button;
    //定義須要調用的presenter對象
    private UserInfoPresenter mUserInfoPresenter =new UserInfoPresenter(this);

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        text = (TextView)findViewById(R.id.text);
        button = (Button)findViewById(R.id.button);
        //在Activity建立的時候同時初始化presenter，這裏onCreater不是指的建立presenter對象，
        // 而是作一些presenter的初始化操做，名字應該取名init更好理解點，我這裏就不重命名了
        mUserInfoPresenter.onCreate();
        //將presenter和PresentView進行綁定，實際上就是將presenter和Activity視圖綁定，
        //這個是MVP模式中V與P交互的關鍵
        mUserInfoPresenter.BindPresentView(mUserInfoPv);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //點擊按鈕觸發presenter裏面的方法
                mUserInfoPresenter.getUserInfo(1);
            }
        });

    }

    //採用內部類方法定義presentView對象，該對象用來將Activity和presenter進行綁定
    //綁定了之後主線程中就能夠經過回調來獲取網絡請求的數據
    private UserInfoPv mUserInfoPv = new UserInfoPv(){
        @Override
        public void onSuccess(UserInfo userInfo) {
            text.setText(userInfo.toString());
        }
    };

    //在Activity銷燬的時候，必定要對CompositeSubscription進行釋放，不然會形成內存泄漏
    //釋放操做封裝到了presenter的ondestroy方法中
    @Override
    protected void onDestroy(){
        super.onDestroy();
        mUserInfoPresenter.onDestroy();
    }
}

到此整個封裝完畢，我也用本身以前作的項目檢驗了下，確實也很好用。下面跟上篇博客同樣介紹下使用方法。

列舉下以後像該項目中擴展業務的步驟，好比加一個訂單功能。

操做步驟:

一、添加對應的model類Order

二、RetrofitApiService中添加對應的網絡請求api，此時的api格式是帶上Result的

三、將新添加的api映射到DataManager中，此時在DataManager中的api是剝離出實際數據以後的

四、添加業務對應的PrensentView實例OrderPv

五、添加業務對應的Presenter實例OrderPresenter

六、在須要該業務的UI線程（Activity或Fragment）中調用具體業務對應的Presenter