Android 在自定义Runnable中使用改装执行请求

我正在使用

改型

从

Volley

迁移到自定义实现，但我正在尝试向我的实现中添加一些我喜欢的

Volley

特性，例如

RequestQueue.cancel（字符串标记）

如果

请求

具有请求的标记，则通过将

布尔值
mCanceled
设置为true来取消该请求。
run
方法检查此值并返回是否为真。
为了能够通过
改型
重现这一点，我应该能够使用实现
可运行
的自定义类，而不是默认类，其中有一个
mTag
和一个
mCanceled
字段。
此外，
Volley
还能够在活动的
线程
内设置这样的标志，并立即停止它们。我已经实现了我的
cancelAll
方法，它只是将队列排入另一个队列，但无法访问活动线程。
使用
翻新
和
线程池执行器
是否可能达到相同的结果？
我想我找到了一个更好的解决方案：我不是阻止请求的
可运行
，而是阻止
回调
执行

我已经扩展了
回调
接口：

public interface CustomCallbackInterface<T> extends Callback<T> {
    public String getTag();
    public String setTag(String tag);
    public void cancel();
    public boolean isCanceled();
}

每次提出新请求时，我都将创建的
CustomCallback
存储在
列表中
cancel只需迭代列表并对具有相同标记的项目调用
cancel（）
。
我已经实现了一个基于Vektor88应答的易于使用的类

public abstract class CancelableCallback<T> implements Callback<T> {

    private static List<CancelableCallback> mList = new ArrayList<>();

    private boolean isCanceled = false;
    private Object mTag = null;

    public static void cancelAll() {
        Iterator<CancelableCallback> iterator = mList.iterator();
        while (iterator.hasNext()){
            iterator.next().isCanceled = true;
            iterator.remove();
        }
    }

    public static void cancel(Object tag) {
        if (tag != null) {
            Iterator<CancelableCallback> iterator = mList.iterator();
            CancelableCallback item;
            while (iterator.hasNext()) {
                item = iterator.next();
                if (tag.equals(item.mTag)) {
                    item.isCanceled = true;
                    iterator.remove();
                }
            }
        }
    }

    public CancelableCallback() {
        mList.add(this);
    }

    public CancelableCallback(Object tag) {
        mTag = tag;
        mList.add(this);
    }

    public void cancel() {
        isCanceled = true;
        mList.remove(this);
    }

    @Override
    public final void success(T t, Response response) {
        if (!isCanceled)
            onSuccess(t, response);
        mList.remove(this);
    }

    @Override
    public final void failure(RetrofitError error) {
        if (!isCanceled)
            onFailure(error);
        mList.remove(this);
    }

    public abstract void onSuccess(T t, Response response);

    public abstract void onFailure(RetrofitError error);
}

公共抽象类CancelableCallback实现回调{
私有静态列表mList=newarraylist（）；
私有布尔值isCanceled=false；
私有对象mTag=null；
公共静态void cancelAll（）{
迭代器迭代器=mList.Iterator（）；
while（iterator.hasNext（））{
iterator.next（）.isCanceled=true；
iterator.remove（）；
}
}
公共静态无效取消（对象标记）{
如果（标记！=null）{
迭代器迭代器=mList.Iterator（）；
可取消的回调项；
while（iterator.hasNext（））{
item=iterator.next（）；
if（tag.equals（item.mTag））{
item.isCanceled=true；
iterator.remove（）；
}
}
}
}
公共可取消回调（）{
添加（本）；
}
公共可取消回调（对象标记）{
mTag=标签；
添加（本）；
}
公开作废取消（）{
isCanceled=true；
删除（此）；
}
@凌驾
公开最终无效成功（T，响应）{
如果（！已取消）
onSuccess（t，response）；
删除（此）；
}
@凌驾
公共最终作废失败（改装错误）{
如果（！已取消）
失败（错误）；
删除（此）；
}
成功时公开摘要无效（T，响应）；
公开摘要失效（错误）；
}

用法示例

rest.request(..., new CancelableCallback<MyResponse>(TAG) {
    @Override
    public void onSuccess(MyResponse myResponse, Response response) {
        ...
    }

    @Override
    public void onFailure(RetrofitError error) {
       ...
    }
});

// if u need to cancel all
CancelableCallback.cancelAll();
// or cancel by tag
CancelableCallback.cancel(TAG);

rest.request（…，新的CancelableCallback（标记）{
@凌驾
成功时公共无效（MyResponse MyResponse，Response Response）{
...
}
@凌驾
公共void onFailure（改型错误）{
...
}
});
//如果你需要取消所有
CancelableCallback.cancelAll（）；
//或者通过标签取消
CancelableCallback.cancel（标记）；
您能再添加一点代码吗？喜欢这个要求吗call@letroll您将请求作为一个普通的请求发出，但不使用
new Callback
而是使用
Callback cb=new Callback
，这样您就有了一个引用，然后可以调用
callbacks.add（cb）
我不是专家，但我认为您是在请求得到响应后返回的（在您的代码中：成功）。您并没有在空中取消请求：），但我可能错了。@feresr是的，在改装2.0之前，无法取消任何正在进行的请求，但这样的话，响应就会被忽略。另外@feresr他在请求得到响应后返回，但在请求成功时他什么也没做，这意味着请求实际上被取消了，我也认为这是最好的方式，因为在改装过程中，没有办法取消请求
rest.request(..., new CancelableCallback<MyResponse>(TAG) {
    @Override
    public void onSuccess(MyResponse myResponse, Response response) {
        ...
    }

    @Override
    public void onFailure(RetrofitError error) {
       ...
    }
});

// if u need to cancel all
CancelableCallback.cancelAll();
// or cancel by tag
CancelableCallback.cancel(TAG);