Java 如果失败，则在给定时间内执行任务

我正在尝试创建一个能够执行某些任务（方法）的服务，并在任务失败时重试

对于创建计时器，我使用石英的计时器服务（我无法更改计时器服务）

计时器服务具有方法

this.timerService.createTimerRunRepeatedly(
            handledId,
            timerId,
            optionalDescription,
            totalFireCount,
            intervalMiliSeconds,
            offsetMiliseconds,
            optionalCallbackData);

它还能够为创建的计时器注册处理程序

this.timerService.registerHandler(
                  handlerId,
                  firedCallback,
                  expiredCallback);

firedCallback->（可选）回调，每次使用此处理程序启动计时器时调用（

final Consumer firedCallback

）

expiredCallback->（可选）上次使用此处理程序启动计时器后调用的回调（

final Consumer expiredCallback

）

---

我创建了一个新的<强> TaskReSeryService < /St>>但是我不知道如何将某种方法传递给这个ReSeriService来执行它。

< P>因为您正在使用Spring Cype使用具有“框外”特性来处理失败和重试。

通过使用

@Retryable（SomeException.class）

注释方法，在引发

SomeException

时将重试该方法。它可以进一步定制，以将重试尝试、尝试之间的延迟（随机和指数）指定为

@Retryable（maxturets=12，backoff=@backoff（delay=100，maxDelay=500））

对于失败，将调用回调

@Recover

带注释的方法

有关更多实现说明，请查看github上的文章

---

希望这有帮助

事实上，我成功地让它工作了，因为我拥有了我所需要的一切。刚刚注册了一个处理程序

 @PostConstruct
 public void onPostConstruct() {
    handler = this.retryService.registerHandler("1", this::fireCallback, this::expiredCallback);
 }

回调是

private <T> void fireCallback(final T t) {
    System.out.println("fireCallback");
}
private <T> void expiredCallback(final T t) {
    System.out.println("expiredCallback");
}

在重试服务中，我有

public void retryTask(final HandlerId<String> handlerId,
                      final String timerId,
                      final Integer intervalTimeMinutes,
                      final Integer retryTimeMinutes) {
    this.timerService.createTimerRunRepeatedly(handlerId,
            timerId,
            "timer",
            getTotalFireCount(intervalTimeMinutes, retryTimeMinutes),
            (int) TimeUnit.MINUTES.toMillis(intervalTimeMinutes),
            0,
            null).thenAccept(timerWasCreated -> {
        if (timerWasCreated) {
            System.out.println("Timer was created");
        } else {
            System.out.println("Error while creating timer");
        }
    });
}

public void retryTask（最终HandlerId HandlerId，
最终字符串timerId，
最终整数间隔时间分钟，
最终整数（retryTimeMinutes）{
此.timerService.createTimerRunRepeatedly（handlerId，
蒂梅丽德，
“计时器”，
getTotalFireCount（intervalTimeMinutes，retryTimeMinutes），
（int）时间单位。分钟。托米利斯（intervalTimeMinutes），
0,
空）。然后接受（TimerWareScreated->{
如果（创建时间）{
System.out.println（“创建了计时器”）；
}否则{
System.out.println（“创建计时器时出错”）；
}
});
}

及

public HandlerId registerHandler（最终字符串HandlerId，
最终消费者firedCallback，
最终消费者过期（回调）{
返回this.timerService.registerHandler（handlerId、firedCallback、expiredCallback）；
}

这是你问的问题吗？是的，类似。我来看看。

public void retryTask(final HandlerId<String> handlerId,
                      final String timerId,
                      final Integer intervalTimeMinutes,
                      final Integer retryTimeMinutes) {
    this.timerService.createTimerRunRepeatedly(handlerId,
            timerId,
            "timer",
            getTotalFireCount(intervalTimeMinutes, retryTimeMinutes),
            (int) TimeUnit.MINUTES.toMillis(intervalTimeMinutes),
            0,
            null).thenAccept(timerWasCreated -> {
        if (timerWasCreated) {
            System.out.println("Timer was created");
        } else {
            System.out.println("Error while creating timer");
        }
    });
}

public <T> HandlerId<T> registerHandler(final String handlerId,
                                        final Consumer<T> firedCallback,
                                        final Consumer<T> expiredCallback) {
    return this.timerService.registerHandler(handlerId, firedCallback, expiredCallback);
}