美文网首页
Volley源码解析

Volley源码解析

作者: CSU_IceLee | 来源:发表于2018-03-28 16:32 被阅读7次
  1. 通过Volley.newReuqestQueue新建一个请求队列(VolleyQueue),在创建请求队列之后,会调用start()方法,在后台开启5个线程,一个是缓存线程,4个网络请求的线程。start()方法如下:
    public void start() {
        mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
        mCacheDispatcher.start();//启动缓存线程  父类是Thread

        // 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();//启动网络线程 父类是Thread
        }
    }

上面的mCacheQueue,mNetworkQueue都是阻塞队列,作用在下文可以体现。

  1. 当我们往队列中加入request的时候,会检查request是否可以被缓存,默认情况下是可以的,如果用户设置了不可以被缓存,那么会直接将request加入到网络请求的队列当中(mNetworkQueue)。

  2. 如果可以被缓存,且如果没有相同的request正在请求,那么会将request加入到缓存队列,并在一个Hashmap中加入该Request的key,value为null。如果在Request请求的过程中,有相同的Request到来,那么会将这些新的Request通过链表连接,放入到Hashmap的value中。等待正在请求的Request完成之后,会将这些相同的Request全部取出,加入到缓存队列。
    add()方法代码如下:

public <T> Request<T> add(Request<T> request) {
        request.setRequestQueue(this);//保存VolleyQueue对象 request完成之后会进行回调
        synchronized (mCurrentRequests) {
            mCurrentRequests.add(request);//加入到正在请求的Request集合
        }

        if (!request.shouldCache()) {
            mNetworkQueue.add(request);//request不支持缓存   直接添加到网络请求队列 
            return request;
        }

        // 支持缓存
        synchronized (mWaitingRequests) {
            String cacheKey = request.getCacheKey();
            //mWaitingRequests就是上面提到的那个Hashmap
            if (mWaitingRequests.containsKey(cacheKey)) {//含有key  说明有正在请求的Request
                Queue<Request<?>> stagedRequests = mWaitingRequests.get(cacheKey);
                if (stagedRequests == null) {
                    stagedRequests = new LinkedList<Request<?>>();
                }
                stagedRequests.add(request);//之后key相同的Request用链表串起来
                mWaitingRequests.put(cacheKey, stagedRequests);
            } else {
                mWaitingRequests.put(cacheKey, null);//第一次value为null
                mCacheQueue.add(request);//新的request添加到缓存队列
            }
            return request;
        }
    }
  1. 缓存线程会不断从缓存队列中取出request,并查看是否已经有了缓存,如果有缓存并且缓存还没有过期,则会将response分发到主线程中进行回调,采用的是handler机制发送到主线程
    缓存线程(CacheDispatcher)的run方法:
    public void run() {
        mCache.initialize();//初始化缓存
        Request<?> request;
        while (true) {
            request = null;
            try {
                // 从缓存队列取request 如果没有request  会阻塞
                //典型的生产者  消费者模型   
                request = mCacheQueue.take(); 
            } catch (InterruptedException e) {
                if (mQuit) {
                    return;
                }
                continue;
            }
            try {
                // If the request has been canceled, don't bother dispatching it.
                if (request.isCanceled()) {
                    request.finish("cache-discard-canceled");//完成request
                    continue;
                }

                // Attempt to retrieve this item from cache.
                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;
                }

                // 能到达这步说明  缓存可用
                Response<?> response = request.parseNetworkResponse(
                        new NetworkResponse(entry.data, entry.responseHeaders));

                if (!entry.refreshNeeded()) {
                    // 缓存不需要更新  直接分派缓存的response就好
                    mDelivery.postResponse(request, response);
                } else {
                    request.setCacheEntry(entry);

                    response.intermediate = true;

                    // 缓存需要刷新 将结果分派给用户 并重新添加到网络请求队列
                    final Request<?> finalRequest = request;
                    mDelivery.postResponse(request, response, new Runnable() {
                        @Override
                        public void run() {
                            try {
                                mNetworkQueue.put(finalRequest);//重新添加到网络请求队列
                            } catch (InterruptedException e) {
                                // Not much we can do about this.
                            }
                        }
                    });
                }
            } catch (Exception e) {
                VolleyLog.e(e, "Unhandled exception %s", e.toString());
            }
        }
    }
  1. 如果缓存过期了,那么会将request加入到网络请求队列之中。网络请求线程会从网络请求队列中取出request,进行网络请求,请求完成之后会将结果进行缓存,并将结果传回主线程
