Android中的Volley通信框架

感谢原作者：Android中的Volley通信框架

1. 什么是Volley？

在这之前，我们在程序中需要和网络通信的时候，大体使用的东西莫过于AsyncTaskLoader，HttpURLConnection，AsyncTask，HTTPClient（Apache）等，在2013年Google I/O 上，Volley发布了。Volley是Android平台上的网络通信库，能使网络通信更快，更简单，更健壮。

2. Volley引入的背景

比如在以前从网上下载图片的步骤可能是这样的流程：

在ListAdapter#getView()里开始图像的读取。
通过AsyncTask等机制使用HttpURLConnection从服务器去的图片资源
在AsyncTask#onPostExecute()里设置相应ImageView的属性。

再比如，屏幕旋转的时候，有时候会导致再次从网络取得数据。为了避免这种不必要的网络访问，我们可能需要自己写很多针对各种情况的处理，比如cache什么的。

再有，比如ListView的时候，我们滚动过快，可能导致有些网络请求返回的时候，早已经滚过了当时的位置，根本没必要显示在list里了，虽然我们可以通过ViewHolder来保持url等来实现防止两次取得，但是那些已经没有必须要的数据，还是会浪费系统的各种资源
3. 提供的功能

JSON，图像等的异步下载；
网络请求的排序（scheduling）
网络请求的优先级处理
缓存
多级别取消请求
和Activity和生命周期的联动（Activity结束时同时取消所有网络请求）

Volley可是说是把AsyncHttpClient和Universal-Image-Loader的优点集于了一身，既可以像AsyncHttpClient一样非常简单地进行HTTP通信，也可以像Universal-Image-Loader一样轻松加载网络上的图片。除了简单易用之外，Volley在性能方面也进行了大幅度的调整，它的设计目标就是非常适合去进行数据量不大，但通信频繁的网络操作，而对于大数据量的网络操作，比如说下载文件等，Volley的表现就会非常糟糕。

下图所示的这些应用都是属于数据量不大，但网络通信频繁的，因此非常适合使用Volley。



volley中网络请求

首先使用Volley类创建 RequestQueue queue = Volley.newRequestQueue(

this

);

Making GET Requests

<span style="font-size:14px;">final String url = "http://httpbin.org/get?param1=hello";

// prepare the Request
JsonObjectRequest getRequest = new JsonObjectRequest(Request.Method.GET, url, null,
new Response.Listener<JSONObject>()
{
@Override
public void onResponse(JSONObject response) {
// display response
Log.d("Response", response.toString());
}
},
new Response.ErrorListener()
{
@Override
public void onErrorResponse(VolleyError error) {
Log.d("Error.Response", response);
}
}
);

// add it to the RequestQueue
queue.add(getRequest);</span>

Making POST Requests

url = "http://httpbin.org/post";
StringRequest postRequest = new StringRequest(Request.Method.POST, url,
new Response.Listener<String>()
{
@Override
public void onResponse(String response) {
// response
Log.d("Response", response);
}
},
new Response.ErrorListener()
{
@Override
public void onErrorResponse(VolleyError error) {
// error
Log.d("Error.Response", response);
}
}
) {
@Override
protected Map<String, String> getParams()
{
Map<String, String>  params = new HashMap<String, String>();
params.put("name", "Alif");
params.put("domain", "http://itsalif.info");

return params;
}
};
queue.add(postRequest);

Making PUT Requests

url = "http://httpbin.org/put";
StringRequest putRequest = new StringRequest(Request.Method.PUT, url,
new Response.Listener<String>()
{
@Override
public void onResponse(String response) {
// response
Log.d("Response", response);
}
},
new Response.ErrorListener()
{
@Override
public void onErrorResponse(VolleyError error) {
// error
Log.d("Error.Response", response);
}
}
) {

@Override
protected Map<String, String> getParams()
{
Map<String, String>  params = new HashMap<String, String> ();
params.put("name", "Alif");
params.put("domain", "http://itsalif.info");

return params;
}

};

queue.add(putRequest);

Making DELETE Requests

