Spray.io 路由可以拆分为多个“控制器”吗？

Question

我还没有找到将 Spray.io 路由拆分为多个文件的可靠示例或结构。我发现我的路由的当前结构将变得非常繁琐，最好将它们抽象为一个非常简单的 REST API 应用程序的不同“控制器”。

文档似乎没有太大帮助：http://spray.io/documentation/spray-routing/key-concepts/directives/#directives

这是我目前所拥有的：

class AccountServiceActor extends Actor with AccountService {

  def actorRefFactory = context

  def receive = handleTimeouts orElse runRoute(demoRoute)

  def handleTimeouts: Receive = {
    case Timeout(x: HttpRequest) =>
      sender ! HttpResponse(StatusCodes.InternalServerError, "Request timed out.")
  }
}


// this trait defines our service behavior independently from the service actor
trait AccountService extends HttpService {

  val demoRoute = {
    get {
      path("") {
        respondWithMediaType(`text/html`) { // XML is marshalled to `text/xml` by default, so we simply override here
          complete(index)
        }
      } ~
      path("ping") {
        complete("PONG!")
      } ~
      path("timeout") { ctx =>
        // we simply let the request drop to provoke a timeout
      } ~
      path("crash") { ctx =>
        throw new RuntimeException("crash boom bang")
      } ~
      path("fail") {
        failWith(new RuntimeException("aaaahhh"))
      } ~
      path("riaktestsetup") {
        Test.setupTestData
        complete("SETUP!")
      } ~
      path("riaktestfetch" / Rest) { id =>
        complete(Test.read(id))
      }
    }
  }
}

感谢您的帮助！

Answer 1

我个人将它用于大型 API：

class ApiActor extends Actor with Api {
  override val actorRefFactory: ActorRefFactory = context

  def receive = runRoute(route)
}

/**
 * API endpoints
 *
 * Individual APIs are created in traits that are mixed here
 */
trait Api extends ApiService
  with AccountApi with SessionApi
  with ContactsApi with GroupsApi
  with GroupMessagesApi with OneToOneMessagesApi
  with PresenceApi
  with EventsApi
  with IosApi
  with TelephonyApi
  with TestsApi {
  val route = {
    presenceApiRouting ~
    oneToOneMessagesApiRouting ~
    groupMessagesApiRouting ~
    eventsApiRouting ~
    accountApiRouting ~
    groupsApiRouting ~
    sessionApiRouting ~
    contactsApiRouting ~
    iosApiRouting ~
    telephonyApiRouting ~
    testsApiRouting
  }
}

我建议将最常见的路由放在首位，并在子路由中尽快使用pathPrefix，这样可以减少 Spray 为每个传入请求运行的测试数量。

您会在下面找到一条我认为经过优化的路线：

  val groupsApiRouting = {
    pathPrefix("v3" / "groups") {
      pathEnd {
        get {
          traceName("GROUPS - Get joined groups list") { listJoinedGroups }
        } ~
        post {
          traceName("GROUPS - Create group") { createGroup }
        }
      } ~
      pathPrefix(LongNumber) { groupId =>
        pathEnd {
          get {
            traceName("GROUPS - Get by ID") { getGroupInformation(groupId) }
          } ~
          put {
            traceName("GROUPS - Edit by ID") { editGroup(groupId) }
          } ~
          delete {
            traceName("GROUPS - Delete by ID") { deleteGroup(groupId) }
          }
        } ~
        post {
          path("invitations" / LongNumber) { invitedUserId =>
            traceName("GROUPS - Invite user to group") { inviteUserToGroup(groupId, invitedUserId) }
          } ~
          path("invitations") {
            traceName("GROUPS - Invite multiple users") { inviteUsersToGroup(groupId) }
          }
        } ~
        pathPrefix("members") {
          pathEnd {
            get {
              traceName("GROUPS - Get group members list") { listGroupMembers(groupId) }
            }
          } ~
          path("me") {
            post {
              traceName("GROUPS - Join group") { joinGroup(groupId) }
            } ~
            delete {
              traceName("GROUPS - Leave group") { leaveGroup(groupId) }
            }
          } ~
          delete {
            path(LongNumber) { removedUserId =>
              traceName("GROUPS - Remove group member") { removeGroupMember(groupId, removedUserId) }
            }
          }
        } ~
        path("coverPhoto") {
          get {
            traceName("GROUPS - Request a new cover photo upload") { getGroupCoverPhotoUploadUrl(groupId) }
          } ~
          put {
            traceName("GROUPS - Confirm a cover photo upload") { confirmCoverPhotoUpload(groupId) }
          }
        } ~
        get {
          path("attachments" / "new") {
            traceName("GROUPS - Request attachment upload") { getGroupAttachmentUploadUrl(groupId) }
          }
        }
      }
    }
  }

Answer 2

您可以使用 ~ 组合器组合来自不同“控制器”的路由。

class AccountServiceActor extends Actor with HttpService {

  def actorRefFactory = context

  def receive = handleTimeouts orElse runRoute(
  new AccountService1.accountService1 ~  new AccountService2.accountService2)

  def handleTimeouts: Receive = {
    case Timeout(x: HttpRequest) =>
      sender ! HttpResponse(StatusCodes.InternalServerError, "Request timed out.")
  }
}



class AccountService1 extends HttpService {

  val accountService1 = {
    get {
      path("") {
        respondWithMediaType(`text/html`) { // XML is marshalled to `text/xml` by default, so we simply override here
          complete(index)
        }
      }
    }
}


class AccountService2 extends HttpService {

  val accountService2 = {
    get {
      path("someotherpath") {
        respondWithMediaType(`text/html`) { // XML is marshalled to `text/xml` by default, so we simply override here
          complete(index)
        }
      }
    }
}

Answer 3

我从上面的代码 sn-p 中尝试了这种方式，基本格式和作品。

import akka.actor.ActorSystem
import akka.actor.Props
import spray.can.Http
import akka.io.IO
import akka.actor.ActorRefFactory
import spray.routing.HttpService
import akka.actor.Actor


/**
 * API endpoints
 *
 * Individual APIs are created in traits that are mixed here
 */

trait Api extends ApiService
with UserAccountsService
{
  val route ={
    apiServiceRouting ~
    accountsServiceRouting
  }

}

trait ApiService extends HttpService{
  val apiServiceRouting={
    get{
      path("ping") {
       get {
        complete {
          <h1>pong</h1>
        }
       }
      }
    }
  }
}

trait UserAccountsService extends HttpService{
  val accountsServiceRouting={
     path("getAdmin") {
      get {
        complete {
          <h1>AdminUserName</h1>
        }
      }
    }
  }
}
class ApiActor extends Actor with Api {
  override val actorRefFactory: ActorRefFactory = context

  def receive = runRoute(this.route)
}


object MainTest extends App {

  // we need an ActorSystem to host our application in
  implicit val system = ActorSystem("UserInformaitonHTTPServer")

  // the handler actor replies to incoming HttpRequests
  val handler = system.actorOf(Props[ApiActor], name = "handler")

  // starting the server
  IO(Http) ! Http.Bind(handler, interface = "localhost", port = 8080)

}