Retrofit与Rxjava封装终结者(二)原理解析

若是没有了解过基本用法的，能够先看一下上篇博客
Retrofit与Rxjava封装终结者(一)基本用法，先看一下封装以前的代码,

Map<String, String> map = new HashMap<>();
        map.put("_t", PrefUtils.getString(mContext, "token", ""));
        RxRequest.getInstance()
                .getProxy(RxUrl.class)
                .getServiceType(map)
                .subscribeOn(Schedulers.io())
                .compose(bindToLifecycle())//绑定生命周期
                .compose(bindUntilEvent(ActivityEvent.DESTROY))//Destroy时销毁
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<ArrayList<ServiceBean>>() {
                    @Override
                    public void onCompleted() {
                        //TODO 完成的回调
                    }

                    @Override
                    public void onError(Throwable e) {
                        //TODO 失败的回调
                    }

                    @Override
                    public void onNext(ArrayList<ServiceBean> serviceBeen) {
                        //TODO 成功的回调
                        Log.d(TAG, "onSuccessResult: " + serviceBeen.size());
                        mBeanList = serviceBeen;
                        getPeople();
                        if (isFirstClass) {
                            isFirstClass = false;
                        }
                    }
                });复制代码

• 代码重复太多，并且每次要回调三个方法，当时想着偷懒，只回调一个方法，向下面这样写

.subscribe(new Action1<ArrayList<ServiceBean>>() {
                    @Override
                    public void call(ArrayList<ServiceBean> serviceBeen) {
                        //TODO 成功的回调
                        Log.d(TAG, "onSuccessResult: " + serviceBeen.size());
                        mBeanList = serviceBeen;
                        getPeople();
                        if (isFirstClass) {
                            isFirstClass = false;
                        }
                    }
                });复制代码

• 这样写会报错，由于没有复写onError方法，好吧，那就只能向下面这样写了

.subscribe(new Action1<ArrayList<ServiceBean>>() {
                    @Override
                    public void call(ArrayList<ServiceBean> serviceBeen) {
                        //TODO 成功的回调
                        Log.d(TAG, "onSuccessResult: " + serviceBeen.size());
                        mBeanList = serviceBeen;
                        getPeople();
                        if (isFirstClass) {
                            isFirstClass = false;
                        }
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        //TODO 失败的回调
                    }
                });复制代码

认真的思考一下，咱们想要的是什么

• 生命周期统一管理
• 缓存进行处理,GET请求进行缓存，POST请求不缓存
• 只回调成功后的结果,错误以及异常统一处理

针对以上3点，对上述请求进行了改进

1.针对生命周期以及多余的代码，也很好解决，这些都是经过Observable来实现的，因此每次咱们建立一个Observable对象以后，统一进行处理

if (observable != null)
            observable.compose(subscriber.getActivity().bindToLifecycle())//绑定生命周期
                    .compose(subscriber.getActivity().bindUntilEvent(ActivityEvent.DESTROY))
                    .subscribeOn(Schedulers.io())//操做线程
                    .unsubscribeOn(Schedulers.io())//解绑线程
                    .observeOn(AndroidSchedulers.mainThread())//回调线程
                    .subscribe(subscriber);复制代码

2.关于缓存，咱们须要一个标记为，由于用户发起请求以前咱们是不知道是否进行缓存的，因此增长了一个方法getProxy(),经过传递布尔值来设置是否进行缓存

public RxUrl getProxy(boolean isCache) {
        RxUrl mRxUrl = null;
        if (isCache) {
            mRxUrl = getCacheRetrofit().create(RxUrl.class);
        } else {
            mRxUrl = getRetrofit().create(RxUrl.class);
        }
//若是不须要token值失效后自动刷新的需求，此处能够直接返回RxUrl
        return (RxUrl) Proxy.newProxyInstance(RxUrl.class.getClassLoader(), new Class<?>[]{RxUrl.class}, new ProxyHandler(mRxUrl, false));
    }复制代码

1. 很明显，若是直接复写Subscriber的成功或者失败的方法，最少也须要复写两个方法，因此须要把Subcriber单独抽取出来，只对其成功的方法进行回调，这个时候你可能想到了接口，是的，我最开始也是这么想的，可是若是用接口进行回调的话就必须复写该接口的全部方法，因此并不适合，咱们想要的结果是，成功方法必须回调，失败方法能够选择回调或者不回调，因此这个地方须要用到抽象类，代码以下:

回调的抽象类

public abstract class Callback<T> {

    public abstract void onSuccess(T t);

    public void onError(Throwable e) {
        Log.d("net_error---->", e.toString());
    }

}复制代码

自定义的Subcriber

@SuppressWarnings("unchecked")
public class RxSubscriber<T> extends Subscriber<T> {
    private SoftReference<Callback> rxListener;
    private SoftReference<RxAppCompatActivity> mActivity;
//构造方法传入当前的RxAppCompatActivity和回调的抽象类
    public RxSubscriber(RxAppCompatActivity rxAppCompatActivity, Callback<T> listener) {
        this.mActivity = new SoftReference(rxAppCompatActivity);
        this.rxListener = new SoftReference(listener);
    }

    @Override
    public void onStart() {
        //TODO 但是作一些初始化操做,好比说谈一个对话框或者进度条
    }

    @Override
    public void onNext(T t) {
        if (rxListener.get() != null) {
            rxListener.get().onSuccess(t);
        }
    }

    @Override
    public void onCompleted() {
        //TODO 请求完成时走此方法

    }

    @Override
    public void onError(Throwable e) {
        // TODO 请求发生错误时走此方法
        if (rxListener.get() != null) {
            rxListener.get().onError(e);
        }
    }
}复制代码

上面写了比较多，总结起来就是3个类

1. RxRequest:统一配置Observable，包括是否缓存，生命周期统一管理
2. RxSubscriber:能够统一处理加载进度条，回调网络请求结果
3. RequestManager:发送请求

最终的使用方法

HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("strDate", "2017-03-25");//构造参数
        Observable<OneBean> weather=RxRequest.getInstance().getProxy(false).postData(hashMap);//建立Observable对象
        RxSubscriber subscriber = new RxSubscriber(this, new Callback<OneBean>() {
            @Override
            public void onSuccess(OneBean oneBean) {
                tvData.setText(oneBean.getHpEntity().getStrContent());
            }
        });//建立Rxsubscrber对象
        RequestManager.getInstance().sendRequest(weather, subscriber);//发送请求复制代码

框架下载地址