为什么要用Volley中的RequestFuture封装RxJava来用异步请求处理同步请求?

Posted callMeVita

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了为什么要用Volley中的RequestFuture封装RxJava来用异步请求处理同步请求?相关的知识,希望对你有一定的参考价值。

前几天健哥喊我研究一下RvJava,在网络请求用,更简洁更有条理,然后就会抽空研究研究,现在项目里网络库是Volley,就结合项目和网上的demo看,突然脑袋蹦出这个问题,现在看起来这个问题有一点蠢蠢的。

firstly,名词解释一下。

 

Volley是谷歌爸爸给咱们封装好了的网络请求库,帮我们封装了具体的请求,线程切换以及数据转换,适合短小多并发的网络请求。

Volley要主要用到的两个类:RequestQueueRequest

两个最基础的Request实现JsonObjectRequest和StringRequest,都是请求的作用,用以请求的“信物“”不同而已,所有的HTTP请求都是由这个类创建的,它封装了用于HTTP请求的主要参数。(这是异步网络请求,所以有Response Listener,Error Listener的回调)

  1. METHOD Type – GET, POST, PUT, DELETE
  2. URL
  3. Request data (HTTP Body)
  4. Successful Response Listener
  5. Error Listener

RequsetQueue:这是一个分发队列,用来取Requst并在工作线程中执行,如果cache中找到就从cache中获取response,没有就获取,然后将结果回传到UI线程。

然而·Volley作为优秀的网络请求库,是也可以完成同步网络请求,需要用到的类: RequestFuture。

(同步请求就是,打个比方喊你过来,你不过来,我就一直喊,不走了(线程阻塞在那),直到你过来,调用OnResponse,你要是超过我设定的时间一直不过来,我就调用OnError;异步请求就是,我喊了一声让你过来,然后我就走了,至于啥时候过来我就不管了,你过来了,我就回调onResponse ,你不过来,我就回调onError)

RequestFuture工作原理:

  1. 构造RequestFuture:RequestFuture<JSONObject> future = RequestFuture.newFuture();
  2. 构造volley请求的时候,将上面的对象传入请求中;JSONObjectRequest request=JSONObjectRequest(Request.Method.GET, Url,future,future,....);
  3. 将请求加入请求队列:    RequestManager.getRequestQueue().add(request);
  4. 随后调用RequestFuture.get方法,该方法会在当前线程阻塞
  5. get方法内部调用wait(time),在等待时间内还没有结果这抛出超时异常;(wait(0)是无限期等待)
  6. 在get的wait过程中,如果volley请求到来了,则会调用RequestFuture的onResponse方法,设置该对象中的private T mResult;  RequestFuture.get()会返回结果,同时调用notifyall(),唤醒等待中的线程,不在阻塞。
  7. 注意,因为该方法是会阻塞的,因此千万不要在UI线程中调用get方法!!因此需要在一个新线程中进行阻塞,这个交给RxJava实现吧。

 

 

RxJava :借用扔物线的话

RxJava 到底是什么

一个词:异步

RxJava 在 GitHub 主页上的自我介绍是 "a library for composing asynchronous and event-based programs using observable sequences for the Java VM"(一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库)。这就是 RxJava ,概括得非常精准。

然而,对于初学者来说,这太难看懂了。因为它是一个『总结』,而初学者更需要一个『引言』。

其实, RxJava 的本质可以压缩为异步这一个词。说到根上,它就是一个实现异步操作的库,而别的定语都是基于这之上的。

RxJava 好在哪

换句话说,『同样是做异步,为什么人们用它,而不用现成的 AsyncTask / Handler / XXX / ... ?』

一个词:简洁

异步操作很关键的一点是程序的简洁性,因为在调度过程比较复杂的情况下,异步代码经常会既难写也难被读懂。 android 创造的 AsyncTask 和Handler ,其实都是为了让异步代码更加简洁。RxJava 的优势也是简洁,但它的简洁的与众不同之处在于,随着程序逻辑变得越来越复杂,它依然能够保持简洁。

这是RxJava特性,具体移步  http://gank.io/post/560e15be2dca930e00da1083


好了,名词解释就到这。下面来回答问题,为什么要用Volley中的RequestFuture封装RxJava来用异步请求处理同步请求?

