Android - Volley - 同步和异步 http 请求

Question

我正在编写一个与 HTTP 服务器通信的应用程序。

我有同步请求和异步请求。我有一个单例，其中包含用于异步请求的 Volley RequestQueue。现在我想实现一个同步请求队列，例如:

Request i -> ... -> Response i -> Request i+1 -> ... -> Response i+1

但不是:

Request i -> Request i+1 -> ... -> Response i -> Response i+1

我已阅读此主题:Can I do a synchronous request with volley?

我想注入(inject)不同的 Listener 和 ErrorListener(取决于请求类型)。所以我在 RequestFuture 类中添加了新的 Listener 和 ErrorListener 对象作为变量。

public class RequestFuture<T> implements Future<T>, Response.Listener<T>, Response.ErrorListener {
    ...
    Response.Listener mListener;
    Response.ErrorListener mErrorListener;
    ...
}

但我真正想做的是一个异步请求队列。我如何使用 Volley 做到这一点？

我想知道我是继续使用 Volley 还是 HTTPRequestExecutor(已被弃用)？

非常感谢任何反馈，谢谢。

Answer 1

老实说，我不再使用这种方法了。最好使用回调而不是同步请求队列，它会让你的代码更容易更新，更容易被其他开发人员理解。不要犹豫，添加一个额外的回调参数，例如:request_1 (callback_1, ...), callback_1 calls request_2(callback_2, ...) in listener events >> etc.

下面是旧答案:

我在这里发布我的解决方案(它不是很干净，但这是我目前的工作):

• 对异步和同步请求使用相同的 Volley 请求队列。
• 创建新类 SyncRequestLoader 实现 Response.ErrorListener、Response.Listener。

我的类(class):

public class SyncRequestLoader implements Response.ErrorListener, Response.Listener {
    public final String TAG = "SyncRequestLoader";

    private RequestQueue mRequestQueue;

    private Response.Listener mListener;
    private Response.ErrorListener mErrorListener;

    private LinkedList<StringRequest> mSyncRequests;

    private Handler.Callback mCallback;

    public SyncRequestLoader(RequestQueue mRequestQueue) {
        this.mRequestQueue = mRequestQueue;
        mSyncRequests = new LinkedList<>();
    }

    synchronized public void add(StringRequest request) {
        mSyncRequests.add(request);

        if (size() == 1)
            transceive();
    }

    @Override
    synchronized public void onResponse(Object response) {
        mListener.onResponse(response);

        //do anything here if u want

        removeCompletedRequest();

        continueIfPossible();
    }

    @Override
    synchronized public void onErrorResponse(VolleyError error) {
        mErrorListener.onErrorResponse(error);

        //do anything here if u want

        removeCompletedRequest();

        continueIfPossible();
    }

    synchronized private void transceive() {
        StringRequest request = mSyncRequests.getFirst();
        mListener = request.getListener();
        mErrorListener = request.getErrorListener();

        StringRequest new_request = new StringRequest(request.getUrl(), this, this);

        mRequestQueue.add(new_request);
    }

    synchronized private void removeCompletedRequest() {
        mSyncRequests.removeFirst();
    }

    synchronized private void continueIfPossible() {
        if (size() > 0)
            transceive();
        else if (isOnCallback())
            mCallback.handleMessage(Message.obtain(null, 1));
    }

    public boolean isOnCallback() {
        return (mCallback != null);
    }

    public void setCallback(Handler.Callback callback) {
        this.mCallback = callback;
    }

}

我正在使用 SyncRequestLoader mCallback 通知同步请求队列已完成。我将所有同步请求存储在一个链表中，然后一个一个地添加到 volley 队列中。因为我们得到了前一个请求的响应，所以每个请求都会被注入(inject)到 Volley 请求队列中。我在这里通过使用局部变量 mListener 和 mErrorListener 发出新请求来“欺骗”，你可以看到我在之后解析了对“真实”监听器的响应。