Android 截击-如何发送删除请求参数？

我正在尝试使用Volley向我的服务器发送一个删除类型请求，并向该请求添加参数。到目前为止我还没能做到

创建自定义请求并重写getParams（）方法对我没有帮助，因为删除类型请求不会调用此方法

---

如何在凌空中向删除请求添加参数？

在阅读凌空的代码之后，我得出结论，凌空中没有将参数附加到删除请求的方法，这很可能是一种设计选择，因为这似乎是普遍不赞成的

我想弄清楚怎么做，因为我想给发送到服务器的每种类型的请求都附加一个API密钥

如果有人发现自己也有类似的问题，那么我最终要做的就是（现在我很确定这就是要做的）在请求的头部分发送API密钥。特别是在Volley中，这意味着重写getHeaders（）方法并在其中添加所需的参数

以下是我的代码：

@Override
public Map<String, String> getHeaders() throws AuthFailureError {
    Map<String, String> headers = super.getHeaders();

    if (headers == null
            || headers.equals(Collections.emptyMap())) {
        headers = new HashMap<String, String>();
    }

    headers.put("API_KEY", apiKey);

    return headers;
}

@覆盖
公共映射getHeaders（）引发AuthFailureError{
Map headers=super.getHeaders（）；
if（headers==null
||headers.equals（Collections.emptyMap（））{
headers=newhashmap（）；
}
headers.put（“API_KEY”，apiKey）；
返回标题；
}

这里也有同样的问题，但我找到了解决办法

问题在于com.android.volley.toolbox.HttpClientStack.java中createHttpRequest方法的实现，只有当请求方法是POST、PUT或PATCH时，才会添加主体

/**
 * Creates the appropriate subclass of HttpUriRequest for passed in request.
 */
@SuppressWarnings("deprecation")
/* protected */ static HttpUriRequest createHttpRequest(Request<?> request,
        Map<String, String> additionalHeaders) throws AuthFailureError {
    switch (request.getMethod()) {
        case Method.DEPRECATED_GET_OR_POST: {
            // This is the deprecated way that needs to be handled for backwards compatibility.
            // If the request's post body is null, then the assumption is that the request is
            // GET.  Otherwise, it is assumed that the request is a POST.
            byte[] postBody = request.getPostBody();
            if (postBody != null) {
                HttpPost postRequest = new HttpPost(request.getUrl());
                postRequest.addHeader(HEADER_CONTENT_TYPE, request.getPostBodyContentType());
                HttpEntity entity;
                entity = new ByteArrayEntity(postBody);
                postRequest.setEntity(entity);
                return postRequest;
            } else {
                return new HttpGet(request.getUrl());
            }
        }
        case Method.GET:
            return new HttpGet(request.getUrl());
        case Method.DELETE:
            return new HttpDelete(request.getUrl());
        case Method.POST: {
            HttpPost postRequest = new HttpPost(request.getUrl());
            postRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
            setEntityIfNonEmptyBody(postRequest, request);
            return postRequest;
        }
        case Method.PUT: {
            HttpPut putRequest = new HttpPut(request.getUrl());
            putRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
            setEntityIfNonEmptyBody(putRequest, request);
            return putRequest;
        }
        case Method.HEAD:
            return new HttpHead(request.getUrl());
        case Method.OPTIONS:
            return new HttpOptions(request.getUrl());
        case Method.TRACE:
            return new HttpTrace(request.getUrl());
        case Method.PATCH: {
            HttpPatch patchRequest = new HttpPatch(request.getUrl());
            patchRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
            setEntityIfNonEmptyBody(patchRequest, request);
            return patchRequest;
        }
        default:
            throw new IllegalStateException("Unknown request method.");
    }
}

到

并编写自己的HttpClientStack实现，在其中更改方法createHttpRequest（）中“Method.POST:”的大小写。您还必须创建一个类似“OwnHttpDelete”的对象作为HttpEntityEnclosingRequestBase的扩展，以使用方法setEntityIfNonEmptyBody（）

