Объединить много будущего [Seq] в одно будущее [Seq]

Question

Без будущего, вот как я объединяю все меньшие Seq в один большой Seq с плоской картой

category.getCategoryUrlKey(id: Int):Seq[Meta] // main method
val appDomains: Seq[Int]

val categories:Seq[Meta] = appDomains.flatMap(category.getCategoryUrlKey(_))

Теперь метод getCategoryUrlKey может потерпеть неудачу. Я поставил автоматический выключатель впереди, чтобы избежать вызова его для следующих элементов после количества maxFailures. Теперь автоматический выключатель не возвращает Seq но Future[Seq]

lazy val breaker = new akka.pattern.CircuitBreaker(...)

private def getMeta(appDomainId: Int): Future[Seq[Meta]] = {
  breaker.withCircuitBreaker {
    category.getCategoryUrlKey(appDomainId)
  }
}

Как перебрать Список appDomains и объединить результат в одно Future[Seq], возможно в Seq?

Если применимо функциональное программирование, существует ли способ прямого преобразования без временных переменных?

Answer 1

Сквош секью фьючерсы с использованием Future.sequence

Future.sequenceновообращенные Seq[Future[T]] в Future[Seq[T]]

В твоем случае T является Seq, После выполнения последовательности вы получите Seq[Seq[T]]. Так что просто сгладьте его после операции последовательности, используя flatten.

def squashFutures[T](list: Seq[Future[Seq[T]]]): Future[Seq[T]] =
  Future.sequence(list).map(_.flatten)

Ваш код становится

Future.sequence(appDomains.map(getMeta)).map(_.flatten)

Answer 2

От TraversableOnce[Future[A]] к будущему [TraversableOnce[A]]

val categories = Future.successful(appDomains).flatMap(seq => {
    val fs = seq.map(i => getMeta(i))
    val sequenced = Future.sequence(fs)
    sequenced.map(_.flatten)
})

• Future.successful(appDomains) поднимает appDomains в контексте Future

Надеюсь это поможет.

Answer 3

val metaSeqFutureSeq = appDomains.map(i => getMeta(i))
// Seq[Future[Seq[Meta]]]

val metaSeqSeqFuture = Future.sequence(metaSeqFutureSeq)
// Future[Seq[Seq[Meta]]]
// NOTE :: this future will fail if any of the futures in the sequence fails

val metaSeqFuture = metaSeqSeqFuture.map(seq => seq.flatten)
// Future[Seq[Meta]]

Если вы хотите отказаться от единственных неудачных фьючерсов, но сохранить успешный, мы должны быть немного креативными и строить свое будущее, используя обещание.

import java.util.concurrent.locks.ReentrantLock

import scala.collection.mutable.ArrayBuffer
import scala.concurrent.{Future, Promise}
import scala.util.{Failure, Success}

def futureSeqToOptionSeqFuture[T](futureSeq: Seq[Future[T]]): Future[Seq[Option[T]]] = {
  val promise = Promise[Seq[Option[T]]]()

  var remaining = futureSeq.length

  val result = ArrayBuffer[Option[T]]()
  result ++ futureSeq.map(_ => None)

  val resultLock = new ReentrantLock()

  def handleFutureResult(option: Option[T], index: Int): Unit = {
    resultLock.lock()
    result(index) = option
    remaining = remaining - 1
    if (remaining == 0) {
      promise.success(result)
    }
    resultLock.unlock()
  }

  futureSeq.zipWithIndex.foreach({ case (future, index) => future.onComplete({
    case Success(t) => handleFutureResult(Some(t), index)
    case Failure(ex) => handleFutureResult(None, index)
  }) })

  promise.future
}

val metaSeqFutureSeq = appDomains.map(i => getMeta(i))
// Seq[Future[Seq[Meta]]]

val metaSeqOptionSeqFuture = futureSeqToOptionSeqFuture(metaSeqFutureSeq)
// Future[Seq[Option[Seq[Meta]]]]

val metaSeqFuture = metaSeqSeqFuture.map(seq => seq.flatten.flatten)
// Future[Seq[Meta]]