标签：
1. Volley简介
我们平时在开发Android应用的时候不可避免地都需要用到网络技术，而多数情况下应用程序都会使用HTTP协议来发送和接收网络数据。Android系统中主要提供了两种方式来进行HTTP通信，HttpURLConnection和HttpClient，几乎在任何项目的代码中我们都能看到这两个类的身影，使用率非常高。
不过HttpURLConnection和HttpClient的用法还是稍微有些复杂的，如果不进行适当封装的话，很容易就会写出不少重复代码。于是乎，一些Android网络通信框架也就应运而生，比如说AsyncHttpClient，它把HTTP所有的通信细节全部封装在了内部，我们只需要简单调用几行代码就可以完成通信操作了。再比如Universal-Image-Loader，它使得在界面上显示网络图片的操作变得极度简单，开发者不用关心如何从网络上获取图片，也不用关心开启线程、回收图片资源等细节，Universal-Image-Loader已经把一切都做好了。
Android开发团队也是意识到了有必要将HTTP的通信操作再进行简单化，于是在2013年Google I/O大会上推出了一个新的网络通信框架——Volley。Volley可是说是把AsyncHttpClient和Universal-Image-Loader的优点集于了一身，既可以像AsyncHttpClient一样非常简单地进行HTTP通信，也可以像Universal-Image-Loader一样轻松加载网络上的图片。除了简单易用之外，Volley在性能方面也进行了大幅度的调整，它的设计目标就是非常适合去进行数据量不大，但通信频繁的网络操作，而对于大数据量的网络操作，比如说下载文件等，Volley的表现就会非常糟糕。
下图所示的这些应用都是属于数据量不大，但网络通信频繁的，因此非常适合使用Volley。
介绍了这么多理论的东西，下面我们就准备开始进行实战了，首先需要将Volley的jar包准备好，如果你的电脑上装有Git，可以使用如下命令下载Volley的源码：
git clone https://android.googlesource.com/platform/frameworks/volley
下载完成后将它导入到你的Eclipse工程里，然后再导出一个jar包就可以了。如果你的电脑上没有Git，那么也可以直接使用我导出好的jar包，下载地址是：http://www.kwstu.com/ResourcesView/kwstu_201441183330928 。
新建一个Android项目，将volley.jar文件复制到libs目录下，这样准备工作就算是做好了。
前面已经说过，Volley的用法非常简单，那么我们就从最基本的HTTP通信开始学习吧，即发起一条HTTP请求，然后接收HTTP响应。首先需要获取到一个RequestQueue对象，可以调用如下方法获取到：
RequestQueue mQueue = Volley.newRequestQueue(context);
注意这里拿到的RequestQueue是一个请求队列对象，它可以缓存所有的HTTP请求，然后按照一定的算法并发地发出这些请求。RequestQueue内部的设计就是非常合适高并发的，因此我们不必为每一次HTTP请求都创建一个RequestQueue对象，这是非常浪费资源的，基本上在每一个需要和网络交互的Activity中创建一个RequestQueue对象就足够了。
接下来为了要发出一条HTTP请求，我们还需要创建一个StringRequest对象，如下所示
StringRequest stringRequest = new StringRequest("http://www.baidu.com", new Response.Listener<String>() { @Override public void onResponse(String response) { Log.d("TAG", response); } }, new Response.ErrorListener() { @Override public void onErrorResponse(VolleyError error) { Log.e("TAG", error.getMessage(), error); } });
可以看到，这里new出了一个StringRequest对象，StringRequest的构造函数需要传入三个参数，第一个参数就是目标服务器的URL地址，第二个参数是服务器响应成功的回调，第三个参数是服务器响应失败的回调。其中，目标服务器地址我们填写的是百度的首页，然后在响应成功的回调里打印出服务器返回的内容，在响应失败的回调里打印出失败的详细信息。
最后，将这个StringRequest对象添加到RequestQueue里面就可以了，如下所示：
mQueue.add(stringRequest);
好了，就是这么简单，如果你现在运行一下程序，并发出这样一条HTTP请求，就会看到LogCat中会打印出如下图所示的数据。
这样的话，一个最基本的HTTP发送与响应的功能就完成了。你会发现根本还没写几行代码就轻易实现了这个功能，主要就是进行了以下三步操作：
1. 创建一个RequestQueue对象。
2. 创建一个StringRequest对象。
3. 将StringRequest对象添加到RequestQueue里面。
不过大家都知道，HTTP的请求类型通常有两种，GET和POST，刚才我们使用的明显是一个GET请求，那么如果想要发出一条POST请求应该怎么做呢？StringRequest中还提供了另外一种四个参数的构造函数，其中第一个参数就是指定请求类型的，我们可以使用如下方式进行指定：
StringRequest stringRequest = new StringRequest(Method.POST, url, listener, errorListener);
可是这只是指定了HTTP请求方式是POST，那么我们要提交给服务器的参数又该怎么设置呢？很遗憾，StringRequest中并没有提供设置POST参数的方法，但是当发出POST请求的时候，Volley会尝试调用StringRequest的父类——Request中的getParams()方法来获取POST参数，那么解决方法自然也就有了，我们只需要在StringRequest的匿名类中重写getParams()方法，在这里设置POST参数就可以了，代码如下所示：
StringRequest stringRequest = new StringRequest(Method.POST, url, listener, errorListener) { @Override protected Map<String, String> getParams() throws AuthFailureError { Map<String, String> map = new HashMap<String, String>(); map.put("params1", "value1"); map.put("params2", "value2"); return map; } };
你可能会说，每次都这样用起来岂不是很累？连个设置POST参数的方法都没有。但是不要忘记，Volley是开源的，只要你愿意，你可以自由地在里面添加和修改任何的方法，轻松就能定制出一个属于你自己的Volley版本。
学完了最基本的StringRequest的用法，我们再来进阶学习一下JsonRequest的用法。类似于StringRequest，JsonRequest也是继承自Request类的，不过由于JsonRequest是一个抽象类，因此我们无法直接创建它的实例，那么只能从它的子类入手了。JsonRequest有两个直接的子类，JsonObjectRequest和JsonArrayRequest，从名字上你应该能就看出它们的区别了吧？一个是用于请求一段JSON数据的，一个是用于请求一段JSON数组的。
至于它们的用法也基本上没有什么特殊之处，先new出一个JsonObjectRequest对象，如下所示：
JsonObjectRequest jsonObjectRequest = new JsonObjectRequest("http://m.weather.com.cn/data/101010100.html", null, new Response.Listener<JSONObject>() { @Override public void onResponse(JSONObject response) { Log.d("TAG", response.toString()); } }, new Response.ErrorListener() { @Override public void onErrorResponse(VolleyError error) { Log.e("TAG", error.getMessage(), error); } });
可以看到，这里我们填写的URL地址是http://m.weather.com.cn/data/101010100.html，这是中国天气网提供的一个查询天气信息的接口，响应的数据就是以JSON格式返回的，然后我们在onResponse()方法中将返回的数据打印出来。
最后再将这个JsonObjectRequest对象添加到RequestQueue里就可以了，如下所示：
mQueue.add(jsonObjectRequest);
这样当HTTP通信完成之后，服务器响应的天气信息就会回调到onResponse()方法中，并打印出来。现在运行一下程序，发出这样一条HTTP请求，就会看到LogCat中会打印出如下图所示的数据。
由此可以看出，服务器返回给我们的数据确实是JSON格式的，并且onResponse()方法中携带的参数也正是一个JSONObject对象，之后只需要从JSONObject对象取出我们想要得到的那部分数据就可以了。JsonObjectRequest的用法和StringRequest的用法基本上是完全一样的.
前面我们已经学习过了StringRequest和JsonRequest的用法，并且总结出了它们的用法都是非常类似的，基本就是进行以下三步操作即可：
1. 创建一个RequestQueue对象。
2. 创建一个Request对象。
3. 将Request对象添加到RequestQueue里面。
其中，StringRequest和JsonRequest都是继承自Request的，所以它们的用法才会如此类似。那么不用多说，今天我们要学习的ImageRequest，相信你从名字上就已经猜出来了，它也是继承自Request的，因此它的用法也是基本相同的，首先需要获取到一个RequestQueue对象，可以调用如下方法获取到：
RequestQueue mQueue = Volley.newRequestQueue(context);
接下来自然要去new出一个ImageRequest对象了，代码如下所示：
ImageRequest imageRequest = new ImageRequest( "http://developer.android.com/images/home/aw_dac.png", new Response.Listener<Bitmap>() { @Override public void onResponse(Bitmap response) { imageView.setImageBitmap(response); } }, 0, 0, Config.RGB_565, new Response.ErrorListener() { @Override public void onErrorResponse(VolleyError error) { imageView.setImageResource(R.drawable.default_image); } });
可以看到，ImageRequest的构造函数接收六个参数，第一个参数就是图片的URL地址，这个没什么需要解释的。第二个参数是图片请求成功的回调，这里我们把返回的Bitmap参数设置到ImageView中。第三第四个参数分别用于指定允许图片最大的宽度和高度，如果指定的网络图片的宽度或高度大于这里的最大值，则会对图片进行压缩，指定成0的话就表示不管图片有多大，都不会进行压缩。第五个参数用于指定图片的颜色属性，Bitmap.Config下的几个常量都可以在这里使用，其中ARGB_8888可以展示最好的颜色属性，每个图片像素占据4个字节的大小，而RGB_565则表示每个图片像素占据2个字节大小。第六个参数是图片请求失败的回调，这里我们当请求失败时在ImageView中显示一张默认图片。
最后将这个ImageRequest对象添加到RequestQueue里就可以了，如下所示：
mQueue.add(imageRequest);
现在如果运行一下程序，并尝试发出这样一条网络请求，很快就能看到网络上的图片在ImageView中显示出来了，如下图所示：
如果你觉得ImageRequest已经非常好用了，那我只能说你太容易满足了 ^_^。实际上，Volley在请求网络图片方面可以做到的还远远不止这些，而ImageLoader就是一个很好的例子。ImageLoader也可以用于加载网络上的图片，并且它的内部也是使用ImageRequest来实现的，不过ImageLoader明显要比ImageRequest更加高效，因为它不仅可以帮我们对图片进行缓存，还可以过滤掉重复的链接，避免重复发送请求。
由于ImageLoader已经不是继承自Request的了，所以它的用法也和我们之前学到的内容有所不同，总结起来大致可以分为以下四步：
1. 创建一个RequestQueue对象。
2. 创建一个ImageLoader对象。
3. 获取一个ImageListener对象。
4. 调用ImageLoader的get()方法加载网络上的图片。
下面我们就来按照这个步骤，学习一下ImageLoader的用法吧。首先第一步的创建RequestQueue对象我们已经写过很多遍了，相信已经不用再重复介绍了，那么就从第二步开始学习吧，新建一个ImageLoader对象，代码如下所示：
ImageLoader imageLoader = new ImageLoader(mQueue, new ImageCache() { @Override public void putBitmap(String url, Bitmap bitmap) { } @Override public Bitmap getBitmap(String url) { return null; } });
可以看到，ImageLoader的构造函数接收两个参数，第一个参数就是RequestQueue对象，第二个参数是一个ImageCache对象，这里我们先new出一个空的ImageCache的实现即可。
接下来需要获取一个ImageListener对象，代码如下所示：
ImageListener listener = ImageLoader.getImageListener(imageView,
R.drawable.default_image, R.drawable.failed_image);
我们通过调用ImageLoader的getImageListener()方法能够获取到一个ImageListener对象，getImageListener()方法接收三个参数，第一个参数指定用于显示图片的ImageView控件，第二个参数指定加载图片的过程中显示的图片，第三个参数指定加载图片失败的情况下显示的图片。
最后，调用ImageLoader的get()方法来加载图片，代码如下所示：
imageLoader.get("http://img.my.csdn.net/uploads/201404/13/1397393290_5765.jpeg", listener);
get()方法接收两个参数，第一个参数就是图片的URL地址，第二个参数则是刚刚获取到的ImageListener对象。当然，如果你想对图片的大小进行限制，也可以使用get()方法的重载，指定图片允许的最大宽度和高度，如下所示：
imageLoader.get("http://img.my.csdn.net/uploads/201404/13/1397393290_5765.jpeg", listener, 200, 200);
现在运行一下程序并开始加载图片，你将看到ImageView中会先显示一张默认的图片，等到网络上的图片加载完成后，ImageView则会自动显示该图，效果如下图所示。
除了以上两种方式之外，Volley还提供了第三种方式来加载网络图片，即使用NetworkImageView。不同于以上两种方式，NetworkImageView是一个自定义控制，它是继承自ImageView的，具备ImageView控件的所有功能，并且在原生的基础之上加入了加载网络图片的功能。NetworkImageView控件的用法要比前两种方式更加简单，大致可以分为以下五步：
1. 创建一个RequestQueue对象。
2. 创建一个ImageLoader对象。
3. 在布局文件中添加一个NetworkImageView控件。
4. 在代码中获取该控件的实例。
5. 设置要加载的图片地址。
其中，第一第二步和ImageLoader的用法是完全一样的，因此这里我们就从第三步开始学习了。首先修改布局文件中的代码，在里面加入NetworkImageView控件，如下所示：
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:orientation="vertical" > <Button android:id="@+id/button" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Send Request" /> <com.android.volley.toolbox.NetworkImageView android:id="@+id/network_image_view" android:layout_width="200dp" android:layout_height="200dp" android:layout_gravity="center_horizontal" /> </LinearLayout>
接着在Activity获取到这个控件的实例，这就非常简单了，代码如下所示：
networkImageView = (NetworkImageView) findViewById(R.id.network_image_view);
得到了NetworkImageView控件的实例之后，我们可以调用它的setDefaultImageResId()方法、setErrorImageResId()方法和setImageUrl()方法来分别设置加载中显示的图片，加载失败时显示的图片，以及目标图片的URL地址，如下所示：
networkImageView.setDefaultImageResId(R.drawable.default_image); networkImageView.setErrorImageResId(R.drawable.failed_image); networkImageView.setImageUrl("http://img.my.csdn.net/uploads/201404/13/1397393290_5765.jpeg", imageLoader);
其中，setImageUrl()方法接收两个参数，第一个参数用于指定图片的URL地址，第二个参数则是前面创建好的ImageLoader对象。
好了，就是这么简单，现在重新运行一下程序，你将看到和使用ImageLoader来加载图片一模一样的效果，这里我就不再截图了。
这时有的朋友可能就会问了，使用ImageRequest和ImageLoader这两种方式来加载网络图片，都可以传入一个最大宽度和高度的参数来对图片进行压缩，而NetworkImageView中则完全没有提供设置最大宽度和高度的方法，那么是不是使用NetworkImageView来加载的图片都不会进行压缩呢？
其实并不是这样的，NetworkImageView并不需要提供任何设置最大宽高的方法也能够对加载的图片进行压缩。这是由于NetworkImageView是一个控件，在加载图片的时候它会自动获取自身的宽高，然后对比网络图片的宽度，再决定是否需要对图片进行压缩。也就是说，压缩过程是在内部完全自动化的，并不需要我们关心，NetworkImageView会始终呈现给我们一张大小刚刚好的网络图片，不会多占用任何一点内存，这也是NetworkImageView最简单好用的一点吧。
当然了，如果你不想对图片进行压缩的话，其实也很简单，只需要在布局文件中把NetworkImageView的layout_width和layout_height都设置成wrap_content就可以了，这样NetworkImageView就会将该图片的原始大小展示出来，不会进行任何压缩。
这样我们就把使用Volley来加载网络图片的用法都学习完了。
1. 自定义JSONObjectRequest
我们应该去参考一下Volley的源码，看一看StringRequest是怎么实现的，然后就可以模仿着写出XMLRequest了。首先看下StringRequest的源码，如下所示：\
/** * A canned request for retrieving the response body at a given URL as a String. */ public class StringRequest extends Request<String> { private final Listener<String> mListener; /** * Creates a new request with the given method. * * @param method the request {@link Method} to use * @param url URL to fetch the string at * @param listener Listener to receive the String response * @param errorListener Error listener, or null to ignore errors */ public StringRequest(int method, String url, Listener<String> listener, ErrorListener errorListener) { super(method, url, errorListener); mListener = listener; } /** * Creates a new GET request. * * @param url URL to fetch the string at * @param listener Listener to receive the String response * @param errorListener Error listener, or null to ignore errors */ public StringRequest(String url, Listener<String> listener, ErrorListener errorListener) { this(Method.GET, url, listener, errorListener); } @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)); } }
可以看到，StringRequest的源码很简练，根本就没几行代码，我们一起来分析下。首先StringRequest是继承自Request类的，Request可以指定一个泛型类，这里指定的是String，接下来StringRequest中提供了两个有参的构造函数，参数包括请求类型，请求地址，以及响应回调等，由于我们已经很熟悉StringRequest的用法了，相信这几个参数的作用都不用再解释了吧。但需要注意的是，在构造函数中一定要调用super()方法将这几个参数传给父类，因为HTTP的请求和响应都是在父类中自动处理的。
另外，由于Request类中的deliverResponse()和parseNetworkResponse()是两个抽象方法，因此StringRequest中需要对这两个方法进行实现。deliverResponse()方法中的实现很简单，仅仅是调用了mListener中的onResponse()方法，并将response内容传入即可，这样就可以将服务器响应的数据进行回调了。parseNetworkResponse()方法中则应该对服务器响应的数据进行解析，其中数据是以字节的形式存放在NetworkResponse的data变量中的，这里将数据取出然后组装成一个String，并传入Response的success()方法中即可。
参考StringRequest的实现原理，实现JSONObjectRequest如下
public class JSONObjectRequest extends Request<JSONObject> { private final Listener<String> mListener; private JSONObject mRequestBody; private Map<String, String> sendCookie = new HashMap<String, String>(1); public JSONObjectRequest(int method, String url, JSONObject requestBody, Listener<JSONObject> listener, ErrorListener errorListener) { this( method, url, requestBody, null, listener, errorListener ); } public JSONObjectRequest(int method, String url, JSONObject requestBody, String cookie, Listener<JSONObject> listener, ErrorListener errorListener) { super(method, url, errorListener); mListener = listener; mRequestBody = requestBody; } public StringRequest(String url, Listener<String> listener, ErrorListener errorListener) { this(Method.GET, url, listener, errorListener); } private void setCookie(String cookie) { if (cookie == null) return; sendCookie.put("Cookie", cookie); } @Override public Map<String, String> getHeaders() { return sendCookie; @Override protected void deliverResponse(JSONObject response) { mListener.onResponse(response); } @Override public byte[] getBody() { return (mRequestBody == null ? null : mRequestBody.toString().getByte()); } @Override protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) { try { String jsonString = new String(response.data, HttpHeaderParser.parseCharset(response.headers)); JSONObject obj = new JSONObject(jsonString); if (setCookie(response.headers)) { obj.put("Cookie", mCookie); } return Response.success(obj, HttpHeaderParser.parseCacheHeaders(response)); } catch (UnsupportedEncodingException e) { return Response.error(new ParseError(e)); } catch (JSONException je) { return Response.error(new ParseError(je)); } } }
其实，Volley的官方文档中本身就附有了一张Volley的工作流程图，如下图所示。
说起分析源码，那么应该从哪儿开始看起呢？这就要回顾一下Volley的用法了，还记得吗，使用Volley的第一步，首先要调用Volley.newRequestQueue(context)方法来获取一个RequestQueue对象，那么我们自然要从这个方法开始看起了，代码如下所示：
public static RequestQueue newRequestQueue(Context context) { return newRequestQueue(context, null); }
这个方法仅仅只有一行代码，只是调用了newRequestQueue()的方法重载，并给第二个参数传入null。那我们看下带有两个参数的newRequestQueue()方法中的代码，如下所示：
1 public static RequestQueue newRequestQueue(Context context, HttpStack stack) { 2 File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR); 3 String userAgent = "volley/0"; 4 try { 5 String packageName = context.getPackageName(); 6 PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0); 7 userAgent = packageName + "/" + info.versionCode; 8 } catch (NameNotFoundException e) { 9 } 10 if (stack == null) { 11 if (Build.VERSION.SDK_INT >= 9) { 12 stack = new HurlStack(); 13 } else { 14 stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent)); 15 } 16 } 17 Network network = new BasicNetwork(stack); 18 RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network); 19 queue.start(); 20 return queue; 21 }
可以看到，这里在第10行判断如果stack是等于null的，则去创建一个HttpStack对象，这里会判断如果手机系统版本号是大于9的，则创建一个HurlStack的实例，否则就创建一个HttpClientStack的实例。实际上HurlStack的内部就是使用HttpURLConnection进行网络通讯的，而HttpClientStack的内部则是使用HttpClient进行网络通讯的
在Android 2.2版本之前，HttpClient拥有较少的bug，因此使用它是最好的选择。
而在Android 2.3版本及以后，HttpURLConnection则是最佳的选择。它的API简单，体积较小，因而非常适用于Android项目。压缩和缓存机制可以有效地减少网络访问的流量，在提升速度和省电方面也起到了较大的作用。对于新的应用程序应该更加偏向于使用HttpURLConnection，因为在以后的工作当中我们也会将更多的时间放在优化HttpURLConnection上面。
创建好了HttpStack之后，接下来又创建了一个Network对象，它是用于根据传入的HttpStack对象来处理网络请求的，紧接着new出一个RequestQueue对象，并调用它的start()方法进行启动，然后将RequestQueue返回，这样newRequestQueue()的方法就执行结束了。
那么RequestQueue的start()方法内部到底执行了什么
1 public void start() { 2 stop(); // Make sure any currently running dispatchers are stopped. 3 // Create the cache dispatcher and start it. 4 mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery); 5 mCacheDispatcher.start(); 6 // Create network dispatchers (and corresponding threads) up to the pool size. 7 for (int i = 0; i < mDispatchers.length; i++) { 8 NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork, 9 mCache, mDelivery); 10 mDispatchers[i] = networkDispatcher; 11 networkDispatcher.start(); 12 } 13 }
这里先是创建了一个CacheDispatcher的实例，然后调用了它的start()方法，接着在一个for循环里去创建NetworkDispatcher的实例，并分别调用它们的start()方法。这里的CacheDispatcher和NetworkDispatcher都是继承自Thread的，而默认情况下for循环会执行四次，也就是说当调用了Volley.newRequestQueue(context)之后，就会有五个线程一直在后台运行，不断等待网络请求的到来，其中CacheDispatcher是缓存线程，NetworkDispatcher是网络请求线程。
得到了RequestQueue之后，我们只需要构建出相应的Request，然后调用RequestQueue的add()方法将Request传入就可以完成网络请求操作了，那么不用说，add()方法的内部肯定有着非常复杂的逻辑，我们来一起看一下：
1 public <T> Request<T> add(Request<T> request) { 2 // Tag the request as belonging to this queue and add it to the set of current requests. 3 request.setRequestQueue(this); 4 synchronized (mCurrentRequests) { 5 mCurrentRequests.add(request); 6 } 7 // Process requests in the order they are added. 8 request.setSequence(getSequenceNumber()); 9 request.addMarker("add-to-queue"); 10 // If the request is uncacheable, skip the cache queue and go straight to the network. 11 if (!request.shouldCache()) { 12 mNetworkQueue.add(request); 13 return request; 14 } 15 // Insert request into stage if there‘s already a request with the same cache key in flight. 16 synchronized (mWaitingRequests) { 17 String cacheKey = request.getCacheKey(); 18 if (mWaitingRequests.containsKey(cacheKey)) { 19 // There is already a request in flight. Queue up. 20 Queue<Request<?>> stagedRequests = mWaitingRequests.get(cacheKey); 21 if (stagedRequests == null) { 22 stagedRequests = new LinkedList<Request<?>>(); 23 } 24 stagedRequests.add(request); 25 mWaitingRequests.put(cacheKey, stagedRequests); 26 if (VolleyLog.DEBUG) { 27 VolleyLog.v("Request for cacheKey=%s is in flight, putting on hold.", cacheKey); 28 } 29 } else { 30 // Insert ‘null‘ queue for this cacheKey, indicating there is now a request in 31 // flight. 32 mWaitingRequests.put(cacheKey, null); 33 mCacheQueue.add(request); 34 } 35 return request; 36 } 37 }
可以看到，在第11行的时候会判断当前的请求是否可以缓存，如果不能缓存则在第12行直接将这条请求加入网络请求队列，可以缓存的话则在第33行将这条请求加入缓存队列。在默认情况下，每条请求都是可以缓存的，当然我们也可以调用Request的setShouldCache(false)方法来改变这一默认行为。
OK，那么既然默认每条请求都是可以缓存的，自然就被添加到了缓存队列中，于是一直在后台等待的缓存线程就要开始运行起来了，我们看下CacheDispatcher中的run()方法，代码如下所示：
1 public class CacheDispatcher extends Thread { 2 3 …… 4 5 @Override 6 public void run() { 7 if (DEBUG) VolleyLog.v("start new dispatcher"); 8 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); 9 // Make a blocking call to initialize the cache. 10 mCache.initialize(); 11 while (true) { 12 try { 13 // Get a request from the cache triage queue, blocking until 14 // at least one is available. 15 final Request<?> request = mCacheQueue.take(); 16 request.addMarker("cache-queue-take"); 17 // If the request has been canceled, don‘t bother dispatching it. 18 if (request.isCanceled()) { 19 request.finish("cache-discard-canceled"); 20 continue; 21 } 22 // Attempt to retrieve this item from cache. 23 Cache.Entry entry = mCache.get(request.getCacheKey()); 24 if (entry == null) { 25 request.addMarker("cache-miss"); 26 // Cache miss; send off to the network dispatcher. 27 mNetworkQueue.put(request); 28 continue; 29 } 30 // If it is completely expired, just send it to the network. 31 if (entry.isExpired()) { 32 request.addMarker("cache-hit-expired"); 33 request.setCacheEntry(entry); 34 mNetworkQueue.put(request); 35 continue; 36 } 37 // We have a cache hit; parse its data for delivery back to the request. 38 request.addMarker("cache-hit"); 39 Response<?> response = request.parseNetworkResponse( 40 new NetworkResponse(entry.data, entry.responseHeaders)); 41 request.addMarker("cache-hit-parsed"); 42 if (!entry.refreshNeeded()) { 43 // Completely unexpired cache hit. Just deliver the response. 44 mDelivery.postResponse(request, response); 45 } else { 46 // Soft-expired cache hit. We can deliver the cached response, 47 // but we need to also send the request to the network for 48 // refreshing. 49 request.addMarker("cache-hit-refresh-needed"); 50 request.setCacheEntry(entry); 51 // Mark the response as intermediate. 52 response.intermediate = true; 53 // Post the intermediate response back to the user and have 54 // the delivery then forward the request along to the network. 55 mDelivery.postResponse(request, response, new Runnable() { 56 @Override 57 public void run() { 58 try { 59 mNetworkQueue.put(request); 60 } catch (InterruptedException e) { 61 // Not much we can do about this. 62 } 63 } 64 }); 65 } 66 } catch (InterruptedException e) { 67 // We may have been interrupted because it was time to quit. 68 if (mQuit) { 69 return; 70 } 71 continue; 72 } 73 } 74 } 75 }
代码有点长，我们只挑重点看。首先在11行可以看到一个while(true)循环，说明缓存线程始终是在运行的，接着在第23行会尝试从缓存当中取出响应结果，如何为空的话则把这条请求加入到网络请求队列中，如果不为空的话再判断该缓存是否已过期，如果已经过期了则同样把这条请求加入到网络请求队列中，否则就认为不需要重发网络请求，直接使用缓存中的数据即可。之后会在第39行调用Request的parseNetworkResponse()方法来对数据进行解析，再往后就是将解析出来的数据进行回调了，这部分代码我们先跳过，因为它的逻辑和NetworkDispatcher后半部分的逻辑是基本相同的，那么我们等下合并在一起看就好了，先来看一下NetworkDispatcher中是怎么处理网络请求队列的，代码如下所示：
1 public class NetworkDispatcher extends Thread { 2 …… 3 @Override 4 public void run() { 5 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); 6 Request<?> request; 7 while (true) { 8 try { 9 // Take a request from the queue. 10 request = mQueue.take(); 11 } catch (InterruptedException e) { 12 // We may have been interrupted because it was time to quit. 13 if (mQuit) { 14 return; 15 } 16 continue; 17 } 18 try { 19 request.addMarker("network-queue-take"); 20 // If the request was cancelled already, do not perform the 21 // network request. 22 if (request.isCanceled()) { 23 request.finish("network-discard-cancelled"); 24 continue; 25 } 26 addTrafficStatsTag(request); 27 // Perform the network request. 28 NetworkResponse networkResponse = mNetwork.performRequest(request); 29 request.addMarker("network-http-complete"); 30 // If the server returned 304 AND we delivered a response already, 31 // we‘re done -- don‘t deliver a second identical response. 32 if (networkResponse.notModified && request.hasHadResponseDelivered()) { 33 request.finish("not-modified"); 34 continue; 35 } 36 // Parse the response here on the worker thread. 37 Response<?> response = request.parseNetworkResponse(networkResponse); 38 request.addMarker("network-parse-complete"); 39 // Write to cache if applicable. 40 // TODO: Only update cache metadata instead of entire record for 304s. 41 if (request.shouldCache() && response.cacheEntry != null) { 42 mCache.put(request.getCacheKey(), response.cacheEntry); 43 request.addMarker("network-cache-written"); 44 } 45 // Post the response back. 46 request.markDelivered(); 47 mDelivery.postResponse(request, response); 48 } catch (VolleyError volleyError) { 49 parseAndDeliverNetworkError(request, volleyError); 50 } catch (Exception e) { 51 VolleyLog.e(e, "Unhandled exception %s", e.toString()); 52 mDelivery.postError(request, new VolleyError(e)); 53 } 54 } 55 } 56 }
同样地，在第7行我们看到了类似的while(true)循环，说明网络请求线程也是在不断运行的。在第28行的时候会调用Network的performRequest()方法来去发送网络请求，而Network是一个接口，这里具体的实现是BasicNetwork，我们来看下它的performRequest()方法，如下所示：
1 public class BasicNetwork implements Network { 2 …… 3 @Override 4 public NetworkResponse performRequest(Request<?> request) throws VolleyError { 5 long requestStart = SystemClock.elapsedRealtime(); 6 while (true) { 7 HttpResponse httpResponse = null; 8 byte[] responseContents = null; 9 Map<String, String> responseHeaders = new HashMap<String, String>(); 10 try { 11 // Gather headers. 12 Map<String, String> headers = new HashMap<String, String>(); 13 addCacheHeaders(headers, request.getCacheEntry()); 14 httpResponse = mHttpStack.performRequest(request, headers); 15 StatusLine statusLine = httpResponse.getStatusLine(); 16 int statusCode = statusLine.getStatusCode(); 17 responseHeaders = convertHeaders(httpResponse.getAllHeaders()); 18 // Handle cache validation. 19 if (statusCode == HttpStatus.SC_NOT_MODIFIED) { 20 return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED, 21 request.getCacheEntry() == null ? null : request.getCacheEntry().data, 22 responseHeaders, true); 23 } 24 // Some responses such as 204s do not have content. We must check. 25 if (httpResponse.getEntity() != null) { 26 responseContents = entityToBytes(httpResponse.getEntity()); 27 } else { 28 // Add 0 byte response as a way of honestly representing a 29 // no-content request. 30 responseContents = new byte[0]; 31 } 32 // if the request is slow, log it. 33 long requestLifetime = SystemClock.elapsedRealtime() - requestStart; 34 logSlowRequests(requestLifetime, request, responseContents, statusLine); 35 if (statusCode < 200 || statusCode > 299) { 36 throw new IOException(); 37 } 38 return new NetworkResponse(statusCode, responseContents, responseHeaders, false); 39 } catch (Exception e) { 40 …… 41 } 42 } 43 } 44 }
这段方法中大多都是一些网络请求细节方面的东西，我们并不需要太多关心，需要注意的是在第14行调用了HttpStack的performRequest()方法，这里的HttpStack就是在一开始调用newRequestQueue()方法是创建的实例，默认情况下如果系统版本号大于9就创建的HurlStack对象，否则创建HttpClientStack对象。前面已经说过，这两个对象的内部实际就是分别使用HttpURLConnection和HttpClient来发送网络请求的，我们就不再跟进去阅读了，之后会将服务器返回的数据组装成一个NetworkResponse对象进行返回。
在NetworkDispatcher中收到了NetworkResponse这个返回值后又会调用Request的parseNetworkResponse()方法来解析NetworkResponse中的数据，以及将数据写入到缓存，这个方法的实现是交给Request的子类来完成的，因为不同种类的Request解析的方式也肯定不同。还记得我们在上一篇文章中学习的自定义Request的方式吗？其中parseNetworkResponse()这个方法就是必须要重写的。
在解析完了NetworkResponse中的数据之后，又会调用ExecutorDelivery的postResponse()方法来回调解析出的数据，代码如下所示：
public void postResponse(Request<?> request, Response<?> response, Runnable runnable) { request.markDelivered(); request.addMarker("post-response"); mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable)); }
其中，在mResponsePoster的execute()方法中传入了一个ResponseDeliveryRunnable对象，就可以保证该对象中的run()方法就是在主线程当中运行的了，我们看下run()方法中的代码是什么样的：
1 private class ResponseDeliveryRunnable implements Runnable { 2 private final Request mRequest; 3 private final Response mResponse; 4 private final Runnable mRunnable; 5 6 public ResponseDeliveryRunnable(Request request, Response response, Runnable runnable) { 7 mRequest = request; 8 mResponse = response; 9 mRunnable = runnable; 10 } 11 12 @SuppressWarnings("unchecked") 13 @Override 14 public void run() { 15 // If this request has canceled, finish it and don‘t deliver. 16 if (mRequest.isCanceled()) { 17 mRequest.finish("canceled-at-delivery"); 18 return; 19 } 20 // Deliver a normal response or error, depending. 21 if (mResponse.isSuccess()) { 22 mRequest.deliverResponse(mResponse.result); 23 } else { 24 mRequest.deliverError(mResponse.error); 25 } 26 // If this is an intermediate response, add a marker, otherwise we‘re done 27 // and the request can be finished. 28 if (mResponse.intermediate) { 29 mRequest.addMarker("intermediate-response"); 30 } else { 31 mRequest.finish("done"); 32 } 33 // If we have been provided a post-delivery runnable, run it. 34 if (mRunnable != null) { 35 mRunnable.run(); 36 } 37 } 38 }
代码虽然不多，但我们并不需要行行阅读，抓住重点看即可。其中在第22行调用了Request的deliverResponse()方法，有没有感觉很熟悉？没错，这个就是我们在自定义Request时需要重写的另外一个方法，每一条网络请求的响应都是回调到这个方法中，最后我们再在这个方法中将响应的数据回调到Response.Listener的onResponse()方法中就可以了。
好了，到这里我们就把Volley的完整执行流程全部梳理了一遍，你是不是已经感觉已经很清晰了呢？对了，还记得在文章一开始的那张流程图吗，刚才还不能理解，现在我们再来重新看下这张图：
其中蓝色部分代表主线程，绿色部分代表缓存线程，橙色部分代表网络线程。我们在主线程中调用RequestQueue的add()方法来添加一条网络请求，这条请求会先被加入到缓存队列当中，如果发现可以找到相应的缓存结果就直接读取缓存并解析，然后回调给主线程。如果在缓存中没有找到结果，则将这条请求加入到网络请求队列中，然后处理发送HTTP请求，解析响应结果，写入缓存，并回调主线程。
标签：
原文地址：http://www.cnblogs.com/code4mobile/p/4553511.html
