如何同步执行 RoboSpice 请求？

Question

如何同步执行 RoboSpice 请求？可能吗？我想在 IntentService 中使用 RoboSpice。

编辑：

有时需要同步执行某些事情，例如在服务中。在我最近的项目中，我必须对一些不同类型的请求进行排队，并且我想将 IntentService 与 RoboSpice 一起使用。在我的情况下，当我执行不同的请求时，我需要等待来自request1 的结果，然后将数据从它传递到request2 并执行它。

我想要某种批处理请求队列。假设我们有两种类型的请求：request1 和 request2。 request2需要request1获取的数据：

1. 执行request1
2. 等一下
3. 获取request1获取的数据并传递给request2
4. 执行request2
5. 等一下
6. 转到 1。

我想使用 IntentService（队列），但由于异步，它在启动请求后死掉了。

在我看来，使用监听器或 CountDownLatch 并不是最好的方法。

Answer 1

根据 Riccardo Ciovatti on the RoboSpice mailing list 的建议，您的问题的直接答案是：

final CountDownLatch latch = new CountDownLatch(1);

final YourRequest request = new YourRequest();
spiceManager.execute(request, new RequestListener<YourResponse>() {

    @Override
    public void onRequestFailure(SpiceException spiceException) {
        latch.countDown();
    }

    @Override
    public void onRequestSuccess(YourResponse response) {
        latch.countDown();
    }
});

latch.await();

但这不是一个好的习惯用法，除非它在后台线程上执行。异步处理是 RoboSpice 的基本特性；它使 UI 线程保持空闲。

Answer 2

在 IntentService 中使用 RoboSpice。在 CountDownLatch 的帮助下解决了这个问题。假设我们有 2 个不同的 SpiceManagers 和一些 syncMethods 在 IntentService 中按顺序执行。

全局：

private final SpiceManager aSpiceManager =
       new SpiceManager(ASpiceService.class);
private final SpiceManager bSpiceManager =
       new SpiceManager(BSpiceService.class);

private CountDownLatch handleIntentLatch;

onHandleIntent：在我们执行 syncMethodA 之前 - 我们用 1 初始化我们的 CountDownLatch。在执行 syncMethodA 之后，我们在我们的锁存器上 await() for countDown()。当稍后某些方法将在我们的闩锁上调用 countDown() 至少一次 - 方法 onHandleIntent 将继续执行并完成，这将触发 IntentService onDestroy() 回调。

@Override
protected void onHandleIntent(Intent intent) {
    handleIntentLatch = new CountDownLatch(1);

    syncMethodA();

    try {
        handleIntentLatch.await();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

syncMethodA()： 假设我们需要依次启动一些同步方法（syncMethodA，其中回调执行syncMethodB等）。

private void syncMethodA() {
    SpiceRequest requestA = new SpiceRequest();

    if (!aSpiceManager.isStarted()) {
        LogUtils.LOGD(TAG, "starting aSpiceManager");
        aSpiceManager.start(getApplicationContext());
    }

    aSpiceManager.execute(requestA , new RequestListener<ResponseA>() {
        @Override
        public void onRequestSuccess(final ResponseA responseA) {
            // SOME LOGIC

            syncMethodB();

            // SOME LOGIC

        @Override
        public void onRequestFailure(SpiceException spiceException) {
            handleIntentLatch.countDown();
            // SOME LOGIC
        }
    });
}

syncMethodB、syncMethodC 等都是一样的——在 onRequestSuccess 我们开始下一个 syncMethodX。在 onRequestFailure 中，我们 countDown() 我们的闩锁 (handleIntentLatch)。

非常重要！！！ 在顺序的最后一个 syncMethodX 中（完成后我们希望 onHandleIntent 方法继续执行并完成这将导致 IntentService 停止） - 我们 countDown() 我们在 onRequestSuccess ALSO 中的锁存器.

onDestroy：在这里我们停止我们的 SpinceManagers。

@Override
public void onDestroy() {
    super.onDestroy();
    LogUtils.LOGD(TAG, "onDestroy");
    shutDownSpiceManagers();
}

shutDownSpiceManagers：

private void shutDownSpiceManagers() {
    if (aSpiceManager.isStarted()) {
        LogUtils.LOGD(TAG, "stopping aSpiceManager");
        aSpiceManager.shouldStop();
    }
    if (bSpiceManager.isStarted()) {
        LogUtils.LOGD(TAG, "stopping bSpiceManager");
        bSpiceManager.shouldStop();
     }
}

现在一切都应该好了：没有泄露的上下文，SpiceManagers 将在 onDestroy 中被杀死 并且仅在解决回调之后。

Answer 3

如果您不希望完全同步执行，而只想按某种顺序顺序执行请求，您可以编写自己的简单类，当请求 A 成功或失败时只执行请求 B。像这样：https://github.com/Deepscorn/Shared/blob/master/app/src/main/java/com/gamelift/shared/request/base/RequestSequenceExecutor.java。 因此，代码将如下所示：

sequenceExecutor.setRequest(new FirstRequest());
sequenceExecutor.setOnSuccessListener(FirstRequest.class, new OnSuccessListener {
   public void onSuccess() {
     sequenceExecutor.setRequest(new SecondRequest());
   }
};

sequenceExecutor.setOnFaulListener(FirstRequest.class, new OnFailListener {
   public void onFail() {
     sequenceExecutor.setRequest(new OnFirstFailRequest());
   }
};

sequenceExecutor.setOnSuccessListener(SecondRequest.class, new OnSuccessListener {
   public void onSuccess() {
     notifyDone();
     return;
   }
};

sequenceExecutor.setDefaultOnFailListener(new OnFailListener {
   public void onFail(Exception e) {
     notifyDone();
     log(e);
     return;
   }
};
sequenceExecutor.execute() //starts execution