Volley的框架的终结篇

Volley的框架的终结篇

之前都是各个模块讲解，当然Volley其实也是各个模块分开了，职责分明，这样探索源码，可以各个突破，最后顺着使用流程去看一遍就会融汇贯通

使用

    RequestQueue mQueue = Volley.newRequestQueue(this);
    StringRequest stringRequest =
        new StringRequest("http://www.baidu.com", new Response.Listener<String>() {
          @Override public void onResponse(String response) {
            Log.d("TAG", response);
          }
        }, new Response.ErrorListener() {
          @Override public void onErrorResponse(VolleyError error) {
            Log.e("TAG", error.getMessage(), error);
          }
        });
    mQueue.add(stringRequest);

newRequestQueue()

    public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
        ...

        if (stack == null) {
            if (Build.VERSION.SDK_INT >= 9) {
                stack = new HurlStack();
            } else {
                stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
            }
        }

        Network network = new BasicNetwork(stack);

        RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
        queue.start();

        return queue;

这里看重点:

1.HttpStack

代码中根据版本选了，连接网络使用HttpConnection还是HttpClient

这一块要看细节的可以看我之前写的
Volley的框架解读一（Http的封装）
我简单的说一下吧,无论是HurlStack和HttpClientStack都实现了HttpStack，接口中有个performRequest()方法

performRequest():就是获取连接网络获取的所有内容，接着封装成一个实体类返回了.

2.Network

返回给谁了呢，就是它 BasicNetwork 他实现了NetWork，performRequest()中对HttpStack返回实体类，取出返回码，根据返回码又做了一些实体类赋值，然后就返回了实体类,
如果不太对Network理解的，可以看我之前写的 Volley的框架解读二（Http访问及处理）

3.RequestQueue

Network的返回值就是返回给他了，我们看构造方法

    private static final int DEFAULT_NETWORK_THREAD_POOL_SIZE = 4;

    public RequestQueue(Cache cache, Network network) {
        this(cache, network, DEFAULT_NETWORK_THREAD_POOL_SIZE);
    }

    public RequestQueue(Cache cache, Network network, int threadPoolSize) {
        this(cache, network, threadPoolSize,
                new ExecutorDelivery(new Handler(Looper.getMainLooper())));
    }

    public RequestQueue(Cache cache, Network network, int threadPoolSize,
            ResponseDelivery delivery) {
        mCache = cache;
        mNetwork = network;
        mDispatchers = new NetworkDispatcher[threadPoolSize];
        mDelivery = delivery;
    }

构造方法中，设置了缓存策略，Network，NetworkDispatcher(网络线程)核心线程为4，ResponseDelivery消息分发机制

接着我看start方法:

    public void start() {
        stop();  // Make sure any currently running dispatchers are stopped.
        // Create the cache dispatcher and start it.
        mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
        mCacheDispatcher.start();

        // Create network dispatchers (and corresponding threads) up to the pool size.
        for (int i = 0; i < mDispatchers.length; i++) {
            NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
                    mCache, mDelivery);
            mDispatchers[i] = networkDispatcher;
            networkDispatcher.start();
        }
    }

这里启动了缓存线程和4个网络线程,我们再看看其中线程中做了什么?

缓存线程

线程嘛，主要看run方法

    public void run() {
        ...
        //缓存初始化，会根据你缓存策略进行初始化
        mCache.initialize();
        while (true) {
            try {
                //获取请求
                final Request<?> request = mCacheQueue.take();
                request.addMarker("cache-queue-take");
            //请求取消了，直接跳过
                if (request.isCanceled()) {
                    request.finish("cache-discard-canceled");
                    continue;
                }
                Cache.Entry entry = mCache.get(request.getCacheKey());
        //如果为空直接进行网络请求
                if (entry == null) {
                    request.addMarker("cache-miss");
                    mNetworkQueue.put(request);
                    continue;
                }
        //如果已经请求过时了重新网络请求
                if (entry.isExpired()) {
                    request.addMarker("cache-hit-expired");
                    request.setCacheEntry(entry);
                    mNetworkQueue.put(request);
                    continue;
                }
                request.addMarker("cache-hit");
        //根据使用者实现的request子类，将返回的数据处理结果得到
                Response<?> response = request.parseNetworkResponse(
                        new NetworkResponse(entry.data, entry.responseHeaders));
                request.addMarker("cache-hit-parsed");
                if (!entry.refreshNeeded()) {
                    mDelivery.postResponse(request, response);
                } else {
                    request.addMarker("cache-hit-refresh-needed");
                    request.setCacheEntry(entry);
                    response.intermediate = true;
                    mDelivery.postResponse(request, response, new Runnable() {
                        @Override
                        public void run() {
                            try {
                                mNetworkQueue.put(request);
                            } catch (InterruptedException e) {
                                // Not much we can do about this.
                            }
                        }
                    });
                }

            } catch (InterruptedException e) {
                // We may have been interrupted because it was time to quit.
                if (mQuit) {
                    return;
                }
                continue;
            }
        }
    }

