Slick

Question

我正在研究一个图书馆数据模型，其中每本书可以有多个作者，反之亦然（多对多）。我想将书籍列表传递到 html 查看页面，每本书都包含其作者列表。为此，我为书籍和作者定义了下表：

  private class BookTable(tag: Tag) extends Table[Book](tag, "book") {

    def id = column[Long]("id", O.PrimaryKey, O.AutoInc)

    def name = column[String]("name")

    def publishDate = column[Date]("publish_date")

    def memberId = column[Option[Long]]("member_id")

    def member = foreignKey("member_fk",memberId,members)(_.id)

    type Data = (Long, String, Date, Option[Long])

    def constructBook: Data => Book = {
      case (id, name, publishDate, memberId) =>
        Book(id, name, publishDate, memberId)
    }

    def extractBook: PartialFunction[Book, Data] = {
      case Book(id, name, publishDate, memberId, _) =>
        (id, name, publishDate, memberId)
    }

    def * = (id, name, publishDate, memberId) <> (constructBook, extractBook.lift)
  }


private class AuthorBookTable (tag: Tag) extends Table[AuthorBook](tag, "author_book") {


 def id = column[Long]("id", O.PrimaryKey, O.AutoInc)

 def authorId = column[Long]("author_id")

 def bookId = column[Long]("book_id")

  def memberId = column[Option[Long]]("member_id")

  def author = foreignKey("author_fk",authorId,authors)(_.id)

  def book = foreignKey("book_fk",bookId,books)(_.id)

 def * = (id, authorId, bookId) <> ((AuthorBook.apply _).tupled, AuthorBook.unapply)
}


private class AuthorTable (tag: Tag) extends Table[Author](tag, "author") {

 def id = column[Long]("id", O.PrimaryKey, O.AutoInc)

 def name = column[String]("name")

 def * = (id, name) <> ((Author.apply _).tupled, Author.unapply)
}

书架class如下：

case class Book(id: Long, name: String, publishDate: Date, memberId: Option[Long] = None, authors: Seq[Author]= Seq.empty)
{

  def updateAuthors(authorss: Seq[Author]) = {
    this.copy(authors=authorss)
  }
}

在控制器中我使用以下：

  def getBooks = Action.async { implicit request =>
    repo.getBooks.map { books =>
      val booksWithAuthors=books.map( b=> {val updateB=b.updateAuthors( repo.getBookAuthors(b.id))
        updateB})
      Ok(Json.toJson(booksWithAuthors))
    }
  }

我的问题是关于如下所示的 getBookAuthors 实现：

  implicit def waitForFuture[A](f:Future[A]) = {
    def res: A = Await.result(f, Duration.Inf)
    res
  }

  def getBookAuthors(id: Long): Seq[Author] = {
    val result=db.run {
      val innerJoin = for {
        (ab, a) <- authorBooks join authors on (_.authorId === _.id)
      } yield (a, ab.bookId)
      innerJoin.filter(_._2 === id).sortBy(_._1.name).map(_._1).result
    }
    waitForFuture(result)
  }

我担心 getBookAuthors 函数会阻塞，我不确定这是否是最佳做法。请告知是否有更好的方法来做到这一点。

Answer 1

正如您所说，阻塞方法在这种情况下非常糟糕，您将失去使用非阻塞库作为 Slick 的优势。

getBookAuthors会这样写，返回一个Future[Seq[Author]]需要在调用者管理

def getBookAuthors(id: Long): Future[Seq[Author]] =
  db.run {
    val innerJoin = for {
      (ab, a) <- authorBooks join authors on (_.authorId === _.id)
    } yield (a, ab.bookId)
    innerJoin.filter(_._2 === id).sortBy(_._1.name).map(_._1).result
  }

所以调用者应该重写为：

def getBooks = Action.async { implicit request =>
  repo.getBooks.flatMap { books =>
    Future.sequence(
      books.map { b => 
        repo.getBookAuthors(b.id).map(authors => b.updateAuthors(authors))
      }
    ).map { booksWithAuthors =>
      Ok(Json.toJson(booksWithAuthors))
    }
  }
}

这意味着，一旦您获得 books: Seq[Book]，您将映射它以整合作者，这将以 Seq[Future[Book]] 结束。然后可以用Future.sequence方法转化为Future[Seq[Book]]（with authors）。最后你需要在外 Future 上 flatMap 从 Future[Future[Seq[Book]]] 移动到更简单的 Future[Seq[Book]]

可以利用 for-comprehension 以更简洁的方式重构第二个代码段，它是 flatMap

的语法糖

private def addAuthorsToBooks(books: Seq[Book]): Future[Seq[Book]] = 
  Future.sequence(
    books.map { b => 
      repo.getBookAuthors(b.id).map(authors => b.updateAuthors(authors))
    }
  )

def getBooks = Action.async { implicit request =>
  for {
    books <- repo.getBooks
    booksWithAuthors <- addAuthorsToBooks(books)
  } yield Ok(Json.toJson(booksWithAuthors))
}

Slick - 多对多关系

Slick - many to many relationship

scala