如何同步执行RoboSpice请求？

Question

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

编辑：

有时需要同步执行一些东西，例如在服务中。在我最近的项目中，我不得不对一些不同类型的请求进行排队，我想在RoboSpice中使用RoboSpice。在我的例子中，当我执行不同的请求时，我需要等待来自request1的结果，然后将数据从它传递到request2并执行它。

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

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

我想使用IntentService (队列)，但是由于异步，它在启动请求后就会死掉。

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

Answer 1

按照Riccardo 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

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

Globals

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

private CountDownLatch handleIntentLatch;

在执行onHandleIntent：之前，我们使用1插入CountDownLatch。在执行syncMethodA之后，我们将等待()在锁存器上查找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
        }
    });
}

在onRequestSuccess中，syncMethodB、syncMethodC等都是一样的--我们从下一个syncMethodX开始。在onRequestFailure中，我们使用countDown()锁存器(handleIntentLatch)。

非常重要！在最后一个syncMethodX中按顺序排列(在完成之后，我们希望onHandleIntent方法继续它的执行并完成，这将导致IntentService停止)--我们countDown()我们的锁存器也是中的。

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