url = "http://httpbin.org/delete";
StringRequest dr = new StringRequest(Request.Method.DELETE, url,
new Response.Listener<String>()
{
@Override
public void onResponse(String response) {
// response
Toast.makeText($this, response, Toast.LENGTH_LONG).show();
}
},
new Response.ErrorListener()
{
@Override
public void onErrorResponse(VolleyError error) {
// error.

}
}
);
queue.add(dr);

Volley中图片加载

volley图片加载有三种方式：

记得：Volley中已经实现了磁盘缓存了，查看源码得知通过

context.getCacheDir()获取到了 /data/data/<application package>/cache内部存储路径，默认大小是5MB.所以我们只需要再实现内存缓存就可以了

1. ImageRequest

singleImg=(ImageView)findViewById(R.id.volley_img_single_imgeview);
ImageRequest imgRequest=new ImageRequest(url, new Response.Listener<Bitmap>() {
@Override
public void onResponse(Bitmap arg0) {
// TODO Auto-generated method stub
singleImg.setImageBitmap(arg0);
}
}, 300, 200, Config.ARGB_8888, new ErrorListener(){
@Override
public void onErrorResponse(VolleyError arg0) {
// TODO Auto-generated method stub

}
});
mRequestQueue.add(imgRequest);

可以看到，ImageRequest的构造函数接收六个参数，第一个参数就是图片的URL地址，这个没什么需要解释的。第二个参数是图片请求成功的回调，这里我们把返回的Bitmap参数设置到ImageView中。第三第四个参数分别用于指定允许图片最大的宽度和高度，如果指定的网络图片的宽度或高度大于这里的最大值，则会对图片进行压缩，指定成0的话就表示不管图片有多大，都不会进行压缩。第五个参数用于指定图片的颜色属性，Bitmap.Config下的几个常量都可以在这里使用，其中ARGB_8888可以展示最好的颜色属性，每个图片像素占据4个字节的大小，而RGB_565则表示每个图片像素占据2个字节大小。第六个参数是图片请求失败的回调，这里我们当请求失败时在ImageView中显示一张默认图片。

最后将这个ImageRequest对象添加到RequestQueue里就可以了
2. ImageLoader

RequestQueue mRequestQueue = Volley.newRequestQueue(this);
final LruCache<String, Bitmap> mImageCache = new LruCache<String, Bitmap>(
20);
ImageCache imageCache = new ImageCache() {
@Override
public void putBitmap(String key, Bitmap value) {
mImageCache.put(key, value);
}

@Override
public Bitmap getBitmap(String key) {
return mImageCache.get(key);
}
};
ImageLoader mImageLoader = new ImageLoader(mRequestQueue, imageCache);
// imageView是一个ImageView实例
// ImageLoader.getImageListener的第二个参数是默认的图片resource id
// 第三个参数是请求失败时候的资源id，可以指定为0
ImageListener listener = ImageLoader
.getImageListener(imageView, android.R.drawable.ic_menu_rotate,
android.R.drawable.ic_delete);
mImageLoader.get(url, listener);

可以看出ImageLoader这个类需要一个Request的实例以及一个ImageCache的实例。图片通过一个URL和一个ImageListener实例的get()方法就可以被加载。从哪里，ImageLoader会检查ImageCache,而且如果缓存里没有图片就会从网络上获取。Volley的ImageCache接口允许你使用你喜欢的L1缓存实现。不幸的是Volley没有提供默认的实现。在I/O的介绍中展示了BitmapLruCache的一点代码片段，但是Volley这个库本身并不包含任何相关的实现。

ImageCache接口有两个方法，getBitmap(String url)和putBitmap(String url, Bitmap bitmap).这两个方法足够简单直白，他们可以添加任何的缓存实现。

3.NetworkImageView

除了以上两种方式之外，Volley还提供了第三种方式来加载网络图片，即使用NetworkImageView。不同于以上两种方式，NetworkImageView是一个自定义控制，它是继承自ImageView的，具备ImageView控件的所有功能，并且在原生的基础之上加入了加载网络图片的功能。NetworkImageView控件的用法要比前两种方式更加简单，大致可以分为以下五步：

1. 创建一个RequestQueue对象。

