Scala Lagom主题订阅服务器-如何在将来的异常中重试？

我在lagom有一个主题订户，如下所示

fooService.fooTopic().subscribe
  .atLeastOnce(
    Flow[fooMsg].map {
      case fooMsg(_) =>
        foo()
      case a =>
        println(a)
    }.async.map{ _ =>
      Done
    }
  )

为了订阅这个主题，我使用

atleastone

作为方法，这样如果有任何异常，我希望流重新启动/重试。当我抛出一个正常异常时，它可以继续正常重试

  private def foo() = {
    throw new RuntimeException("testing error")
  }

但是，将来发生异常时，无论我如何尝试，流都不会重新启动。下面是我将来处理异常的一个尝试

  private def foo() = {
    val test: Future[Int] = Future(throw new RuntimeException("asd"))
    val result = for {
      y1 <- test
    } yield (y1)

    result.onComplete{
      case Success(value) => println("SUCCESS")
      case Failure(exception) => println(exception.getMessage)
                                 throw exception
    }
  }
  private def foo() = {
    val test: Future[Int] = Future(throw new RuntimeException("asd"))

    test.onComplete{
      case Success(value) => println("SUCCESS")
      case Failure(exception) => println(exception.getMessage)
                                 throw exception
    }
  }

private def foo（）={
val test:Future[Int]=Future（抛出新的运行时异常（“asd”））
val结果=用于{
y1 println（“成功”）
案例失败（异常）=>println（exception.getMessage）
抛出异常
}
}
私有def foo（）={
val test:Future[Int]=Future（抛出新的运行时异常（“asd”））
测试完成{
案例成功（值）=>println（“成功”）
案例失败（异常）=>println（exception.getMessage）
抛出异常
}
}

---

它将显示异常，但

流

不会自动重新启动它。我应该如何处理/抛出

未来的异常

？

我认为，如果您只有一次失败，则无需重新启动全流程。我建议以后只重试

。例如，您可以编写这样的代码来重试您的调用，替换Future。方法调用成功（10）：

        val test: Future[Int] = Future(throw new RuntimeException("asd")).recoverWith {
          case NonFatal(e) =>
            Future.successful(10)
        }

        val result = for {
          y1 <- test
        } yield (y1)

在我的例子中，如果有任何异常，我需要重试整个流。实际上，未来的结果是通过http调用接收的。因此，我需要重试整个流，然后重新发送http调用。我的结果是由
async.map
给出的，您可以尝试第二个选项，它将不断重试，直到成功
map（）.async
（和
async.map（）
）和
mapsync（）
是非常不同的事情。流中的
async
操作符只是意味着在具体化时流中有一个异步边界，因此消息可以在任意一侧同时处理（流水线）
mapAsync
（以及其他附加了
Async
的同步运算符）表示该阶段的逻辑是异步的（涉及未来）。
  kafka.topic1.subscribe.atLeastOnce(Flow[String]
    .mapAsync(1) {
      case envelope: String =>

        val test: Future[String] = Future(throw new RuntimeException("asd"))
      /*.recoverWith {
          case NonFatal(e) =>
            Future.successful("10")
        }*/

        val result = for {
          y1 <- test
        } yield (y1)

        println(s"code block $envelope")
       result.onComplete{
          case Success(value) => println(s"Message from topic: $envelope $result")
          case Failure(exception) => println(exception.getMessage)
            throw exception
        }
      result.map(_ => Done)
    }
)