Android 截击请求不带参数

我有一个自定义截击请求，但在发送请求时没有使用我的参数，我的代码怎么了？ 我在

getParams

和

getPostParams

设置了一个断点，但它们都没有通过

我使用了

com.mcxiaoke.volley:library:1.0.+

，它是从GoogleVolley派生来支持maven的

我发现这门课在real device上很好，但在genymotion上却不行

public class GsonRequest<T> extends Request<T> {
  private Class<T> clazz;
  private Map<String, String> headers;
  private Map<String, String> params;
  private Listener<T> listener;

  public GsonRequest(Api api, Class<T> clazz, Listener<T> listener, ErrorListener errorListener) {
    this(api, clazz, null, null, listener, errorListener);
  }

  public GsonRequest(Api api, Class<T> clazz, Map<String, String> params, Listener<T> listener,
      ErrorListener errorListener) {
    this(api, clazz, params, null, listener, errorListener);
  }

  /**
   * Make a GET request and return a parsed object from JSON.
   *
   * @param url
   *            URL of the request to make
   * @param clazz
   *            Relevant class object, for Gson's reflection
   * @param headers
   *            Map of request headers
   */
  public GsonRequest(Api api, Class<T> clazz, Map<String, String> params, Map<String, String> headers,
      Listener<T> listener, ErrorListener errorListener) {
    super(api.method, api.url, errorListener);
    this.clazz = clazz;
    this.params = params;
    this.headers = headers;
    this.listener = listener;
  }

  // use new GsonRequest()
  @Deprecated
  public GsonRequest(String url, Class<T> clazz, Map<String, String> headers, Listener<T> listener,
      ErrorListener errorListener) {
    super(Method.GET, url, errorListener);
    this.clazz = clazz;
    this.headers = headers;
    this.listener = listener;
  }

  @Override
  public Map<String, String> getHeaders() throws AuthFailureError {
    return headers != null ? headers : super.getHeaders();
  }

  @Override
    public Map<String, String> getParams() throws AuthFailureError {  
    Map<String, String> result = params;
    return result;
    }

  @Override
  public Map<String, String> getPostParams() throws AuthFailureError {   
    Map<String, String> result = params;
    return result;
  }

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

  @Override
  protected Response<T> parseNetworkResponse(NetworkResponse response) {
    try {
      String json = new String(response.data, HttpHeaderParser.parseCharset(response.headers, "utf-8"));
//      Log.d("zhch", json);
      return Response.success(GsonUtils.fromJson(json, clazz), HttpHeaderParser.parseCacheHeaders(response));
    } catch (UnsupportedEncodingException e) {
      return Response.error(new ParseError(e));
    } catch (JsonSyntaxException e) {
      return Response.error(new ParseError(e));
    }
  }
}

公共类GsonRequest扩展请求{
私人课堂；
私有映射头；
私有映射参数；
私人倾听者；
公共GsonRequest（Api、类clazz、侦听器侦听器、ErrorListener ErrorListener）{
这（api、clazz、null、null、listener、errorListener）；
}
公共GsonRequest（Api、类clazz、映射参数、侦听器、，
ErrorListener（错误监听器）{
这（api、clazz、params、null、listener、errorListener）；
}
/**
*发出GET请求并从JSON返回已解析的对象。
*
*@param-url
*要发出的请求的URL
*@param-clazz
*相关类对象，用于Gson的反射
*@param头文件
*请求头的映射
*/
公共GsonRequest（Api、类clazz、映射参数、映射头、，
监听器监听器，错误监听器（错误监听器）{
super（api.method、api.url、errorListener）；
this.clazz=clazz；
this.params=params；
this.headers=标题；
this.listener=listener；
}
//使用新的GsonRequest（）
@不赞成
公共GsonRequest（字符串url、类clazz、映射头、侦听器、，
ErrorListener（错误监听器）{
super（Method.GET、url、errorListener）；
this.clazz=clazz；
this.headers=标题；
this.listener=listener；
}
@凌驾
公共映射getHeaders（）引发AuthFailureError{
返回标题！=null？标题：super.getHeaders（）；
}
@凌驾
公共映射getParams（）引发AuthFailureError{
映射结果=参数；
返回结果；
}
@凌驾
公共映射getPostParams（）引发AuthFailureError{
映射结果=参数；
返回结果；
}
@凌驾
受保护的无效交付响应（T响应）{
onResponse（response）；
}
@凌驾
受保护的响应parseNetworkResponse（NetworkResponse响应）{
试一试{
String json=新字符串（response.data，HttpHeaderParser.parseCharset（response.headers，“utf-8”）；
//Log.d（“zhch”，json）；
返回Response.success（GsonUtils.fromJson（json，clazz），HttpHeaderParser.parseCacheHeaders（Response））；
}捕获（不支持的编码异常e）{
返回Response.error（新的ParseError（e））；
}捕获（JsonSyntaxException e）{
返回Response.error（新的ParseError（e））；
}
}
}

