Android网络框架volley学习(七)调度器NetworkDispatcher简析

前一篇《Android网络框架volley学习(六)调度器CacheDispatcher简析》了解了关于缓存线程调度CacheDispatcher的工作原理,它里面会判断缓存是否存在、是否过期以及是否需要刷新等操作,如果不满足的话则需要加入到网络请求队列,从而让NetworkDispatcher去处理它。本篇我们继续来学习NetworkDispatcher实现过程,看看网络线程是如何处理请求的?

NetworkDispatcher

同样的,我们首先了解一下它的内部成员变量。

/** 请求队列 */
    private final BlockingQueue<Request<?>> mQueue;
    /** 执行网络请求的接口 */
    private final Network mNetwork;
    /** 缓存类接口 */
    private final Cache mCache;
    /** 结果分发 */
    private final ResponseDelivery mDelivery;

接着我们看下它的初始化过程,也就是构造函数。

 public NetworkDispatcher(BlockingQueue<Request<?>> queue,
            Network network, Cache cache, ResponseDelivery delivery) {
        mQueue = queue;
        mNetwork = network;
        mCache = cache;
        mDelivery = delivery;
    }

很简单,从前面我们得知,NetworkDispatcher其实也是一个线程,那么我们来看下它的run方法。

 @Override
    public void run() {
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        while (true) {
            try {
                processRequest();
            } catch (InterruptedException e) {
                // We may have been interrupted because it was time to quit.
                if (mQuit) {
                    return;
                }
            }
        }
    }

跟CacheDispatcher一样的逻辑,接着查看processRequest方法内部实现细节,由于这个方法实现过程代码比较长,我们一步一步进行分析。

  Request<?> request = mQueue.take();
   if (request.isCanceled()) {
                request.finish("network-discard-cancelled");
                request.notifyListenerResponseNotUsable();
                return;
   }

同样的,首先从网络请求队列中取出一条请求,判断它是否取消了,接着往下看。

 // Perform the network request.
 NetworkResponse networkResponse = mNetwork.performRequest(request);

执行了网络请求,然后解析网络请求结果到response

//判断是否是304(表示资源没有修改过)
if (networkResponse.notModified && request.hasHadResponseDelivered()) {
                request.finish("not-modified");
                request.notifyListenerResponseNotUsable();
                return;
            }

            // Parse the response here on the worker thread.
            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");
            }

            // Post the response back.
            request.markDelivered();
            mDelivery.postResponse(request, response);
            request.notifyListenerResponseReceived(response);

首先判断这个请求结果是否应该缓存,同时分发这个网络请求结果出去。到这里NetworkDispatcher都讲完了,但是,是不是一脸懵逼?讲的啥?里面还有很多东西没有讲到,我们接着分析。

执行网络请求

上面有行代码时执行网络请求的,

NetworkResponse networkResponse = mNetwork.performRequest(request);

具体是如何实现这个请求的呢?通过performRequest,它是

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

它是一个接口,我们需要知道它的实现类,我们通过查看volley的源码可以知道,它的实现类是BasicNetwork,接下来我们分析一下它的实现过程。

纵观的源码,我们可以看到其中有个成员变量

/**
     * @deprecated Should never have been exposed in the API. This field may be removed in a future
     *             release of Volley.
     */
    @Deprecated
    protected final HttpStack mHttpStack;

其实,HttpStack mHttpStack是实际的网络请求类,进去可以看到它是一个接口,它的实现类有两个

  1. HttpClientStack,基于Apache的HttpClient请求方式
  2. HurlStack,基于Java的HttpURLConnection请求方式

《Android网络框架volley学习(三)底层网络请求分析》我们可以了解到网络请求方式有两种,根据api是否大于9来判断使用哪种方式。

我们接着分析performRequest方法,

