Volley源码学习笔记_RequestQueue和BasicNetWork

最新推荐文章于 2021-09-14 11:40:01 发布

哈哈哈哈哈哈_Y

最新推荐文章于 2021-09-14 11:40:01 发布

阅读量451

点赞数

分类专栏： Volley 文章标签：源码 volley

本文链接：https://blog.csdn.net/u010904027/article/details/72902308

版权

Volley 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1.开始

Volley也只是听过没用过，新接的项目里面请求用的是Volley，只能赶鸭子上架的看了些简单的使用。现在理解下源码。（ps:这里不涉及有关图片相关的部分pps：理解不对的地方请指出，灰常感谢）

2.Volley的使用

关于Volley的使用，比较简洁的。

  //首先创建请求队列
  RequestQueue requestQueue = Volley.newRequestQueue(Context);
  //创建一个request
  Request request=new Request() {...};
  //将request添加到请求队列中
  requestQueue.add(request);

下面根据上面的三行代码，来一步步的看相关的实现源码。

3.RequestQueue

我们先看 new RequestQueue的代码，它只传入了一个Context

 public static RequestQueue newRequestQueue(Context context) {
        return newRequestQueue(context, (HttpStack)null);
    }

 public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
        File cacheDir = new File(context.getCacheDir(), "volley");
        String userAgent = "volley/0";

        try {
            String network = context.getPackageName();
            PackageInfo queue = context.getPackageManager().getPackageInfo(network, 0);
            userAgent = network + "/" + queue.versionCode;
        } catch (NameNotFoundException var6) {
            ;
        }

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

        BasicNetwork network1 = new BasicNetwork((HttpStack)stack);
        RequestQueue queue1 = new RequestQueue(new DiskBasedCache(cacheDir), network1);
        queue1.start();
        return queue1;
    }

以上代码包含的内容还是很多的。主要是先根据VERSION.SDK_INT
来判断使用什么网络连接请求类。然后实例化一个BasicNetWork来进行网络交互请求。然后创建一个请求队列，传入一个DiskBasedCache，一个BasicNetwork，最后队列start。下面先看一下RequestQueue的构造函数。

   public RequestQueue(Cache cache, Network network, int threadPoolSize, ResponseDelivery delivery) {

       //下面这5个有的是直接在外面初始化的
        this.mSequenceGenerator = new AtomicInteger();
        this.mWaitingRequests = new HashMap();
        this.mCurrentRequests = new HashSet();
        this.mCacheQueue = new PriorityBlockingQueue();
        this.mNetworkQueue = new PriorityBlockingQueue();
        //这里
        this.mCache = cache;
        this.mNetwork = network;
        this.mDispatchers = new NetworkDispatcher[threadPoolSize];
        this.mDelivery = delivery;
    }

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

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

从下往上， this(cache, network, 4);这是的4就是线程数目，记得之前好像还是可以自己输入的现在默认是4个。这里有一个ExecutorDelivery，主要作用就是传递消息（response）,可以看到它的实现要传递一个Handler。这个后期再看。下面看一下RequestQueue的start()。

   public void start() {
        this.stop();
        this.mCacheDispatcher = new CacheDispatcher(this.mCacheQueue, this.mNetworkQueue, this.mCache, this.mDelivery);
        this.mCacheDispatcher.start();

        for(int i = 0; i < this.mDispatchers.length; ++i) {
            NetworkDispatcher networkDispatcher = new NetworkDispatcher(this.mNetworkQueue, this.mNetwork, this.mCache, this.mDelivery);
            this.mDispatchers[i] = networkDispatcher;
            networkDispatcher.start();
        }

    }

从上面可以看出，只要new了一个RequestQueue那么就会开启1个缓存线程，4个网络请求
线程。这就意味着一次最多只能并发5个线程，如果缓存线程没有命中，那么最多并发4个网
络请求线程。NetworkDispatcher基本就是从队列中获取请求，然后请求网络数据
（BasicNetWork）同时更新到UI线程。（ExecutorDelivery）。

既然是队列了，那他是如何addRequest的呢？

 public <T> Request<T> add(Request<T> request) {
        // Tag the request as belonging to this queue and add it to the set of current requests.
        request.setRequestQueue(this);
        synchronized (mCurrentRequests) {
            mCurrentRequests.add(request);
        }

        // Process requests in the order they are added.
        //先记着一个队列序号，先入先出
        request.setSequence(getSequenceNumber());
        request.addMarker("add-to-queue");

        // If the request is uncacheable, skip the cache queue and go straight to the network.
        //请求不用缓存就加入到网络请求队列中，但是这个值默认是true
        if (!request.shouldCache()) {
            mNetworkQueue.add(request);
            return request;
        }


//根据key值判断请求是否已经在重复请求队列，但是会发现最终都是要添加到这个队列里面的
        // Insert request into stage if there's already a request with the same cache key in flight.
        synchronized (mWaitingRequests) {
            String cacheKey = request.getCacheKey();
            if (mWaitingRequests.containsKey(cacheKey)) {
                // There is already a request in flight. Queue up.
                Queue<Request<?>> stagedRequests = mWaitingRequests.get(cacheKey);
                if (stagedRequests == null) {
                    stagedRequests = new LinkedList<>();
                }
                stagedRequests.add(request);
                mWaitingRequests.put(cacheKey, stagedRequests);
                if (VolleyLog.DEBUG) {
                    VolleyLog.v("Request for cacheKey=%s is in flight, putting on hold.", cacheKey);
                }
            } else {
                // Insert 'null' queue for this cacheKey, indicating there is now a request in
                // flight.
                mWaitingRequests.put(cacheKey, null);
                //添加到缓存队列里面去
                mCacheQueue.add(request);
            }
            return request;
        }
    }