此答案假设您正在尝试发出GET请求

我也有类似的问题。在使用截击传递参数时，GET请求与POST请求略有不同。 当您发出GET请求时，传递参数的方法之一是在url字符串本身内部，这对我很有用：

（这是一个局部示例，但应该为您提供修改自己的代码所需的大部分内容）

在发送请求的类中，我使用了一个小方法将参数附加到url：

//this method sits somewhere in your class
private String createGetWithParams(String url, Map<String, Object> params)
{
    StringBuilder builder = new StringBuilder();
    for (String key : params.keySet())
    {
        Object value = params.get(key);
        if (value != null)
        {
            try
            {
                value = URLEncoder.encode(String.valueOf(value), HTTP.UTF_8);
                if (builder.length() > 0)
                    builder.append("&");
                builder.append(key).append("=").append(value);
            }
            catch (UnsupportedEncodingException e)
            {
            }
        }
    }

    return (url += "?" + builder.toString());
}


//this method sits somewhere in the same class, this fires the request
public void doSomeRequest()
{
    Map<String, Object> jsonParams = new HashMap<>();
    jsonParams.put("SomeParam", SomeParamValue);
    jsonParams.put("SomeOtherParam", SomeOtherParamValue);

    String url = createGetWithParams("some/request/url", jsonParams);

    StringRequest request = new StringRequest(Request.Method.GET, url,
            new Response.Listener<String>()
            {
                @Override
                public void onResponse(String response)
                {
                 // do whatever
                }
            },
            new Response.ErrorListener()
            {
                @Override
                public void onErrorResponse(VolleyError error)
                {
                    if (null != error.networkResponse)
                    {
                        Log.d(" Volley Error Response code: ", ""+ error.networkResponse.statusCode);
                    }
                }
            });

      requestQueue.add(request);

//此方法位于类中的某个位置
私有字符串createGetWithParams（字符串url、映射参数）
{
StringBuilder=新的StringBuilder（）；
for（字符串键：params.keySet（））
{
对象值=params.get（键）；
if（值！=null）
{
尝试
{
value=URLEncoder.encode（String.valueOf（value），HTTP.UTF_8）；
如果（builder.length（）>0）
建筑商。追加（“&”）；
builder.append（key.append（“=”）.append（value）；
}
捕获（不支持的编码异常e）
{
}
}
}
返回（url+=“？”+builder.toString（））；
}
//此方法位于同一类中的某个位置，这将触发请求
公共无效DoSomereRequest（）
{
Map jsonParams=newhashmap（）；
jsonParams.put（“SomeParam”，SomeParamValue）；
jsonParams.put（“SomeOtherParam”，SomeOtherParamValue）；
字符串url=createGetWithParams（“some/request/url”，jsonParams）；
StringRequest=新的StringRequest（request.Method.GET，url，
新的Response.Listener（）
{
@凌驾
公共void onResponse（字符串响应）
{
//做任何事
}
},
新的Response.ErrorListener（）
{
@凌驾
公共无效onErrorResponse（截击错误）
{
if（null！=错误。networkResponse）
{
Log.d（“截击错误响应代码：”，“+错误.networkResponse.statusCode”）；
}
}
});
添加（请求）；

我还创建了一个自定义请求类，该类替换了StringRequest，但这是为了更好地控制对响应的解析—不过可能会对您有所帮助，在这个类中，我只覆盖响应：

public class CustomStringRequest extends StringRequest
{
 private final Response.Listener<String> mListener;

 public CustomStringRequest(int method, String url, Response.Listener<String> listener, Response.ErrorListener errorListener)
 {
    super(method,url, listener, errorListener);
    mListener = listener;
 }

 @Override
 protected Response<String> parseNetworkResponse(NetworkResponse response)
 {
     try
     {
         // response.data is the byte array, do whatever..
         String responseBody = new String(response.data, "utf-8");
         Log.d(" NetworkResponse", responseBody);

         return (Response.success(responseBody, getCacheEntry()));
     }
     catch (UnsupportedEncodingException e)
     {
         VolleyLog.e("UnsupportedEncodingException");
         Log.d("NetworkResponse Exception", e.getMessage() );
         return (null);
     }
 }

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

公共类CustomStringRequest扩展了StringRequest
{
私人最终回应。监听器；
公共CustomStringRequest（int方法、字符串url、Response.Listener、Response.ErrorListener ErrorListener）
{
super（方法、url、侦听器、errorListener）；
mListener=监听器；
}
@凌驾
受保护的响应parseNetworkResponse（NetworkResponse响应）
{
尝试
{
//response.data是字节数组，请执行任何操作。。
字符串responseBody=新字符串（response.data，“utf-8”）；
Log.d（“网络响应”，响应库）；
return（Response.success（responseBody，getCacheEntry（））；
}
捕获（不支持的编码异常e）
{
截击日志（UnsupportedEncodingException）；
瞧