Java 使用Actor Supervised，如果发生故障，如何在定义的时间间隔内重试同一消息，重试次数为定义的次数

我正在遵循akka.io容错

http://doc.akka.io/docs/akka/current/java/fault-tolerance.html

。我已将此代码作为参考。我的要求如下： 让我们假设演员在收到消息时崩溃 并由其主管重新启动。然后他开始处理下一个问题 他的邮箱里有一封信。导致崩溃的消息是 “dropped”。但我想在特定的时间（假设3次）内处理相同的操作，并在它们之间定义一个间隔（假设1秒）。如何使用akka监督来实现这一点。实际上，通过actor，我正在尝试检查某个特定的服务api是否正常工作（即，给出一些异常）。因此，如果在某个特定的尝试中存在任何异常（假设404未找到），请将消息重新发送给失败的工作器 直到达到主管策略规定的最大重试次数。如果worker失败了“maxnrofreetries”次，那么只需记录“此xx消息的最大尝试次数”。我将如何在java中执行此操作

我的班主任：

public class Supervisor extends UntypedActor {


 private static SupervisorStrategy strategy =

 new OneForOneStrategy(3, Duration.create("1 minute"),
  new Function<Throwable, Directive>() {
    @Override
    public Directive apply(Throwable t) {
      if (t instanceof Exception) {
        return restart();
      }else if (t instanceof IllegalArgumentException) {
        return stop();
      } else {
        return escalate();
      }
    }
  });

 @Override
 public SupervisorStrategy supervisorStrategy() {
 return strategy;


}
public void onReceive(Object o) {
if (o instanceof Props) {
  getSender().tell(getContext().actorOf((Props) o), getSelf());
} else {
  unhandled(o);
}


 }
}

创建参与者：

Props superprops = Props.create(Supervisor.class);
ActorRef supervisor = system.actorOf(superprops, "supervisor");
ActorRef child = (ActorRef) Await.result(ask(supervisor,
Props.create(Child.class), 5000), timeout);
child.tell("serVice_url", ActorRef.noSender());

对于服务url，如果出现故障，我想重复这个过程。但它没有发生。如果将CreatingActor中的下一行写为

child.tell（“serVice_url_2”，ActorRef.noSender（））然后这一行被显示出来，但我想在特定的时间（假设3次）内以定义的间隔处理相同的操作（发生故障）。
请指导我实现这一目标。
我认为我已经找到了一种方法。尽管我仍然需要在生产层面上进行测试。我在下面写下答案，因为它可能会对试图实现同样目标的人有所帮助。如果有人找到更好的方法，那么他/她将受到欢迎。
这里要提到的是，通过这种方法，主管在一个时间范围内对同一个操作（以及发生故障的消息）进行特定次数（假设3次）的处理。我无法定义它们之间的间隔。
这是代码。班主任

public class MyUntypedActor extends UntypedActor {
//here I have given Max no retrilas as 10.I will controll this number from logic as per my own requirements.But user given number of retrials can not exceed 10.
private static SupervisorStrategy strategy = new AllForOneStrategy(10, Duration.create(5, TimeUnit.MINUTES),
        new Function<Throwable, SupervisorStrategy.Directive>() {
            @Override
            public SupervisorStrategy.Directive apply(Throwable t) {
                if (t instanceof Exception) {
                    //System.out.println("exception" + "*****" + t.getMessage() + "***" + t.getLocalizedMessage());
                    return restart();
                } else if (t instanceof NullPointerException) {
                    return restart();
                } else if (t instanceof IllegalArgumentException) {
                    return stop();
                } else {
                    return escalate();
                }
            }
        });

@Override
public SupervisorStrategy supervisorStrategy() {
    return strategy;
}

public void onReceive(Object o) {
    if (o instanceof Props) {
        getSender().tell(getContext().actorOf((Props) o), getSelf());
    } else {
        unhandled(o);
    }
}
}

现在让我们创建演员

Props superprops = Props.create(MyUntypedActor.class);
SetRules setRules=new SetRules(3,0);
ActorSystem system = ActorSystem.create("helloakka");
ActorRef supervisor = system.actorOf(superprops, "supervisor");
ActorRef child = (ActorRef) Await.result(ask(supervisor, Props.create(Child.class), 5000), Duration.create(5, "minutes"));
Future<Object> future = Patterns.ask(child, service_Url, new Timeout(Duration.create(5, "minutes")));
Object result =  Await.result(future, Duration.create(5, "minutes"));
System.out.println(result);

