Android 截击补丁请求预棒棒糖

我目前使用volley作为我的网络库（我使用的是最新版本）。 我目前看到，如果棒棒糖前的设备发出补丁请求，则会发生以下错误：

 Unknown method 'PATCH'; must be one of [OPTIONS, GET, HEAD, POST, PUT,  DELETE, TRACE]

我已经看到了这个链接，它说使用okhttp将一个新的httpstack定义为带有OkUrlFactory的传输层

问题是OkUrlFactory现在已被弃用，文档中说现在使用HttpUrlConnection，所以这是一个问题，因为HttpUrlConnection不能用于某些设备的补丁请求

---

有没有其他方法可以通过截击来执行补丁请求

没有弃用

OkUrlFactory

类。
在依赖项中添加以下内容：

dependencies {
    compile 'com.squareup.okhttp:okhttp-urlconnection:2.7.5'
    compile 'com.squareup.okhttp3:okhttp:3.2.0'
    compile 'com.squareup.okio:okio:1.8.0'
}

然后您可以使用

OkHttpStack

类：

import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URL;

import com.android.volley.toolbox.HurlStack;
import com.squareup.okhttp.OkHttpClient;
import com.squareup.okhttp.OkUrlFactory;

public class OkHttpStack extends HurlStack {
    private final OkUrlFactory mFactory;

    public OkHttpStack() {
        this(new OkHttpClient());
    }

    public OkHttpStack(OkHttpClient client) {
        if (client == null) {
            throw new NullPointerException("Client must not be null.");
        }
        mFactory = new OkUrlFactory(client);
    }

    @Override protected HttpURLConnection createConnection(URL url) throws IOException {
        return mFactory.open(url);
    }
}

然后您必须创建一个截击请求队列，如下所示：

---

Volley.newRequestQueue（getApplicationContext（），new-OkHttpStack（））.add（putRequest）
在前面的答案之后
是的，OkUrlFactory类没有被弃用。
但是，由于您询问了如何使用OkHttp而不是Hurstack定义新的HttpStack，因此可以遵循以下示例

dependencies {
    implementation 'com.squareup.okhttp3:logging-interceptor:3.12.12'
    implementation 'com.squareup.okhttp3:okhttp-urlconnection:3.12.12'
    implementation  'com.squareup.okhttp3:okhttp:3.12.12'
}

对于新的HttpStack，它将如下所示：


import android.annotation.SuppressLint;
import android.text.TextUtils;
import android.util.Log;

import com.android.volley.AuthFailureError;
import com.android.volley.Request;
import com.android.volley.toolbox.HttpStack;
import com.schibsted.scm.nextgenapp.backend.managers.ConfigManager;
import com.schibsted.scm.nextgenapp.config.ConfigContainer;
import com.schibsted.scm.nextgenapp.utils.Utils;

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.ProtocolVersion;
import org.apache.http.StatusLine;
import org.apache.http.conn.ssl.StrictHostnameVerifier;
import org.apache.http.entity.BasicHttpEntity;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicHttpResponse;
import org.apache.http.message.BasicStatusLine;

import java.io.IOException;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import javax.net.ssl.SSLSocketFactory;

import okhttp3.Call;
import okhttp3.Headers;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Protocol;
import okhttp3.RequestBody;
import okhttp3.Response;
import okhttp3.ResponseBody;
import okhttp3.logging.HttpLoggingInterceptor;

/**
 * OkHttp backed {@link com.android.volley.toolbox.HttpStack HttpStack} that does not
 * use okhttp-urlconnection
 */
public class OkHttp3Stack implements HttpStack {

    private SSLSocketFactory sslSocketFactory;
    public OkHttp3Stack(SSLSocketFactory sslSocketFactory) {
        this.sslSocketFactory = sslSocketFactory;
    }

