写在最前面的话：送给还在迷茫看不懂的童鞋，跟着我一步步看，小白也能看懂，从而对整体有一个把握，分析的开始以基本使用为切入点，一步步深入。
1. 创建获取
RequestQueue对象
开始进入：：：Vollery # newRequestQueue()1
2
3
4
5
6
7
8
9
10
11
12
13
14
15public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
.....
if (stack == null) {
if (VERSION.SDK_INT >= 9) {
stack = new HurlStack();
} else {
stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
}
}
Network network = new BasicNetwork((HttpStack)stack);
RequestQueue queue = new RequestQueue(new NoCache(), network);
queue.start();
return queue;
}
看到我开始罗列代码了，不要慌，还好不长，在能力范围内:
刚开始就根据不同的Android 系统版本，创建不同的对象，我们先可以大概了解一下 HurlStack 和 HttpClientStack 是啥？
HurlStack.java1
2
3
4
5
6
7
8
9public class HurlStack implements HttpStack {
....
public HttpResponse performRequest(Request<?> request,
Map<String, String> additionalHeaders) {
....
URL parsedUrl = new URL(url);
HttpURLConnection connection = this.openConnection(parsedUrl, request);
....
}
HttpClientStack.java1
2
3
4
5
6
7
8
9public class HttpClientStack implements HttpStack {
protected final HttpClient mClient;
...
public HttpResponse performRequest(Request<?> request,
Map<String, String> additionalHeaders) {
....
return this.mClient.execute(httpRequest)
}
}
HttpStack.java1
2
3public interface HttpStack {
HttpResponse performRequest(Request<?> var1, Map<String, String> var2) ;
}
看到这里我们大概明白了，原来是根据不同的系统版本，确定最终选择进行的网络请求，那为什么大于9 用 HttpUrlConnection 小于9用 HttpClient 呢？在这里不过多介绍了，网上一搜就知道了。
Ok，那我们继续向下走，回到上面的代码，为了方便查看，我重新粘贴一份代码下来：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
.....
if (stack == null) {
if (VERSION.SDK_INT >= 9) {
stack = new HurlStack();
} else {
stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
}
}
//HttpStack 又一次被封装为Network接口类型
Network network = new BasicNetwork((HttpStack)stack);
RequestQueue queue = new RequestQueue(new NoCache(), network);
queue.start();
return queue;
}
Network.java1
2
3public interface Network {
NetworkResponse performRequest(Request<?> var1) throws VolleyError;
}
哦 原来是接口，它的实现类 BasicNetworkBasicNetwork.java1
2
3
4
5
6
7public class BasicNetwork implements Network {
//将网络请求的实例传入，方便后面的调用
public BasicNetwork(HttpStack httpStack) {
this(httpStack, new ByteArrayPool(DEFAULT_POOL_SIZE));
}
....
}
目前而止，那么它们之间的关系是啥样的呢，我画了一张图：
很清晰吧，目前我们先不考虑这个 BasicNetwork 类中干了什么，我们先根据代码的思路一步步向下走，保证我们整体主干不变，避免陷入只见树木不见森林的局势。
Ok，我们再次回到原来的代码：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
.....
if (stack == null) {
if (VERSION.SDK_INT >= 9) {
stack = new HurlStack();
} else {
stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
}
}
//HttpStack 又一次被封装为Network接口类型，
//创建BasicNetwork调用了构造方法是一个参数的
Network network = new BasicNetwork((HttpStack)stack);
//到这里了...........
//创建一个 请求队列 RequestQueue,并且在构造函数中，传入了两个
//参数，好，我们接下来就要去RequestQueue.java类中看一眼了。
RequestQueue queue = new RequestQueue(new NoCache(), network);
queue.start();
return queue;
}
RequestQueue.java1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17public RequestQueue(Cache cache, Network network) {
this(cache, network, 2);
}
public RequestQueue(Cache cache, Network network, int threadPoolSize) {
this(cache, network, threadPoolSize, new ExecutorDelivery(new Handler(Looper.getMainLooper())));
}
public RequestQueue(Cache cache, Network network, int threadPoolSize, ResponseDelivery delivery) {
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;
}
在构造方法中，传入一个Cache 对象，network 对象，默认初始化一个threadPoolSize = 2,还有一系列初始化操作.
Ok,再次返回我们之前的代码：1
2
3 ....
RequestQueue queue = new RequestQueue(new NoCache(), network);
queue.start();
RequestQueue#start() 方法了：1
2
3
4
5
6
7
8
9
10
11
12public 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();
}
}
这里又创建了一个 CacheDispatcher 类。调用四个参数的构造方法。并调用了 start() 方法。
接下来，我们就认识下 CacheDispatcher.java 类：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29//原来它是一个线程
public class CacheDispatcher extends Thread {
//缓存队列，用BlockingQueue 管理存储
private final BlockingQueue<Request<?>> mCacheQueue;
public CacheDispatcher(BlockingQueue<Request<?>> cacheQueue, BlockingQueue<Request<?>> networkQueue, Cache cache, ResponseDelivery delivery) {
//参数赋值
this.mCacheQueue = cacheQueue;
this.mNetworkQueue = networkQueue;
this.mCache = cache;
this.mDelivery = delivery;
}
//调用start 方法必定调用run 方法
public void run() {
.....
Process.setThreadPriority(10);
//这里初始化缓存，还记得我们之前默认传入了一个 NoCache 吗？
//这里Cache 是接口，子类有两种NoCache 和 DiskBasedCache两种
this.mCache.initialize();
//嵌套了好多循环啊......因为要不断去读取是否有任务嘛，没有的时候就一直等待
while(true) {
while(true) {
while(true) {
while(true) {
try {
// 表示从缓存队列中取出一个 Request, 那第一次肯定没有啊，就一直等待......
final Request<?> request = (Request)this.mCacheQueue.take();
.....这里我先省略了，因为还没真正到这一步
}
OK，返回到我们之前的操作：RequestQueue.java1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
private NetworkDispatcher[] mDispatchers ;
private static final int DEFAULT_NETWORK_THREAD_POOL_SIZE = 2;
public RequestQueue(Cache cache, Network network, int threadPoolSize, ResponseDelivery delivery) {
....
this.mDispatchers = new NetworkDispatcher[threadPoolSize];
....
}
public void start() {
this.stop();
this.mCacheDispatcher = new CacheDispatcher(this.mCacheQueue, this.mNetworkQueue, this.mCache, this.mDelivery);
this.mCacheDispatcher.start();
//到这里啦，
//从构造方法我们可以得知 mDispatchers.length = 2 ，上
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();
}
}
循环遍历生成2 个 NetworkDispatcher 对象，并将 NetworkDispatcher 对象存储在一个 mDispatchers 的数组中去了，最后调用了 start 方法。
Ok，那接下来我们就看下这个 NetworkDispatcher.java 类了。
NetworkDispatcher.java1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30public class NetworkDispatcher extends Thread {
// 网络请求队列
private final BlockingQueue<Request<?>> mQueue；
//对象初始化
public NetworkDispatcher(BlockingQueue<Request<?>> queue, Network network, Cache cache, ResponseDelivery delivery) {
this.mQueue = queue;
this.mNetwork = network;
this.mCache = cache;
this.mDelivery = delivery;
}
//既然是线程，调用 start 方法，必定调用 run 方法
public void run() {
Process.setThreadPriority(10);
//线程也是，既然要做网络请求，就要一直等待获取
while(true) {
Request request;
while(true) {
try {
// 从网络请求队列中获取任务，那一开始我们初始化肯定没东西，队列里没请求任务
request = (Request)this.mQueue.take();
break;
} catch (InterruptedException var4) {
if (this.mQuit) {
return;
}
}
}
.....底部代码我也省略了，因为都是获取到请求之后所做的处理
至此，对于RequestQueue 的初始化第一步我们完成了对它的了解，你明白了吗？ 下一篇我们针对 mQueue.add(request) 真正需要进行网络请求进行继续分析。如果这篇文章有帮助到你，给个赞就是我最大的鼓励了，比心💗。