换一种思考,为什么不用Volley中的RequestFuture封装RxJava来用异步请求处理异步请求?听起来更蠢对不对,异步,开一个线程,异步处理再开一个线程,这样就开了两个线程,很浪费对不对。

为什么不用Volley中的RequestFuture封装RxJava来用同步请求异步处理请求?RxJava也可以实现同步的,观察者被观察者放一个线程里头。之前用Volley都是异步请求,就实现了我们想要的功能,为什么还要使用RxJava,还给同步了?我们用RxJava因为它的异步+有条理,物尽其用呀。

这个算反证法吧,所以我们用Volley中的RequestFuture封装RxJava来用异步请求处理同步请求。

 

RxJava+Volley

public class RxRequest {

    /**
     * 发送post请求
     *
     * @param url
     * @param target
     * @param <T>
     * @return
     */
    public static <T> Observable<T> post(String url, Class<?> target) {
        return request(url, target, Request.Method.POST, new DefaultRetryPolicy());
    }

    /**
     * 发送post请求
     *
     * @param url
     * @param target
     * @param <T>
     * @return
     */
    public static <T> Observable<T> post(String url, Class<?> target, RetryPolicy retryPolicy) {
        return request(url, target, Request.Method.POST, retryPolicy);
    }

    /**
     * 发送Get请求
     *
     * @param url
     * @param target
     * @param <T>
     * @return
     */
    public static <T> Observable<T> get(String url, Class<?> target) {
        return request(url, target, Request.Method.GET, new DefaultRetryPolicy());
    }

    /**
     * 发送Get请求
     *
     * @param url
     * @param target
     * @param <T>
     * @return
     */
    public static <T> Observable<T> get(String url, Class<?> target, RetryPolicy retryPolicy) {
        return request(url, target, Request.Method.GET, retryPolicy);
    }

    public static <T> Observable<T> request(String url, Class<?> target, int method, RetryPolicy retryPolicy) {

        final RequestFuture<T> requestFuture = RequestFuture.newFuture();

        final GsonRequest<T> request = new GsonRequest<T>(target, method, url, null, requestFuture, requestFuture);
        request.setRetryPolicy(retryPolicy);
        request.setTag(url);

        requestFuture.setRequest(request);//这是为了下面的requestFuture.isCancelled

        return Observable.create(new Observable.OnSubscribe<T>() {

            @Override
            public void call(Subscriber<? super T> subscriber) {
                try {
                    //只在被订阅后才进行网络请求处理
                    RequestManager.getRequestQueue().add(request);
                    if (!subscriber.isUnsubscribed() && !requestFuture.isCancelled()) {
                        subscriber.onNext(requestFuture.get());//阻塞,返回结果,唤醒
                        subscriber.onCompleted();
                    }
                } catch (Exception e) {
                    subscriber.onError(e);
                }
            }

        }).subscribeOn(Schedulers.io());//开io线程,网络请求
    }

    /**
     * 取消请求
     *
     * @param url
     */
    public static void cancel(final String url) {
        RequestManager.getRequestQueue().cancelAll(new RequestQueue.RequestFilter() {
            @Override
            public boolean apply(Request<?> request) {
                return request.getTag().equals(url);
            }
        });
    }
}

activity(或fragment中)

 RxRequest.<MyModel>post(url, MyModel.class)
            .observeOn(AndroidSchedulers.mainThread())//观察者在UI线程
            .subscribe(new Subscriber<MyModel>() { @Override public void onCompleted() { Log.i("RxRequest", "onCompleted"); } @Override public void onError(Throwable e) { Log.e("RxRequest", "onError", e); } @Override public void onNext(MyModel myModel) { Log.i("RxRequest", "onNext==>" + myModel); } });

 




以上是关于为什么要用Volley中的RequestFuture封装RxJava来用异步请求处理同步请求?的主要内容,如果未能解决你的问题,请参考以下文章

Android之使用Volley框架在ListView中加载大量图片

Android应用开发:网络工具——Volley

一起Talk Android吧(第三百三十六回: Android中的volley一)

如何处理 Android API 23 中的 volley(删除相关的 apache http 包)?

解决Volley中的JsonObjectRequest jsonRequest参数无法被服务端读取的问题

您将在 Android Studio 项目中的何处添加 volley 库?