码迷，mamicode.com
首页 > 其他好文 > 详细

volley介绍04

时间：2016-03-24 19:58:45      阅读：337      评论：0      收藏：0      [点我收藏+]

标签：

-------------------------------------------------------------------------------

转载：http://blog.csdn.net/crazy__chen/article/details/46490635

-------------------------------------------------------------------------------

上一篇文章给大家说明了Request<T>的内部结构，对于这个类而言，volley让我们关注的主要请求获得响应以后，怎么根据自己的需要解析响应，然后在主线程中回调监听器的方法，至于是怎么获得响应的，线程又是怎么开启的，都跟Request无关。

前面已经提到，Request会放在队列里面等待线程的提取，RequestQueue类作为volley的核心类，可以说是连接请求与响应的桥梁。另外，RequestQueue类作为一个集合，还给我们统一管理请求带来更大的方便，这样的思想是很值得我们学习的。

android设计上，也有使用队列这种形式的设计，一个比较典型的例子，就是handler,loop,message的实现。具体大家可以参考这篇文章blog.csdn.net/crazy__chen/article/details/44889479

下面从源码角度看RequestQueue类，首先当然是属性

 

[java] view plain copy
 
  1. /** 
  2.  * A request dispatch queue with a thread pool of dispatchers. 
  3.  *  
  4.  * Calling {@link #add(Request)} will enqueue the given Request for dispatch, 
  5.  * resolving from either cache or network on a worker thread, and then delivering 
  6.  * a parsed response on the main thread. 
  7.  * 一个拥有线程池的请求队列 
  8.  * 调用add()分发，将添加一个用于分发的请求 
  9.  * worker线程从缓存或网络获取响应，然后将该响应提供给主线程 
  10.  */  
  11. public class RequestQueue {  
  12.   
  13.     /**  
  14.      * Callback interface for completed requests. 
  15.      * 任务完成的回调接口  
  16.      */  
  17.     public static interface RequestFinishedListener<T> {  
  18.         /** Called when a request has finished processing. */  
  19.         public void onRequestFinished(Request<T> request);  
  20.     }  
  21.   
  22.     /**  
  23.      * Used for generating monotonically-increasing sequence numbers for requests. 
  24.      * 使用原子类，记录队列中当前的请求数目  
  25.      */  
  26.     private AtomicInteger mSequenceGenerator = new AtomicInteger();  
  27.   
  28.     /** 
  29.      * Staging area for requests that already have a duplicate request in flight.<br> 
  30.      * 等候缓存队列，重复请求集结map,每个queue里面都是相同的请求 
  31.      * <ul> 
  32.      *     <li>containsKey(cacheKey) indicates that there is a request in flight for the given cache 
  33.      *          key.</li> 
  34.      *     <li>get(cacheKey) returns waiting requests for the given cache key. The in flight request 
  35.      *          is <em>not</em> contained in that list. Is null if no requests are staged.</li> 
  36.      * </ul> 
  37.      * 如果map里面包含该请求的cachekey，说明已经有相同key的请求在执行 
  38.      * get(cacheKey)根据cachekey返回对应的请求 
  39.      */  
  40.     private final Map<String, Queue<Request<?>>> mWaitingRequests =  
  41.             new HashMap<String, Queue<Request<?>>>();  
  42.   
  43.     /** 
  44.      * The set of all requests currently being processed by this RequestQueue. A Request 
  45.      * will be in this set if it is waiting in any queue or currently being processed by 
  46.      * any dispatcher. 
  47.      * 队列当前拥有的所以请求的集合 
  48.      * 请求在队列中，或者正被调度，都会在这个集合中 
  49.      */  
  50.     private final Set<Request<?>> mCurrentRequests = new HashSet<Request<?>>();  
  51.   
  52.     /**  
  53.      * The cache triage queue. 
  54.      * 缓存队列  
  55.      */  
  56.     private final PriorityBlockingQueue<Request<?>> mCacheQueue =  
  57.         new PriorityBlockingQueue<Request<?>>();  
  58.   
  59.     /**  
  60.      * The queue of requests that are actually going out to the network. 
  61.      * 网络队列，有阻塞和fifo功能  
  62.      */  
  63.     private final PriorityBlockingQueue<Request<?>> mNetworkQueue =  
  64.         new PriorityBlockingQueue<Request<?>>();  
  65.   
  66.     /**  
  67.      * Number of network request dispatcher threads to start. 
  68.      * 默认用于调度的线程池数目  
  69.      */  
  70.     private static final int DEFAULT_NETWORK_THREAD_POOL_SIZE = 4;  
  71.   
  72.     /**  
  73.      * Cache interface for retrieving and storing responses. 
  74.      * 缓存  
  75.      */  
  76.     private final Cache mCache;  
  77.   
  78.     /**  
  79.      * Network interface for performing requests. 
  80.      * 执行请求的网络  
  81.      */  
  82.     private final Network mNetwork;  
  83.   
  84.     /** Response delivery mechanism. */  
  85.     private final ResponseDelivery mDelivery;  
  86.   
  87.     /**  
  88.      * The network dispatchers. 
  89.      * 该队列的所有网络调度器  
  90.      */  
  91.     private NetworkDispatcher[] mDispatchers;  
  92.   
  93.     /**  
  94.      * The cache dispatcher. 
  95.      * 缓存调度器  
  96.      */  
  97.     private CacheDispatcher mCacheDispatcher;  
  98.   
  99.     /** 
  100.      * 任务完成监听器队列 
  101.      */  
  102.     private List<RequestFinishedListener> mFinishedListeners =  
  103.             new ArrayList<RequestFinishedListener>();  


属性很多，而且耦合的类也比较多，我挑重要的讲，这里大家只要先记住某个属性是什么就可以，至于它的具体实现我们先不管

 

1，首先看List<RequestFinishedListener> mFinishedListeners任务完成监听器队列，这个队列保留了很多监听器，这些监听器都是监听RequestQueue请求队列的，而不是监听单独的某个请求。RequestQueue中每个请求完成后，都会回调这个监听队列里面的所有监听器。这是RequestQueue的统一管理的体现。

2，AtomicInteger mSequenceGenerator原子类，对java多线程熟悉的朋友应该知道，这个是为了线程安全而创造的类，不了解的朋友，可以把它认识是int类型，用于记录当前队列中的请求数目

3，PriorityBlockingQueue<Request<?>> mCacheQueue缓存队列，用于存放向请求缓存的request,线程安全，有阻塞功能，也就是说当队列里面没有东西的时候，线程试图从队列取请求，这个线程就会阻塞

4,PriorityBlockingQueue<Request<?>> mNetworkQueue网络队列，用于存放准备发起网络请求的request，功能同上

5,CacheDispatcher mCacheDispatcher缓存调度器,继承了Thread类,本质是一个线程，这个线程将会被开启进入一个死循环，不断从mCacheQueue缓存队列取出请求，然后去缓存Cache中查找结果

6，NetworkDispatcher[] mDispatchers网络调度器数组，继承了Thread类，本质是多个线程，所以线程都将被开启进入死循环，不断从mNetworkQueue网络队列取出请求，然后去网络Network请求数据

7，Set<Request<?>> mCurrentRequests记录队列中的所有请求，也就是上面mCacheQueue缓存队列与mNetworkQueue网络队列的总和，用于统一管理

8，Cache mCache缓存对象，面向对象的思想，把缓存看成一个实体

9，Network mNetwork网络对象，面向对象的思想，把网络看成一个实体

10,ResponseDelivery mDelivery分发器，就是这个分发器，负责把响应发给对应的请求，分发器存在的意义之前已经提到了，主要是为了耦合更加送并且能在主线程中操作UI

11，Map<String, Queue<Request<?>>> mWaitingRequests等候缓存队列，重复请求集结map,每个queue里面都是相同的请求。为什么需要这个map呢？map的key其实是request的url，如果我们有多个请求的url都是相同的，也就是说请求的资源是相同的，volley就把这些请求放入一个队列，在用url做key将队列放入map中。

因为这些请求都是相同的，可以说结果也是相同的。那么我们只要获得一个请求的结果，其他相同的请求，从缓存中取就可以了。

所以等候缓存队列的作用就是，当其中的一个request获得响应，我们就将这个队列放入缓存队列mCacheQueue中，让这些request去缓存获取结果就好了。

这是volley处理重复请求的思路。

 

其实看懂上面的属性就可以了解RequestQueue类的作用，大家结合上面的属性，看一下流程图技术分享

 

ok，我们还是从构造函数开始看起吧

 

[java] view plain copy
 
  1. /** 
  2.      * Creates the worker pool. Processing will not begin until {@link #start()} is called. 
  3.      * 创建一个工作池，在调用start()方法以后，开始执行 
  4.      * @param cache A Cache to use for persisting responses to disk 
  5.      * @param network A Network interface for performing HTTP requests 
  6.      * @param threadPoolSize Number of network dispatcher threads to create 
  7.      * @param delivery A ResponseDelivery interface for posting responses and errors 
  8.      */  
  9.     public RequestQueue(Cache cache, Network network, int threadPoolSize,  
  10.             ResponseDelivery delivery) {  
  11.         mCache = cache;//缓存，用于保留响应到硬盘  
  12.         mNetwork = network;//网络接口，用于执行http请求  
  13.         mDispatchers = new NetworkDispatcher[threadPoolSize];//根据线程池大小，创建调度器数组  
  14.         mDelivery = delivery;//一个分发接口，用于响应和错误  
  15.     }  
  16.   
  17.     /** 
  18.      * Creates the worker pool. Processing will not begin until {@link #start()} is called. 
  19.      * 
  20.      * @param cache A Cache to use for persisting responses to disk 
  21.      * @param network A Network interface for performing HTTP requests 
  22.      * @param threadPoolSize Number of network dispatcher threads to create 
  23.      */  
  24.     public RequestQueue(Cache cache, Network network, int threadPoolSize) {  
  25.         this(cache, network, threadPoolSize,  
  26.                 new ExecutorDelivery(new Handler(Looper.getMainLooper())));  
  27.     }  

对于RequestQueue来说，必须有的参数是缓存，网络，分发器，网络线程的数目

 

对应上面的属性可以知道，原来这些东西都是外部传进来的，参照本专栏的开篇，可以知道，是在Volley这个类里面传进来的，同时在外部，我们也是通过Volley.newRequestQueue()方法来创建并且开启queue队列的。

 

紧接着来看start()方法，这个方法用于启动队列

 

[java] view plain copy
 
  1. /** 
  2.      * Starts the dispatchers in this queue. 
  3.      */  
  4.     public void start() {  
  5.         stop();  //保证当前所有运行的分发停止 Make sure any currently running dispatchers are stopped.  
  6.         // Create the cache dispatcher and start it.  
  7.         //创建新的缓存调度器，并且启动它  
  8.         mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);  
  9.         mCacheDispatcher.start();  
  10.   
  11.         // Create network dispatchers (and corresponding threads) up to the pool size.  
  12.         //创建网络调度器,并且启动它们  
  13.         for (int i = 0; i < mDispatchers.length; i++) {  
  14.             NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,  
  15.                     mCache, mDelivery);  
  16.             mDispatchers[i] = networkDispatcher;  
  17.             networkDispatcher.start();  
  18.         }  
  19.     }  