2. 创建一个ImageLoader对象。

3. 在布局文件中添加一个NetworkImageView控件。

4. 在代码中获取该控件的实例。

5. 设置要加载的图片地址。

其中，第一第二步和ImageLoader的用法是完全一样的，因此这里我们就从第三步开始学习了。首先修改布局文件中的代码，在里面加入NetworkImageView控件，如下所示

XML

<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地址，如下所示：

1 networkImageView.setDefaultImageResId(R.drawable.default_image);
2
3 networkImageView.setErrorImageResId(R.drawable.failed_image);
4
5 networkImageView.setImageUrl("http://img.my.csdn.net/uploads/201404/13/1397393290_5765.jpeg", imageLoader);

好了，就是这么简单，现在重新运行一下程序，你将看到和使用ImageLoader来加载图片一模一样的效果，这里我就不再截图了。

这时有的朋友可能就会问了，使用ImageRequest和ImageLoader这两种方式来加载网络图片，都可以传入一个最大宽度和高度的参数来对图片进行压缩，而NetworkImageView中则完全没有提供设置最大宽度和高度的方法，那么是不是使用NetworkImageView来加载的图片都不会进行压缩呢？
其实并不是这样的，NetworkImageView并不需要提供任何设置最大宽高的方法也能够对加载的图片进行压缩。这是由于NetworkImageView是一个控件，在加载图片的时候它会自动获取自身的宽高，然后对比网络图片的宽度，再决定是否需要对图片进行压缩。也就是说，压缩过程是在内部完全自动化的，并不需要我们关心，NetworkImageView会始终呈现给我们一张大小刚刚好的网络图片，不会多占用任何一点内存，这也是NetworkImageView最简单好用的一点吧。
当然了，如果你不想对图片进行压缩的话，其实也很简单，只需要在布局文件中把NetworkImageView的layout_width和layout_height都设置成wrap_content就可以了，这样NetworkImageView就会将该图片的原始大小展示出来，不会进行任何压缩。
这样我们就把使用Volley来加载网络图片的用法都学习完了。
Volley自定义Request及使用单例封装RequestQueue

一.自定义Request

Volley的所有的请求的超类型是Resuest，所有我们常用的请求都是这个类的子类，那么我们自定义View肯定也是基于这个类的。

案例：

package com.zhy.velloydemo;

import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;

import com.android.volley.AuthFailureError;
import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.Response.ErrorListener;
import com.android.volley.Response.Listener;
import com.android.volley.toolbox.HttpHeaderParser;
import com.google.gson.Gson;
import com.google.gson.JsonSyntaxException;

public class JsonRequestWithAuth<T> extends Request<T>
{
private final Gson gson = new Gson();
private final Class<T> clazz;
private final Listener<T> listener;

private static Map<String, String> mHeader = new HashMap<String, String>();
/**
* 设置访问自己服务器时必须传递的参数，密钥等
*/
static
{
mHeader.put("APP-Key", "LBS-AAA");
mHeader.put("APP-Secret", "ad12msa234das232in");
}

/**
* @param url
* @param clazz
*            我们最终的转化类型
* @param headers
*            请求附带的头信息
* @param listener
* @param appendHeader
*            附加头数据
* @param errorListener
*/
public JsonRequestWithAuth(String url, Class<T> clazz, Listener<T> listener, Map<String, String> appendHeader,
ErrorListener errorListener)
{
super(Method.GET, url, errorListener);
this.clazz = clazz;
this.listener = listener;
mHeader.putAll(appendHeader);
}

@Override
public Map<String, String> getHeaders() throws AuthFailureError
{
// 默认返回 return Collections.emptyMap();
return mHeader;
}

@Override
protected void deliverResponse(T response)
{
listener.onResponse(response);
}

@Override
protected Response<T> parseNetworkResponse(NetworkResponse response)
{
try
{
/**
* 得到返回的数据
*/
String jsonStr = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
/**
* 转化成对象
*/
return Response.success(gson.fromJson(jsonStr, clazz), HttpHeaderParser.parseCacheHeaders(response));
} catch (UnsupportedEncodingException e)
{
return Response.error(new ParseError(e));
} catch (JsonSyntaxException e)
{
return Response.error(new ParseError(e));
}
}
}

