RXJava+Retrofit+MVP的简单封装

马上就要过年了，躁动的心早已按耐不住，还是写上一篇文章来冷静下。这次主要是搭建一个app框架（网络请求方面），这也是自己慢慢摸索去搭建的。首先这个框架主要用的东西：看标题就知道了。
OK，废话不多说，RxJava用的1.0，（这个可以升的，只是有些方法名改了），Retrofit用的2.0
首先引用这些玩意吧：

    compile 'io.reactivex:rxjava:1.0.14'
    compile 'io.reactivex:rxandroid:1.0.1'
    compile 'com.squareup.retrofit2:retrofit:2.1.0'
    compile 'com.squareup.retrofit2:converter-gson:2.1.0'
    compile 'com.google.code.gson:gson:2.6.2'
    compile 'com.squareup.retrofit2:adapter-rxjava:2.0.0'
    compile 'com.squareup.okhttp3:logging-interceptor:3.1.2'

一般请求服务器，都会返回一些相同的数据，像什么code，message，status等，如果你们后台不是给这样的数据，那你就别这样整了，例如下面的数据：

{
  "status": 0,
  "message": "成功",
  "pageNum": 0,
  "total": 0,
  "data": {
    "id": 1,
    "username": "admin",
    "password": "admin",
    "dsId": 1,
    "dsPhone": "10086",
    "status": 1,
    "createTime": 1481812879000,
    "modifyTime": 1481812879000
  }
}

这个json数据最外面就是公共的，data一般才是我们需要的数据，所以是可以抽取出来的，所以建一个实体类。

public class HttpsResult<T> {
    private int status;
    private String message;
    private int pageNum;
    private int total;
    private T data;

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public int getPageNum() {
        return pageNum;
    }

    public void setPageNum(int pageNum) {
        this.pageNum = pageNum;
    }

    public int getTotal() {
        return total;
    }

    public void setTotal(int total) {
        this.total = total;
    }

    public T getData() {
        return data;
    }

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

    @Override
    public String toString() {
        return "HttpsResult{" +
                "status=" + status +
                ", message='" + message + '\'' +
                ", pageNum=" + pageNum +
                ", total=" + total +
                ", data=" + data +
                '}';
    }
}

那个泛型就是我们最后想要的数据，这个到时根据自己API的数据去写吧。
那么接下来编写retrofit接口吧。
因为要这里才用了RxJava，编写接口有一点点不一样，前面变成了Observable，这里你就会发现，我们在HttpsResult后面传入了个泛型Person，而这个Person就是我们需要的数据。

    @POST("restful/loginPost")
    Observable<HttpsResult<Person>> login(@Body RequestBody body);

好了，避免每次请求都要去初始化Retrofit，这里我们就可以封装下，而且还可以统一设置所有请求的Header。如下就是封装后的RetrofitClient:

public class RetrofitClient {
    public static Retrofit mRetrofit;
    private static final int DEFAULT_TIMEOUT = 5;

    public static Retrofit retrofit() {
        if (mRetrofit == null) {
            OkHttpClient.Builder httpClientBuilder = new OkHttpClient.Builder();
            if (BuildConfig.DEBUG) {
                // Log信息拦截器
                HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
                loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
                //设置 Debug Log 模式
                httpClientBuilder.addInterceptor(loggingInterceptor);
            }
            /**
             * 添加拦截器，设置请求header
             */
            httpClientBuilder.addInterceptor(new Interceptor() {
                @Override
                public Response intercept(Chain chain) throws IOException {
                    Request original = chain.request();

                    Request request = original.newBuilder()
                            .header("Content-Type", "application/json")
                            .method(original.method(), original.body())
                            .build();
                    return chain.proceed(request);
                }
            });

            httpClientBuilder.connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS);
            Gson gson = new GsonBuilder()
                    //配置Gson
                    .setDateFormat("yyyy-MM-dd hh:mm:ss")
                    .create();

            OkHttpClient okHttpClient = httpClientBuilder.build();
            mRetrofit=new Retrofit.Builder()
                    .baseUrl(ApiStore.BASE_URL)
                    .addConverterFactory(GsonConverterFactory.create(gson))
                    .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                    .client(okHttpClient)
                    .build();

        }
        return mRetrofit;
    }
}

当然我们还可以将RXJava的Subscriber进行封装，这里我主要是为了拦截Http请求异常，并针对某个异常进行处理，比如说请求服务器接口出现了401，503等错误。

public abstract class ApiCallBack<M> extends Subscriber<M> {
    public abstract void onSuccess(M model);

    public abstract void onFailure(String msg);

    public abstract void onFinish();

