Question

我使用akka actor的喷雾构建了一个scala应用程序。

我的问题是请求已同步，服务器无法同时管理多个请求。

这是正常行为吗？我该怎么做才能避免这种情况？

这是我的启动代码：

object Boot extends App with Configuration {

  // create an actor system for application
  implicit val system = ActorSystem("my-service")
//context.actorOf(RoundRobinPool(5).props(Props[TestActor]), "router")
  // create and start property service actor
  val RESTService = system.actorOf(Props[RESTServiceActor], "my-endpoint")

  // start HTTP server with property service actor as a handler
  IO(Http) ! Http.Bind(RESTService, serviceHost, servicePort)
}

演员代码：

class RESTServiceActor extends Actor 
                            with RESTService  {
  implicit def actorRefFactory = context

  def receive = runRoute(rest)
}



trait RESTService extends HttpService  with SLF4JLogging{
  val myDAO = new MyDAO



  val AccessControlAllowAll = HttpHeaders.RawHeader(
    "Access-Control-Allow-Origin", "*"
  )
  val AccessControlAllowHeadersAll = HttpHeaders.RawHeader(
    "Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept"
  )
  val rest =  respondWithHeaders(AccessControlAllowAll, AccessControlAllowHeadersAll) { 
    respondWithMediaType(MediaTypes.`application/json`){
      options {
            complete {
              ""
            }
          } ~
      path("some"/"path"){
         get {
            parameter('parameter){ (parameter) => 
              ctx: RequestContext =>
                    handleRequest(ctx) {
                      myDAO.getResult(parmeter)
                    }
            }
          }
        } 
    }
  }

    /**
   * Handles an incoming request and create valid response for it.
   *
   * @param ctx         request context
   * @param successCode HTTP Status code for success
   * @param action      action to perform
   */
  protected def handleRequest(ctx: RequestContext, successCode: StatusCode = StatusCodes.OK)(action: => Either[Failure, _]) {
    action match {
      case Right(result: Object) =>
        println(result)
        ctx.complete(successCode,result.toString())
      case Left(error: Failure) =>
      case _ =>
        ctx.complete(StatusCodes.InternalServerError)
    }
  }
}

我看到了：

Akka Mist为构建RESTful Web提供了极好的基础 Scala中的服务，因为它结合了良好的可扩展性（由其支持具有一般轻量级的异步，非阻塞性质

那是我缺少的吗？是默认喷涂还是我需要添加它，以及如何？

我有点困惑。任何帮助表示赞赏。

Answer 1

如果您从头开始，我建议使用Akka HTTP，记录在http://doc.akka.io/docs/akka-stream-and-http-experimental/1.0-M4/scala/http/。它是Spray的一个端口，但是使用Akka Streams，这将是重要的前进。

至于使代码完全异步，关键模式是将Future返回到结果，而不是结果数据本身。换句话说，RESTServiceActor应返回返回数据的Future，而不是实际数据。这将允许Spray / Akka HTTP接受其他连接，并且服务actor的异步完成将在结束时返回结果。

Answer 2

而不是将结果发送到完整方法：

ctx.complete(successCode,result.toString())

我使用了未来的方法：

import concurrent.Future
import concurrent.ExecutionContext.Implicits.global

ctx.complete(successCode,Future(Option(result.toString())))

spala scala构建非阻塞servlet

2 个答案: