• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

Scala Route类代码示例

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

本文整理汇总了Scala中spray.routing.Route的典型用法代码示例。如果您正苦于以下问题:Scala Route类的具体用法?Scala Route怎么用?Scala Route使用的例子?那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。



在下文中一共展示了Route类的10个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于我们的系统推荐出更棒的Scala代码示例。

示例1: addManifest

//设置package包名称以及导入依赖的类
package com.pacbio.common.services

import scala.collection.mutable.ArrayBuffer
import spray.routing.{Route, RouteConcatenation}
import com.pacbio.common.models.PacBioComponentManifest
import com.pacbio.common.dependency.Singleton

import scala.collection.mutable

trait ServiceComposer extends RouteConcatenation with RouteProvider {
  val services = ArrayBuffer.empty[Singleton[PacBioService]]
  private val _manifests = mutable.Set.empty[PacBioComponentManifest]

  // Enable loading manifests that are "external" to the system (e.g., SL, SL UI)
  def addManifest(m: PacBioComponentManifest): PacBioComponentManifest = {
    _manifests.add(m)
    m
  }

  def addManifests(ms: Set[PacBioComponentManifest]): Set[PacBioComponentManifest] = {
    _manifests ++= ms
    ms
  }

  def addService(service: Singleton[PacBioService]) = {
    services += service
  }

  def routes(): Route = {
    services.map(_().prefixedRoutes).reduce(_ ~ _)
  }

  // This is a clumsy way to create a Set with 'id' being the
  // single component to compute equality
  def manifests(): Set[PacBioComponentManifest] = {
    (services.map(_().manifest).toSet ++ _manifests)
      .toList
      .map(x => (x.id, x))
      .toMap.values.toSet
  }

} 
开发者ID:PacificBiosciences,项目名称:smrtflow,代码行数:43,代码来源:ServiceComposer.scala


示例2: CreditApprovalsServiceActor

//设置package包名称以及导入依赖的类
package org.kda.credit.service

import akka.actor.Actor
import spray.httpx.SprayJsonSupport
import spray.routing.{HttpService, Route}
import org.kda.credit.model._
import spray.httpx.SprayJsonSupport._

class CreditApprovalsServiceActor extends Actor with CreditApprovalsService {
  def actorRefFactory = {
    context
  }

  def receive = {
    runRoute( applicationRoute )
  }
}

trait CreditApprovalsService extends HttpService with SprayJsonSupport {

  import spray.http.MediaTypes._
  import org.kda.credit.model.{ApprovedApplication, PendingApplication, CreditLine, Customer}
  import org.kda.credit.service.CreditApprovalJSonProtocol._

  //@formatter:off
  val applicationRoute: Route =
    path( "credit-approvals" ) {
      get {
        complete {
          PendingApplication( "123" ) // you can POST this payload to the service to convert it into an approved application
        }
      } ~
      post {
        respondWithMediaType( `application/json` )
        entity( as[ PendingApplication ] ) { application =>
          detach() {
            // in Part 4 this code will be integrated with the rules engine to actually perform the business logic
            val customer = Customer( application.customerId, 400 )
            val credit = CreditLine( customer, BigDecimal( 5000 ) )
            complete {
              ApprovedApplication( customer.id, Some( credit ) )
            }
          }
        }
      }
    }
} 
开发者ID:knowledgedataaction,项目名称:credit-approvals,代码行数:48,代码来源:CreditService.scala


示例3: sending

//设置package包名称以及导入依赖的类
package eu.shiftforward.apso.spray

import akka.actor.ActorSystem
import akka.io.IO
import spray.can.Http
import spray.http.{ HttpHeader, HttpRequest, RemoteAddress, Uri }
import spray.http.HttpHeaders.{ `Remote-Address`, `X-Forwarded-For` }
import spray.routing.{ Directive1, RequestContext, Route }


trait ProxySupport extends ClientIPDirectives {

  private def sending(f: RequestContext => HttpRequest)(implicit system: ActorSystem): Route = {
    val transport = IO(Http)(system)
    ctx => transport.tell(f(ctx), ctx.responder)
  }