    @Override
    public void onError(Throwable e) {
        e.printStackTrace();
        if (e instanceof HttpException) {
            HttpException httpException = (HttpException) e;
            //httpException.response().errorBody().string()
            int code = httpException.code();
            String msg = httpException.getMessage();
            Log.d("dandy","code=" + code);
            if (code == 504) {
                msg = "网络不给力";
            }
            if (code == 502 || code == 404) {
                msg = "服务器异常，请稍后再试";
            }
            onFailure(msg);
        } else {
            onFailure(e.getMessage());
        }
        Log.e("dandy","请求异常了 "+e.toString());
        onFinish();
    }

    @Override
    public void onCompleted() {

    }

    @Override
    public void onNext(M m) {
        onSuccess(m);
    }
}

既然是框架，当然少不了对activity，fragment的封装了咯。

public abstract class BaseActivity extends AppCompatActivity implements ActivityCompat.OnRequestPermissionsResultCallback {
    protected Context mContext;
    private static final int REQUEST_CODE_PERMISSON = 2020; //权限请求码
    private boolean isNeedCheckPermission = true; //判断是否需要检测，防止无限弹框申请权限
    private Toolbar mToolbar;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        initView();
        initData();
    }

    protected void initData() {

    }

    protected abstract void initView();

    @Override
    protected void onResume() {
        super.onResume();
        if (isNeedCheckPermission){
            checkAllPermission();
        }
    }

    /**
     * 检查全部的权限，无权限则申请相关权限
     */
    protected void checkAllPermission(){
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M){
            List<String> needRequestPermissonList = getDeniedPermissions(getNeedPermissions());
            if (null != needRequestPermissonList && needRequestPermissonList.size() > 0) {
                ActivityCompat.requestPermissions(this, needRequestPermissonList.toArray(
                        new String[needRequestPermissonList.size()]), REQUEST_CODE_PERMISSON);
            }
        }
    }

    /**
     * 获取权限集中需要申请权限的列表
     *
     * @param permissions
     * @return
     */
    private List<String> getDeniedPermissions(String[] permissions) {
        List<String> needRequestPermissonList = new ArrayList<>();
        for (String permission : permissions) {
            if (ContextCompat.checkSelfPermission(this, permission) !=
                    PackageManager.PERMISSION_GRANTED ||
                    ActivityCompat.shouldShowRequestPermissionRationale(this, permission)) {
                needRequestPermissonList.add(permission);
            }
        }
        return needRequestPermissonList;
    }
    /**
     *
     */
    public void addToolbar(){
         mToolbar = findView(R.id.toolbar);
        setSupportActionBar(mToolbar);
        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
    }

    /**
     * 弹出Toast
     *
     * @param text
     */
    public void showToast(String text) {
        Toast toast = Toast.makeText(this, text, Toast.LENGTH_SHORT);
        toast.setGravity(Gravity.CENTER, 0, 0);
        toast.show();
    }

    /**
     * 解决绑定view时类型转换
     * @param id
     * @param <E>
     * @return
     */
    @SuppressWarnings("unchecked")
    public final <E extends View> E findView(int id){
        try {
            return (E) findViewById(id);
        }catch (ClassCastException e){
            throw  e;
        }
    }

    /**
     * 授权之后回调
     * @param requestCode
     * @param permissions
     * @param grantResults
     */
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode==REQUEST_CODE_PERMISSON){
            if (!verifyPermissions(grantResults)) {
                permissionGrantedFail();
                showTipsDialog();
                isNeedCheckPermission = false;
            } else permissionGrantedSuccess();
        }
    }

    /**
     * 检测所有的权限是否都已授权
     *
     * @param grantResults
     * @return
     */
    private boolean verifyPermissions(int[] grantResults) {
        for (int grantResult : grantResults) {
            if (grantResult != PackageManager.PERMISSION_GRANTED) {
                return false;
            }
        }
        return true;
    }

    /**
     * 显示提示对话框
     */
    protected void showTipsDialog() {
        new AlertDialog.Builder(this).setTitle("信息").setMessage("当前应用缺少" + getDialogTipsPart()
                + "权限，该功能暂时无法使用。如若需要，请单击【确定】按钮前往设置中心进行权限授权。")
                .setNegativeButton("取消", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        finish();
                    }
                })
                .setPositiveButton("确定", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        startAppSettings();
                    }
                }).show();
    }

    /**
     * 启动当前应用设置页面
     */
    private void startAppSettings() {
        Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
        intent.setData(Uri.parse("package:" + getPackageName()));
        startActivity(intent);
    }
    /**
     * 获取需要进行检测的权限数组
     */
    protected abstract String[] getNeedPermissions();

    /**
     * 获取弹框提示部分内容
     *
     * @return
     */
    protected String getDialogTipsPart() {
        return "必要";
    }
    /**
     * 权限授权成功
     */
    protected abstract void permissionGrantedSuccess();
    /**
     * 权限授权失败
     */
    protected abstract void permissionGrantedFail();

}