httpResponse = mBaseHttpStack.executeRequest(request, additionalRequestHeaders);
                int statusCode = httpResponse.getStatusCode();

                responseHeaders = httpResponse.getHeaders();
                // 首先判断请求资源是否被修改过
                if (statusCode == HttpURLConnection.HTTP_NOT_MODIFIED) {
                    Entry entry = request.getCacheEntry();
                    if (entry == null) {
                        return new NetworkResponse(HttpURLConnection.HTTP_NOT_MODIFIED, null, true,
                                SystemClock.elapsedRealtime() - requestStart, responseHeaders);
                    }
                    // Combine cached and response headers so the response will be complete.
                    List<Header> combinedHeaders = combineHeaders(responseHeaders, entry);
                    return new NetworkResponse(HttpURLConnection.HTTP_NOT_MODIFIED, entry.data,
                            true, SystemClock.elapsedRealtime() - requestStart, combinedHeaders);
                }

首先判断请求的内容是否被修改过,如果没有被修改过,再根据缓存中是否存在该结果,包装返回NetworkResponse。如果已经修改过的话,则获取请求结果,再次包装返回请求结果。

// Some responses such as 204s do not have content.  We must check.
                InputStream inputStream = httpResponse.getContent();
                if (inputStream != null) {
                  responseContents =
                          inputStreamToBytes(inputStream, httpResponse.getContentLength());
                } else {
                  // Add 0 byte response as a way of honestly representing a
                  // no-content request.
                  responseContents = new byte[0];
                }

                // if the request is slow, log it.
                long requestLifetime = SystemClock.elapsedRealtime() - requestStart;
                logSlowRequests(requestLifetime, request, responseContents, statusCode);

                if (statusCode < 200 || statusCode > 299) {
                    throw new IOException();
                }
                return new NetworkResponse(statusCode, responseContents, false,
                        SystemClock.elapsedRealtime() - requestStart, responseHeaders);

如果期间出错的话,则需要根据code来进行分别处理,包括


int statusCode;
                if (httpResponse != null) {
                    statusCode = httpResponse.getStatusCode();
                } else {
                    //网络有问题
                    throw new NoConnectionError(e);
                }
                VolleyLog.e("Unexpected response code %d for %s", statusCode, request.getUrl());
                NetworkResponse networkResponse;
                if (responseContents != null) {
                    networkResponse = new NetworkResponse(statusCode, responseContents, false,
                            SystemClock.elapsedRealtime() - requestStart, responseHeaders);
                    if (statusCode == HttpURLConnection.HTTP_UNAUTHORIZED ||
                            statusCode == HttpURLConnection.HTTP_FORBIDDEN) {
                        attemptRetryOnException("auth",
                                request, new AuthFailureError(networkResponse));
                    } else if (statusCode >= 400 && statusCode <= 499) {
                        // Don't retry other client errors.
                        throw new ClientError(networkResponse);
                    } else if (statusCode >= 500 && statusCode <= 599) {
                        if (request.shouldRetryServerErrors()) {
                            attemptRetryOnException("server",
                                    request, new ServerError(networkResponse));
                        } else {
                            throw new ServerError(networkResponse);
                        }
                    } else {
                        // 3xx? No reason to retry.
                        throw new ServerError(networkResponse);
                    }
                } else {
                    attemptRetryOnException("network", request, new NetworkError());
                }
  1. 如果根本就没有响应内容httpResponse==null,说明网络连接有问题(也就是说手机没有联网),自己抛出异常结束
  2. 302,301错误,说明资源被重定向,做简单的记录
  3. 401,403错误,身份验证错误,重试
  4. 302,301错误,重试

回顾一下,总结流程。

图片来自于

图片来自于Volley 源码解析

阅读更多
版权声明:本文为博主原创文章,转载请注明出处,联系作者:QQ:275137657 https://blog.csdn.net/lj188266/article/details/79169786
上一篇Android网络框架volley学习(六)调度器CacheDispatcher简析
下一篇Android网络框架volley学习(八)缓存Cache简析
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