  private def getHeaders(ip: Option[RemoteAddress], headers: List[HttpHeader] = Nil) = {
    // filter `Host` header
    val hs = headers.filterNot(header => header.is("host"))
    // add `X-Forwarded-For` header
    ip.fold(hs)(addForwardedFor(_, hs))
  }

  private def addForwardedFor(ip: RemoteAddress, headers: List[HttpHeader]): List[HttpHeader] = {
    headers match {
      case Nil =>
        // No `X-Forwarded-For` found in headers, so just add the new one
        `X-Forwarded-For`(ip) :: Nil

      case `X-Forwarded-For`(ips) :: tail =>
        `X-Forwarded-For`(ips :+ ip) :: tail

      case notForwardedFor :: tail =>
        notForwardedFor :: addForwardedFor(ip, tail)
    }
  }

  private val optionalRemoteAddress: Directive1[Option[RemoteAddress]] =
    headerValuePF { case `Remote-Address`(address) => Some(address) } | provide(None)

  def proxyTo(uri: Uri)(implicit system: ActorSystem): Route = {
    optionalRemoteAddress { ip =>
      sending(ctx => ctx.request.copy(
        uri = uri,
        headers = getHeaders(ip, ctx.request.headers)))
    }
  }

  def proxyToUnmatchedPath(uri: Uri)(implicit system: ActorSystem): Route = {
    optionalRemoteAddress { ip =>
      sending { ctx =>
        ctx.request.copy(
          uri = uri.withPath(uri.path.++(ctx.unmatchedPath)).withQuery(ctx.request.uri.query),
          headers = getHeaders(ip, ctx.request.headers))
      }
    }
  }
} 
开发者ID:ShiftForward,项目名称:apso,代码行数:60,代码来源:ProxySupport.scala


示例4: SSServer

//设置package包名称以及导入依赖的类
package com.server

import com.services.StorageService

import akka.actor.ActorSystem
import com.support.CORSSupport
import spray.http.MediaTypes
import spray.routing.{Route, SimpleRoutingApp}

object SSServer extends App with SimpleRoutingApp with CORSSupport{


  implicit val actorSystem = ActorSystem()


  //Custom directive to replace the inclcusion of the stated return type header
  def getJson(route: Route) = get{
    respondWithMediaType(MediaTypes.`application/json`){
      route
    }
  }

  //Define Each route independently as lazy vals to keep code clean
  //Link the names of each route in the start server method

  lazy val helloRoute = get {
      cors{
        path("hello") {
          complete {
            "Welcome to the AWS Storage Service \n here are a list of the available routes:"
          }
        }
      }
  }
  
  lazy val store_pcs_processA = get {
      cors{
        path("storageServices" / "s3" / "processControllers" / "processA" / "withObject" / Segment / "andDestination" / Segment ) { (data, fileName) =>
          complete {
             StorageService.writeObjectToS3(data,fileName)
          }
        }
      }
  }
  
  
  

  startServer(interface = "localhost", port = 8084) {
    helloRoute~
    store_pcs_processA
  }

} 
开发者ID:dbdev138,项目名称:DEV-FYP-AWS-Storage-Service,代码行数:55,代码来源:SSServer.scala


示例5: RestRoutingSpecs

//设置package包名称以及导入依赖的类
package com.cart.routing

import java.util.UUID

import org.scalatest.FlatSpec
import org.scalatest.Matchers

import com.cart.Cart
import com.cart.Carts
import com.cart.GetCarts
import com.cart.RestMessage

import akka.testkit.TestActorRef
import akka.testkit.TestProbe
import spray.routing.Route
import spray.testkit.ScalatestRouteTest


class RestRoutingSpecs extends FlatSpec with ScalatestRouteTest with Matchers {
  val getCartsService = TestProbe()
  
  def restRouting = TestActorRef(new RestRouting() {
    override def carts(message: RestMessage): Route =
      ctx => perRequest(ctx, getCartsService.ref, message)
  })
  
