Android - 齐射 - 同步和异步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?

我要注入不同的监听器和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

老实说，我不再使用这种方法。使用Callback代替同步请求队列会更好，它会让你的代码更容易更新，更容易让其他开发人员去理解。不要犹豫，加入一个额外的回调parametre，例如：request_1（callback_1，...），callback_1调用request_2（callback_2，...）的监听器事件>>等

下面是老答案：

我在这里发布我的解决方案（这不是很干净，但它是我的工作至今）：

• 使用相同的凌空请求队列两个异步和同步请求。
• 创建新类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的通知同步请求队列已经完成。我将所有同步请求存储在一个链接列表中，然后逐个添加到排队队列中。每个请求都会被注入到Volley请求队列中，因为我们得到了前一个请求的响应。我在这里通过用局部变量mListener和mErrorListener发出一个新的请求来“欺骗”你可以看到我之后解析了对“真实”监听器的响应。