Volley源码分析

虽然在2017年,volley已经是一个逐渐被淘汰的框架,但其代码短小精悍,网络架构设计巧妙,还是有很多值得学习的地方。

第一篇文章,分析了请求队列的代码,请求队列也是我们使用Volley的关键一步。

第二篇文章会分析Dispatcher

RequestQueue

创建RequestQueue对象的方式是采用如下的代码:

RequestQueue queue = Volley.newRequestQueue(getApplicationContext());

该队列是用来发起Http请求。主要看newRequestQueue方法

该方法的核心实现是2个参数的方法

newRequestQueue(Context context, HttpStack stack)

该方法做的事情如下:

  1. 创建一个CacheDir目录
  2. 创建一个userAgent,默认是volly/0,实际是包名 + 版本代码。如果出异常,userAgent就是默认值
  3. 初始化stack,如果是Android2.3一下 就用HttpClientStack创建对象,HttpClientStack是用HttpClient实现的。如果是Android2.3以上,就用HurlStack创建对象。后面我们在分析这个类的作用。
  4. 用创建好的stack去初始化NetWork对象,即 Network network = new BasicNetwork(stack); 用创建好的CacheDir去初始化DiskBasedCache对象,从而完成RequestQueue对象的初始化,RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
  5. 调用queue对象的start方法。

下面,我们看一下HttpStack的作用,以及DiskBasedCache和NetWork的作用,最后看一下start方法做了什么。

HttpStack是一个接口,该接口只有两个实现类,一个是HttpClientStack,另一个是HulStack。我们先不看具体的实现类,只看接口方法的声明。

 HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
throws IOException, AuthFailureError;

该方法的作用是用来真正进行网络请求的,具体用那种http实现类去请求,就分成了HttpClient以及HttpUrl。

再看NetWork接口,该接口只有一个实现类,BasicNetWork,我们还是先不看具体的实现类,只看接口的方法声明:

NetworkResponse performRequest(Request<?> request) throws VolleyError;

该方法的说明是执行一个指定的Request。

最后再看DiskBasedCache的功能。该类是Cache的一个具体的实现类,该类的功能是用缓存的文件存在硬盘中,默认的硬盘大小是5M。

上面的几个接口的功能都说完了,通过其实现类的对象最终构造了RequestQueue。接下来我们看一下构造器方法的执行。

RequestQueue的成员变量以及方法

我们先看一下RequestQueue的成员变量都有什么:

  • mSequenceGenerator 该类型为AtomicInteger,其功能是统计请求的个数,采用原子类的整形。
  • mWaitingRequests 该类型是一个HashMap,其功能是存储request,key是cachekey。存储的quest是重复的request。
  • mCurrentRequests 该类型是一个HashSet,其功能是存储request,该request能被放入的条件是当前正在被分派或者在等待。
  • mCacheQueue 该类型是PriorityBlockingQueue,其功能是存储缓存的队列。
  • mNetworkQueue 该类型是PriorityBlockingQueue,其功能是正在进行工作的队列
  • DEFAULT_NETWORK_THREAD_POOL_SIZE 默认的分派器的线程 初始值为4
  • mCache 该类型是Cache 功能是存储响应报文的对象response
  • mNetWork 该类型是NetWork 功能是进行网络请求。
  • mDelivery 该类型是ResponseDelivery,其功能是分派response
  • mDispatchers 该类型是NetworkDispatcher[] 其功能是NetWork分派器
  • mCacheDispatcher 该类型是CacheDispatcher[] 其功能是Cache分派器

下面我们继续看构造方法:

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

无论几个参数的构造方法,最终都会执行这个。上面在 new RequestQueue中,我们的传入的构造方法只有Cache和NetWork对象,这样的话,threadPoolSize默认就是4,而delivery就是 new ExecutorDelivery(new Handler(Looper.getMainLooper()))

关于这个ExecutorDelivery这个后面在分析。

下面,我们主要看RequestQueue的几个关键方法:

  • start
  • stop
  • cancel
  • finsh
  • add

stop方法

    public void stop() {
if (mCacheDispatcher != null) {
mCacheDispatcher.quit();
}
for (final NetworkDispatcher mDispatcher : mDispatchers) {
if (mDispatcher != null) {
mDispatcher.quit();
}
}
}

stop方法的全部代码非常少,主要的做的事情如下:

  1. 如果CacheDispatcher不为空,则调用quit方法退出他。
  2. 如果NetWorkDispatcher不为空,则调用quit方法退出他。

