Question

我正在使用volley来处理来自我的Android应用程序的make HTTP请求。这是我正在使用的代码：

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);
    }
}

我想向队列添加请求但控制它们的执行方式，例如：

在任意时间向池中添加多个请求，池将只执行第一个请求（队列头），然后在完成后执行下一个请求......依此类推......

也许有办法让两个串行和并行请求执行？

有可能吗？

感谢。

Answer 1

这可以通过创建一个线程池为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);
}

getNetwork（）方法中的

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);
}

和我们一起启动（）请求队列的start方法。

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

现在将请求添加到volleys请求队列的此队列内部。例如：

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);

在这种情况下，结果requestTwo将首先处理，然后分别处理requestOne和requestThree。如果您不想阻止请求处理，并且还要连续发生这种情况，这会有所帮助。

Answer 2

如果要运行并行请求，则只需继续向队列添加请求。默认情况下，请求是异步的。

如果您想运行串行请求，则有两种方法。

一种是在第一个请求onResponse中添加第二个请求。这基本上会链接多个异步请求。

两个是使用阻塞的RequestFuture。例如，执行此方法将阻止，直到获得响应。

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;
}

基本上你可以堆叠多个阻塞请求方法，如下所示：

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

blockingRequest2完成后将执行

blockingRequest1。如果没有Future，两种方法将同时执行。毋庸置疑，您需要在UI线程中运行阻塞方法 not （例如Thread，AsyncTask和个人喜欢的RxJava Observable）。

Answer 3

这就是我正在使用的：

private static RequestQueue newRequestQueue(Context context) {
    File cacheFile = new File(context.getCacheDir(), "volley");
    Cache cache = new DiskBasedCache(cacheFile);
    RequestQueue queue = new RequestQueue(cache, new BasicNetwork(new HurlStack()), 1);
    queue.start();
    return queue;
}

排球 - 串行请求而不是并行？

3 个答案: