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));
    }

3. 很明显，如果直接复写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);//发送请求

框架下载地址