Android Volley kann den Cache für eine bestimmte Anfrage nicht deaktivieren, die OkHttp3 als Transport verwendet

Question

Ich habe einige Methoden ausprobiert, um den Cache für eine bestimmte Volleyanforderung zu deaktivieren, aber die App verwendet immer die zwischengespeicherten Daten. Ich habe header("Cache-Control: no-store,no-cache, must-revalidate"); in meinem Feed-Header. Ich habe mehrere Tests von Android Studio gestartet und die Zeitstempel der Feeds sind im Logcat immer noch dieselben.

Ich habe bereits stringRequest.setShouldCache(false); hinzugefügt und löschen Sie den Cache queue.getCache().clear();, bevor Sie eine Anfrage stellen, aber es funktioniert nicht.

Aktivitätsklasse:

private RequestQueue queue; 

public void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 

    /* 
    *VolleyStringRequest is basically a class 
    * that extends StringRequest with some common methods like `getHeaders()`. 
    */ 

    VolleyStringRequest stringRequest = new VolleyStringRequest(Request.Method.GET, url, 
       new Response.Listener<String>() { 
        @Override 
        public void onResponse(String response) { 
         Log.d("note", response); 
        } 
       }, 
       new Response.ErrorListener() { 
        @Override 
        public void onErrorResponse(VolleyError error) { 
         new VolleyErrorListener(context, error); 
        } 
       } 
     ); 

     queue = CustomVolleyRequestQueue.getInstance(this.getApplicationContext()) 
       .getRequestQueue(); 

     /**************HERE***************/ 
     queue.getCache().clear(); 

     stringRequest.setShouldCache(false); 


     queue.add(stringRequest); 
} 

CustomVolleyRequestQueue Klasse:

public class CustomVolleyRequestQueue { 

    private static CustomVolleyRequestQueue mInstance; 

    private static Context mCtx; 

    private RequestQueue mRequestQueue; 

    private CustomVolleyRequestQueue(Context context) { 

     mCtx = context; 
     mRequestQueue = getRequestQueue(); 
    } 

    public static synchronized CustomVolleyRequestQueue getInstance(Context context) { 
     if (mInstance == null) { 
      mInstance = new CustomVolleyRequestQueue(context); 
     } 
     return mInstance; 
    } 

    public RequestQueue getRequestQueue() { 
     if (mRequestQueue == null) { 
      Cache cache = new DiskBasedCache(mCtx.getCacheDir(), 10 * 1024 * 1024); 
      Network network = new BasicNetwork(new OkHttpStack()); 
      mRequestQueue = new RequestQueue(cache, network); 
      // Don't forget to start the volley request queue 
      mRequestQueue.start(); 
     } 
     return mRequestQueue; 
    } 

} 

Ich habe auch okHttpRequestBuilder.cacheControl(CacheControl.FORCE_NETWORK); im OKHTTP Stapel Klasse versucht zu sehen, ob es zu OkHttp3 verwandt ist, aber es macht keinen Unterschied machen:

public class OkHttpStack implements HttpStack { 

    public OkHttpStack() { 
    } 

    @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.connectTimeout(timeoutMs, TimeUnit.MILLISECONDS); 
     clientBuilder.readTimeout(timeoutMs, TimeUnit.MILLISECONDS); 
     clientBuilder.writeTimeout(timeoutMs, TimeUnit.MILLISECONDS); 

     okhttp3.Request.Builder okHttpRequestBuilder = new okhttp3.Request.Builder(); 
     okHttpRequestBuilder.url(request.getUrl()); 

     /****************HERE*****************/ 
     okHttpRequestBuilder.cacheControl(CacheControl.FORCE_NETWORK); 

     Map<String, String> headers = request.getHeaders(); 
     for(final String name : headers.keySet()) { 
      okHttpRequestBuilder.addHeader(name, headers.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; 
    } 

Answer 1

Wir können den Cache von OKhht deaktivieren p wie unten:

OkHttpClient client = new OkHttpClient(); 
client.setCache(null); 

und dies sollte Ihnen helfen, die Anfrage hinzuzufügen.

Volley.newRequestQueue(context.getApplicationContext(), new OkHttpStack(client)); 

setCache() Methode Cache deaktivieren. Ich hoffe, das war hilfreich. ThankYou

Answer 2

Wir können Cache von Volley selbst

reqObj.setShouldCache(false); 

, bevor die Anforderung in der Warteschlange deaktivieren hinzufügen