关键就在于quit方法。

quit方法的代码如下:

    public void quit() {
mQuit = true;
interrupt();
}

CacheDispatcher是继承与Thread。quit方法的作用是设置一个退出的标志位,并且调用interrupt方法,这样在run方法执行的过程中,由于线程已经中断,会执行catch语句块的内容,检查标志位,直接return。

下面是去掉了与自身功能相关的代码以后,剩下的部分。可以看出是很标准的线程退出写法。

public void run() {
//执行初始化的操作,省略掉
while (true) {
try {
//执行业务代码,省略掉
} catch (InterruptedException e) {
// We may have been interrupted because it was time to quit.
if (mQuit) {
return;
}
}
}
}

stop的方法分析完毕

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();
}
}

start方法比较简洁,因此我在这里放出全部的方法源码。start方法主要做了以下几件事情。

  1. 调用stop方法停止了正在运行的dispatchers。
  2. 创建CacheDispatcher,并且启动它。
  3. 根据初始化的线程数量创建NetworkDispatcher,并启动他。

stop方法上面已经分析了,就不在说了,先调用stop的目的就是先停止已经启动的dispatcher。

创建CacheDispather,NetWorkDispatcher,他们其实就是一堆线程,调用他们的start方法。关于他们的分析,后面在具体介绍。

cancel方法

cancel方法实际上是cancalAll方法,但实际上最终都会调用cancelAll(RequestFilter filter) filter的作用实际上是过滤出要取消的request。然后调用request.cancel。

关于request类,这个放到后面的分析。

finish方法


<T> void finish(Request<T> request) {
// Remove from the set of requests currently being processed.
synchronized (mCurrentRequests) {
mCurrentRequests.remove(request);
}
synchronized (mFinishedListeners) {
for (RequestFinishedListener<T> listener : mFinishedListeners) {
listener.onRequestFinished(request);
}
} if (request.shouldCache()) {
synchronized (mWaitingRequests) {
String cacheKey = request.getCacheKey();
Queue<Request<?>> waitingRequests = mWaitingRequests.remove(cacheKey);
if (waitingRequests != null) {
if (VolleyLog.DEBUG) {
VolleyLog.v("Releasing %d waiting requests for cacheKey=%s.",
waitingRequests.size(), cacheKey);
}
// Process all queued up requests. They won't be considered as in flight, but
// that's not a problem as the cache has been primed by 'request'.
mCacheQueue.addAll(waitingRequests);
}
}
}
}

finish方法是一个泛型方法,该finish方法执行了以下几个事情:

  1. 从CurrentRequest中移除掉该request.
  2. 调用finishListener
  3. 判断该request是否需要缓存,对需要缓存的request,将其他放到CacheQueue。

从上面的成员变量说明上,可以看出CurrentRequst实际上存储正在分派或者执行的request,对于finish自然是从该队列中移除。

     /** Callback interface for completed requests. */
public interface RequestFinishedListener<T> {
/** Called when a request has finished processing. */
void onRequestFinished(Request<T> request);
}

该接口的目的是提供一个request结束以后回调的接口。

判断request是否需要缓存,可以通过setShouldCache设置,然后从mWaitingReuqests中移除该key对应的队列,然后将队列加入cacheQueue。也就说,如果waitingQueue中还存在一样的request,则全部移除掉。

add方法

add方法是添加request的方法,其全部的代码如下:

     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.
if (!request.shouldCache()) {
mNetworkQueue.add(request);
return request;
} // 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<Request<?>>();
}
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;
}
}

将request关联到当前的requestQueue,然后mCurrentRequeue添加添加该request,request设置加入队列的次序,判断该request是否需要缓存,如果不需要缓存,就直接加入netWorkQueue中,等待被执行。

如果需要缓存,就先判断该WaitingRequest中是否有该request,如果有就得到该cacheKey对应的队列,把该request加进去,如果没有,就创建一个stagedRequests,将它加进去。然后将stagedRequests放入WaitiingRequest中。如果没有cacheKey,waitingRequest就插入一个key为cacheKey,value为null的值进入,然后将request加入cacheQueue。

至此,RequestQueue的部分就分析完了,其主要的功能是根据传入的Request来决定将该Request加入到那个Queue中,然后在通过Dispatcher进行调度。