  "RestRouting" should "get Carts" in {
    val getCarts = Get("/carts") ~> restRouting.underlyingActor.route

    getCartsService.expectMsg(GetCarts())
    val uuid = UUID.randomUUID().toString()
    getCartsService.reply(Carts(Seq(Cart(uuid))))

    getCarts ~> check {
      responseAs[String] should equal(s"""{"carts":[{"id":"$uuid"}]}""")
    }
  }
} 
开发者ID:bbiletskyy,项目名称:shopping-cart-service,代码行数:39,代码来源:RestRoutingSpecs.scala


示例6: RestService

//设置package包名称以及导入依赖的类
package com.me.finalization

import akka.actor.{Actor, ActorRef}
import akka.io.IO
import akka.pattern.ask
import com.me.finalization.Domain.{Container, Junction}
import com.me.finalization.Messages.{Go, WhereShouldIGo}
import spray.can.Http
import spray.routing.{HttpServiceBase, Route}

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._


class RestService(nextActorRef: ActorRef, exposedPort: Int) extends Actor with RestInterface {

  implicit val system = context.system

  override def decider: ActorRef = nextActorRef

  def receive = runRoute(route)
  IO(Http) ! Http.Bind(self, interface = "0.0.0.0", port = exposedPort)
}

trait RestInterface extends HttpServiceBase {

  import spray.httpx.SprayJsonSupport._

  val route: Route = {
    path("junctions" / IntNumber / "decisionForContainer" / IntNumber) { (junctionId, containerId) =>
      get {
        complete {
          //println(s"Request for junction $junctionId and container $containerId")
          val junction = Junction(junctionId)
          val container = Container(containerId)
          //val decision = Decisions.whereShouldContainerGo(junction, container)
          decider.ask(WhereShouldIGo(junction, container))(5 seconds).mapTo[Go]
        }
      }
    }
  }

  def decider: ActorRef = ???
} 
开发者ID:PuspenduBanerjee,项目名称:ScalaAkkaBlah,代码行数:45,代码来源:RestInterface.scala


示例7: RoutedHttpService

//设置package包名称以及导入依赖的类
package com.example.spray

import scala.util.control.NonFatal
import akka.actor.{Actor, ActorLogging, Props}
import spray.routing.{ExceptionHandler, HttpService, RejectionHandler, Route, RouteConcatenation, RoutingSettings}
import spray.util.LoggingContext
import spray.http.StatusCodes.InternalServerError
import com.example.spray.add.AddService
import com.example.spray.hello.HelloService
import com.example.spray.swagger.SwaggerDocService


class RoutedHttpService(route: Route) extends Actor with HttpService with ActorLogging {

  implicit def actorRefFactory = context

  implicit val handler = ExceptionHandler {
    case NonFatal(ErrorResponseException(statusCode, entity)) => ctx =>
      ctx.complete((statusCode, entity))

    case NonFatal(e) => ctx => {
      log.error(e, InternalServerError.defaultMessage)
      ctx.complete(InternalServerError)
    }
  }


  def receive: Receive =
    runRoute(route)(handler, RejectionHandler.Default, context, RoutingSettings.default, LoggingContext.fromActorRefFactory)

} 
开发者ID:pjfanning,项目名称:swagger-spray-sample,代码行数:32,代码来源:Api.scala


示例8: ApiActor

//设置package包名称以及导入依赖的类
package org.xiaon
package hashservice
package http

import akka.actor.{ ActorRef, Props, ActorLogging }

import spray.routing.{ RequestContext, Route, HttpService, HttpServiceActor }
import spray.http.StatusCodes
import spray.httpx.SprayJsonSupport._

import domain.SimpleJob
import processor.ProcessingActor

class ApiActor(settings: Settings) extends HttpServiceActor with HttpService with ActorLogging {
  import ApiActor._
  import ProcessingActor._

  private[http] val timeout = settings.Timeout

  def receive = runRoute(route)

  private[hashservice] def route: Route = {
    path(Ping) {
      get {
        complete(StatusCodes.OK -> "pong")
      }
    } ~
      pathPrefix(Api) {
        path(Service) {
          post {
            entity(as[SimpleJob]) { job =>
              requestContext =>
                val processor = createProcessor(requestContext)
                processor ! job
            }
          }
        }
      }
  }

