用阿卡-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) 
}