RequestQueue的add方法，从这里我们可以看到四个参数 mWaitingRequests ，mCurrentRequests ，mCacheQueue ，mNetworkQueue。分别是重复请求队列，当前请求或者等待请求集合，缓存队列，网络请求队列，这里重复队列就是一个Map集合，key是cacheKey，就是getUrl。mCacheQueue ,mNetworkQueue是一个优先级队列。根据优先级来执行，同等优先级是无序的。
当mCacheQueue或者mNetworkQueue利用add方法添加请求之后，在运行的线程就会接收到请求（Cache线程接收到请求，会将相应的请求提那家到mNetworkQueue，这样在请求线程中就可以处理请求队列中的请求），从而去处理相对应的请求，最后将处理的结果由mDelivery来发送到主线程进行更新。

BasicNetWork的具体作用有：

1）对于已经有缓存的请求，添加其头部信息，如下：

    private void addCacheHeaders(Map<String, String> headers, Entry entry) {
        if(entry != null) {
            if(entry.etag != null) {
                headers.put("If-None-Match", entry.etag);
            }

            if(entry.serverDate > 0L) {
                Date refTime = new Date(entry.serverDate);
                headers.put("If-Modified-Since", DateUtils.formatDate(refTime));
            }

        }
    }

2）调用 HttpStack 对象去网络中获取数据，返回httpResonse 对象。

 httpResponse = this.mHttpStack.performRequest(request, e);

3）根据状态编码来返回不同的NetworkResponse对象

如304（未修改）就返回缓存中的数据，如果不是，则根据响应中的数据，重新构造一个NetworkResponse对象。

   if(networkResponse1 == 304) {
                    return new NetworkResponse(304, request.getCacheEntry().data, responseHeaders1, true);
                }
                 ...

  long requestLifetime = SystemClock.elapsedRealtime() - requestStart;
                this.logSlowRequests(requestLifetime, request, responseContents1, statusCode2);
                if(networkResponse1 >= 200 && networkResponse1 <= 299) {
                    return new NetworkResponse(networkResponse1, responseContents1, responseHeaders1, false);
                }
                ...
  NetworkResponse networkResponse = null;
                if(httpResponse == null) {
                    throw new NoConnectionError(var15);
                }

                int statusCode1 = httpResponse.getStatusLine().getStatusCode();
                VolleyLog.e("Unexpected response code %d for %s", new Object[]{Integer.valueOf(statusCode1), request.getUrl()});
                if(responseContents == null) {
                    throw new NetworkError(networkResponse);
                }

                networkResponse = new NetworkResponse(statusCode1, (byte[])responseContents, responseHeaders, false);
                if(statusCode1 != 401 && statusCode1 != 403) {
                    throw new ServerError(networkResponse);
                }

4）BasicNetwork实现了重试的机制

如果第一次从网络获取失败，默认会重新再尝试一次，如果失败，则会将Error返回，默认的实现类是DefaultRetryPolicy类。

   private static void attemptRetryOnException(String logPrefix, Request<?> request, VolleyError exception) throws VolleyError {
        RetryPolicy retryPolicy = request.getRetryPolicy();
        int oldTimeout = request.getTimeoutMs();

        try {
            retryPolicy.retry(exception);
        } catch (VolleyError var6) {
            request.addMarker(String.format("%s-timeout-giveup [timeout=%s]", new Object[]{logPrefix, Integer.valueOf(oldTimeout)}));
            throw var6;
        }

        request.addMarker(String.format("%s-retry [timeout=%s]", new Object[]{logPrefix, Integer.valueOf(oldTimeout)}));
    }

下面看一下3的内容

//具体代码就不贴了
   public NetworkResponse performRequest(Request<?> request) throws VolleyError {
   ....
}

public interface Network {
    NetworkResponse performRequest(Request<?> var1) throws VolleyError;
}

BasicNetwork是Network 的实现类。。Network 的方法只有一个performRequest（），参数是Request。用来获取网络请求到的数据，然后在NetworkDispatcher中被解析后通过ExecutorDelivery将请求结果传到UI线程。
这里有一段代码：

  byte[] responseContents1;
                if(httpResponse.getEntity() != null) {
                    responseContents1 = this.entityToBytes(httpResponse.getEntity());
                } else {
                    responseContents1 = new byte[0];
                }
 if(networkResponse1 >= 200 && networkResponse1 <= 299) {
                    return new NetworkResponse(networkResponse1, responseContents1, responseHeaders1, false);
                }

这是请求到数据的时候，然后在状态码返回200-299之间的时候创建一个NetworkResponse对象并将其data设置为获取到内容。除了在状态码304的时候，还有一个地方也创建了NetworkResponse对象。这里的responseContents是开始创建的一个空对象。

  networkResponse = new NetworkResponse(statusCode1, (byte[])responseContents, responseHeaders, false);
                if(statusCode1 != 401 && statusCode1 != 403) {
                    throw new ServerError(networkResponse);
                }

以上。不对的地方麻烦大家指出，非常感谢。