[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();
			}
		};
}