    @Override
    public HttpResponse performRequest(com.android.volley.Request<?> request, Map<String, String> additionalHeaders)
            throws IOException, AuthFailureError {

        OkHttpClient.Builder clientBuilder = new OkHttpClient.Builder();
        int timeoutMs = request.getTimeoutMs();
        clientBuilder.hostnameVerifier(new StrictHostnameVerifier());
        clientBuilder.connectTimeout(timeoutMs, TimeUnit.MILLISECONDS);
        clientBuilder.readTimeout(timeoutMs, TimeUnit.MILLISECONDS);
        clientBuilder.writeTimeout(timeoutMs, TimeUnit.MILLISECONDS);
        clientBuilder.addInterceptor(httpInteceptor());
        okhttp3.Request.Builder okHttpRequestBuilder = new okhttp3.Request.Builder();
        okHttpRequestBuilder.url(request.getUrl());
        Map<String, String> headers = request.getHeaders();
        for(final String name : headers.keySet()) {
            okHttpRequestBuilder.addHeader(name, headers.get(name));
        }
        for(final String name : additionalHeaders.keySet()) {
            okHttpRequestBuilder.addHeader(name, additionalHeaders.get(name));
        }

        setConnectionParametersForRequest(okHttpRequestBuilder, request);

        OkHttpClient client = clientBuilder.build();
        okhttp3.Request okHttpRequest = okHttpRequestBuilder.build();
        Call okHttpCall = client.newCall(okHttpRequest);
        Response okHttpResponse = okHttpCall.execute();

        StatusLine responseStatus = new BasicStatusLine(parseProtocol(okHttpResponse.protocol()), okHttpResponse.code(), okHttpResponse.message());
        BasicHttpResponse response = new BasicHttpResponse(responseStatus);
        response.setEntity(entityFromOkHttpResponse(okHttpResponse));

        Headers responseHeaders = okHttpResponse.headers();
        for(int i = 0, len = responseHeaders.size(); i < len; i++) {
            final String name = responseHeaders.name(i), value = responseHeaders.value(i);
            if (name != null) {
                response.addHeader(new BasicHeader(name, value));
            }
        }
        return response;
    }
    @SuppressLint("LogNotTimber")
    private static HttpLoggingInterceptor httpInteceptor() {
        HttpLoggingInterceptor logging = new HttpLoggingInterceptor(message -> {
            Log.d(
                    "myCustomLogger",
                    message
            );
        });
        logging.setLevel( HttpLoggingInterceptor.Level.BODY);
        return logging;
    }

    private static HttpEntity entityFromOkHttpResponse(Response r) throws IOException {
        BasicHttpEntity entity = new BasicHttpEntity();
        ResponseBody body = r.body();
        entity.setContent(body.byteStream());
        if(body.byteStream()==null)
            entity.setContentLength(0);
        else
        entity.setContentLength(body.contentLength());
        entity.setContentEncoding(r.header("Content-Encoding"));
        if (body.contentType() != null) {
            entity.setContentType(body.contentType().type());
        }
        return entity;
    }

    @SuppressWarnings("deprecation")
    private static void setConnectionParametersForRequest(okhttp3.Request.Builder builder, com.android.volley.Request<?> request)
            throws IOException, AuthFailureError {
        switch (request.getMethod()) {
            case Request.Method.DEPRECATED_GET_OR_POST:
                // Ensure backwards compatibility.  Volley assumes a request with a null body is a GET.
                byte[] postBody = request.getBody();
                if (postBody != null) {
                    builder.post(RequestBody.create(MediaType.parse(request.getBodyContentType()), postBody));
                }
                break;
            case Request.Method.GET:
                builder.get();
                break;
            case Request.Method.DELETE:
                builder.delete();
                break;
            case Request.Method.POST:
                builder.post(createRequestBody(request));
                break;
            case Request.Method.PUT:
                builder.put(createRequestBody(request));
                break;
            case Request.Method.HEAD:
                builder.head();
                break;
            case Request.Method.OPTIONS:
                builder.method("OPTIONS", null);
                break;
            case Request.Method.TRACE:
                builder.method("TRACE", null);
                break;
            case Request.Method.PATCH:
                builder.patch(createRequestBody(request));
                break;
            default:
                throw new IllegalStateException("Unknown method type.");
        }
    }

    private static ProtocolVersion parseProtocol(final Protocol p) {
        switch (p) {
            case HTTP_1_0:
                return new ProtocolVersion("HTTP", 1, 0);
            case HTTP_1_1:
                return new ProtocolVersion("HTTP", 1, 1);
            case SPDY_3:
                return new ProtocolVersion("SPDY", 3, 1);
            case HTTP_2:
                return new ProtocolVersion("HTTP", 2, 0);
        }

        throw new IllegalAccessError("Unkwown protocol");
    }

    private static RequestBody createRequestBody(Request r) throws AuthFailureError {
        final byte[] body = r.getBody();
        if (body == null) {
            return RequestBody.create(null, new byte[0]);
        }

        return RequestBody.create(MediaType.parse(r.getBodyContentType()), body);
    }
}


