Volley的使用

一：volley在android2.3之前使用的是HttpClient进行联网，在2.3及以上版本使用的是HttpUrlConnection联网方式；
     android新的网络通信库，更快更稳定；适用于通信数据量不大，但是非常频繁的情景；
二：volley提供的功能：
JSON，图像等的异步下载；
网络请求的排序（scheduling）
网络请求的优先级处理
缓存
多级别取消请求
和Activity和生命周期的联动（Activity结束时同时取消所有网络请求）
三：适用volley的NetworkImageView
Volley提供了一个新的控件NetworkImageView来代替传统的ImageView，这个控件的图片属性可以通过
mImageView.setImageUrl(url, imageLoader)
来设定。而且，这个控件在被从父控件detach的时候，会自动取消网络请求的，即完全不用我们担心相关网络请求的生命周期问题。
四：适用自定制的request
我们也可以通过继承Request根据自己的需求来定制自己的request
@Override
protected Response 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));
    }
}
里面使用的gson（com.google.gson.Gson）是JSON的序列化和反序列化的库，可以在JSON和java model object之间进行转换。
以下是使用自定制request的例子：
mRequestQueue.add( new GsonRequest(url, ListResponse.class, null,
    new Listener() {
        public void onResponse(ListResponse response) {
            appendItemsToList(response.item);
            notifyDataSetChanged();
        }
    }
}

五：volley使用示例：
1.创建自己的request继承自Volley的request，实现相应的方法，设置请求信息和请求成功回调接口；
public class VolleyRequest extends Request<NetworkResponse> {

private final Listener<NetworkResponse> mListener;
private byte[] mRequestBytes;
private Map<String, String> mHeaders;

/**
* 初始化请求
*
* @param method
*            请求类型
* @param url
*            请求地址
* @param listener
*            成功回调
* @param errorListener
*            失败回调
*
* */
public VolleyRequest(int method, String url,
Listener<NetworkResponse> listener,
Response.ErrorListener errorListener) {
super(method, url, errorListener);
mListener = listener;

}

@Override
protected void deliverResponse(NetworkResponse response) {
mListener.onResponse(response);
}

@Override
protected Response<NetworkResponse> parseNetworkResponse(
NetworkResponse response) {
return Response.success(response,
HttpHeaderParser.parseCacheHeaders(response));
}

public void setRequestBytes(byte[] pRequestBytes) {
this.mRequestBytes = pRequestBytes;
}

@Override
public byte[] getBody() throws AuthFailureError {
return mRequestBytes;
}

public void setHeaders(Map<String, String> pHeaders) {
this.mHeaders = pHeaders;
}

@Override
public Map<String, String> getHeaders() throws AuthFailureError {
if(mHeaders!=null&&mHeaders.size()>0)
return mHeaders;
return  Collections.emptyMap();
}

}
2.创建一个外部调用Volley的接口，该接口提供创建自定义request以及对应回调接口的方法：
public class VolleyConnection {

private Context mContext;
private String mUrl;
private byte[] mRequestBytes;
private IHttpCallback mHttpCallback;
private int METHOD;

/**
* 判断同步方式 HTTP POST或GET
*
* @param aUrl
*            服务器地址
* @param aRequestBytes
*            POST到服务器的数据。
* @param aCallBack
*            回调接口。
*
* */
public VolleyConnection(Context aContext, String aUrl,
byte[] aRequestBytes, IHttpCallback aCallBack) {
mContext = aContext;
mUrl = aUrl;
mRequestBytes = aRequestBytes;
mHttpCallback = aCallBack;
if (mRequestBytes == null || mRequestBytes.length == 0)
METHOD = Request.Method.GET;
else
METHOD = Request.Method.POST;
}

private Listener<NetworkResponse> getResponseListener() {
return new Response.Listener<NetworkResponse>() {
@Override
public void onResponse(NetworkResponse response) {
if (mHttpCallback != null) {
mHttpCallback.onCompleted(response.statusCode,
response.data);
}
}
};
}

private ErrorListener getErrorListener() {
return new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
if (mHttpCallback != null) {
mHttpCallback.onException(error);
}
}
};
}

public void connect() {
VolleyRequest request = new VolleyRequest(METHOD, mUrl,
getResponseListener(), getErrorListener());
// if (BasicAuthorUtil.isBasicAuthor(mUrl)) {
Map<String, String> headers = new HashMap<String, String>();
headers.put(
"Authorization",
"Basic "
+ new String(Base64.encodeBase64("flsyjh:flSYjhx2012"
.getBytes())));
request.setHeaders(headers);
// }
request.setRequestBytes(mRequestBytes);
VolleyConnectionManager.addRequest(request, mContext);
}

}
3.提供一个Manager对象，该对象提供 一个全局静态变量RequestQueue，并在应用启动时初始化该队列，并在内部封装添加自定义request和提供自定义request的接口；外部接口进行联网时每次创建一个requst然后放到requestQueue列表；
public class VolleyConnectionManager {

private static RequestQueue mRequestQueue;

public static void init(Context context) {
mRequestQueue = Volley.newRequestQueue(context);
}

public static RequestQueue getRequestQueue() {
if (mRequestQueue != null) {
return mRequestQueue;
} else {
throw new IllegalStateException("RequestQueue not initialized");
}
}

public static void addRequest(Request<?> request, Object tag) {
if (tag != null) {
request.setTag(tag);
}
mRequestQueue.add(request);
}

public static void cancelAll(Object tag) {
mRequestQueue.cancelAll(tag);
}
}