如何重构这个scala代码？

我想将这段代码重构成更具可读性和更好的代码。我知道在Scala中通常有一些整洁的方法来做事情，但对我来说，这有点混乱（顺便说一句，我在代码中使用了Play库）。这是我的代码片段：

class HomeController @Inject()
  (cc: ControllerComponents)
  (implicit val config: Configuration)
  extends AbstractController(cc) {

  def removeIdElement(uid: String) =
    HAction(uid, "AuthEvent", 1, "login", parse.text).async {
      implicit request: Request[String] =>
        val promise = Promise[Result]()
        Future {
          val removeId = request.body.toLong
          println(s"remove id $removeId")

          promise completeWith {
            idElementsDAO.remove(removeId, uid.toLong) map {
              _ => Ok("")
            } recover {
              case t: Throwable =>
                val errorMessage: String = getMessageFromThrowable(t)
                println("remove id element failure " + errorMessage)
                BadRequest(errorMessage)
            }
          }
        } recover {
          case t: Throwable =>
            val errorMessage: String = getMessageFromThrowable(t)
            println("remove id element failure " + errorMessage)
            promise.success(BadRequest(errorMessage))
        }
        promise.future
    }
}

---

下面是一个更简单的代码版本：

class HomeController @Inject()(cc: ControllerComponents)(implicit val config: Configuration)
  extends AbstractController(cc) {

  def removeIdElement(uid: String) = HAction(uid, "AuthEvent", 1, "login", parse.text).async {
    implicit request: Request[String] =>

    Future {
      val removeId = request.body.toLong
      println(s"Removing id $removeId")
      removeId
    }.flatMap(id => idElementsDAO.remove(id, uid.toLong))
     .map(_ => Ok(""))
     .recover {
       case t: Throwable =>
         val errorMessage = getMessageFromThrowable(t)
         println(s"Removing id element failed: ${errorMessage}")
         BadRequest(errorMessage)
     }
  }
}

---

在上面的代码中，不需要

承诺

，并且不会重复

恢复

组合器。

下面是一个简单的代码版本：

class HomeController @Inject()(cc: ControllerComponents)(implicit val config: Configuration)
  extends AbstractController(cc) {

  def removeIdElement(uid: String) = HAction(uid, "AuthEvent", 1, "login", parse.text).async {
    implicit request: Request[String] =>

    Future {
      val removeId = request.body.toLong
      println(s"Removing id $removeId")
      removeId
    }.flatMap(id => idElementsDAO.remove(id, uid.toLong))
     .map(_ => Ok(""))
     .recover {
       case t: Throwable =>
         val errorMessage = getMessageFromThrowable(t)
         println(s"Removing id element failed: ${errorMessage}")
         BadRequest(errorMessage)
     }
  }
}

---

在上面的代码中，不需要

承诺

，而且

恢复

组合符也不会重复。

假设

理想元素dao.remove

返回一个

未来

，这可能更为惯用：

def removeIdElement(uid: String) =
  HAction(uid, "AuthEvent", 1, "login", parse.text).async {implicit request =>
    val removeId = request.body.toLong
    println(s"remove id $removeId")

    idElementsDAO.remove(removeId, uid.toLong)
      .map(_ => NoContent) // probably more correct than `Ok("")`
      .recover {
        case t: Throwable =>
          val errorMessage: String = getMessageFromThrowable(t)
          println("remove id element failure " + errorMessage)
          BadRequest(errorMessage)
      }
  }

不需要

承诺

或调用

Future{…}

（

Future.apply

）

请记住，直接将any

Throwable

的底层错误传递给http客户端（浏览器？）可能不是最好的方法

如果将通用错误处理代码添加到记录错误并向前端发送通用消息的全局错误处理程序（针对意外错误），则可以这样编写：

def removeIdElement(uid: String) =
  HAction(uid, "AuthEvent", 1, "login", parse.text).async {implicit request =>
    val removeId = request.body.toLong
    println(s"remove id $removeId")

    for {
      _ <- idElementsDAO.remove(removeId, uid.toLong)
    } yield NoContent
  }

def重新删除（uid:String）=
HAction（uid，“AuthEvent”，1，“login”，parse.text）。异步{隐式请求=>
val removeId=request.body.toLong
println（s“删除id$removeId”）
为了{
_假设
idElementsDAO.remove
返回一个
Future
，这可能更惯用：

def removeIdElement(uid: String) =
  HAction(uid, "AuthEvent", 1, "login", parse.text).async {implicit request =>
    val removeId = request.body.toLong
    println(s"remove id $removeId")

    idElementsDAO.remove(removeId, uid.toLong)
      .map(_ => NoContent) // probably more correct than `Ok("")`
      .recover {
        case t: Throwable =>
          val errorMessage: String = getMessageFromThrowable(t)
          println("remove id element failure " + errorMessage)
          BadRequest(errorMessage)
      }
  }

不需要
承诺
或调用
Future{…}
（
Future.apply
）

请记住，直接将any
Throwable
的底层错误传递给http客户端（浏览器？）可能不是最好的方法

如果将通用错误处理代码添加到记录错误并向前端发送通用消息的全局错误处理程序（针对意外错误），则可以这样编写：

def removeIdElement(uid: String) =
  HAction(uid, "AuthEvent", 1, "login", parse.text).async {implicit request =>
    val removeId = request.body.toLong
    println(s"remove id $removeId")

    for {
      _ <- idElementsDAO.remove(removeId, uid.toLong)
    } yield NoContent
  }

def重新删除（uid:String）=
HAction（uid，“AuthEvent”，1，“login”，parse.text）。异步{隐式请求=>
val removeId=request.body.toLong
println（s“删除id$removeId”）
为了{
_我建议从拆分成更小的方法开始。future中的代码可以是另一个具有良好名称的不同方法。我建议从拆分成更小的方法开始。future中的代码可以是另一个具有良好名称的不同方法，如果将来由
idElementsDAO.remove返回异常
，此代码仍将不正确地返回
Ok
…因为第一个
map
正在生成一个嵌套的未来，而
recover
调用仅处理
外部的
一个。如果
idElementsDAO.remove
在未来返回异常，此代码仍将不正确地返回
Ok
>…因为第一个
map
正在生成嵌套的未来，而
recover
调用只处理
外部的未来。