上面的注释都很清楚了，OK，接下来对fragment进行封装吧，

public abstract class BaseFragment extends android.support.v4.app.Fragment{
    private Activity mActivity;


    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        mActivity = getActivity();
        View view = initView(inflater,container);
        initFindViewById(view);
        return view;
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        initData();
        setLinstener();
    }

    protected abstract View initView(LayoutInflater inflater,ViewGroup container);
    protected abstract void initFindViewById(View view);
    //初始化数据
    public void initData(){

    }
    //设置事件
    public void setLinstener(){

    }

}

既然是采用MVP架构，当然少不了对它们的一些封装，首先对view接口进行简单的封装，一般都是一些公共的功能，像显示dialog等，这个可以根据自己项目的需求吧

public interface BaseView {
    void showDialog();
    void cancelDialog();
    void toastMeassager(String msg);
}

少不了MVP中的P（Presenter），它就是负责model与view沟通的，所以它在整个环节处于很重要的位置。这里并没有过多的内容，只是一个网络请求，负责添加，与注销，当有多个subscriber需要工作的时候就可以采用CompositeSubscription来进行添加，这个玩意好像在RxJava2.0里面找不到了，不知道是不是换名字了。

public class BasePresenter<V> {
    public V mvpView;
    protected ApiStore mApiStore;
    private CompositeSubscription mCompositeSubscription;

    public void attachView(V mvpView){
        this.mvpView=mvpView;
        mApiStore = RetrofitClient.retrofit().create(ApiStore.class);

    }

    public void detachView() {
        this.mvpView = null;
        onUnsubscribe();
    }


    /**
     * rxJava取消注册
     */
    public void onUnsubscribe() {
        if (mCompositeSubscription != null && mCompositeSubscription.hasSubscriptions()) {
            mCompositeSubscription.unsubscribe();
        }
    }

    public void addSubscription(Observable observable, Subscriber subscriber) {
        if (mCompositeSubscription == null) {
            mCompositeSubscription = new CompositeSubscription();
        }

        mCompositeSubscription.add(observable
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(subscriber));
    }
}

好了，写了这么多代码，那就拿个功能来实现下吧，接下来将以用户登录来试试。
首先写View接口，主要操作是获取用户名，密码，跳转到主activity，提示错误信息。

public interface IUserLoginView extends BaseView{
    String getUseName();
    String getPassword();
    void toMainActivity();
    void showFailedError();
    int getUserType();
    void userOrPwdIsNull();
}

好了，接下来Presenter，那个保存token不用管，这是我自己项目的玩意，这里就有个login方法，一旦被调用就会通过IUserLoginView去获取用户名和密码，然后转成网络请求的参数去请求服务器：

public class UserLoginPresenter extends BasePresenter<IUserLoginView>{
    private int type;
    private IUserLoginView mUserLoginView;
    private Context mContext;


    public UserLoginPresenter( IUserLoginView mUserLoginView) {

        this.mUserLoginView = mUserLoginView;
        attachView(mUserLoginView);
        mContext=DriverApplication.getContextObject();
    }

    public void login(){
        String userName=mUserLoginView.getUseName();
        String pwd=mUserLoginView.getPassword();
        type=mUserLoginView.getUserType();

        if (userName==null||userName.equals("")||pwd==null||pwd.equals("")){
            mUserLoginView.userOrPwdIsNull();
            return;
        }
        mUserLoginView.showDialog();
        ApiCallBack<HttpsResult<Person>> subscriber1=new ApiCallBack<HttpsResult<Person>>() {
            @Override
            public void onSuccess(HttpsResult<Person> model) {

                mUserLoginView.cancelDialog();
                if (model.getStatus()==0){
                    closeRetrofit();
                    mUserLoginView.toMainActivity();
                    savaUserToken(model);
                }else {
                    mUserLoginView.toastMeassager(model.getMessage());
                }
            }

            @Override
            public void onFailure(String msg) {
                //Log.e("dandy","error "+msg);
                mUserLoginView.cancelDialog();
            }

            @Override
            public void onFinish() {

            }
        };
        User user=new User();
        user.setCategory(type);
        user.setUsername(userName);
        user.setPassword(pwd);
        Gson gson=new Gson();
        String route= gson.toJson(user);
        RequestBody body=RequestBody.create(okhttp3.MediaType.parse("application/json; charset=utf-8"),route);
        addSubscription(mApiStore.login(body),subscriber1);

    }