可以看出缓存线程，也就是对request中的缓存标识符识别后，进行处理，最后如果有缓存，就分发给了使用者 mDelivery.postResponse(request, response);

因为使用者都是继承request来得到访问内容的，可以猜想postResponse里肯定通过request把内容回调回去了，当然只是猜想还是得看源码

  @Override
    public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {
        request.markDelivered();
        request.addMarker("post-response");
        mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable));
    }


    private class ResponseDeliveryRunnable implements Runnable {
        private final Request mRequest;
        private final Response mResponse;
        private final Runnable mRunnable;

        public ResponseDeliveryRunnable(Request request, Response response, Runnable runnable) {
            mRequest = request;
            mResponse = response;
            mRunnable = runnable;
        }

        @SuppressWarnings("unchecked")
        @Override
        public void run() {
            if (mRequest.isCanceled()) {
                mRequest.finish("canceled-at-delivery");
                return;
            }
            if (mResponse.isSuccess()) {
                mRequest.deliverResponse(mResponse.result);
            } else {
                mRequest.deliverError(mResponse.error);
            }
            if (mResponse.intermediate) {
                mRequest.addMarker("intermediate-response");
            } else {
                mRequest.finish("done");
            }
            if (mRunnable != null) {
                mRunnable.run();
            }
       }
    }

终于在ResponseDeliveryRunnable中看了我们熟悉的两个方法deliverResponse,deliverError

网络线程

大家可以猜想，之前看的缓存线程，基本可以套用在网络线程中，大家就看看源码哈，代码都有注释

    public void run() {
        // 设置该线程的优先级
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        // 从网络请求队列中获取的请求
        Request<?> request;
        //会一直在网络请求队列中读取request  如果网络请求队列为空则等待
        while (true) {
            try {
                // 方法.take()是一个阻塞方法，如果网络队列中没有请求，那么会一直等待。直到获取一个请求
                request = mQueue.take();
            } catch (InterruptedException e) {
                // 如果该请求被interrupt了 那么就放弃该请求，开始获取下一个请求
                if (mQuit) {
                    return;
                }
                continue;
            }
            try {
                request.addMarker("network-queue-take");
                // network request. 如果该请求被取消了，那么就放弃当前请求 开始下一个请求
                if (request.isCanceled()) {
                    request.finish("network-discard-cancelled");
                    continue;
                }
                addTrafficStatsTag(request);
                // Perform the network request.
                // 访问网络，得到数据
                NetworkResponse networkResponse = mNetwork
                        .performRequest(request);
                request.addMarker("network-http-complete");
                //如果响应状态码是304（304表示该次响应返回值与上次没变化，也就是说可以使用上次的响应），并且该请求已经被分发了，那么就开始下一次请求
                if (networkResponse.notModified
                        && request.hasHadResponseDelivered()) {
                    request.finish("not-modified");
                    continue;
                }
                //将响应解析出来
                Response<?> response = request
                        .parseNetworkResponse(networkResponse);
                request.addMarker("network-parse-complete");
                // 写入缓存
                if (request.shouldCache() && response.cacheEntry != null) {
                    mCache.put(request.getCacheKey(), response.cacheEntry);
                    request.addMarker("network-cache-written");
                }
                //标记还请求已经被分配响应了
                request.markDelivered();
                mDelivery.postResponse(request, response);
            } catch (VolleyError volleyError) {
                //如果出现错误，那就传递错误信息
                parseAndDeliverNetworkError(request, volleyError);
            } catch (Exception e) {
                VolleyLog.e(e, "Unhandled exception %s", e.toString());
                mDelivery.postError(request, new VolleyError(e));
            }
        }
    }

整个Volley 就这样结束了，当然其中可以看到的是，代码中学到了很多东西，比如:

• 为了减少byte[]的创建及销毁的内存消耗，引入了缓存池
• 为了让使用者更大程度的，封装成自己的网络解析，把request抽象了，给使用者自己实现
• 同时引入了缓存线程，减少网络请求
• 代码中各个模块之间，职责分明，最后用组合的方法，形成一个新的功能