Volley源码分析一的更多相关文章

  1. Volley源码分析(2)----ImageLoader

    一:imageLoader 先来看看如何使用imageloader: public void showImg(View view){ ImageView imageView = (ImageView) ...

  2. Volley源码分析(一)RequestQueue分析

    Volley源码分析 虽然在2017年,volley已经是一个逐渐被淘汰的框架,但其代码短小精悍,网络架构设计巧妙,还是有很多值得学习的地方. 第一篇文章,分析了请求队列的代码,请求队列也是我们使用V ...

  3. Volley 源码分析

    Volley 源码分析 图片分析 要说源码分析,我们得先看一下官方的配图: 从这张图中我们可以了解到 volley 工作流程: 1.请求加入优先队列 2.从缓存调度器中查看是否存在该请求,如果有(没有 ...

  4. Android Volley源码分析

    今天来顺手分析一下谷歌的volley http通信框架.首先从github上 下载volley的源码, 然后新建你自己的工程以后 选择import module 然后选择volley. 最后还需要更改 ...

  5. Volley源码分析

    取消请求的源码分析: public void cancelAll(RequestFilter filter) { synchronized (mCurrentRequests) { for (Requ ...

  6. [Android]Volley源码分析(五)

    前面几篇通过源码分析了Volley是怎样进行请求调度及请求是如何被实际执行的,这篇最后来看下请求结果是如何交付给请求者的(一般是Android的UI主线程). 类图:

  7. [Android]Volley源码分析(三)

    上篇看了关于Request的源码,这篇接着来看下RequestQueue的源码. RequestQueue类图:

  8. [Android]Volley源码分析(二)

    上一篇介绍了Volley的使用,主要接触了Request与RequestQueue这两个类,这篇就来了解一下这两个类的具体实现. Request类图:

  9. Volley源码分析(四)NetWork与ResponseDelivery工作原理

    这篇文章主要分析网络请求和结果交付的过程. NetWork工作原理 之前已经说到通过mNetWork.performRequest()方法来得到NetResponse,看一下该方法具体的执行流程,pe ...

随机推荐

  1. poj2739尺取法+素数筛

    Some positive integers can be represented by a sum of one or more consecutive prime numbers. How man ...

  2. Java面试小试题

    面试是我们每个人都要经历的事情,大部分人且不止一次,这里给大家总结最新的2016年面试题,让大家在2017年找工作时候能够事半功倍. 1 Switch能否用string做参数? a.在 Java 7 ...

  3. 分针网——每日分享: jquery选择器的用法

    jQuery选择器是jQuery库的一大特色,用这些选择器不但可以省去繁琐的JavaScript 书写方式,还可以节省时间和效率,正是有这些jQuery选择器,才让我们更容易的操作JavaScript ...

  4. js快速去除数组重复项

    function unique1(arr) { var tmp = new Array(); tmp.push(arr[0]); for(var i=0;i<arr.length;i++) { ...

  5. 【网站管理1】_dede织梦后台如何发布文章

    对于新手可能不了解,dede织梦后台是如何发文章的.下面说下我的经验. 发布文章步骤 1.打开浏览器,推介谷歌,360极速浏览器,火狐浏览器,输入网站后台网址   出现如下图登入界面 2.输入账号密码 ...

  6. JavaScript ,Python,java,C#,Go系列算法之【插入排序篇】

    常见的内部排序算法有:插入排序.希尔排序.选择排序.冒泡排序.归并排序.快速排序.堆排序.基数排序等.用一张图概括: 插入排序 插入排序(英语:Insertion Sort)是一种简单直观的排序算法. ...

  7. NSA永恒之蓝病毒,如何通过360工具修复?

    简介: NSA武器库的公开被称为是网络世界"核弹危机",其中有十款影响Windows个人用户的黑客工具,包括永恒之蓝.永恒王者.永恒浪漫.永恒协作.翡翠纤维.古怪地鼠.爱斯基摩卷. ...

  8. [刷题]算法竞赛入门经典 3-10/UVa1587 3-11/UVa1588

    书上具体所有题目:http://pan.baidu.com/s/1hssH0KO 题目:算法竞赛入门经典 3-10/UVa1587:Box 代码: //UVa1587 - Box #include&l ...

  9. java容器类

    一.  容器类: 下图摘自<Java编程思想>,很好地展示了整个容器类的结构. 由上图可知,容器类库可分为两大类,各自实现了Collection接口和Map接口,下面就常见的类进行一下分类 ...

  10. 从.Net版本演变看String和StringBuild性能之争

    在C#中string关键字的映射实际上指向.NET基类System.String.System.String是一个功能非常强大且用途非常广泛的基类,所以我们在用C#string的时候实际就是在用.NE ...