导入android.annotation.SuppressLint；
导入android.text.TextUtils；
导入android.util.Log；
导入com.android.volley.AuthFailureError；
导入com.android.volley.Request；
导入com.android.volley.toolbox.HttpStack；
导入com.schibsted.scm.nextgenapp.backend.managers.ConfigManager；
导入com.schibsted.scm.nextgenapp.config.ConfigContainer；
导入com.schibsted.scm.nextgenapp.utils.utils；
导入org.apache.http.Header；
导入org.apache.http.HttpEntity；
导入org.apache.http.HttpResponse；
导入org.apache.http.ProtocolVersion；
导入org.apache.http.StatusLine；
导入org.apache.http.conn.ssl.StrictHostnameVerifier；
导入org.apache.http.entity.BasicHttpEntity；
导入org.apache.http.message.BasicHeader；
导入org.apache.http.message.BasicHttpResponse；
导入org.apache.http.message.BasicStatusLine；
导入java.io.IOException；
导入java.util.Map；
导入java.util.concurrent.TimeUnit；
导入javax.net.ssl.SSLSocketFactory；
导入okhttp3.Call；
导入okhttp3.Headers；
导入okhttp3.MediaType；
导入okhttp3.OkHttpClient；
导入okhttp3.协议；
导入okhttp3.RequestBody；
导入okhttp3.响应；
进口okhttp3.0响应电子书；
导入okhttp3.logging.HttpLoggingInterceptor；
/**
*OkHttp支持的{@link com.android.volley.toolbox.HttpStack HttpStack}没有
*使用HTTP urlconnection
*/
公共类OkHttp3Stack实现HttpStack{
私人SSLSocketFactory SSLSocketFactory；
公共OkHttp3Stack（SSLSocketFactory SSLSocketFactory）{
this.sslSocketFactory=sslSocketFactory；
}
@凌驾
公共HttpResponse performRequest（com.android.volley.Request请求，映射附加标头）
抛出IOException、AuthFailureError{
OkHttpClient.Builder clientBuilder=新的OkHttpClient.Builder（）；
int timeoutMs=request.getTimeoutMs（）；
hostnameVerifier（新的StrictHostnameVerifier（））；
connectTimeout（timeoutMs，TimeUnit.ms）；
readTimeout（timeoutMs，TimeUnit.ms）；
writeTimeout（timeoutMs，TimeUnit.ms）；
addInterceptor（httpInteceptor（））；
okhttp3.Request.Builder okHttpRequestBuilder=新的okhttp3.Request.Builder（）；
okHttpRequestBuilder.url（request.getUrl（））；
Map headers=request.getHeaders（）；
for（最终字符串名称：headers.keySet（））{
okHttpRequestBuilder.addHeader（名称，headers.get（名称））；
}
for（最终字符串名称：additionalHeaders.keySet（））{
okHttpRequestBuilder.addHeader（名称，additionalHeaders.get（名称））；
}
setConnectionParametersForRequest（okHttpRequestBuilder，请求）；
OkHttpClient=clientBuilder.build（）；
okhttp3.Request okHttpRequest=okHttpRequestBuilder.build（）；
Call okHttpCall=client.newCall（okHttpRequest）；
响应okHttpResponse=okHttpCall.execute（）；
StatusLine responseStatus=new BasicStatusLine（解析协议（okHttpResponse.protocol（）），okHttpResponse.code（），okHttpResponse.message（））；
BasicHttpResponse response=新的BasicHttpResponse（responseStatus）；
response.setEntity（entityFromOkHttpResponse（okHttpResponse））；
Headers responseHeaders=okHttpResponse.Headers（）；
for（int i=0，len=responseHeaders.size（）；i{
对数d(
“myCustomLogger”，
消息
);
});
logging.setLevel（HttpLoggingInterceptor.Level.BODY）；
回程测井；
}
私有静态HttpEntity entityFromOkHttpResponse（响应r）引发IOException{
BasicHttpEntity=新的BasicHttpEntity（）；
响应主体=r.主体（）；
setContent（body.byteStream（））；
if（body.byteStream（）==null）
entity.setContentLength（0）；
其他的
entity.setContentLength（body.contentLength（））；
setContentEncoding（r.header（“内容编码”））；
if（body.contentType（）！=null）{
entity.setContentType（body.contentType（）.type（））；
}
返回实体；
}
@抑制警告（“弃用”）
私有静态void setConnectionParametersForRequest（okhttp3.Request.Builder、com.android.volley.Request）
抛出IOException、AuthFailureError{
开关（request.getMethod（））{