public类OwnHttpClientStack扩展com.android.volley.toolbox.HttpClientStack{
私有最终静态字符串头\u CONTENT\u TYPE=“CONTENT TYPE”；
公有HttpClientStack（HttpClient客户端）{
超级（客户）；
}
@凌驾
公共HttpResponse performRequest（请求、映射附加头）
抛出IOException、AuthFailureError{
HttpUriRequest httpRequest=createHttpRequest（请求，附加标头）；
addHeaders（httpRequest，additionalHeaders）；
addHeaders（httpRequest，request.getHeaders（））；
onPrepareRequest（httpRequest）；
HttpParams HttpParams=httpRequest.getParams（）；
int timeoutMs=request.getTimeoutMs（）；
//TODO:基于更广泛的范围重新评估此连接超时
//wifi和3G的数据收集和可能不同。
HttpConnectionParams.setConnectionTimeout（httpParams，5000）；
HttpConnectionParams.setSoTimeout（httpParams，timeoutMs）；
返回mClient.execute（httpRequest）；
}
私有静态void addHeaders（HttpUriRequest、httpRequest、映射头）{
for（字符串键：headers.keySet（））{
setHeader（key，headers.get（key））；
}
}
静态HttpUriRequest createHttpRequest（请求请求，映射附加标头）抛出AuthFailureError{
开关（request.getMethod（））{
case Request.Method.DEPRECATED\u GET\u或\u POST：{
字节[]postBody=request.getPostBody（）；
if（postBody！=null）{
HttpPost postRequest=新的HttpPost（request.getUrl（））；
addHeader（HEADER\u CONTENT\u TYPE，request.getPostBodyContentType（））；
http实体；
实体=新的ByteArrayEntity（postBody）；
postRequest.setEntity（实体）；
返回请求；
}否则{
返回新的HttpGet（request.getUrl（））；
}
}
case Request.Method.GET：
返回新的HttpGet（request.getUrl（））；
case Request.Method.DELETE：
OwnHttpDelete deleteRequest=新的OwnHttpDelete（request.getUrl（））；
deleteRequest.addHeader（HEADER\u CONTENT\u TYPE，request.getBodyContentType（））；
SetEntityIfNoneEmptyBody（deleteRequest，request）；
返回删除请求；
case Request.Method.POST：{
HttpPost postRequest=新的HttpPost（request.getUrl（））；
addHeader（HEADER\u CONTENT\u TYPE，request.getBodyContentType（））；
SetEntityIfNoneEmptyBody（postRequest，request）；
返回请求；
}
case Request.Method.PUT：{
HttpPut putRequest=新的HttpPut（request.getUrl（））；
putRequest.addHeader（HEADER\u CONTENT\u TYPE，request.getBodyContentType（））；
SetEntityIfNoneEmptyBody（putRequest，request）；
返回请求；
}
案例请求.Method.HEAD：
返回新的HttpHead（request.getUrl（））；
case Request.Method.OPTIONS：
返回新的HttpOptions（request.getUrl（））；
case Request.Method.TRACE：
返回新的HttpTrace（request.getUrl（））；
case Request.Method.PATCH：{
HttpPatch patchRequest=新的HttpPatch（request.getUrl（））；
patchRequest.addHeader（HEADER\u CONTENT\u TYPE，request.getBodyContentType（））；
SetEntityIfNoneEmptyBody（补丁请求，请求）；
返回补丁请求；
}
违约：
抛出新的IllegalStateException（“未知请求方法”）；
}
}
私有静态void SetEntityIfNoneEmptyBody（HttpEntityEnclosingRequestBase httpRequest，
请求）抛出AuthFailureError{
字节[]body=request.getBody（）；
if（body！=null）{
RequestQueue requestQueue = Volley.newRequestQueue(sContext);

    String userAgent = "volley/0";
    try {
        String packageName = getContext().getPackageName();
        PackageInfo info = getContext().getPackageManager().getPackageInfo(packageName, 0);
        userAgent = packageName + "/" + info.versionCode;
    } catch (PackageManager.NameNotFoundException e) {}
    HttpStack httpStack = new OwnHttpClientStack(AndroidHttpClient.newInstance(userAgent));
    RequestQueue requesQueue = Volley.newRequestQueue(sContext, httpStack);

public class OwnHttpClientStack extends com.android.volley.toolbox.HttpClientStack {
    private final static String HEADER_CONTENT_TYPE = "Content-Type";

    public OwnHttpClientStack(HttpClient client) {
        super(client);
    }

    @Override
    public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
            throws IOException, AuthFailureError {
        HttpUriRequest httpRequest = createHttpRequest(request, additionalHeaders);
        addHeaders(httpRequest, additionalHeaders);
        addHeaders(httpRequest, request.getHeaders());
        onPrepareRequest(httpRequest);
        HttpParams httpParams = httpRequest.getParams();
        int timeoutMs = request.getTimeoutMs();
        // TODO: Reevaluate this connection timeout based on more wide-scale
        // data collection and possibly different for wifi vs. 3G.
        HttpConnectionParams.setConnectionTimeout(httpParams, 5000);
        HttpConnectionParams.setSoTimeout(httpParams, timeoutMs);
        return mClient.execute(httpRequest);
    }

    private static void addHeaders(HttpUriRequest httpRequest, Map<String, String> headers) {
        for (String key : headers.keySet()) {
            httpRequest.setHeader(key, headers.get(key));
        }
    }

    static HttpUriRequest createHttpRequest(Request<?> request, Map<String, String> additionalHeaders) throws AuthFailureError {
        switch (request.getMethod()) {
            case Request.Method.DEPRECATED_GET_OR_POST: {
                byte[] postBody = request.getPostBody();
                if (postBody != null) {
                    HttpPost postRequest = new HttpPost(request.getUrl());
                    postRequest.addHeader(HEADER_CONTENT_TYPE, request.getPostBodyContentType());
                    HttpEntity entity;
                    entity = new ByteArrayEntity(postBody);
                    postRequest.setEntity(entity);
                    return postRequest;
                } else {
                    return new HttpGet(request.getUrl());
                }
            }
            case Request.Method.GET:
                return new HttpGet(request.getUrl());
            case Request.Method.DELETE:
                OwnHttpDelete deleteRequest =  new OwnHttpDelete(request.getUrl());
                deleteRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
                setEntityIfNonEmptyBody(deleteRequest, request);
                return deleteRequest;
            case Request.Method.POST: {
                HttpPost postRequest = new HttpPost(request.getUrl());
                postRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
                setEntityIfNonEmptyBody(postRequest, request);
                return postRequest;
            }
            case Request.Method.PUT: {
                HttpPut putRequest = new HttpPut(request.getUrl());
                putRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
                setEntityIfNonEmptyBody(putRequest, request);
                return putRequest;
            }
            case Request.Method.HEAD:
                return new HttpHead(request.getUrl());
            case Request.Method.OPTIONS:
                return new HttpOptions(request.getUrl());
            case Request.Method.TRACE:
                return new HttpTrace(request.getUrl());
            case Request.Method.PATCH: {
                HttpPatch patchRequest = new HttpPatch(request.getUrl());
                patchRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
                setEntityIfNonEmptyBody(patchRequest, request);
                return patchRequest;
            }
            default:
                throw new IllegalStateException("Unknown request method.");
        }
    }

    private static void setEntityIfNonEmptyBody(HttpEntityEnclosingRequestBase httpRequest,
                                                Request<?> request) throws AuthFailureError {
        byte[] body = request.getBody();
        if (body != null) {
            HttpEntity entity = new ByteArrayEntity(body);
            httpRequest.setEntity(entity);
        }
    }

    private static class OwnHttpDelete extends HttpPost {
        public static final String METHOD_NAME = "DELETE";

        public OwnHttpDelete() {
            super();
        }

        public OwnHttpDelete(URI uri) {
            super(uri);
        }

        public OwnHttpDelete(String uri) {
            super(uri);
        }

        public String getMethod() {
            return METHOD_NAME;
        }
    }
}