一個封裝Volley框架的幫助類

實現了String,JSONObject以及Image的簡單封裝，方便了使用者進行調用。

/**
 * VolleyHelper
 *
 * @author mislead
 *         2015/6/29
 *         DESC:
 **/
public class VolleyHelper {

  private static String TAG = "VolleyHelper";

  private static RequestQueue queue = null;

  // set time out limit is 20s, not retry
  private static RetryPolicy defaultPolicy = new DefaultRetryPolicy(20 * 1000, 1, 1.0f);

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

  /**
   * requestStringGet
   *
   * @param url request url
   * @param listener handle request listener
   */
  public static void requestStringGet(String url, ResponseListener<String> listener) {
    StringRequest request = new StringRequest(Request.Method.GET, url, listener, listener);
    request.setShouldCache(true);
    request.setTag(url);
    queue.add(request);
  }

  public static void requestStringWithParams(int method, String url,
      ResponseListener<String> listener, final Map<String, String> params) {
    requestStringWithHeadersAndParams(method, url, listener, null, params);
  }

  public static void requestStringWithHeadersAndParams(int method, String url,
      ResponseListener<String> listener, final Map<String, String> headers,
      final Map<String, String> params) {
    StringRequest request = new StringRequest(method, url, listener, listener) {
      @Override protected Map<String, String> getParams() throws AuthFailureError {
        if (params == null) {
          return super.getParams();
        } else {
          return params;
        }
      }

      @Override public Map<String, String> getHeaders() throws AuthFailureError {
        if (headers == null) {
          return super.getHeaders();
        } else {
          return headers;
        }
      }
    };
    request.setShouldCache(true);
    request.setTag(url);
    request.setRetryPolicy(defaultPolicy);
    queue.add(request);
  }

  public static void requestJSONObjectWithEncodingParams(int method, String url,
      ResponseListener<JSONObject> listener, final Map<String, String> params) {
    JsonObjectRequest request = new JsonObjectRequest(method, url, null, listener, listener) {
      @Override protected Map<String, String> getParams() throws AuthFailureError {
        if (params == null) {
          return super.getParams();
        } else {
          return params;
        }
      }

      @Override protected String getParamsEncoding() {
        return super.getParamsEncoding();
      }
    };
    request.setShouldCache(true);
    request.setTag(url);
    request.setRetryPolicy(defaultPolicy);
    queue.add(request);
  }

  public static void requestJSONObject(int method, String url, JSONObject requestJson,
      ResponseListener<JSONObject> listener) {

    requestJSONObjectWithHeader(method, url, requestJson, listener, null);
  }

  public static void requestJSONObjectWithHeader(int method, String url, JSONObject requestJson,
      ResponseListener<JSONObject> listener, final Map<String, String> header) {
    requestJSONObjectWithHeaderAndParams(method, url, requestJson, listener, header, null);
  }

  public static void requestJSONObjectWithParams(int method, String url, JSONObject requestJson,
      ResponseListener<JSONObject> listener, final Map<String, String> params) {
    requestJSONObjectWithHeaderAndParams(method, url, requestJson, listener, null, params);
  }

  public static void requestJSONObjectWithHeaderAndParams(int method, String url,
      JSONObject requestJson, ResponseListener<JSONObject> listener,
      final Map<String, String> header, final Map<String, String> params) {
    JsonObjectRequest request;
    request = new JsonObjectRequest(method, url, requestJson, listener, listener) {
      @Override public Map<String, String> getHeaders() throws AuthFailureError {
        if (header == null) {
          return super.getHeaders();
        } else {
          return header;
        }
      }

      @Override protected Map<String, String> getParams() throws AuthFailureError {
        if (params == null) {
          return super.getParams();
        } else {
          return params;
        }
      }
    };
    request.setRetryPolicy(defaultPolicy);
    request.setTag(url);
    queue.add(request);
  }

  public static void requestKanxuePost(String url, ResponseListener<KanxueResponse> listener,
      Map<String, String> params) {
    KanxuePostJSONRequest request = new KanxuePostJSONRequest(url, listener);
    request.setParams(params);
    request.setRetryPolicy(defaultPolicy);
    request.setTag(url);
    queue.add(request);
  }

  public static void requestPostWithJSONParams(String url, ResponseListener<JSONObject> listener,
      Map<String, String> params) {
    JsonObjectRequest request =
        new JsonObjectRequest(Request.Method.POST, url, new JSONObject(params), listener, listener);
    request.setRetryPolicy(defaultPolicy);
    request.setTag(url);
    queue.add(request);
  }