可以看到，所谓启动队列，就是创建了CacheDispatcher缓存调度器，和mDispatchers[]网络调度器数组，根据前面的介绍我们知道，它们都是线程，所以start()方法里面，其实就是调用了它们的start()方法。也就是说RequestQueue启动的本质，是这些调度器的启动，这些调度器启动以后，会进入死循环，不断从队列中取出request来进行数据请求。

 

由于Dispatcher调度器的数目有限(是根据我们给构造方法传入的参数threadPoolSize决定的)，意味着Volley框架，同时在执行数据请求的线程数目是有限的，这样避免了重复创建线程所带来的开销，同时可能会带来效率的下降。

所以threadPoolSize对不同的应用，设置的大小大家不同，大家要根据自己项目实际情况，经过测试来确定这个值。

 

说完开启，我们再来看RequestQueue的关闭

 

[java] view plain copy
 
  1. /** 
  2.      * Stops the cache and network dispatchers. 
  3.      * 停止调度器(包括缓存和网络) 
  4.      */  
  5.     public void stop() {  
  6.         if (mCacheDispatcher != null) {  
  7.             mCacheDispatcher.quit();  
  8.         }  
  9.         for (int i = 0; i < mDispatchers.length; i++) {  
  10.             if (mDispatchers[i] != null) {  
  11.                 mDispatchers[i].quit();  
  12.             }  
  13.         }  
  14.     }  