这里说一下，我在Header中放置了APP-key等数据，也就是说只要我们这个请求发的都会有这几个值，大家开发app时肯定有很多请求参数是需要每次都发往服务器校验的，可以在这里设置。

二 使用单例模式（封装RequestQueue ）

如果app连接网络比较频繁，最合理的方式就是把RequestQueue实现为单实例类型，并这个实例在app运行的整个生命周期中存活。有两种方式实现 单实例，推荐的一种做法就是实现一个封装了请求队列和其他volley功能的单例类。还有一种不建议使用的方式就是创建一个继承Application的 字类，并在Application.onCreate（）方法中创建请求队列。一个静态的单实例类能够以模块化的方式提供同样的功能。

使 用推荐的方式实现单实例最重要的概念就是请求队列对象必须以应用上下文（application context）而不是活动上下文（activity context）的形式进行实例化。以此确保了请求队列对象在app运行的整个生命周期中存在，而不是随着活动的重新创建而创建。结合设计模式单例模式的 实现，来看看MySingleton.java类的实现，这个类提供了一个请求队列和图片加载：

private static MySingleton mInstance;
private RequestQueue mRequestQueue;
private ImageLoader mImageLoader;
private static Context mCtx;

private MySingleton(Context context){
mCtx = context;
mRequestQueue = getRequestQueue();

mImageLoader = new ImageLoader(mRequestQueue,n
new ImageLoader.ImageCache(){
private final LruCache<String,Bitmap>(20)
cache = new LruCache<String,Bitmap>(20);

@Override
public Bitmap getBitmap(String url){
return cache.get(url)；
}
@Override
public void putBitmap(String url,Bitmap bitmap){
cache.put(url,bitmap);
}
});
}

//异步获取单实例
public static synchronized MySingleton getInstance(Context context){
if(mInstance == null){
mInstance = new MySingleton(context);
}
return mInstance
}

public RequestQueue getRuquestQueue(){
if(mRequestQueue == null){
//getApplication()方法返回一个当前进程的全局应用上下文，这就意味着
//它的使用情景为：你需要一个生命周期独立于当前上下文的全局上下文，
//即就是它的存活时间绑定在进程中而不是当前某个组建。
mRequestQueue = Volley.newRequestQueue(mCtx.getApplication());
}
return mRequestQueue;
}

public <T> void addToRequestQueue(Request<T>req){
getRequestQueue.add(req);
}

public ImageLoader getImageLoader(){
return mImageLoader;
}

在上面的代码中，构造方法中封装了请求队列和图片加载，接着就是异步获取实例、获取请求队列、把请求添加到请求队列、获取图片加载。

最后我们使用这个单例类执行请求队列操作：

//获取请求队列
RequestQueue queue = MySingleton.getInstance(this.getApplication().
getRequest();
.......
//把请求（在这个例子中请求为StringRequest）添加到请求队列
MySingleton.getInstance(this).addToRequestQueue(StringRequest);

Volley二次封装

产品中使用Volley框架已有多时，本身已有良好封装的Volley确实给程序开发带来了很多便利与快捷。但随着产品功能的不断增加，服务器接口的不断复杂化，直接使用Volley原生的JSONObjectRequest已经导致Activity或Fragment层中耦合了大量的数据解析代码，同时当多处调用同一接口时，类似的数据解析代码还不可复用，导致大量重复代码的出现，已经让我越发地无法忍受。基于此，最近思考着对Volley原生的JSONObjectRequest（因为产品中目前和服务器交互所有的接口，数据都是json格式的）进行二次封装，把Activity和Fragment中大量的数据解析代码剥离出来，同时实现数据解析代码的复用。

为了把问题表现出来，先上一段坑爹的代码。

</pre><pre class="java" name="code">package com.backup;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.json.JSONException;
import org.json.JSONObject;

import com.amuro.volleytest01_image.R;
import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.JsonObjectRequest;
import com.android.volley.toolbox.Volley;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ListView;
import android.widget.SimpleAdapter;
import android.widget.TextView;

public class TestActivity02 extends Activity
{
private RequestQueue mQueue;
private ListView listView;
private List<Map<String, String>> list = new ArrayList<Map<String,String>>();

String url = "http://10.24.4.196:8081/weather.html";

@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test02_layout);
listView = (ListView)findViewById(R.id.lv_test02);
mQueue = Volley.newRequestQueue(this);
getWeatherInfo();

SimpleAdapter simpleAdapter = new SimpleAdapter(this, list,
android.R.layout.simple_list_item_2, new String[] {"title","content"},
new int[] {android.R.id.text1, android.R.id.text2});

listView.setAdapter(simpleAdapter);

listView.setOnItemClickListener(new OnItemClickListener()
{

@Override
public void onItemClick(AdapterView<?> parent, View view,
int position, long id)
{
TextView tv = (TextView)view.findViewById(android.R.id.text1);
tv.setText("111111111111111111");
}
});
}