  private[hashservice] def createProcessor(ctx: RequestContext): ActorRef =
    context.actorOf(Props(new ProcessingActor(timeout, resultCallback = completeJobRequest(ctx))))

  private[hashservice] def completeJobRequest(ctx: RequestContext)(result: JobResult): Unit = {
    result match {
      case Right(job)  => ctx.complete(StatusCodes.Accepted -> job)

      case Left(error) => ctx.complete(StatusCodes.ServiceUnavailable -> error)
    }
  }
}

object ApiActor {
  private[hashservice] val Ping = "ping"
  private[hashservice] val Api = "api"
  private[hashservice] val Service = "service"
} 
开发者ID:adilakhter,项目名称:hashing-as-a-service,代码行数:58,代码来源:ApiActor.scala


示例9: SSServer

//设置package包名称以及导入依赖的类
package com.server

import com.services.StorageService

import akka.actor.ActorSystem
import com.support.CORSSupport
import spray.http.MediaTypes
import spray.routing.{Route, SimpleRoutingApp}

object SSServer extends App with SimpleRoutingApp with CORSSupport{


  implicit val actorSystem = ActorSystem()


  //Custom directive to replace the inclcusion of the stated return type header
  def getJson(route: Route) = get{
    respondWithMediaType(MediaTypes.`application/json`){
      route
    }
  }

  //I have defined each route independently as lazy vals to keep the code clean

  //Endpoint: List avalable endpoints
  lazy val helloRoute = get {
      cors{
        path("hello") {
          complete {
            "Welcome to the MicroDG AWS-Stroage-Service" +
            "\n Routes:" +
            "\n Store output fro, Process A: storageServices/s3/processControllers/processA/withObject/{json_object}/andDestination/{url}"
          }
        }
      }
  }
  
  //Endpoint: Write output from Process A to an S3 bucket
  lazy val store_pcs_processA = get {
      cors{
        path("storageServices" / "s3" / "processControllers" / "processA" / "withObject" / Segment / "andDestination" / Segment ) { (data, fileName) =>
          complete {
             StorageService.writeObjectToS3(data,fileName)
          }
        }
      }
  }
  
  startServer(interface = "localhost", port = 8084) {
    helloRoute~
    store_pcs_processA
  }

} 
开发者ID:microdg,项目名称:BETA-AWS-Storage-Service,代码行数:55,代码来源:SSServer.scala


示例10: SprayEndpoints

//设置package包名称以及导入依赖的类
package org.zachary.demo

import akka.actor.ActorSystem
import akka.stream.ActorMaterializer
import spray.httpx.SprayJsonSupport._
import spray.json.DefaultJsonProtocol._
import spray.json._
import spray.routing.{HttpServiceActor, Route}

class SprayEndpoints(actorSystem: ActorSystem, am: ActorMaterializer) extends HttpServiceActor {
  implicit val printer = CompactPrinter
  implicit val orderFormat = jsonFormat2(Order.apply)

  implicit val actorMaterializer = am
  implicit val ec = actorSystem.dispatcher

  def receive = runRoute(routes)

  lazy val routes: Route = blockingGet

  val blockingGet: Route = path("blocking" / IntNumber)(i => {
    get {
      complete {
        Order.source(i)
          .runFold(Seq.empty[Order])(_ :+ _)
      }
    }
  })

} 
开发者ID:zacharyp,项目名称:akka-http-presentation,代码行数:31,代码来源:SprayEndpoints.scala



注:本文中的spray.routing.Route类示例整理自Github/MSDocs等源码及文档管理平台,相关代码片段筛选自各路编程大神贡献的开源项目,源码版权归原作者所有,传播和使用请参考对应项目的License;未经允许,请勿转载。


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
Scala ActorRefRoutee类代码示例发布时间:2022-05-23
下一篇:
Scala NetHttpTransport类代码示例发布时间:2022-05-23
热门推荐
热门话题
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap