Question

我正在编写一个传递http服务器的应用程序。

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

<div class="p2">
  <a href="#">Hello 2</a>
  <div class="p1">
    <a href="#">Hello 2-1</a>
    <div class="p2">
      <a href="#">Hello 2-1-2</a>
    </div>
  </div>
</div>
<div class="p1">
  <a href="#">Hello 1</a>
  <div class="p2">
    <a href="#">Hello 1-2</a>
    <div class="p1">
      <a href="#">Hello 1-2-1</a>
    </div>
  </div>
</div>

但不是：

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

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

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

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

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

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

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

Answer 1

老实说，我不再使用这种方法了。最好使用Callback而不是同步请求队列，这将使您的代码更容易更新，更容易让其他开发人员理解。不要犹豫，在侦听器事件中添加额外的回调参数，例如：request_1（callback_1，...），callback_1调用request_2（callback_2，...）＆gt;＆gt;等

以下是旧答案：

我在这里发布我的解决方案（它不是很干净但是到目前为止我的工作）：

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

我的课程：

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来通知Sync Request Queue已经完成。我将所有同步请求存储在Linkedlist中，然后逐个添加到排序队列中。因为我们得到了先前请求的响应，所以每个请求都将被注入Volley请求队列。我通过使用局部变量mListener和mErrorListener发出新请求来“欺骗”，你可以看到我在之后解析了对“真正”侦听器的响应。

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

1 个答案: