Как я могу объединить два Future [JsArray]?

Question

У меня есть два Future[JsArray], f1 и f2, и мне нужно подождать, чтобы оба они были завершены с результатом.

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

Как я могу это сделать?

Answer 1

Одно из решений

1. Определить map2 функции для Future с:

   def map2[A, B, C](fa: Future[A], fb: Future[B])(g: (A, B) => C) 
          (implicit executor: ExecutionContext): Future[C] = 
       for { 
       a <- fa 
       b <- fb 
       } yield g(a, b) 
   

2. Определить merge функции для объединения двух JsArray с (т.е. извлечения и конкатенаций элементов и используйте результат для создания нового JsArray):

   def merge(array1: JsArray, array2: JsArray): JsArray = 
       JsArray(array1.elements ++ array2.elements: _*) 
   

   Примечание: вам необходимо указать тип, чтобы передать полученный результат Vector в JsArray's apply method.

3. Вызов

   map2(f1, f2)(merge) 
   

Пробный запуск в REPL

scala> import spray.json._ 
import spray.json._ 

scala> import scala.concurrent.Future 
import scala.concurrent.Future 

scala> import scala.concurrent.ExecutionContext.Implicits.global 
import scala.concurrent.ExecutionContext.Implicits.global 

scala> val f1 = Future(JsArray(JsNumber(1), JsNumber(2))) 
f1: scala.concurrent.Future[spray.json.JsArray] = List() 

scala> val f2 = Future(JsArray(JsNumber(3), JsNumber(4), JsNumber(5))) 
f2: scala.concurrent.Future[spray.json.JsArray] = List() 

scala> map2(f1, f2)(merge).onComplete(println) 
Success([1,2,3,4,5]) 

Answer 2

Вы можете комбинировать фьючерсы с использованием синтаксиса «для». Что-то вроде:

val f1:Future[Int] = getF1() 
val f2:Future[Int] = getF2() 
val res:Future[Int] = for (
    v1 <- f1; 
    v2 <- f2 
) yield (v1 + v2) 

Answer 3

Предполагая, что «суммирующих массивы» вы имеете в виду конкатенации их ++, вы хотите сделать:

Future.sequence(Set(getF1,getF2)) map { _ reduce(_ ++ _)} 

последовательность будет иметь успех, если и только если все фьючерсы успеха. Затем мы уменьшаем полученный результат Set на ++ - все его элементы.

Answer 4

прямой и простое решение

Будущее поддерживает zip операцию, которая очень удобно.

val f1: Future[JsArray] 
val f2: Future[JsArray] 
val resultF = f1.zip(f2).map {case (a, b) => a ++ b} 

если f1 или f2 терпит неудачу, resultF также не будет с тем же исключением f1 или f2 недостаточности.

необязательно можно удалить скобка

val resultF = f1 zip f2 map { case (f1Result, f2Result) => f1Result ++ f2Result }