Scala 如何在reactivemongo中对这些未来函数进行排序？

我有4个函数，

createUser

，

updateUser

，

deleteUser

，

listUser

这4个功能都是被动的

如何按此顺序执行它们

createUser->listUser(list created user)->updateUser->listUser(list updated user)>deleteUser->listUser

我的createUser：

def createSomeUser() {
  var users = List[BSONDocument]()
  val user1 = BSONDocument(
    "firstName" -> "Kobe",
    "lastName" -> "Bryant",
    "Number" -> "8"
  )
  users = user1 :: users
  val enumerator = Enumerator.enumerate(users)
  val future = collection.bulkInsert(enumerator)
  future.onComplete {
    case Failure(e) => throw e
    case Success(lastError) => {
      println("All users were inserted to DB")
    }
  } 
}

我的更新程序：

def updateAUser(firstName: String, number: Int)  {
  val selector = BSONDocument("firstName" -> firstName)

  val modifier = BSONDocument(
    "$set" -> BSONDocument(
      "Number" -> number))
  val futureUpdate = collection.update(selector, modifier)
  //get a future update
  futureUpdate.onComplete {
    case Failure(e) => throw e
    case Success(lastError) => {
      println("successfully Update user")
    }
  }
}

我的删除用户：

def deleteAUser(firstName: String) {
  val selector = BSONDocument(
    "firstName" -> firstName)
  val futureRemove = collection.remove(selector)
  futureRemove.onComplete {
    case Failure(e) => throw e
    case Success(lasterror) => {
      println("successfully removed users")
    }
  }
}

我的列表用户：

def listDocs() = {
  // Select all documents
  val query = BSONDocument()
  // select all fields
  val filter = BSONDocument(
    "lastName" -> 1,
    "firstName" -> 1,
    "Number" -> 1,
    "_id" -> 1)

  val fList = collection.
    find(query, filter).
    cursor[BSONDocument].
    collect[List]()

  fList.map { list =>
    list.foreach { doc =>
      println("found User: " + BSONDocument.pretty(doc))
    }
  }
}

---

您可以使用

flatMap

，但必须稍微更改函数实现，因为它们不会返回您可以链接的未来，例如：

def createSomeUser(): Future[SomeType] = {
  (omitted for brevity)
  collection.bulkInsert(enumerator)
}

def updateAUser(firstName: String, number: Int): Future[SomeType] = {
   (omitted for brevity)
   collection.update(selector, modifier)
}

def deleteAUser(firstName: String): Future[SomeType] = {
  (omitted for brevity)
  collection.remove(selector)
}

它们现在都返回一个未来，其中包含一些价值，现在使用

flatMap

您可以链接执行：

createSomeUser().flatMap {
  created => updateAUser(someName, someNumber).flatMap {
    updatedUser => deleteAUser(created.getName).flatMap {
      deleted => // and so on...
    }
  }
}

---

在这种情况下，修改函数实现似乎是合乎逻辑的，如果您不想这样做，您很可能需要在另一个将来（在被调用时）包装它们，或者在

onComplete

方法中链接函数执行，但这将对行为进行硬编码，并且不可能创建像我向您展示的那样的自定义调用链。

您可以使用

flatMap

，但您必须稍微更改您的函数实现，因为它们不会返回您可以链接的未来，例如：

def createSomeUser(): Future[SomeType] = {
  (omitted for brevity)
  collection.bulkInsert(enumerator)
}

def updateAUser(firstName: String, number: Int): Future[SomeType] = {
   (omitted for brevity)
   collection.update(selector, modifier)
}

def deleteAUser(firstName: String): Future[SomeType] = {
  (omitted for brevity)
  collection.remove(selector)
}

它们现在都返回一个未来，其中包含一些价值，现在使用

flatMap

您可以链接执行：

createSomeUser().flatMap {
  created => updateAUser(someName, someNumber).flatMap {
    updatedUser => deleteAUser(created.getName).flatMap {
      deleted => // and so on...
    }
  }
}

在这种情况下，修改函数实现似乎是合乎逻辑的，如果您不想这样做，您很可能需要在另一个将来（在被调用时）包装它们，或者在

onComplete

方法中链接函数执行，但这将对行为进行硬编码，并且不可能像我向您展示的那样创建自定义调用链