Akka HTTP + Schauspieler + Slick postgresql

Question

ich wieder lernen Scala, und ich wollte ein System fließen tun wie folgt

Routen (Akka-Http), die ein Schauspieler Model (Akka) fragt, die dann die Datenbank fragt durch ein Slick-Modell.

So etwas wie

Strecke

path("rooms"){ 
    get { 
    val rooms = (actorRoom ? GetRooms).mapTo[Seq[Room]] //bad code 
    complete(rooms) //bad code 
    } 
} 

ActorRoom

def receive = { 
    case GetRooms => sender() ! ModelRoom.getRooms() 

Slick Modell

val rooms = TableQuery[RoomTable] 
def getRooms(): Future[Seq[Room]] = rooms.result 

Mein Problem ist, dass ich nicht sicher bin, wenn die Räume zu lösen.

Sollte ich es innerhalb des Schauspielers tun? (Die Route komplett scheint nicht zu warten)

Soll ich es innerhalb der Route tun? (Wie soll ich es tun?)

Ist dieser Ansatz richtig, oder der Schauspieler ist zu viel?

Answer 1

Das Hinzufügen eines Actors im Nachrichtenfluss, wenn Ihr DB-Aufruf selbst asynchron ist, kann gefährlich sein, da dies zu unvorhersehbaren Ergebnissen führen kann.

Aber wenn man all die Unberechenbarkeit ignorieren und wollen immer noch, es zu tun, können Sie es so funktioniert,

Ihre Route,

import akka.pattern.ask 
import akka.actor.Status 
import scala.util.{Success, Failure} 

path("rooms"){ 
    get { 
    val dbCallThroughActor = (actorRoom ? GetRooms).map({ 
     case Status.Success(seq) => seq 
     case Status.Failure(ex) => throw ex 
    }) 
    onComplete(dbCallThroughActor.mapTo[Seq[Room]]) { 
     case Success(seq) => complete(seq) 
     // or your can reject with your rejection handler 
     case Failure(ex) => complete(ex) 
    } 
    } 
} 

Ihre Schauspieler,

import context.dispatcher 

def receive = { 
    case GetRooms => 
    ModelRoom.getRooms().pipeTo(sender()) 
} 

Ihr glattes Modell,

val rooms = TableQuery[RoomTable] 
def getRooms()(implicit ec: ExecutionContext): Future[Seq[Room]] = database.run(rooms.result)