Props superprops=Props.create（MyUntypedActor.class）；
SetRules SetRules=新的SetRules（3,0）；
ActorSystem=ActorSystem.create（“helloakka”）；
ActorRef supervisor=system.actorOf（superprops，supervisor）；
ActorRef child=（ActorRef）wait.result（提问（主管，道具.创建（child.class），5000），持续时间.创建（5，“分钟”）；
Future=Patterns.ask（子项、服务Url、新超时（Duration.create（5，“分钟”））；
Object result=wait.result（未来、持续时间、创建（5，“分钟”）；
系统输出打印项次（结果）；
我想我已经找到了一种方法。尽管我还需要在生产层面上做一个测试。我在下面写下答案，因为它可能会对试图实现同样目标的人有所帮助。如果有人找到更好的方法，那么他/她将受到欢迎。
这里要提到的是，通过这种方法，主管在一个时间范围内对同一个操作（以及发生故障的消息）进行特定次数（假设3次）的处理。我无法定义它们之间的间隔。
这是代码。班主任

public class MyUntypedActor extends UntypedActor {
//here I have given Max no retrilas as 10.I will controll this number from logic as per my own requirements.But user given number of retrials can not exceed 10.
private static SupervisorStrategy strategy = new AllForOneStrategy(10, Duration.create(5, TimeUnit.MINUTES),
        new Function<Throwable, SupervisorStrategy.Directive>() {
            @Override
            public SupervisorStrategy.Directive apply(Throwable t) {
                if (t instanceof Exception) {
                    //System.out.println("exception" + "*****" + t.getMessage() + "***" + t.getLocalizedMessage());
                    return restart();
                } else if (t instanceof NullPointerException) {
                    return restart();
                } else if (t instanceof IllegalArgumentException) {
                    return stop();
                } else {
                    return escalate();
                }
            }
        });

@Override
public SupervisorStrategy supervisorStrategy() {
    return strategy;
}

public void onReceive(Object o) {
    if (o instanceof Props) {
        getSender().tell(getContext().actorOf((Props) o), getSelf());
    } else {
        unhandled(o);
    }
}
}

现在让我们创建演员

Props superprops = Props.create(MyUntypedActor.class);
SetRules setRules=new SetRules(3,0);
ActorSystem system = ActorSystem.create("helloakka");
ActorRef supervisor = system.actorOf(superprops, "supervisor");
ActorRef child = (ActorRef) Await.result(ask(supervisor, Props.create(Child.class), 5000), Duration.create(5, "minutes"));
Future<Object> future = Patterns.ask(child, service_Url, new Timeout(Duration.create(5, "minutes")));
Object result =  Await.result(future, Duration.create(5, "minutes"));
System.out.println(result);

Props superprops=Props.create（MyUntypedActor.class）；
SetRules SetRules=新的SetRules（3,0）；
ActorSystem=ActorSystem.create（“helloakka”）；
ActorRef supervisor=system.actorOf（superprops，supervisor）；
ActorRef child=（ActorRef）wait.result（提问（主管，道具.创建（child.class），5000），持续时间.创建（5，“分钟”）；
Future=Patterns.ask（子项、服务Url、新超时（Duration.create（5，“分钟”））；
Object result=wait.result（未来、持续时间、创建（5，“分钟”）；
系统输出打印项次（结果）；
我几乎和你同时问了一个问题；我也在复习你的。有了这个解决方案，您确实可以将消息放回去，但您无法定义重启之间的时间（退避）。是的，我无法定义重启之间的间隔。有什么建议吗？@uıɥɔɯ我几乎与您同时问了一个问题；我也在复习你的。使用此解决方案，您确实可以将消息放回，但无法定义重启之间的时间（回退）。是的，我无法定义重启之间的间隔。有什么建议吗？@uıɥɔɯ
Props superprops = Props.create(MyUntypedActor.class);
SetRules setRules=new SetRules(3,0);
ActorSystem system = ActorSystem.create("helloakka");
ActorRef supervisor = system.actorOf(superprops, "supervisor");
ActorRef child = (ActorRef) Await.result(ask(supervisor, Props.create(Child.class), 5000), Duration.create(5, "minutes"));
Future<Object> future = Patterns.ask(child, service_Url, new Timeout(Duration.create(5, "minutes")));
Object result =  Await.result(future, Duration.create(5, "minutes"));
System.out.println(result);