Google Volley Listeners

Question

我正在使用Google的Volley (AOSP的一部分)来处理我的网络。我想知道我是否应该为我发出的每个请求创建新的侦听器(成功和错误)，或者只为每个请求创建一个并继续重用它们是可以的吗？

例如，我现在正在为每个请求创建一个新的侦听器：

GsonRequest<Object> request = 
    new GsonRequest<Object>(Method.POST, 
         path, 
         Object.class, 
         createSuccessListener(), 
         createErrorListener());

其中创建方法被定义为( createSuccessListener()遵循相同的想法，所以我不会发布它)：

private ErrorListener createErrorListener() {
    return new ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError e) { ... }
    }
}

因此，创建侦听器的一个实例并在我发出请求的任何地方使用它是更好还是更坏：

private ErrorListener mErrorListener;
mListener = createErrorListener();
GsonRequest<Object> request = 
    new GsonRequest<Object>(Method.POST,
        ...
        ...
        mSuccessListener,
        mErrorListener);

Answer 1

这真的是一个偏好问题。两者都是接口，因此它们本质上是无状态的。除非您的实现不期望它们被重用，否则重用它们是无害的。

即

未正确处理状态

public class UseOnlyOnceListener implements Listener<Object> {

    boolean hasCompletedAlready;

    public UseOnlyOnceListener() {
       this.hasCompletedAlready = false;
    }

    public void onResponse(T response) {
       this.hasCompletedAlready = ! hasCompletedAlready;
    }

    public boolean hasCompleted() {
       return this.hasCompletedAlready;
    }

}

VS

public class ReusableListener implements Listener<Object> {

   private boolean hasCompletedAlready;

   public ReusableListener() {
      hasCompletedAlready = false;
   }

   public void onSuccess(Object response) {
       this.hasCompletedAlready = true;
   }

   public boolean hasCompleted() {
       return this.hasCompletedAlready;
   }
}

VS

public class ReusableResponses implements Listener<Pair<Request, Object>> {

   private Queue<Pair<Pair<Request, Object>> responses;

   public ReusableListener() {
       responses = new LinkedList<Pair<Request, Object>();
   }

   public void onSuccess(Pair<Request, Object> response) {
       responses.enqueue(pair);
   }

   public boolean hasCompleted() {
       return !responses.isEmpty();
   }

   public List<Pair<Request, Object>> getCompletedResponses() {
       return new ArrayList<Pair<Request, Object>>(responses);
   }
}

在第一种情况下，即使您可能节省了内存，如果用于多个请求，则调用hasCompleted()的结果是不可靠的(我知道这是一个人为的示例，但它只是为了显示要点)。第二种情况下，您可以确保至少完成了一个请求。然而，如果你真的需要知道来自哪个请求的响应，那么根据你的应用程序，这可能也是不可重用的。这取决于您的实现。

重用实例确实节省了内存，缩短了对象创建时间，减少了GC时间。然而，它并不总是很方便，而且在很多时候会使代码更难阅读和使用。就像我说的，这更多的是一个设计问题。有关接口的任何内容都不会将实例绑定到单个请求。