public void run() {
         Request<?> request;
        while (true) {
            request = null;
            try {
                // 从请求队列里面取request
                request = mQueue.take();
            } catch (InterruptedException e) {
                if (mQuit) {
                    return;
                }
                continue;
            }

            try {
                if (request.isCanceled()) {
                    request.finish("network-discard-cancelled");//完成request
                    continue;
                }
                // Perform the network request.
                NetworkResponse networkResponse = mNetwork.performRequest(request);
                if (networkResponse.notModified && request.hasHadResponseDelivered()) {
                    request.finish("not-modified");
                    continue;
                }

                // 解析Response
                Response<?> response = request.parseNetworkResponse(networkResponse);
                request.addMarker("network-parse-complete");

                // 如果可以  将缓存保存起来.
                if (request.shouldCache() && response.cacheEntry != null) {
                    mCache.put(request.getCacheKey(), response.cacheEntry);
                }

                request.markDelivered();
                mDelivery.postResponse(request, response);//分派结果
            } catch (VolleyError volleyError) {
                volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
                parseAndDeliverNetworkError(request, volleyError);
            } catch (Exception e) {
                VolleyLog.e(e, "Unhandled exception %s", e.toString());
                VolleyError volleyError = new VolleyError(e);
                volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
                mDelivery.postError(request, volleyError);
            }
        }
    }

6.request完成的时候将保存在hashmap中的具有相同key的request取出来,全部加入到缓存队列,由于刚刚才完成对request的请求,所以缓存一般都是有效的,所以会直接把response分发给各个request对应的回调函数。
Request的finish方法:

void finish(final String tag) {
        if (mRequestQueue != null) {
            mRequestQueue.finish(this);//VolleyQueue的finish方法
            onFinish();
        }
        ······
    }

VolleyQueue的finish方法:

<T> void finish(Request<T> request) {
        // Remove from the set of requests currently being processed.
        synchronized (mCurrentRequests) {
            mCurrentRequests.remove(request);//从正在请求的集合移出已完成的request对象
        }
        synchronized (mFinishedListeners) {
          for (RequestFinishedListener<T> listener : mFinishedListeners) {
            listener.onRequestFinished(request);
          }
        }

        if (request.shouldCache()) {//request能够被缓存才需要进行下面的判断
            synchronized (mWaitingRequests) {
                String cacheKey = request.getCacheKey();
                Queue<Request<?>> waitingRequests = mWaitingRequests.remove(cacheKey);
                if (waitingRequests != null) {
                    //将具有相同key的request添加到缓存队列
                    mCacheQueue.addAll(waitingRequests);
                }
            }
        }
    }
  1. 缓存是存在本地的,默认缓存大小是5M,如果缓存满了,会通过FIFO算法,将老的缓存进行删除。

相关文章

  • 每日一题:Volley源码问题分析

    每日一题:Volley源码问题分析 学习推荐_Volley源码解析 面试率: ★★★☆☆ 面试提醒 Volley是...

  • Volley

    Android Volley完全解析(四),带你从源码的角度理解Volley

  • 【源码解析】 Volly

    【源码解析】 Volley的用法及源码解析 前言 Volley是谷歌在2013年I/O大会上推出的新的网络请求框架...

  • Volley 源码解析及对 Volley 的扩展(三)

    在 Volley 源码解析及对 Volley 的扩展系列的第二篇文章中对 Volley 的部分源码进行了分析,也知...

  • Volley源码解析

    Volley是一款轻量级的网络访问框架,适合小批量的数据传输。Volley的使用通过newRequestQueue...

  • Volley源码解析

    源码下载地址:https://github.com/code-study/android-volley-analy...

  • Volley源码解析

    Volley作为轻量级网络请求框架已经被广泛使用,这篇文章就从源码角度深层次了解Volley的构成,立足于熟练使用...

  • Volley源码解析

    抽时间看了下Volley的源码,感觉这个框架还是很不错的,这里对其源码进行分析。 GitHub链接 主要从以下几个...

  • Volley源码解析

    Volley已是老牌的网络请求库了(虽然也就3岁不到),虽然是Google官方的库,但是目前OkHttp才正是大行...

  • Volley源码解析

    通过Volley.newReuqestQueue新建一个请求队列(VolleyQueue),在创建请求队列之后,会...

网友评论

      本文标题:Volley源码解析

      本文链接:https://www.haomeiwen.com/subject/ljcucftx.html