用阿卡-HTTP

Question

我使用時如何完成其​​他演員的要求阿卡-HTTP 1.0，我想用定義爲

def route: Route = path("") { 
    // start actor with requestContext 
    // call requestContext.complete(...) in actor with the result 
} 

如何做到這一點的路線？

Answer 1

對@ jrudolph的評論進行了詳細闡述，下面的代碼滿足您將RequestContext值分配給Actor的要求。你的問題表明你想爲每個請求提供一個新的Actor;然而，下面的代碼對所有請求都使用相同的Actor，我認爲這是更高效/可能的用例。如果需要，Actor創建可以始終在handleRequest內移動。

首先，我們需要一個演員，用於處理對響應的請求：

import akka.actor.Actor 
import akka.http.scaladsl.server.{RequestContext, RouteResult} 
import akka.http.scaladsl.model.HttpResponse 

class RequestActor extends Actor { 

    //business logic - returns empty HttpResponse 
    def handleRequestMessage(requestContext : RequestContext) = 
    RouteResult.Complete(new HttpResponse()) 

    override def receive = { 
    case reqContext : RequestContext => 
     sender ! handleRequestMessage(reqContext) 
    } 
}//end class RequestActor 

現在用於查詢演員創造一個效用函數：

import akka.actor.ActorRef 
import scala.concurrent.Future 
import akka.pattern.ask 

object RequestActor { 
    val handleRequest : ActorRef => RequestContext => Future[RouteResult] = 
    (actorRef) => 
     (requestContext) => 
     ask(actorRef,reqContext).mapTo[RouteResult] 
} 

而所有剩下要做的就是線一切變成服務：

import akka.actor.{ActorSystem, Props} 
import akka.stream.ActorMaterializer 
import akka.http.scaladsl.Http 
import akka.http.scaladsl.server.Directives.{get,path} 
import akka.util.Timeout 

object RouteActorTest extends App { 
    implicit val as = ActorSystem("RouteActorTest") 
    implicit val timeout = new Timeout(1000) 

    val sendRequestToActor : RequestContext => Future[RouteResult] = 
    RequestActor handleRequest (as actorOf Props[RequestActor])  

    val route = path("")(get(sendRequestToActor)) 

    //rest of application... 

}//end object RouteActorTest 

Answer 2

你可能會嘗試更好，如：

package controllers 

import akka.actor.{Actor, ActorSystem, Props} 
import akka.stream.ActorMaterializer 

import scala.concurrent.{Await, Future} 
import akka.http.scaladsl.server.Directives._ 
import akka.stream.ActorMaterializer 
import akka.util.Timeout 
import akka.pattern.ask 
import scala.concurrent.Await 
import scala.concurrent.duration._ 
import scala.io.StdIn 
import akka.actor._ 

import akka.util.Timeout 


case object Message 

class TestActor(name:String) extends Actor { 
    def receive = { 
    case Message => 
     sender ! "Testing Ask pattern Approach" 
     println(s"hello from $name") 

    case _ => 

     println("that was unexpected") 
    } 
} 

object AskTest extends App { 

    implicit val system= ActorSystem("myactor") 
    implicit val material=ActorMaterializer() 

// implicit val props=Props.empty 
implicit val timeout = Timeout(5 seconds) 
    implicit val result =system.actorOf(Props(new TestActor("TestingName")),name = "Scala") 

    val future3:Future[String]= ask(result ,Message).mapTo[String] 
    val results = Await.result(future3, 2 seconds) 
    println(results) 
}