Scala ScalatraServlet类代码示例

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

import com.doanduyhai.service.FibonacciService
import org.json4s.{DefaultFormats, Formats}
import org.scalatra.{InternalServerError, BadRequest, ScalatraServlet}
import org.scalatra.json.JacksonJsonSupport

class FibonacciREST extends ScalatraServlet with JacksonJsonSupport {

  protected implicit val jsonFormats: Formats = DefaultFormats

  before() {
    contentType = formats("json")
  }

  get("/:rank") {
    val rank = params("rank").toInt
    try {
      FibonacciService.computeFibonacci(rank)
    } catch {
      case ex: IllegalArgumentException => BadRequest(ex.getMessage)
      case throwable: Throwable => InternalServerError(throwable.getMessage)
    }
  }


  notFound {
    contentType = "text/html"
    serveStaticResource() getOrElse resourceNotFound()
  }
} 

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

import akka.actor.{ActorRef, ActorSystem}
import org.json4s.{DefaultFormats, Formats, JValue}
import org.scalatra.json.JacksonJsonSupport
import org.scalatra.{FutureSupport, Ok, ScalatraServlet}
import org.slf4j.LoggerFactory

class InterceptionController(actorSystem: ActorSystem, interceptionHandler: ActorRef) extends ScalatraServlet with JacksonJsonSupport with FutureSupport {

  protected implicit val jsonFormats: Formats = DefaultFormats

  protected override def transformRequestBody(body: JValue): JValue = body.camelizeKeys

  protected override def transformResponseBody(body: JValue): JValue = body.underscoreKeys

  protected implicit def executor = scala.concurrent.ExecutionContext.Implicits.global

  protected val log = LoggerFactory.getLogger(classOf[InterceptionController])

  log.info("Starting interception controller")

  before() {
    contentType = formats("json")
  }

  get("/*") {
    Ok
  }

  put("/") {
    val interception = parsedBody.extract[Interception]
    log.info(s"Setting interception: $interception")
    interceptionHandler ! SetInterception(interception)
    Ok
  }

  post("/") {
    val interception = parsedBody.extract[Interception]
    log.info(s"Adding interception: $interception")
    interceptionHandler ! AddInterception(interception)
    Ok
  }

  delete("/*") {
    log.info(s"Deleting interceptions")
    interceptionHandler ! DeleteInterceptions()
    Ok
  }
} 

//设置package包名称以及导入依赖的类
package com.github.twinra.lendmanager.rest

import java.time.LocalDate

import com.github.twinra.lendmanager.dao.LendingRepository
import com.github.twinra.lendmanager.domain.Lending
import com.github.twinra.lendmanager.repo.{ItemRepository, PersonRepository}
import com.github.twinra.utils.json.JLocalDateSerializer
import com.typesafe.scalalogging.LazyLogging
import org.json4s.{DefaultFormats, Formats}
import org.scalatra.ScalatraServlet
import org.scalatra.json.JacksonJsonSupport

import scala.util.{Failure, Success, Try}

private case class LendingMessage(itemId: Long, personId: Long, date: LocalDate)

class LendingsServlet(implicit repo: LendingRepository,
                      itemsRepo: ItemRepository,
                      peopleRepo: PersonRepository) extends ScalatraServlet with LazyLogging with JacksonJsonSupport {
  protected implicit lazy val jsonFormats: Formats = DefaultFormats + JLocalDateSerializer

  before() {
    contentType = formats("json")
  }

  get("/") {
    repo.readAll()
  }

  get("/:id") {
    repo.read(params("id").toLong).getOrElse(halt(404))
  }

  post("/") {
    val lendingRequest = Try(parsedBody.extract[LendingMessage]) match {
      case Success(b) => b
      case Failure(ex) =>
        log("Failed extract lending", ex)
        halt(400)
    }
    val item = itemsRepo.read(lendingRequest.itemId).getOrElse(halt(404))
    val person = peopleRepo.read(lendingRequest.personId).getOrElse(halt(404))
    repo.add(Lending(item, person, lendingRequest.date))
  }

  delete("/:id") {
    repo.delete(params("id").toLong)
  }
} 

//设置package包名称以及导入依赖的类
package com.github.twinra.lendmanager.rest

import com.github.twinra.lendmanager.domain.Item
import com.github.twinra.lendmanager.repo.ItemRepository
import com.typesafe.scalalogging.LazyLogging
import org.json4s.{DefaultFormats, Formats}
import org.scalatra.ScalatraServlet
import org.scalatra.json.JacksonJsonSupport

class ItemsServlet(implicit val repo: ItemRepository) extends ScalatraServlet with LazyLogging with JacksonJsonSupport {
  protected implicit lazy val jsonFormats: Formats = DefaultFormats

  before() {
    contentType = formats("json")
  }

  get("/") {
    repo.readAll()
  }

  get("/:id") {
    repo.read(params("id").toLong).getOrElse(halt(404))
  }

  post("/") {
    val item = parsedBody.extract[Item]
    repo.add(item)
  }

  put("/:id") {
    val item = parsedBody.extract[Item]
    repo.update(params("id").toLong, item)
  }

  delete("/:id") {
    repo.delete(params("id").toLong)
  }
} 

//设置package包名称以及导入依赖的类
package com.github.twinra.lendmanager.rest