    private void savaUserToken(HttpsResult<Person> person){

        UtilSharedPreferences.saveStringData(mContext, Config.KEY_TOKEN,person.getMessage());
        UtilSharedPreferences.saveStringData(mContext,Config.KEY_USERNAME,person.getData().getUsername());
        if (person.getData().getDiscern()==1){
            UtilSharedPreferences.saveStringData(mContext,Config.KEY_USER_TYPE,mContext.getResources().getString(R.string.user_teacher));
        }else {
            UtilSharedPreferences.saveStringData(mContext,Config.KEY_USER_TYPE,mContext.getResources().getString(R.string.user_student));
        }
        if (type==1){
            UtilSharedPreferences.saveStringData(mContext,Config.KEY_USER_TYPE,mContext.getResources().getString(R.string.user_admin));
        }

    }

    /**
     * 注销，取消订阅
     */
    public void destory(){
        detachView();
    }
}

最后就是我们activity了，看到这些接口，我当时整个人都是懵逼的，这也是MVP的恶心之处，但是它的优势就是解耦，一旦项目大的话，你再来看代码会感觉很清晰，所以做项目时不是看哪个框架流行就去用，而是根据项目的需求，如果只是一个简单的APP，你强行整个MVP，那就尴尬了。。。

public class LoginActivity extends BaseActivity implements IUserLoginView{
    private UserLoginPresenter mUserLoginPresenter=new UserLoginPresenter(this);
    private AutoCompleteTextView mUserName;
    private EditText mPassword;
    private RadioGroup mRadioGroup;
    private RadioButton mAdmin,mTeacher,mStudent;
    private ProgressDialog mDialog;
    private Button mSingIn;
    private int mUserType= Config.USER_TYPE_ADMIN;
    private LinearLayout mLoginLayout;


    @Override
    protected void initView() {
        setContentView(R.layout.activity_login);

        mLoginLayout=findView(R.id.longin_layout);
        mUserName=findView(R.id.login_username);
        mPassword=findView(R.id.login_password);
        mRadioGroup=findView(R.id.login_group);
        mAdmin=findView(R.id.login_admin);
        mTeacher=findView(R.id.login_teacher);
        mStudent=findView(R.id.login_student);
        mSingIn=findView(R.id.login_sing_in);

        addToolbar();
        getSupportActionBar().setDisplayHomeAsUpEnabled(false);
    }


    @Override
    protected void initData() {
        mRadioGroup.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(RadioGroup radioGroup, int i) {
                switch (i){
                    case R.id.login_admin:
                        mUserType=Config.USER_TYPE_ADMIN;
                        break;
                    case R.id.login_teacher:
                        mUserType=Config.USER_TYPE_TEACHER;
                        break;
                    case R.id.login_student:
                        mUserType=Config.USER_TYPE_STUDENT;
                        break;
                    default:

                        break;

                }
            }
        });

        mSingIn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                mUserLoginPresenter.login();

            }
        });

        mAdmin.setChecked(true);
    }



    @Override
    protected String[] getNeedPermissions() {
        return new String[0];
    }

    @Override
    protected void permissionGrantedSuccess() {

    }

    @Override
    protected void permissionGrantedFail() {

    }


    @Override
    public String getUseName() {

        return mUserName.getText().toString();
    }

    @Override
    public String getPassword() {
        return mPassword.getText().toString();
    }

    @Override
    public void showDialog() {
        mDialog=ProgressDialog.show(LoginActivity.this,"提示","正在登录...");

    }

    @Override
    public void cancelDialog() {
        mDialog.cancel();
    }

    @Override
    public void toastMeassager(String msg) {
        Snackbar.make(mLoginLayout, msg, Snackbar.LENGTH_LONG)
                .setAction("Action", null).show();
    }

    @Override
    public void toMainActivity() {
        startActivity(new Intent(LoginActivity.this, HomeActivity.class));
        finish();
    }

    @Override
    public void showFailedError() {
    }

    /**
     * 获取用户类型
     * @return
     */
    @Override
    public int getUserType() {
        return mUserType;
    }

    @Override
    public void userOrPwdIsNull() {
        Toast.makeText(LoginActivity.this,"用户名或者密码不能为空",Toast.LENGTH_SHORT).show();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mUserLoginPresenter.destory();
    }
}

以上差不多就是这样的，当然还有很多地方是需要慢慢完善的，毕竟是需要时间去现的。github地址 传送门