scala如何将一种类型的未来转换为另一种类型的未来

Question

i have a function which retrieve data from DB and return type of Future[ResponseDTO], then I need to convert it to Future of HttpResponse

my code:

val responseDTO = database.getResponseDto(service) => Future[ResponseDTO]

responseDTO.onComplete {
   case Success(responseDTO) => HttpResponse(status = responseDTO.responseCode, entity = responseDTO.responsePayload)
   case Failure(exception) => HttpError("error")
}

it wont work

tried this one too, still don't work

responseDTO.map(
  dto => EitherT.pure[Future, HttpError](HttpResponse(status = dto.responseCode, entity = dto.responsePayload))
)

Answer 1

Using transform should give the answer you want:

responseDTO.transform {
  case Success(responseDTO) => Success(HttpResponse(status = responseDTO.responseCode, entity = responseDTO.responsePayload))
  case _ => Success(HttpError("error"))
}

This will return a successful Future whose result type is compatible with both HttpResponse and HttpError .

If you want to retain the information about success/failure it is best to do this by using the status of the Future . In that case your code would use an alternate version of transform , like this:

case class HttpErrorException(err: HttpError) extends Throwable

responseDTO.transform(
  responseDTO => HttpResponse(status = responseDTO.responseCode, entity = responseDTO.responsePayload),
  _ => HttpErrorException(HttpError("error"))
)

You can then use the Future methods in the rest of the code to extract the HttpResponse or HttpErrorException when required.

Answer 2

You want to map the future. The .onComplete method doesn't transform the future, just adds an handler (useful for side effects)

responseDTO.map(dto => HttpResponse(status=dto.responseCode, entity=dto.responsePayload))

Answer 3

You need to use .map for mapping a successful future computation, use .recover to map an exception during future computation and Either to have a successful/failed result.

    val responseDTO: Future[ResponseDTO] = ... 

    val future: Future[Either[HttpError, HttpResponse]] = 
      responseDTO
        .map(d => Right(HttpResponse(status = d.responseCode, entity = d.responsePayload)))
        .recover {
          case t: Throwable => Left(HttpError("error"))
        }

if your classes have one superclass, let's say:

trait Http

case class HttpResponse(...) extends Http

case class HttpError(...) extends Http

you can avoid using Either :

    val future: Future[Http] =
      responseDTO
        .map(d => HttpResponse(status = d.responseCode, entity = d.responsePayload))
        .recover {
          case t: Throwable => HttpError("error")
        }

Answer 4

你需要做的是将你以前的A类未来映射到B类的新未来，未来的onComplete方法是副作用，只是有助于将回调附加到结果，其方法签名返回Unit。