Volley: richieste seriali anziché parallele?

Question

Sto usando volley per fare richieste HTTP dalla mia applicazione Android. Ecco il codice che sto utilizzando:

public class RequestPool { 


    private static RequestPool mInstance; 

    private RequestQueue mRequestQueue; 

    private static Context mContext; 

    private RequestPool(Context context) { 

     mContext = context; 
     mRequestQueue = getRequestQueue(); 


    } 

    public static synchronized RequestPool getInstance(Context context) { 

     if (mInstance == null) { 
      mInstance = new RequestPool(context); 
     } 
     return mInstance; 
    } 

    public RequestQueue getRequestQueue() { 
     if (mRequestQueue == null) { 
      // getApplicationContext() is key, it keeps you from leaking the 
      // Activity or BroadcastReceiver if someone passes one in. 
      mRequestQueue = Volley.newRequestQueue(mContext.getApplicationContext()); 
     } 

     return mRequestQueue; 
    } 

    public <T> void addToRequestQueue(Request<T> req) { 

     getRequestQueue().add(req); 
    } 
} 

voglio aggiungere le richieste alla coda, ma controllare il modo in cui vengono eseguite, ad esempio:

l'aggiunta di richieste multiple per la piscina a volte arbitrari, il pool eseguirà solo la prima richiesta (capo della coda), quindi quando termina verrà eseguito il successivo ... e così via ....

Forse c'è un modo per rendere entrambe le richieste seriali e parallele esecuzione?

È possibile?

Grazie.

Answer 1

questo può essere fatto con la creazione di una richiesta con il pool di thread come 1.

int MAX_SERIAL_THREAD_POOL_SIZE = 1; 
final int MAX_CACHE_SIZE = 2 * 1024 * 1024; //2 MB 

private static RequestQueue prepareSerialRequestQueue(Context context) { 
    Cache cache = new DiskBasedCache(context.getCacheDir(), MAX_CACHE_SIZE); 
    Network network = getNetwork(); 
    return new RequestQueue(cache, network, MAX_SERIAL_THREAD_POOL_SIZE); 
} 

a getNetwork metodo()

private static Network getNetwork() { 
    HttpStack stack; 
    if(Build.VERSION.SDK_INT >= 9) { 
     stack = new HurlStack(); 
    } else { 
     String userAgent = "volley/0"; 
     stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent)); 
    } 
    return new BasicNetwork(stack); 
} 

e noi il metodo start per avviare() la coda di richieste .

RequestQueue serialRequestQueue = prepareSerialRequestQueue(context); 
serialRequestQueue.start(); 

Ora aggiungere la richiesta a questa coda in attesa della coda di richiesta delle chiamate dirette. Ad esempio:

StringRequest requestOne = new StringRequest(Request.Method.GET, "http://www.example1.com", this, this); 
StringRequest requestTwo = new StringRequest(Request.Method.GET, "http://www.example2.com", this, this); 
StringRequest requestThree = new StringRequest(Request.Method.GET, "http://www.example3.com", this, this); 
serialRequestQueue.add(requestTwo); 
serialRequestQueue.add(requestOne); 
serialRequestQueue.add(requestThree); 

in questo caso il risultato requestTwo saranno trattati prima seguita rispettivamente da requestOne e requestThree. Questo aiuta se non vuoi bloccare l'elaborazione della richiesta, e anche farla accadere in serie.

Answer 2

Se si desidera eseguire richieste parallele, è sufficiente continuare ad aggiungere richieste alla coda. Le richieste sono di default asincrone.

Se si desidera eseguire richieste seriali, esistono due approcci.

Uno consiste nell'aggiungere la seconda richiesta all'interno della prima richiesta onResponse. Questo fondamentalmente concatena più richieste asincrone.

Due è utilizzare RequestFuture che sta bloccando. Ad esempio, l'esecuzione di questo metodo bloccherà fino a quando non si ottiene una risposta.

private String blockingRequest(String url) { 

    RequestFuture<String> future = RequestFuture.newFuture(); 

    StringRequest sr = new StringRequest(url, future, future); 
    queue.add(sr); 
    String response = null; 

    try { 
     response = future.get(); 
    } catch (InterruptedException | ExecutionException e) { 
     e.printStackTrace(); 
    } 
    return response; 
} 

Per utilizzare fondamentalmente impilare più metodi di richiesta di blocco in questo modo:

String response1 = blockingRequest1(url1); 
// other methods 
String response2 = blockingRequest2(url2); 

blockingRequest2 viene eseguito dopo che blockingRequest1 ha completato. Senza futuro entrambi i metodi saranno eseguiti simultaneamente. Inutile dire che sarà necessario eseguire i metodi di blocco non nel thread dell'interfaccia utente (ad esempio Thread, AsyncTask e RxJava Observable preferito personale).