import com.github.twinra.lendmanager.domain.Person
import com.github.twinra.lendmanager.repo.PersonRepository
import com.typesafe.scalalogging.LazyLogging
import org.json4s.{DefaultFormats, Formats}
import org.scalatra.ScalatraServlet
import org.scalatra.json._

class PeopleServlet(implicit val repo: PersonRepository) extends ScalatraServlet with LazyLogging with JacksonJsonSupport {
  protected implicit lazy val jsonFormats: Formats = DefaultFormats

  before() {
    contentType = formats("json")
  }

  get("/") {
    repo.readAll()
  }

  get("/:id") {
    repo.read(params("id").toLong).getOrElse(halt(404))
  }

  post("/") {
    val person = parsedBody.extract[Person]
    repo.add(person)
  }

  put("/:id") {
    val person = parsedBody.extract[Person]
    repo.update(params("id").toLong, person)
  }

  delete("/:id") {
    repo.delete(params("id").toLong)
  }
} 

//设置package包名称以及导入依赖的类
package jp.seraphr.fileupload.main

import javax.servlet.ServletContext

import jp.seraphr.fileupload.FileUploadApi
import jp.seraphr.fileupload.model.UploadSettings
import org.scalatra.{ LifeCycle, ScalatraServlet }
import upickle.Api


class ScalatraBootstrap extends LifeCycle {
  class FileUploadServlet extends ScalatraServlet with FileUploadApi {
    override protected val settings: UploadSettings = UploadSettings("fileparam")
    override val jsonApi: Api = upickle.default
  }

  override def init(context: ServletContext): Unit = {
    val tServlet = new FileUploadServlet
    context.mount(tServlet, "/fileupload")
  }
} 

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

import org.scalatra._
import scalate.ScalateSupport

import org.scalatra.ScalatraServlet
import org.scalatra.metrics.{MetricsSupport, HealthChecksSupport}

trait Servlet extends ScalatraServlet with ScalateSupport {
  notFound {
    // remove content type in case it was set through an action
    contentType = null
    // Try to render a ScalateTemplate if no route matched
    findTemplate(requestPath) map { path =>
      contentType = "text/html"
      layoutTemplate(path)
    } orElse serveStaticResource() getOrElse resourceNotFound()
  }
} 

//设置package包名称以及导入依赖的类
package io.foxtrot.mapeador.servlets

import io.foxtrot.mapeador.math.DistanceCalculator
import io.foxtrot.mapeador.math.clustering.DBSCAN
import io.foxtrot.mapeador.models.{TimestampedLocationsClusterFactory, Location, MapRange, TimestampedLocation}
import org.scalatra.scalate.ScalateSupport
import org.scalatra.{Params, ScalatraServlet}
import org.slf4j.LoggerFactory
import play.api.libs.json.{JsArray, JsNumber, Json}


class LocationsServlet(locations: Map[String, Seq[TimestampedLocation]]) extends ScalatraServlet with ScalateSupport {

  private val logger = LoggerFactory.getLogger(this.getClass)

  get("/") {
    contentType = "text/html"
    ssp("/index")
  }

  get("/locations") {
    contentType = "application/json"
    val mapRange = getMapRange(params).getOrElse(MapRange.world)
    Json.toJson(locations.par.map {
      case (key: String, locs: Seq[TimestampedLocation]) =>
        val rangeLocations = locs.filter(l => isInRange(l, mapRange))
        val clustered = if (rangeLocations.size > 1000) {
          DBSCAN(getClusteringMeters(mapRange), 1, includeOutliers = true, new TimestampedLocationsClusterFactory).cluster(rangeLocations).map(_.getCentroid)
        } else {
          rangeLocations
        }
        key -> JsArray(clustered.map {
          case l: TimestampedLocation =>
            JsArray(Seq(JsNumber(l.location.latitude), JsNumber(l.location.longitude)))
        }.toList)
    }.seq)
  }

  private def getMapRange(params: Params): Option[MapRange] = {
    for {
      northeast <- params.get("northeast")
      southwest <- params.get("southwest")
      neLatitude <- northeast.split(",").headOption
      neLongitude <- northeast.split(",").lastOption
      swLatitude <- southwest.split(",").headOption
      swLongitude <- southwest.split(",").lastOption
    } yield MapRange(Location(neLatitude.toDouble, neLongitude.toDouble), Location(swLatitude.toDouble, swLongitude.toDouble))
  }


  private def isInRange(timestampedLocation: TimestampedLocation, mapRange: MapRange): Boolean = {
    timestampedLocation.location.latitude < mapRange.northeast.latitude &&
    timestampedLocation.location.latitude > mapRange.southwest.latitude &&
    timestampedLocation.location.longitude < mapRange.northeast.longitude &&
    timestampedLocation.location.longitude > mapRange.southwest.longitude
  }

  private def getClusteringMeters(mapRange: MapRange): Double = {
    Math.min(DistanceCalculator.vincentyDistance(mapRange.northeast, mapRange.southwest) / 300.0, 50000)
  }
} 

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

import org.scalatra.ScalatraServlet
import org.slf4j.LoggerFactory

class HelloWorldController extends ScalatraServlet {
  val logger = LoggerFactory.getLogger(getClass)

  get("/") {
    "Hello world"
  }

  get("/:name") {
    val name = params.getOrElse("name", "anonymous")
    "Hello " + name
  }

  post("/send") {
    val name = params.getOrElse("name", "noone")

    logger.info("Mi nombre es " + name)
  }
}