对比开启，其实stop()的本质也是关闭所有的调度器，调用了它们的quit()方法，至于这个方法做的是什么，很容易想到，是把它们内部while循环的标志设成false

 

 

再来看add()方法，这方法用于将request加入队列，也是一个非常重要方法

 

[java] view plain copy
 
  1. /** 
  2.      * Adds a Request to the dispatch queue. 
  3.      * @param request The request to service 
  4.      * @return The passed-in request 
  5.      * 向请求队列添加请求 
  6.      */  
  7.     public <T> Request<T> add(Request<T> request) {  
  8.         // Tag the request as belonging to this queue and add it to the set of current requests.  
  9.         request.setRequestQueue(this);//为请求设置其请求队列  
  10.         synchronized (mCurrentRequests) {  
  11.             mCurrentRequests.add(request);  
  12.         }  
  13.   
  14.         // Process requests in the order they are added.  
  15.         request.setSequence(getSequenceNumber());//设置请求序号  
  16.         request.addMarker("add-to-queue");  
  17.   
  18.         // If the request is uncacheable, skip the cache queue and go straight to the network.  
  19.         //如果该请求不缓存，添加到网络队列  
  20.         if (!request.shouldCache()) {  
  21.             mNetworkQueue.add(request);  
  22.             return request;  
  23.         }  
  24.         //如果该请求要求缓存  
  25.         // Insert request into stage if there‘s already a request with the same cache key in flight.  
  26.         synchronized (mWaitingRequests) {  
  27.             String cacheKey = request.getCacheKey();  
  28.             if (mWaitingRequests.containsKey(cacheKey)) {  
  29.                 // There is already a request in flight. Queue up.  
  30.                 //如果已经有一个请求在工作，则排队等候  
  31.                 Queue<Request<?>> stagedRequests = mWaitingRequests.get(cacheKey);  
  32.                 if (stagedRequests == null) {  
  33.                     stagedRequests = new LinkedList<Request<?>>();  
  34.                 }  
  35.                 stagedRequests.add(request);  
  36.                 mWaitingRequests.put(cacheKey, stagedRequests);  
  37.                 if (VolleyLog.DEBUG) {  
  38.                     VolleyLog.v("Request for cacheKey=%s is in flight, putting on hold.", cacheKey);  
  39.                 }  
  40.             } else {  
  41.                 // Insert ‘null‘ queue for this cacheKey, indicating there is now a request in  
  42.                 // flight.  
  43.                 //为该key插入null,表明现在有一个请求在工作  
  44.                 mWaitingRequests.put(cacheKey, null);  
  45.                 mCacheQueue.add(request);  
  46.             }  
  47.             return request;  
  48.         }  
  49.     }  