public void getWeatherInfo()
{
JsonObjectRequest jsonObjectRequest = new JsonObjectRequest(url, null,

new Response.Listener<JSONObject>()
{

@SuppressWarnings("unchecked")
@Override
public void onResponse(JSONObject jsonObject)
{
list.clear();
Iterator<String> it = jsonObject.keys();
while (it.hasNext())
{
String key = it.next();
JSONObject obj = null;
try
{
obj = jsonObject.getJSONObject(key);
}
catch (JSONException e)
{
e.printStackTrace();
}
if (obj != null)
{
Iterator<String> objIt = obj.keys();
while (objIt.hasNext())
{
String objKey = objIt.next();
String objValue;
try
{
objValue = obj.getString(objKey);
HashMap<String, String> map = new HashMap<String, String>();
map.put("title", objKey);
map.put("content", objValue);
list.add(map);
}
catch (JSONException e)
{
e.printStackTrace();
}
}
}
}
}
},

new Response.ErrorListener()
{
@Override
public void onErrorResponse(VolleyError arg0)
{
}
});

mQueue.add(jsonObjectRequest);
}
}

上面的代码大家可以看到，复杂的json解析代码全部写在Activity里，现在如果又来一个Activity需要调用这个接口，这些解析json的代码是完全无法复用的，这不科学

下面开始分析：

1. 面向对象，对于Activity这层来说，它要的只是拿到数据进行展示，至于数据怎么变出来的，它不应该关注，所以第一件事，对数据进行封装，每个接口返回的最终数据，不应该是一个未经解析的jsonObject，而应该是一个bean，千千万万的bean最终可通过泛型来统一，so，我们先需要一个监听器，让我们封装后的Volley层直接把bean回调给Activity。

2. 对错误的处理，从目前的产品需求来看，上层Activity就是要对不同的错误展示不同的界面或跳转不同的界面，所以我们把错误统一为errorCode和errorMessage，在底层封装好后，直接抛给Activity。所以这样一个返回bean或者error的接口就出来了。

package com.amuro.volley_framwork.network_helper;

public interface UIDataListener<T>
{
public void onDataChanged(T data);
public void onErrorHappened(String errorCode, String errorMessage);
}

3. 好，监听器剥离了Activity与我们的Volley层，下面我们就要自己对Volley的JsonObjectRequest进行封装了，先贴这个类：

package com.amuro.volley_framwork.network_request;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.List;
import java.util.Map;

import org.apache.http.NameValuePair;
import org.apache.http.client.utils.URLEncodedUtils;
import org.json.JSONObject;

import com.android.volley.DefaultRetryPolicy;
import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Response;
import com.android.volley.Response.ErrorListener;
import com.android.volley.Response.Listener;
import com.android.volley.toolbox.HttpHeaderParser;
import com.android.volley.toolbox.JsonRequest;

public class NetworkRequest extends JsonRequest<JSONObject>
{
private Priority mPriority = Priority.HIGH;

public NetworkRequest(int method, String url,
Map<String, String> postParams, Listener<JSONObject> listener,
ErrorListener errorListener)
{
super(method, url, paramstoString(postParams), listener, errorListener);
setRetryPolicy(new DefaultRetryPolicy(30000, 0, DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));
}

public NetworkRequest(String url, List<NameValuePair> params,
Listener<JSONObject> listener, ErrorListener errorListener)
{
this(Method.GET, urlBuilder(url, params), null, listener, errorListener);
}

public NetworkRequest(String url, Listener<JSONObject> listener, ErrorListener errorListener)
{
this(Method.GET, url, null, listener, errorListener);
}

private static String paramstoString(Map<String, String> params)
{
if (params != null && params.size() > 0)
{
String paramsEncoding = "UTF-8";
StringBuilder encodedParams = new StringBuilder();
try
{
for (Map.Entry<String, String> entry : params.entrySet())
{
encodedParams.append(URLEncoder.encode(entry.getKey(),
paramsEncoding));
encodedParams.append('=');
encodedParams.append(URLEncoder.encode(entry.getValue(),
paramsEncoding));
encodedParams.append('&');

}
return encodedParams.toString();
}
catch (UnsupportedEncodingException uee)
{
throw new RuntimeException("Encoding not supported: "
+ paramsEncoding, uee);
}
}
return null;
}

@Override
protected Response<JSONObject> parseNetworkResponse(NetworkResponse response)
{

try
{

JSONObject jsonObject = new JSONObject(new String(response.data, "UTF-8"));

return Response.success(jsonObject,
HttpHeaderParser.parseCacheHeaders(response));

}
catch (Exception e)
{

return Response.error(new ParseError(e));

}
}

@Override
public Priority getPriority()
{
return mPriority;
}

public void setPriority(Priority priority)
{
mPriority = priority;
}

private static String urlBuilder(String url, List<NameValuePair> params)
{
return url + "?" + URLEncodedUtils.format(params, "UTF-8");
}
}

4. 接下来就是我们的重头戏，写一个Controller来操作这个request，同时对数据进行bean或error的封装，这是一个抽象类，让不同的子类根据不同的接口，趋实现不同的数据解析方式：

package com.amuro.volley_framwork.network_helper;

import java.util.List;
import java.util.Map;

import org.apache.http.NameValuePair;
import org.json.JSONObject;

import android.content.Context;
import android.util.Log;

import com.amuro.volley_framwork.network_request.NetworkRequest;
import com.amuro.volley_framwork.volley_queue_controller.VolleyQueueController;
import com.android.volley.Request.Method;
import com.android.volley.Response;
import com.android.volley.Response.ErrorListener;
import com.android.volley.VolleyError;

public abstract class NetworkHelper<T> implements Response.Listener<JSONObject>, ErrorListener
{
private Context context;

public NetworkHelper(Context context)
{
this.context = context;
}

protected Context getContext()
{
return context;
}

protected NetworkRequest getRequestForGet(String url, List<NameValuePair> params)
{
if(params == null)
{
return new NetworkRequest(url, this, this);
}
else
{
return new NetworkRequest(url, params, this, this);
}

}

protected NetworkRequest getRequestForPost(String url, Map<String, String> params)
{
return new NetworkRequest(Method.POST, url, params, this, this);
}

public void sendGETRequest(String url, List<NameValuePair> params)
{
VolleyQueueController.getInstance().
getRequestQueue(getContext()).add(getRequestForGet(url, params));
}

public void sendPostRequest(String url, Map<String, String> params)
{
VolleyQueueController.getInstance().
getRequestQueue(context).add(getRequestForPost(url, params));
}

@Override
public void onErrorResponse(VolleyError error)
{
Log.d("Amuro", error.getMessage());
disposeVolleyError(error);
}

protected abstract void disposeVolleyError(VolleyError error);

@Override
public void onResponse(JSONObject response)
{
Log.d("Amuro", response.toString());
disposeResponse(response);
}

protected abstract void disposeResponse(JSONObject response);

private UIDataListener<T> uiDataListener;

public void setUiDataListener(UIDataListener<T> uiDataListener)
{
this.uiDataListener = uiDataListener;
}

protected void notifyDataChanged(T data)
{
if(uiDataListener != null)
{
uiDataListener.onDataChanged(data);
}
}

protected void notifyErrorHappened(String errorCode, String errorMessage)
{
if(uiDataListener != null)
{
uiDataListener.onErrorHappened(errorCode, errorMessage);
}
}

}

