处理我的未来在我的游戏 controller 操作方法中返回 None 的情况，

Question

我想通过下面的更新操作进行重构，使其看起来更具可读性并更好地处理故障情况

userService具有以下功能：

class UserService {
    def getUserByUsername: Future[Option[Int]] // which is the UserId
    def getUserById: Future[User]
}

我的动作看起来像：

def update(userId: Int) = Action.async { implicit request =>
    request.body.validate[User] match {
        case JsSuccess(user, _) => {
            userService.getUserByUsername(user.username).map { userId => 
                userService.getUserById(userId.get).map { existingUser =>
                    userService.update(user.username)

                    Ok
                }
            }
        }
        case JsError(err) => Future.sucessful(BadRequest(err))
    }
}

1. 如何处理 getUserByUsername 返回 None 的情况？
2. 如果它在理解中看起来会更干净吗，它是更好的风格吗？

Answer 1

您的问题中缺少一些数据，例如用户 model、用户服务 class 的案例类。 也最好附上原装的 function。

无论如何，我会做如下事情：

 def update(userId: Int) = Action { implicit request =>
    request.body.validate[User] match {
      case JsSuccess(user: User, _) => {
        val userId = getUserByUsername(user.username)
        userId match {
          case Some(userId) => {
            for {
              _ <- userService.getUserById(userId)
              _ <- userService.update(user.username)
            } yield Ok
          }.recover {
            case t: Throwable => 
              Metrics.errOnUpdate.increment() // Some metric to monitor 
              logger.error(s"update userId: $userId failed with ex: ${t.getMessage}") // log the error 
              InternalServerError(Json.toJson(Json.obj("error" -> "Failure occured on update"))) // return custom made exception to the client
          }
          case None => Future.successful(NotFound(s"No such user with ${user.username}"))
        }
      }
      case JsError(err) => Future.sucessful(BadRequest(err))
    }
  }

注意：如果.update返回 Future，您实际上并没有在向用户返回Ok之前等待update ，因此，如果它失败，它仍然返回Ok 。 要解决此问题，请使用 flatMap，然后使用 map update响应的值。

如果您愿意，您还可以将getUserById的恢复和update分开。

---

编辑：

  def update(userId: Int) = Action { implicit request =>
    request.body.validate[User] match {
      case JsSuccess(user: User, _) => {
          getUserByUsername(user.username).flatMap {
             case Some(userId) => for {
                _ <- userService.getUserById(userId)
                _ <- userService.update(user.username)
              } yield Ok
             case None => Future.successful(NotFound(s"No such user with ${user.username}"))
          }
        }.recover {
          case t: Throwable =>
            Metrics.errOnUpdate.increment() // Some metric to monitor 
            logger.error(s"update userId: $userId failed with ex: ${t.getMessage}") // log the error 
            InternalServerError(Json.toJson(Json.obj("error" -> "Failure occured on update"))) // return custom made exception to the client
        }
      }
      case JsError(err) => Future.sucessful(BadRequest(err))
    }
  }

Answer 2

首先，您可能需要使用Option.fold ：

@inline final def fold[B](ifEmpty: => B)(f: A => B)

然后你可以做这样的事情：

def update(userId: Int) = Action.async { implicit request =>
    def handleJsonErrors(errors: Seq[(JsPath, collection.Seq[JsonValidationError])]): Future[Result] = ???
    def updateUser(userWithoutId: User): Future[Result] = {
        for {
            userId <- userService.getUserByUsername(userWithoutId.username)
            _ <- userService.getUserById(userId.get)
            _ <- userService.update(userWithoutId.username)
        } yield {
            Ok
        }
    }

    request.body.asJson.fold {
        Future.successful(BadRequest("Bad json"))
    } {
        _.validate[User].fold(handleJsonErrors, updateUser).recover {
            case NonFatal(ex) =>
                InternalServerError
        }
    }
}