Volley简介
众所周知,Volley是google在2013年开源的一款异步异步异步http网络请求库,采用Volley进行网络请求非常简单。那么怎样个异步法?最简单的解释就是:
使用Volley你不用再像原生的HttpUrlConnection一样new Thread(new runable());新开工作线程这些事Volley都帮你做了。
Volley为http请求提供了如下的保障:
- response缓存。Volley内部维护了一个cache,用来对网络请求的结果进行缓存,再次发起该请求时会首先访问cache,当请求内容和上次相同时会直接从cache返回数据,避免重复的网络请求。
- request请求队列,Volley会将通过request.add()方法添加的request放置在请求队列,并从该队列中逐一取出请求进行请求。并支持请求优先级的设置。
- response分发。Volley采用异步的请求方式,请求成功并获得返回值时会在工作线程中对结果进行解析,并将response分发到主线程,意味着在Volley的回调方法中,代码直接运行在主线程,方便了UI更新等操作。这一点和okHttp有很大区别,okHttp异步方式的回调仍然运行在工作线程。这样不同的实现也各有各的好处。
- 支持request的自定义,Volley原生request包括了JsonRequest、JsonArrayReuqest、ImageRequest和StringResquest四种,分别用于json对象、json数组以及字符串类型的返回值请求,除此以外,Volley允许继承Request类实现自己的请求,比如你可以实现返回一个JavaBean的请求。
Volley适合频繁但数据量不大的网络请求,例如常见API调用,并不适合大文件的下载。Volley将整个response加载到内存并进行操作(可以是解析等操作)大文件可能会引起OOM
官网对Volley的介绍
Volley简单使用
最简单Volley的使用包括三个步骤:
- 创建RequestQueue
- 创建Request
-
将Request添加到RequestQueue
RequestQueue requestQueue = Volley.newRequestQueue(context); StringRequest stringRequest = new StringRequest(Request.Method.GET, url, new Response.Listener<String>() { @Override public void onResponse(String response) { //这里可以更新UI } }, new Response.ErrorListener() { @Override public void onErrorResponse(VolleyError error) { } }); requestQueue.add(stringRequest);
本文的重点是分析Volley的工作流程,各种请求的具体使用可以参考以下链接:
郭霖教你学Volley
Volley原理解析
先来一张Volley工作流程图镇楼:
Volley中包括以下几种线程:
- 缓冲读取线程(cacheDispatcher)——用于从缓冲中获取数据(继承自Thread)
- 网络请求线程(networkDispatcher)——用于发送网络请求来获取数据(继承自Thread)
- response分发线程(mResponsePoster)——用于将请求结果(可能来自cache和网络)分发到主线程(Executor对象)
1.RequestQueue的创建
既然使用Volley首先创建的是RequestQueue对象,那我们就从Volley.newRequestQueue(context)方法开始。该静态方法通过调用重载的静态方法,内部调用构造方法创建一个requestQueue对象:
public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
//创建缓存
File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);
String userAgent = "volley/0";
try {
String packageName = context.getPackageName();
PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
userAgent = packageName + "/" + info.versionCode;
} catch (NameNotFoundException e) {
}
if (stack == null) {
//API9及以上则使用HttpUrlConnection
if (Build.VERSION.SDK_INT >= 9) {
stack = new HurlStack();
} else {
//小于9则使用HttpClient
// Prior to Gingerbread, HttpUrlConnection was unreliable.
stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
}
}
//用于后面的网络请求
Network network = new BasicNetwork(stack);
//根据设置的缓存目录创建请求队列
RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
//启动请求队列
queue.start();
return queue;
}
从上面的代码可以发现,Volley内部是采用HttpUrlConnection或者HttpClient进行网络请求的(HttpClient已经废弃不再维护)。
我们重点关注一下这一行代码:
RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
以上代码创建了一个新的请求队列。并传入DiskBasedCache(cacheDir)来根据相应目录初始化缓存。
跟踪上述构造方法,发现调用了另一个三个参数的构造方法:
public RequestQueue(Cache cache, Network network) {
//调用三个参数的构造方法
this(cache, network, DEFAULT_NETWORK_THREAD_POOL_SIZE);
}
DEFAULT_NETWORK_THREAD_POOL_SIZE是声明的常量=4,所以我们知道Volley的网络请求线程数量默认为4个。上述构造方法调用了四个参数的构造方法:
public RequestQueue(Cache cache, Network network, int threadPoolSize) {
//调用四个参数对的构造方法
this(cache, network, threadPoolSize,
new ExecutorDelivery(new Handler(Looper.getMainLooper())));
}
注意以上方法的最后一个参数,这是一个绑定了主线程handler的ExecutorDelivery对象,用处在后文进行说明
四个参数的构造方法的实现:
public RequestQueue(Cache cache, Network network, int threadPoolSize,
ResponseDelivery delivery) {
mCache = cache;
mNetwork = network;
mDispatchers = new NetworkDispatcher[threadPoolSize];
mDelivery = delivery;
}
这样requestqueue就创建完成,
2.网络请求的执行
创建的requestqueue.queue.start()方法在创建的最后一行得到了调用。
queue.start()的具体实现:
public void start() {
stop(); // 确保现有的dispatcher停止工作
// 创建cacheDispatcher并启动
mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
mCacheDispatcher.start();
//根据线程池(mDispatchers)的大小创建网络请求线程。
for (int i = 0; i < mDispatchers.length; i++) {
NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,mCache, mDelivery);
mDispatchers[i] = networkDispatcher;
//按创建顺序启动对应的线程
networkDispatcher.start();
}
}
正如代码的注释一样,先创建并启动缓存线程用来读取缓存内容,再创建网络请求线程用于网络请求。mDispatchers为线程数组,默认大小为4,networkDispatcher网络请求执行线程。
我们重点分析一下网络请求线程的创建:
NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,mCache, mDelivery);
我们着重关注一下mDelivery对象,它是一个绑定了主线程handler的ExecutorDelivery对象
由于NetworkDispatcher本身是一个线程,调用start()方式实际会执行它的run()方法,我们来到run()方法内部:
@Override
public void run() {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
while (true) {
long startTimeMs = SystemClock.elapsedRealtime();
Request<?> request;
try {
//从请求队列中取出网络请求
request = mQueue.take();
} catch (InterruptedException e) {
// We may have been interrupted because it was time to quit.
if (mQuit) {
return;
}
continue;
}
try {
request.addMarker("network-queue-take");
//判断请求是否取消,取消则不执行该请求
if (request.isCanceled()) {
request.finish("network-discard-cancelled");
continue;
}
addTrafficStatsTag(request);
// 发送网络请求
NetworkResponse networkResponse = mNetwork.performRequest(request);
...
// 在子线程解析返回结果
Response<?> response = request.parseNetworkResponse(networkResponse);
...
省略的代码用于请求成功的结果进行缓存
...
//将请求的结果发送出去
mDelivery.postResponse(request, response);
} catch (VolleyError volleyError) {
volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
parseAndDeliverNetworkError(request, volleyError);
} catch (Exception e) {
VolleyLog.e(e, "Unhandled exception %s", e.toString());
VolleyError volleyError = new VolleyError(e);
volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
mDelivery.postError(request, volleyError);
}
}
}
代码比较多,由于主要研究网络请求部分,上述代码的请求结果缓存部分我进行了省略,你可以自行查看源码。
上述代码的核心在于以下三个方法:
mNetwork.performRequest()
Response<?> response = request.parseNetworkResponse()
mDelivery.postResponse(request, response);
避免代码过多我就不贴源代码了,作用:
- mNetwork.performRequest()——最终调用HurlStack().performRequest()方法采用httpUrlConnection的方式进行网络请求。
- request.parseNetworkResponse()——根据parseNetworkResponse()的具体逻辑实现在子线程对结果进行解析(这也是自定义Request需要实现的方法之一,比如需要返回javaBean就需要该方法中进行解析)
- mDelivery.postResponse(request, response)——将解析结果分发到主线程
3.Response的分发
最后我们来看看Response的分发。
mDelivery是一个ExecutorDelivery对象,内部存在一个成员对象叫做mResponsePoster(为Executor类型),最终调用这个mResponsePoster.execute()方法对response进行分发。
具体过程如下:
mDelivery.postResponse(request, response)方法怎么把结果分发到主线程:
该方法实现如下,调用了重载的postResponse(request,
response, null)方法:
public void postResponse(Request<?> request, Response<?> response) {
postResponse(request, response, null);
}
源码如下:
public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {
request.markDelivered();
request.addMarker("post-response");
//执行分发
mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable));
}
mResponsePoster也是一个Executor对象,通过execute()方法来执行Runnable对象的run()方法:它的execute()方法实现如下:
public ExecutorDelivery(final Handler handler) {
// 采用handler.post()方法将runnable对象运行在主线程
mResponsePoster = new Executor() {
@Override
public void execute(Runnable command) {
handler.post(command);
}
};
}
可以看到这里使用了handler.post()来使得runnable对象运行在与该handler所绑定的线程中
那么这个handler是在哪里赋值的呢?
往上翻,那就是在前文中两次注明的mDelivery对象,它是一个绑定了主线程handler的ExecutorDelivery对象,所以这里的handler是和主线程绑定的,在分发response的时候,我们的回调方法最终会运行在主线程。
ResponseDeliveryRunnable类的run()方法部分代码实现如下:
// 分发请求结果或者错误消息
if (mResponse.isSuccess()) {
mRequest.deliverResponse(mResponse.result);
} else {
mRequest.deliverError(mResponse.error);
}
deliverResponse(mResponse.result)也是在自定义Request的时候可以覆盖的方法。在Volley自带的StringRequest类中,该方法实现如下:
@Override
protected void deliverResponse(String response) {
mListener.onResponse(response);
}
这里就调用了我们在使用Volley创建StringRequest对象时设置的监听器的onResponse(reponse)方法。然后就可以在改方法中更新UI了。
Volley用到线程池了吗?
直观地看来,Volley是没有用到线程池的,它采用的是一个默认长度为4的线程数组(名为mDispatcher),在具体的网络请求线程(networkDispatcher)的run()方法中,Volley采用了如下的结构:
public void run(){
while(true){
//从请求队列中取出请求
requestQueue.take();
...
}
}
这个死循环使得run()方法永远不会结束,对应的线程也就不会被销毁,而当requestQueue.take()没有获取到请求的时候(即请求队列已空),该线程就会被阻塞而暂时停止运行。有新的请求的时候又得到运行进而发送新的网络请求。
可以发现,Volley没有使用线程池来管理网络请求线程,而是采用死循环的方式来避免了不断地创建、销毁线程带来的开销,达到了和线程池同样的效果。
最后
这里只是简单梳理了一遍Volley的网络请求流程,对缓存部分没有作过多的讲解,若想了解更多,还请读者自行查看源码。
支持原创技术分享,您的鼓励将是我最大的动力! 赏支付宝打赏