Android

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?

我想注入不同的 Listener 和 ErrorListener（取决于请求类型）。所以我在 RequestFuture class.

中添加了新的 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,... ) 在侦听器事件中 >> 等

以下是旧答案：

我 post 我的解决方案（它不是很干净，但这是我目前的工作）：

对异步和同步请求使用相同的 Volley 请求队列。
正在创建新的 class 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 队列中。因为我们得到了前一个请求的响应，所以每个请求都会被注入到 Volley 请求队列中。我 "tricked" 在这里通过使用局部变量 mListener 和 mErrorListener 发出一个新请求，你可以看到我在之后解析了对 "true" 监听器的响应。

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

Android - Volley - synchronous and asynchronous http requests

asynchronous

httprequest

android-volley