对于一个request而言，首先它会被加入mCurrentRequests，这是用于request的统一管理

 

然后，调用shouldCache()判断是从缓存中取还是网络请求，如果是网络请求，则加入mNetworkQueue，然后改方法返回

如果请求缓存，根据mWaitingRequests是否已经有相同的请求在进行，如果是，则将该request加入mWaitingRequests

如果不是，则将request加入mCacheQueue去进行缓存查询

 

到目前为止，我们知道了调度器会从队列里面拿请求，至于具体是怎么请求的，我们还不清楚。这也体现了volley设计的合理性，通过组合来分配各个职责，每个类的职责都比较单一。

我们提到，RequestQueue的一个重要作用，就是对request的统一管理，其实所谓的管理，更多是对request的关闭，下面我来看一下这些方法

 

[java] view plain copy
 
  1. /** 
  2.      * Called from {@link Request#finish(String)}, indicating that processing of the given request 
  3.      * has finished. 
  4.      * 在request类的finish()方法里面，会调用这个方法，说明该请求结束 
  5.      * <p>Releases waiting requests for <code>request.getCacheKey()</code> if 
  6.      *      <code>request.shouldCache()</code>.</p> 
  7.      */  
  8.     public <T> void finish(Request<T> request) {  
  9.         // Remove from the set of requests currently being processed.  
  10.         synchronized (mCurrentRequests) {//从当前请求队列中移除  
  11.             mCurrentRequests.remove(request);  
  12.         }  
  13.         synchronized (mFinishedListeners) {//回调监听器  
  14.           for (RequestFinishedListener<T> listener : mFinishedListeners) {  
  15.             listener.onRequestFinished(request);  
  16.           }  
  17.         }  
  18.   
  19.         if (request.shouldCache()) {//如果该请求要被缓存  
  20.             synchronized (mWaitingRequests) {  
  21.                 String cacheKey = request.getCacheKey();  
  22.                 Queue<Request<?>> waitingRequests = mWaitingRequests.remove(cacheKey);//移除该缓存  
  23.                 if (waitingRequests != null) {//如果存在缓存等候队列  
  24.                     if (VolleyLog.DEBUG) {  
  25.                         VolleyLog.v("Releasing %d waiting requests for cacheKey=%s.",  
  26.                                 waitingRequests.size(), cacheKey);  
  27.                     }  
  28.                     // Process all queued up requests. They won‘t be considered as in flight, but  
  29.                     // that‘s not a problem as the cache has been primed by ‘request‘.  
  30.                     // 处理所有队列中的请求                      
  31.                     mCacheQueue.addAll(waitingRequests);//  
  32.                 }  
  33.             }  
  34.         }  
  35.     }  


finish()用于表示某个特定的request完成了,只有将要完成的request传进来就好了，然后会在各个队列中移除它

 

这里需要注意，一个request完成以后，会将waitingRequests里面所有相同的请求，都加入到mCacheQueue缓存队列中，这就意味着，这些请求从缓存中取出结果就好了，这样就避免了频繁相同网络请求的开销。这也是Volley的亮点之一。

 

然后我们再来看一些取消方法

 

[java] view plain copy
 
  1. /** 
  2.      * A simple predicate or filter interface for Requests, for use by 
  3.      * {@link RequestQueue#cancelAll(RequestFilter)}. 
  4.      * 一个简单的过滤接口,在cancelAll()方法里面被使用 
  5.      */  
  6.     public interface RequestFilter {  
  7.         public boolean apply(Request<?> request);  
  8.     }  
  9.   
  10.     /** 
  11.      * Cancels all requests in this queue for which the given filter applies. 
  12.      * @param filter The filtering function to use 
  13.      * 根据过滤器规则，取消相应请求 
  14.      */  
  15.     public void cancelAll(RequestFilter filter) {  
  16.         synchronized (mCurrentRequests) {  
  17.             for (Request<?> request : mCurrentRequests) {  
  18.                 if (filter.apply(request)) {  
  19.                     request.cancel();  
  20.                 }  
  21.             }  
  22.         }  
  23.     }  
  24.   
  25.     /** 
  26.      * Cancels all requests in this queue with the given tag. Tag must be non-null 
  27.      * and equality is by identity. 
  28.      * 根据标记取消相应请求 
  29.      */  
  30.     public void cancelAll(final Object tag) {  
  31.         if (tag == null) {  
  32.             throw new IllegalArgumentException("Cannot cancelAll with a null tag");  
  33.         }  
  34.         cancelAll(new RequestFilter() {  
  35.             @Override  
  36.             public boolean apply(Request<?> request) {  
  37.                 return request.getTag() == tag;  
  38.             }  
  39.         });  
  40.     }  


上面的设计可以说是非常巧妙的，为了增加取消的灵活性，创建了一个RequestFilter来自定义取消request的规则

 

在cancelAll(RequestFilter filter)方法里面，我们传入过滤器，就可以根据需要取消我想要取消的一类request,这种形式类似文件遍历的FileFilter

而这种形式，volley还为我们提供了一个具体的实现cancelAll(final Object tag)，来根据标签取消request，这里我们也就明白了request<T>类中mTag属性的用处了

可以说volley处处都体现了设计模式的美感。

 

Ok,RequestQueue介绍到这里，就介绍了整个的基本结构，剩下的困惑，是CacheDispatcher，networkDispatcher怎么从队列里面取出request的问题了，但是这些问题跟队列的关系没有那么紧，也就是说具体实现的任务，又交到了这两个类的身上，总而言之，这里也体现了单一责任原则。

接下来的文章，将会分类讲述这两个功能的实现。

volley介绍04

标签：

原文地址：http://www.cnblogs.com/aprz512/p/5316718.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！