我还没有找到一个坚实的例子或结构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))
}
}
}
}
感谢这个帮助！
你可以从不同的“控制器”使用〜组合子相结合的路线。
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)
}
}
}
}
我个人用这个大的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在子路由，只要你能，让你减少的是喷雾运行的每个传入请求测试次数。
你会发现，我相信这是优化的路线如下：
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) }
}
}
}
}
}
我试图从上面的代码片段，基本格式，并以这种方式工作。
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)
}