这里对外直接提供了sendGetRequest方法和sendPostRequest方法，做为api就是要清晰明了，不要让调用者去了解还有Method.GET这样的东西，同时getRequestForGet方法和getRequestForPost方法把最常用的request直接封装好，不需要子类再去写new request的代码。当然为了拓展，这两个方法是protected的，default的request不能符合要求的时候，子类就可直接覆盖这两个方法返回自己的request，而disposeResponse和disponseError两个方法都为抽象方法，让子类针对不同的接口，实现不同的功能。

5. 下面来个子类实例，一看就懂。

package com.amuro.controller.networkhelper;

import org.json.JSONObject;

import android.content.Context;

import com.amuro.bean.RRBean;
import com.amuro.utils.SystemParams;
import com.amuro.volley_framwork.network_helper.NetworkHelper;
import com.android.volley.VolleyError;

//{"errorCode":"0000","errorMessage":"成功","respMsg":"success","success":"true"}
public class ReverseRegisterNetworkHelper extends NetworkHelper<RRBean>
{

public ReverseRegisterNetworkHelper(Context context)
{
super(context);
}

@Override
protected void disposeVolleyError(VolleyError error)
{
notifyErrorHappened(
SystemParams.VOLLEY_ERROR_CODE,
error == null ? "NULL" : error.getMessage());
}

@Override
protected void disposeResponse(JSONObject response)
{
RRBean rrBean = null;

if(response != null)
{
try
{
String errorCode = response.getString("errorCode");
String errorMessage = response.getString("errorMessage");
String respMsg = response.getString("respMsg");
String success = response.getString("success");

if("0000".equals(errorCode))
{
rrBean = new RRBean();
rrBean.setErrorCode(errorCode);
rrBean.setErrorMessage(errorMessage);
rrBean.setRespMsg(respMsg);
rrBean.setSuccess(success);

notifyDataChanged(rrBean);
}
else
{
notifyErrorHappened(errorCode, errorMessage);
}
}
catch(Exception e)
{
notifyErrorHappened(SystemParams.RESPONSE_FORMAT_ERROR, "Response format error");
}
}
else
{
notifyErrorHappened(SystemParams.RESPONSE_IS_NULL, "Response is null!");
}
}
}

5. 大功告成，这个NetworkHelper封装了数据解析的代码，完全可复用，最后看Activity

package com.amuro.ui;

import com.amuro.bean.RRBean;
import com.amuro.controller.networkhelper.ReverseRegisterNetworkHelper;
import com.amuro.utils.SystemParams;
import com.amuro.volley_framwork.network_helper.NetworkHelper;
import com.amuro.volley_framwork.network_helper.UIDataListener;
import com.amuro.volleytest01_image.R;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;

public class MyVolleyTestActivity extends Activity implements UIDataListener<RRBean>
{
private Button button;

private NetworkHelper<RRBean> networkHelper;

@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_my_volley_test_layout);

networkHelper = new ReverseRegisterNetworkHelper(this);
networkHelper.setUiDataListener(this);

button = (Button)findViewById(R.id.bt);
button.setOnClickListener(new OnClickListener()
{

@Override
public void onClick(View v)
{
sendRequest();
}
});
}

private void sendRequest()
{
networkHelper.sendGETRequest(SystemParams.TEST_URL, null);
}

@Override
public void onDataChanged(RRBean data)
{
Toast.makeText(
this,
data.getErrorCode() + ":" +
data.getErrorMessage() + ":" +
data.getRespMsg() + ":" +
data.getSuccess(),
Toast.LENGTH_SHORT).show();

}

@Override
public void onErrorHappened(String errorCode, String errorMessage)
{
Toast.makeText(
this,
errorCode + ":" + errorMessage,
Toast.LENGTH_SHORT).show();

}
}

看，Activity直接拿到的就是数据或者errorCode，把一大堆复杂的数据解析代码剥离了