Volley是Google推出的一个网络请求库,已经被放到了Android源码中,地址在这里,先看使用方法
RequestQueue mRequestQueue = Volley.newRequestQueue(context); JsonObjectRequest req = new JsonObjectRequest(URL, null, new Response.Listener<JSONObject>() { @Override public void onResponse(JSONObject response) { try { VolleyLog.v("Response:%n %s", response.toString(4)); } catch (JSONException e) { e.printStackTrace(); } } }, new Response.ErrorListener() { @Override public void onErrorResponse(VolleyError error) { VolleyLog.e("Error: ", error.getMessage()); } }); mRequestQueue.add(req);
详细的使用方法就不说了,网上很多,可以看下这个,这里只大概介绍一下Volley的工作方法,就从上面的例子开始。
我们接触到的Volley的核心就两个,从名字就可以看出其用途。
前面我们看到RequestQueue是通过Volley的方法newRequestQueue获得的,Volley类的唯一作用就是获取RequestQueue的实例,而我们完全可以自己new RequestQueue,不知道为什么不把这两个类合并了。
/** * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it. * * @param context A {@link Context} to use for creating the cache dir. * @param stack An {@link HttpStack} to use for the network, or null for default. * @return A started {@link RequestQueue} instance. */ 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) { if (Build.VERSION.SDK_INT >= 9) { stack = new HurlStack(); } else { // Prior to Gingerbread, HttpUrlConnection was unreliable. // See: http://android-developers.blogspot.com/2011/09/androids-http-clients.html stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent)); } } Network network = new BasicNetwork(stack); RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network); queue.start(); return queue; } /** * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it. * * @param context A {@link Context} to use for creating the cache dir. * @return A started {@link RequestQueue} instance. */ public static RequestQueue newRequestQueue(Context context) { return newRequestQueue(context, null); }
在newRequestQueue里出现了几个重要的概念,首先可以看到newRequestQueue有一个重载方法,接收一个HttpStack的实例,HttpStack只有一个方法:performRequest,用来执行网络请求并返回HttpResponse,如果不传这个参数就根据API Level自己选择:
从这两个类的名字就大概知道了它们的区别了:HurlStack内部使用HttpURLConnection执行网络请求,HttpClientStack内部使用HttpClient执行网络请求,至于为什么么这样,可以自备梯子看这篇文章。
Network是请求网络的接口,只有一个实现类BasicNetwork,只有一个方法performRequest,执行Request返回NetworkResponse。
Network和HttpStack接口都只有一个方法,从方法的名字就可以看出它们的区别,Network.performRequest收Request参数返回om.android.volley.NetworkResponse,HttpStack.performRequest返回org.apache.http.HttpResponse,层次更低,所以应该是Network.performRequest中调用HttpStack.performRequest执行实际的请求,并将HttpStack.performRequest返回的org.apache.http.HttpResponse封装成com.android.volley.NetworkResponse返回。
Volley中使用Cache接口的子类DiskBasedCache做缓存,这是一个文件缓存,Cache接口有一个initialize方法用来初始化缓存,这个方法可能会执行耗时操作,需要在后台线程中执行,看DiskBasedCache可以知道,当它将缓存写到文件时,在文件的头部写了一些Header信息,在initialize时就会将这些Header信息读入内存中。
在Request类中有一个方法叫parseNetworkResponse,Request的子类会覆写这个方法解析网络请求的结果,在这个方法中会调用
return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
返回Response<T>,并通过HttpHeaderParse.parseCacheHeaders解析Cache.Entity,即生成缓存对象,在parseaCheHeaders中会根据网络请求结果中的Header中的Expires、Cache-Control等信息判断是否需要缓存,如果不需要就返回null不缓存。
当对请求做了缓存后,没网的情况下也可以得到数据。
Cache还有一个子类叫NoCache,get方法返回Null,其他方法都是空的,所以使用NoCache就表示不用缓存。
public RequestQueue(Cache cache, Network network, int threadPoolSize) {
this(cache, network, threadPoolSize, new ExecutorDelivery(new Handler(Looper.getMainLooper()))); } /** * Creates the worker pool. Processing will not begin until {@link #start()} is called. * * @param cache A Cache to use for persisting responses to disk * @param network A Network interface for performing HTTP requests */ public RequestQueue(Cache cache, Network network) { this(cache, network, DEFAULT_NETWORK_THREAD_POOL_SIZE); } 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(); } }
RequestQueue是请求队列,负责分发请求,取缓存或读网络,所以其构造函数中需要一个Cache对象和一个Network对象,还有一个ResponseDelivery对象用于派发结果。
新建RequestQueue后要调用它的start方法,在start中会新建一个CacheDispatcher和几个NetworkDispatcher分别处理缓存与网络请求
通过RequestQueue的add方法添加请求:
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; } }
add方法有以下几个步骤:
RequestQueue.add的任务就是这些,可以看到,它并没有执行任何实际的请求操作,包括判断缓存与请求网络,直正的操作是接下来要说的两个类执行的。
mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
在RequestQueue.add方法中,如果使用缓存直接就将Request放入缓存队列mCacheQueue中了,使用mCacheQueue的位置就是CacheDispatcher,CacheDispatcher的构造函数中传入了缓存队列mCacheQueue、网络队列mNetworkQueue、缓存对象mCache及结果派发器mDelivery。
CacheDispatcher继承自Thread,当被start后就执行它的run方法,代码不贴了,主要完成以下工作:
response.intermediate = true; // Post the intermediate response back to the user and have // the delivery then forward the request along to the network. mDelivery.postResponse(request, response, new Runnable() { @Override public void run() { try { mNetworkQueue.put(request); } catch (InterruptedException e) { // Not much we can do about this. } } });
NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork, mCache, mDelivery);
NetworkDispatcher的工作方法同CacheDispatcher一样,继承自Thread,当被start后,不停地从mNetworkQueue取请求,然后通过Network接口请求网络。
当拿到请求结果后,如果服务器返回304(自上次请求后结果无变化)并且结果已经通过缓存派发了(即这次是读了缓存后的Refresh),那么什么也不做,否则调用Request的parseNetworkResponse解析请求结果,如果需要进行缓存,并派发结果
派发请求结果的接口,有一个子类ExecutorDelivery执行实际操作,构造ExecutorDelivery的对象时需要一个Handler对象,当向ExecutorDelivery请求派发结果时会向这个Handler post消息。
Request表示一个请求,支持四种优先级:LOW、NORMAL、HIGH、IMMEDIATE,主要有以下几个方法:
StringRequest将结果转换成了String并Deliver至Response.Listener
@Override protected void deliverResponse(String response) { mListener.onResponse(response); } @Override protected Response<String> parseNetworkResponse(NetworkResponse response) { String parsed; try { parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers)); } catch (UnsupportedEncodingException e) { parsed = new String(response.data); } return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response)); }
JsonRequest<T>
可以在发送请求时同时发送一个JSONObject参数,覆写了getBody
@Override public byte[] getBody() { try { return mRequestBody == null ? null : mRequestBody.getBytes(PROTOCOL_CHARSET); } catch (UnsupportedEncodingException uee) { VolleyLog.wtf("Unsupported Encoding while trying to get the bytes of %s using %s", mRequestBody, PROTOCOL_CHARSET); return null; } }
mRequestBody是构造函数里传进来的一个String,一般是JSONObject.toString()。
继承自JSONRequest<T>,将请求结果解析成JSONObject
public JsonObjectRequest(int method, String url, JSONObject jsonRequest, Listener<JSONObject> listener, ErrorListener errorListener) { super(method, url, (jsonRequest == null) ? null : jsonRequest.toString(), listener, errorListener); } @Override protected Response<JSONObject> rkResponse(NetworkResponse response) { try { String jsonString = new String(response.data, HttpHeaderParser.parseCharset(response.headers)); return Response.success(new JSONObject(jsonString), HttpHeaderParser.parseCacheHeaders(response)); } catch (UnsupportedEncodingException e) { return Response.error(new ParseError(e)); } catch (JSONException je) { return Response.error(new ParseError(je)); } }
JsonArrayRequest
同JsonObjectRequest一样,继承自JSONRequest<T>,只是把结果解析成JSONArray。
Hack性质的请求,用于清除缓存,设置为最高优先级IMMEDIATE,执行请求时会调用Request.isCanceled判断请求是否被取消掉了,就在这里清除了缓存
@Override public boolean isCanceled() { // This is a little bit of a hack, but hey, why not. mCache.clear(); if (mCallback != null) { Handler handler = new Handler(Looper.getMainLooper()); handler.postAtFrontOfQueue(mCallback); } return true; }
Cancel
RequestQueue同样提供了取消请求的方法。通过它的cancelAll方法。
/** * A simple predicate or filter interface for Requests, for use by * {@link RequestQueue#cancelAll(RequestFilter)}. */ public interface RequestFilter { public boolean apply(Request<?> request); } /** * Cancels all requests in this queue for which the given filter applies. * @param filter The filtering function to use */ public void cancelAll(RequestFilter filter) { synchronized (mCurrentRequests) { for (Request<?> request : mCurrentRequests) { if (filter.apply(request)) { request.cancel(); } } } } /** * Cancels all requests in this queue with the given tag. Tag must be non-null * and equality is by identity. */ public void cancelAll(final Object tag) { if (tag == null) { throw new IllegalArgumentException("Cannot cancelAll with a null tag"); } cancelAll(new RequestFilter() { @Override public boolean apply(Request<?> request) { return request.getTag() == tag; } }); }
通过给每个请求设置一个Tag,然后通过cancelAll(final Object tag)就可以取消对应Tag的请求,也可以直接使用RequestFilter
通过ImageRequest、ImageLoader和NetworkImageView等类,Volley还可用于加载图片,通过加锁实现了同时只解析一张图片,同时只解析一张,而不是只加载一张,网络请求还是跟普通的请求一样,返回的是byte数组,解析指byte[]->Bitmap,由于请求结果是byte[],大图应该很容易内存溢出,而且不支持本地图片,所以不考虑使用,略过。
Volley的扩展应该还是比较容易的,网络已经有各种版本扩展了,像Cache,Request等都是提供的接口,很容易有自己的实现,比如实现GsonRequest用于使用Gson解析返回的json结果:
protected Response<T> parseNetworkResponse(NetworkResponse response) { try { String json = new String( response.data, HttpHeaderParser.parseCharset(response.headers)); return Response.success( gson.fromJson(json, clazz), HttpHeaderParser.parseCacheHeaders(response)); } catch (UnsupportedEncodingException e) { return Response.error(new ParseError(e)); } catch (JsonSyntaxException e) { return Response.error(new ParseError(e)); } }
Volley被设计用于小的网络请求,所以像上传下载大文件什么的就不适合了,虽然网上已有相应的扩展,而且原生是没有文件上传的。
虽然Volley有NetImageView,ImageLoader等和加载图片相关的,但是我自己是不愿意使用的,将请求结果作为byte[]返回并解析应该很容易就OOM了,而且有其他优秀的图片加载库如UniversalImageLoader
虽然网上都说Volley速度快,易于扩展,也给出了对比数据,但总归是要自己手工扩展,也没看出特别大的优势,和Android-Async-Http相比有一点不同就是2.3后使用了官方建议的HttpUrlConnection。
还有一点最主要的应该就是Volley的缓存方法了,根据进行请求时服务器返回的缓存控制Header对请求结果进行缓存,下次请求时判断如果没有过期就直接使用缓存加快响应速度,如果需要会再次请求服务器进行刷新,如果服务器返回了304,表示请求的资源自上次请求缓存后还没有改变,这种情况就直接用缓存不用再次刷新页面,不过这要服务器支持了。
当对上次的请求进行缓存后,在下次请求时即使没有网络也可以请求成功,关键的是,缓存的处理对用户完全是透明的,对于一些简单的情况会省去缓存相关的一些事情