  /**
   * requestImageWithoutCache
   * if success, you can get the bitmap you requested.
   * if you want cache the bitmap, use {@link #requestImageWithCache(String, ImageView,
   * ImageLoader.ImageCache, int, int, int, int)} or {@link #requestImageWithCacheSimple(String,
   * ImageLoader.ImageCache, ImageLoader.ImageListener)}
   *
   * @param url request url
   * @param maxWidth bitmap maximum width
   * @param maxHeight bitmap maximum height
   * @param config bitmap code type ARGB_8888,RGB_565,ALPHA_8
   * @param listener handler request listener
   */
  public static void requestImageWithoutCache(String url, int maxWidth, int maxHeight,
      Bitmap.Config config, ResponseListener<Bitmap> listener) {
    ImageRequest request = new ImageRequest(url, listener, maxWidth, maxHeight, config, listener);
    request.setShouldCache(true);
    request.setTag(url);
    queue.add(request);
  }

  public static void requestImageViewWithoutCache(String url, ResponseListener<Bitmap> listener) {
    requestImageViewWithoutCache(url, Bitmap.Config.RGB_565, listener);
  }

  public static void requestImageViewWithoutCache(String url, Bitmap.Config config,
      ResponseListener<Bitmap> listener) {
    requestImageWithoutCache(url, 0, 0, config, listener);
  }

  /**
   * requestImageWithCache
   * you can set default image & error image on the view.
   *
   * if not needed set default image ,you can use {@link #requestImageWithCacheSimple(String,
   * ImageLoader.ImageCache, ImageLoader.ImageListener)}
   *
   * @param url request url
   * @param imageView imageView to display image
   * @param cache image cache
   * @param defaultImageResId default image
   * @param errorImageResId error image
   * @param maxWidth maximum image width
   * @param maxHeight maximum image height
   */
  public static void requestImageWithCache(String url, ImageView imageView,
      ImageLoader.ImageCache cache, int defaultImageResId, int errorImageResId, int maxWidth,
      int maxHeight) {
    ImageLoader imageLoader = new ImageLoader(queue, cache);
    imageLoader.get(url,
        ImageLoader.getImageListener(imageView, defaultImageResId, errorImageResId), maxWidth,
        maxHeight);
  }

  public static void requestImageWithCache(String url, ImageView imageView,
      ImageLoader.ImageCache cache, int defaultImageResId, int errorImageResId) {
    requestImageWithCache(url, imageView, cache, defaultImageResId, errorImageResId, 0, 0);
  }

  /**
   * requestImageWithCacheSimple
   * request a image, cache it,and deal it in listener.
   * if you don't need, use {@link #requestAndCacheImage(String, ImageLoader.ImageCache)}
   *
   * @param url request url
   * @param cache image cache
   * @param listener image request listener
   */
  public static void requestImageWithCacheSimple(String url, ImageLoader.ImageCache cache,
      ImageLoader.ImageListener listener) {
    ImageLoader imageLoader = new ImageLoader(queue, cache);
    imageLoader.get(url, listener);
  }

  public static void requestImageWithCacheAndHeader(String url, final Map<String, String> headers,
      ResponseListener<Bitmap> listener) {
    com.android.volley.toolbox.ImageRequest request =
        new com.android.volley.toolbox.ImageRequest(url, listener, 0, 0, Bitmap.Config.RGB_565,
            listener) {
          @Override public Map<String, String> getHeaders() throws AuthFailureError {
            if (headers != null) {
              return headers;
            } else {
              return super.getHeaders();
            }
          }
        };

    request.setRetryPolicy(defaultPolicy);
    request.setTag(url);
    request.setShouldCache(true);
    queue.add(request);
  }

  /**
   * requestAndCacheImage
   * just cahce a image for the next use.
   * if you want to deal it immediately, use {@link #requestImageWithCacheSimple(String,
   * ImageLoader.ImageCache, ImageLoader.ImageListener)}
   */
  public static void requestAndCacheImage(String url, ImageLoader.ImageCache cache) {
    requestImageWithCacheSimple(url, cache, new SimpleImageListener());
  }

  /**
   * getCacheKey
   * get cache key about image url, used for getImage from cache;
   *
   * @param url image url
   * @param maxWidth cache maximum width
   * @param maxHeight cache maximum height
   */
  public static String getCacheKey(String url, int maxWidth, int maxHeight) {
    return (new StringBuilder(url.length() + 12)).append("#W")
        .append(maxWidth)
        .append("#H")
        .append(maxHeight)
        .append(url)
        .toString();
  }

  public static String getCacheKey(String url) {
    return getCacheKey(url, 0, 0);
  }

  public static interface ResponseListener<T> extends Response.Listener<T>, Response.ErrorListener {

  }

  static class SimpleImageListener implements ImageLoader.ImageListener {

    @Override public void onResponse(ImageLoader.ImageContainer imageContainer, boolean b) {

    }

    @Override public void onErrorResponse(VolleyError volleyError) {

    }
  }
}