[Android]Volley源码分析（一）

一. 如何使用Volley？

1. 首先定义一个RequestManager类，用来在Android程序启动时对Volley进行初始化。RequestManager为单例类，因为只有在程序启动时调用，所以不需要考虑并发问题。

/**
* Manager for the queue
*/
public class RequestManager {

/**
* 请求队列
*/
private static RequestQueue mRequestQueue;

/**
* 私有化构造函数
*/
private RequestManager() {
// no instances
}

/**
* @param context 应用程序上下文
*/
public static void init(Context context) {
mRequestQueue = Volley.newRequestQueue(context);
}

/**
* @return
*         请求队列
* @throws
*         IllegalStatException if init has not yet been called
*/
public static RequestQueue getRequestQueue() {
if (mRequestQueue != null) {
return mRequestQueue;
} else {
throw new IllegalStateException("Not initialized");
}
}
}

2. 为了方便对请求的Body（PUT或POST请求时）及响应体进行解析，我们可以继承Volley的Request类，自定义一个通过Gson来解析请求与响应的Request。

/**
* Wrapper for Volley requests to facilitate parsing of json responses.
*/
public class MyGsonRequest<T> extends Request<T>{

/** Charset for request. */
private static final String PROTOCOL_CHARSET = "utf-8";
/** Content type for request. */
private static final String PROTOCOL_CONTENT_TYPE =
String.format("application/json; charset=%s", PROTOCOL_CHARSET);
/**
* Gson parser
*/
private final Gson mGson;
/**
* Class type for the response
*/
private final Class<T> mResponseClass;
private final Object mRequestBody;

/**
* Callback for response delivery
*/
private final Listener<T> mListener;

/**
* @param method
*         Request type.. Method.GET etc
* @param url
*         path for the requests
* @param requestBody
*         Q type instance as request body, if no request body needed set it to null
* @param responseClass
*         expected class type for the response. Used by gson for serialization.
* @param listener
*         handler for the response
* @param errorListener
*         handler for errors
*/
public MyGsonRequest(int method
, String url
, Object requestBody
, Class<T> responseClass
, Listener<T> listener
, ErrorListener errorListener) {

super(method, url, errorListener);
this.mRequestBody = requestBody;
this.mResponseClass = responseClass;
this.mListener = listener;
mGson = new Gson();

}

@Override
protected Response<T> parseNetworkResponse(NetworkResponse response) {
try {
String json = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
return Response.success(mGson.fromJson(json, mResponseClass),
HttpHeaderParser.parseCacheHeaders(response));
} catch (UnsupportedEncodingException e) {
return Response.error(new ParseError(e));
} catch (JsonSyntaxException e) {
return Response.error(new ParseError(e));
}
}

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

@Override
public String getBodyContentType() {
return PROTOCOL_CONTENT_TYPE;
}

@Override
public byte[] getBody() {
try {
return mRequestBody == null ? null : mGson.toJson(mRequestBody).getBytes(PROTOCOL_CHARSET);
} catch (UnsupportedEncodingException uee) {
VolleyLog
.wtf("Unsupported Encoding while trying to get the bytes of %s using %s",
mGson.toJson(mRequestBody), PROTOCOL_CHARSET);
return null;
}
}
}

需要重写Request的以下方法：

1）. parseNetworkResponse 通过Gson将服务器返回的Json字符串解析为你想要的对象 mGson.fromJson(json, mResponseClass)

2）. deliverResponse 调用你自定义的实现了Response.Listener接口的回调方法onResponse

3）. getBodyContentType 获取请求体的内容类型，如json类型，编码为utf-8

4）. getBody 获取请求体的字节数组表示。 同样是通过Gson将你的请求体中对象转换为Json字符串来获取字节数组 mGson.toJson(mRequestBody).getBytes(PROTOCOL_CHARSET)

3. 接下来可以针对不同的领域模型定义一些客户端类，比如对用户的一些服务器请求操作可以定义一个UserManager类，实现注册、登录等功能。

public class UserManager {
　　　　public static UserManager getInstance(){
if(mInstance == null) {
mInstance = new UserManager();
}
return mInstance;
}

　　　　public void register(Listener<String> listener, ErrorListener errorListener, User user){
Uri.Builder uriBuilder = Uri.parse(USER_BASE_URL).buildUpon();
String uri = uriBuilder.build().toString();
MyGsonRequest<String> request = new MyGsonRequest<String>(Method.POST
, uri
, user
, String.class
, listener
, errorListener);

Log.v(TAG, request.toString());
RequestManager.getRequestQueue().add(request);
}
}

上述代码实例化了一个request，将这个request加入Volley的请求队列中，由Volley来负责对请求进行调度处理。

3. 然后别忘了在程序的Application类中，对Volley进行初始化

public class MainApplication extends Application {
@Override
public void onCreate() {
super.onCreate();
RequestManager.init(this);
//其他初始化
}
...
}

4. 最后在具体的Activity中，就可以通过如下方式对服务器发起注册请求了。

//比如点击注册按钮，在onClick方法中调用
UserManager.getInstance().register(createLoginSuccessListener(),
createLoginErrorListener(), user);
//请求成功返回时调用
private Listener<String> createRegisterSuccessListener() {
return new Listener<String>() {
@Override
public void onResponse(String response) {
if (mProgressDialog != null) {
mProgressDialog.dismiss();
}
Toast.makeText(
RegisterActivity.this,
getString(R.string.msg_register_success),
Toast.LENGTH_SHORT).show();

}
};
}

//请求失败时调用
private Response.ErrorListener createRegisterErrorListener() {
return new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
if (mProgressDialog != null) {
mProgressDialog.dismiss();
}
Toast.makeText(
RegisterActivity.this,
VolleyErrorUtil.getMessage(error, RegisterActivity.this),
Toast.LENGTH_SHORT).show();
}
};
}