scala web scalatra（一）

$ java -version
java version "1.7.0_10"
OpenJDK Runtime Environment (IcedTea6 1.11.1) build 1.7.0_10-b18)
Java HotSpot(TM) 64-Bit Server VM (build 23.6-b094, mixed mode)

$ javac -version
javac 1.7.0_10

$ g8 scalatra/scalatra-sbt
organization [com.example]:
name [My Scalatra Web App]:
version [0.1.0-SNAPSHOT]:
servlet_name [MyScalatraServlet]:
package [com.example.app]:
scala_version [2.11.7]:
sbt_version [0.13.9]:
scalatra_version [2.4.0]:

Template applied in ./my-scalatra-web-app

sbt
> jetty:start

sbt
> ~;jetty:stop;jetty:start

project
|_build.properties      <= specifies what version of sbt to use
|_build.scala           <= dependencies and project config are set in here
|_plugins.sbt           <= sbt plugins can be added here

src
|_ main
|  |_ scala
|  |  |   |_ScalatraBootstrap.scala     <= mount servlets in here
|  |  |_org
|  |      |_ yourdomain
|  |         |_ projectname
|  |            |_ MyScalatraServlet.scala
|  |_ webapp
|     |_ WEB-INF
|        |_ views
|        |  |_ hello-scalate.scaml
|        |_ layouts
|        |  |_ default.scaml
|        |_ web.xml
|_ test
   |_ scala
      |_ org
         |_ yourdomain
            |_ projectname
               |_ MyScalatraServletSpec.scala

src
|_ main
   |_ scala
   |  |_ Web.scala
   |_ webapp
      |_ WEB-INF
      |  |_ secret.txt
      |  |_ views
      |  |  |_ default.jade
      |  |
      |  |_ layouts
      |  |  |_ default.jade
      |  |
      |  |_ web.xml
      |- stylesheets
      |  |_ default.css
      |- images
         |_ foo.jpg

class YourServlet extends ScalatraServlet with ScalateSupport {
  // your class here
}

class YourFilter extends ScalatraFilter with ScalateSupport {
  // your class here
}

import sbt._
import Keys._
import org.scalatra.sbt._
import org.scalatra.sbt.PluginKeys._
import com.mojolly.scalate.ScalatePlugin._
import ScalateKeys._

object MyExampleBuild extends Build {
  val Organization = "com.example"
  val Name = "An Example Application"
  val Version = "0.1.0-SNAPSHOT"
  val ScalaVersion = "2.10.1"
  val ScalatraVersion = "2.4.1"

  lazy val project = Project (
    "scalatra-buildfile-example",
    file("."),
    settings = Defaults.defaultSettings ++ ScalatraPlugin.scalatraWithJRebel ++ scalateSettings ++ Seq(
      organization := Organization,
      name := Name,
      version := Version,
      scalaVersion := ScalaVersion,
      resolvers += "Sonatype OSS Snapshots" at "http://oss.sonatype.org/content/repositories/snapshots/",
      resolvers += "Akka Repo" at "http://repo.akka.io/repository",
      libraryDependencies ++= Seq(
        "org.scalatra" %% "scalatra" % ScalatraVersion,
        "org.scalatra" %% "scalatra-scalate" % ScalatraVersion,
        "org.scalatra" %% "scalatra-specs2" % ScalatraVersion % "test",
        "ch.qos.logback" % "logback-classic" % "1.1.3" % "runtime",
        "org.eclipse.jetty" % "jetty-webapp" % "9.2.10.v20150310" % "container",
        "org.eclipse.jetty.orbit" % "javax.servlet" % "3.1.0" % "container;provided;test" artifacts (Artifact("javax.servlet", "jar", "jar"))
      ),
      scalateTemplateConfig in Compile <<= (sourceDirectory in Compile){ base =>
        Seq(
          TemplateConfig(
            base / "webapp" / "WEB-INF" / "templates",
            Seq.empty,  /* default imports should be added here */
            Seq.empty,  /* add extra bindings here */
            Some("templates")
          )
        )
      }
    )
  )
}

//......
def debugJetty = Command.command("debugJetty") { state =>
  import com.earldouglas.xwp.ContainerPlugin.start
  val javaOpts =
    Seq(
      "-Xdebug",
      "-Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n"
    )
  val state2 =
    Project.extract(state).append(
      Seq(javaOptions in Jetty ++= javaOpts),
      state
    )
  Project.extract(state2).runTask(start in Jetty, state2)
  state2
}

commands += debugJetty

class Articles extends ScalatraServlet {
  get("/articles/:id") {  //  <= this is a route matcher
    // this is an action
    // this action would show the article which has the specified :id
  }

  post("/articles") {
    // submit/create an article
  }

  put("/articles/:id") {
    // update the article which has the specified :id
  }

  delete("/articles/:id") {
    // delete the article with the specified :id
  }
}

get("/hello/:name") {
  // Matches "GET /hello/foo" and "GET /hello/bar"
  // params("name") is "foo" or "bar"
  <p>Hello, {params("name")}</p>
}

	get("/say/*/to/*") {
		// Matches "GET /say/hello/to/world"
		val split = multiParams("splat")
		<h1>
			say {split(0)} to {split(1)}
		</h1>
	}

	get("/download/*.*") {
		// Matches "GET /download/path/to/file.xml"
		multiParams("splat") // == Seq("path/to/file", "xml")
		val splat = multiParams("splat")
		<h1>
			you download is {splat(0)}.{splat(1)}
		</h1>
	}

	get("""^\/f(.*)/b(.*)""".r) {
		// Matches "GET /foo/bar"
		multiParams("captures") // == Seq("oo", "ar")
	}

get("/foo", request.getRemoteHost == "127.0.0.1") {
	// Overrides "GET /foo" for local users
	<h1>from host 127.0.0.1</h1>
}

get("/foo", request.getRemoteHost == "127.0.0.1", request.getRemoteUser == "admin") {
  // Only matches if you're the admin, and you're localhost
}

class MyFilter extends ScalatraFilter with MethodOverride {

  // POST to "/foo/bar" with params "id=2" and "_method=put" will hit this route:
  put("/foo/bar/:id") {
    // update your resource here
  }
}

get("/foo/abc", request.getRemoteHost == "127.0.0.1") {
	// Overrides "GET /foo" for local users
	<h1>from host 127.0.0.1</h1>
}

get("/foo/*", request.getRemoteHost == "127.0.0.1") {
	// Overrides "GET /foo" for local users
	<h1>from host 127.0.0.1, 下边的</h1>
}

get("/articles-by/:author/:page") {
  val author:String = params.getOrElse("author", halt(400))
  val page:Int = params.getOrElse("page", "1").toInt
  // now do stuff with your params
}
//经测试不能实现

before() {
	println("请求处理前执行")
}

after(){
	println("请求处理之后执行")
}

before("/admin/*") {
  basicAuth
}

after("/admin/*") {
  user.logout
}

get("/"){
	redirect("/someplace/else")
}

halt(403)
halt(403, <h1>Go away!</h1>)

halt(status = 403,
     reason = "Forbidden",
     headers = Map("X-Your-Mother-Was-A" -> "hamster",
                   "X-And-Your-Father-Smelt-Of" -> "Elderberries"),
     body = <h1>Go away or I shall taunt you a second time!</h1>)

get("/guess/*") {
  <h1>"You missed!"{params("who")}</h1>
}

get("/guess/:who") {
  params("who") match {
    case "Frank" => "You got me!"
    case _ => pass()
  }
}

notFound {
  <h1>Not found. Bummer.</h1>
}

//访问http://127.0.0.1:8080/guess
//http://127.0.0.1:8080/guess/
//都可以
get("foo/bar/?") {
  //...
}

get("/file/:id") {
	params.get("id") match {
		case Some(file) => Ok(file)
		case None       => NotFound("Sorry, the file could not be found")
	}

get("/relative"){
	// 访问 http://127.0.0.1:8080/redirect/relative
	// 重定向到 http://127.0.0.1:8080/page-relative
	redirect(url("page-relative"))
}

get("/context") {
	// 访问 http://127.0.0.1:8080/redirect/context
	// 重定向到 http://127.0.0.1:8080/redirect/en-to-es?one=uno&two=dos
	redirect( url("/en-to-es", Map("one" -> "uno", "two" -> "dos")) )
}

class MyApp extends ScalatraServlet with UrlGeneratorSupport {
  // When you create a route, you can save it as a variable
  val viewUser = get("/user/:id") {
     // your user action would go here
   }

  post("/user/new") {
    // url method provided by UrlGeneratorSupport.  Pass it the route
    // and the params.
    redirect(url(viewUser, "id" -> newUser.id))
  }
}

class GzipServlet extends ScalatratestStack with ContentEncodingSupport {
	get("/") {
		<html>
			<body>
				<h1>This is
					<a href="http://scalatra.org/2.2/guides/http/gzip.html">
						http/gzip
					</a>!
				</h1>
			</body>
		</html>
	}
}

val ScalatraVersion = "2.5.0"

libraryDependencies += "org.scalatra" %% "scalatra-auth" % ScalatraVersion

package com.constructiveproof.example.models
import org.slf4j.LoggerFactory

case class User(id:String)               {
  val logger = LoggerFactory.getLogger(getClass)
  def forgetMe = {
    logger.info("User: this is where you'd invalidate the saved token in you User model")
  }
}

class ProtectedController extends ScentryauthdemoStack with AuthenticationSupport {
  /**
   * 执行验证身份
   */
  before() {
    requireLogin()
  }

  get("/") {
    println(userOption)
    <h1>"这是一个受保护的控制器动作。如果你能看到它，你就登录了。欢迎你"</h1>
  }
}

override def authenticate()(implicit request: HttpServletRequest, response: HttpServletResponse): Option[User] = {
		//获取请求参数app.params.getOrElse("username", "")
		//查询验证身份逻辑
}

override def name: String = "UserLogin"

override def isValid(implicit request: HttpServletRequest) = {
}

class FlashController extends ScalatratestStack with FlashMapSupport{
	get("/toOther"){
		flash("notice") = "dsf"
		redirect(url("/other"))
	}

	get("/other"){
		<h1>toOther的参数是：{flash.get("notice")}</h1>
	}
}

"com.typesafe.akka" %% "akka-actor" % "2.3.4",
"net.databinder.dispatch" %% "dispatch-core" % "0.11.3",

import _root_.akka.actor.{Props, ActorSystem}
import com.example.app._
import org.scalatra._
import javax.servlet.ServletContext


class ScalatraBootstrap extends LifeCycle {

  val system = ActorSystem()
  val myActor = system.actorOf(Props[MyActor])

  override def init(context: ServletContext) {
    context.mount(new PageRetriever(system), "/*")
    context.mount(new MyActorApp(system, myActor), "/actors/*")
  }

  override def destroy(context:ServletContext) {
    system.shutdown()
  }
}

class AkkaController(system:ActorSystem, myActor:ActorRef) extends ScalatratestStack  with FutureSupport {
	implicit val timeout = new Timeout(2 seconds)
	protected implicit def executor: ExecutionContext = system.dispatcher

	// You'll see the output from this in the browser.
	get("/ask") {
		myActor ? "Do stuff and give me an answer"
	}

	// You'll see the output from this in your terminal.
	get("/tell") {
		myActor ! "Hey, you know what?"
		Accepted()
	}

}

"org.scalatra" %% "
" % "2.5.0",
"org.json4s" %% "json4s-jackson" % "3.5.0", //不必须，样例需要

import java.util.Date

import org.json4s.JsonDSL._
import org.json4s._
import org.scalatra._
import org.scalatra.atmosphere._
import org.scalatra.json.{JValueResult, JacksonJsonSupport}
import org.scalatra.scalate.ScalateSupport

import scala.concurrent.ExecutionContext.Implicits.global

class ChatController extends ScalatraServlet
  with ScalateSupport with JValueResult
  with JacksonJsonSupport with SessionSupport
  with AtmosphereSupport {

  atmosphere("/the-chat") {
    new AtmosphereClient {
      def receive = {
          case Connected => //用户连接上服务器执行
          case Disconnected(disconnector, Some(error)) => //断开连接执行
          case Error(Some(error)) => //出现错误
          case TextMessage(text) => send("ECHO: " + text) //文本消息
          case JsonMessage(json) => broadcast(json) //json类型消息
        }
      }
    }
  }

var socket = atmosphere; //获取socket
var author = null;
var transport = 'websocket';

//配置一个websocket请求，实现一系列方法
var request = {
		url: "/chat",
		contentType: "application/json",
		logLevel: 'debug',
		transport: transport,
		fallbackTransport: 'long-polling'
};

//打开连接执行的函数，初始化之后自动执行
request.onOpen = function(response) {
};

//重新连接执行的函数
request.onReconnect = function(rq, rs) {
};

//接受到一个服务端发送的消息
request.onMessage = function(rs) {
		var message = rs.responseBody;
};

request.onClose = function(rs) {
};

request.onError = function(rs) {
};

subSocket = socket.subscribe(request);

//发送消息
//subSocket.push(str);

get("/inline"){
	contentType="text/html"

	<html>
		<head><title>Test</title></head>
		<body>contentType is {contentType}</body>
	</html>
}

class YourServlet extends ScalatraServlet with ScalateSupport {
  get("/") {
    // render your views in the action (see below)
  }
}

get("/") {
  contentType="text/html"
  ssp("/index") //默认查找模板目录
}

get("/") {
  contentType="text/html"
  layoutTemplate("/WEB-INF/templates/views/index.ssp")
}

get("/") {
  contentType="text/html"
  ssp("/index", "foo" -> "uno", "bar" -> "dos")
}

<html>
    <head>
        <title>ssptest</title>
    </head>
    <body>
        <%@ val foo: String %>
        <%@ val bar: String %>
        <p>Foo is <%= foo %></p>
        <p>Bar is <%= bar %></p>
    </body>
</html>

before(){
  if(isAuthenticated) {
    templateAttributes("user") = Some(user)
  }
}

<%@ val body: String %>
<html>
	<head>..</head>
	<body>
		<%= unescape(body) %>
	</body>
</html>

get("/") {
  contentType="text/html"

  jade("/index", "layout" -> "WEB-INF/layouts/app.jade", "foo" -> "uno", "bar" -> "dos")
}

get("/") {
  // This template will render without a layout.
  jade("/index", "layout" -> "", "foo" -> "uno", "bar" -> "dos")
}

notFound {
	//查找路径是否存在这个路径的模板，不存在就查找静态文件，找不到就返回默认NotFind
  findTemplate(requestPath) map { path =>
    contentType = "text/html"
    layoutTemplate(path)
  } orElse serveStaticResource() getOrElse resourceNotFound()
}

notFound {

	contentType = null
	serveStaticResource() getOrElse {
		contentType = "text/html;charset=utf-8"
		ssp("notfound","layout"->"","path"->requestPath)
	}
}

override def isScalateErrorPageEnabled = false

<p>
		<%= List("hi", "there", "reader!").mkString(" ") %>
		${ "yo "+(3+4) }
</p>

<p>
  hi there reader!
  yo 7
</p>

<%
  var foo = "hello"
  foo += " there"
  foo += " you!"
%>
<p>${foo}</p>

<p>hello there you!</p>

<%@ val foo: MyType %>
<%@ val bar: String = "this is the default value" %>

<%@ import val model: Person %>
<p>Hello ${name}, what is the weather like in ${city}</p>

<%@ val model: Person %>
<% import model._ %>
<p>Hello ${name}, what is the weather like in ${city}</p>

<%@ val model: Person %>
<p>Hello ${model.name}, what is the weather like in ${model.city}</p>

<ul>
#for (i <- 1 to 5)
  <li>${i}</li>
#end
</ul>

//就像在Scala语言中，你可以使用序列推导执行多个嵌套循环。

<ul>
#for (x <- 1 to 2; y <- 1 to 2)
  <li>(${x}, ${y})</li>
#end
</ul>

<ul>
  <li>1</li>
  <li>2</li>
  <li>3</li>
  <li>4</li>
  <li>5</li>
</ul>

<ul>
  <li>(1, 1)</li>
  <li>(1, 2)</li>
  <li>(1, 1)</li>
  <li>(2, 1)</li>
</ul>

<p>
#if (customer.type == "Gold")
  Special stuff...
#end
</p>

<p>
#if (n == "James")
  Hey James
#elseif (n == "Hiram")
  Yo Hiram
#else
  Dunno
#end
</p>

<p>
  Special stuff...
</p>
<p>
  Hey James
</p>

#set (head)
  ... some page specific JavaScript includes here...
#end
...rest of the page here...

<%@ var body: String %>
<%@ var title: String = "Some Default Title" %>
<%@ var head: String = "" %>
<html>
<head>
  <title>${title}</title>

  <%-- page specific head goes here --%>
  ${unescape(head)}
</head>
<body>
  <p>layout header goes here...</p>

  ${unescape(body)}

  <p>layout footer goes here...</p>
</body>
</html>

<p>
#match (customer.type)
#case("Gold")
  Great stuff
#case("Silver")
  Good stuff
#otherwise
  No stuff
#end
</p>


<p>
#match (person)
#case(m: Manager)
  ${m.name} manages ${m.manages.size} people
#case(p: Person)
  ${p.name} is not a manager
#otherwise
  Not a person
#end
</p>

<%@ val body: String = "Bar" %>
<table>
 <tr>
   <th>Some Header</th>
 </tr>
 <tr>
   <td><%= body %></td>
 </tr>
</table>

<% render("foo.ssp", Map("body" -> "Foo")) %>
等价于
<% layout("foo.ssp") {%>
Foo
<%}%>
等价于
#do( layout("foo.ssp") )
Foo
#end

#import(java.util.Date)

<p>The time is now ${new Date}</p>

<% render("foo.ssp") %>
<% render("/customers/contact.ssp") %>
<% render("/customers/contact.ssp", Map("customer" -> c, "title" -> "Customer")) %>
<% render("/customers/contact.ssp", Map('customer -> c, 'title -> "Customer")) %>

<%@ var body: String %>
<%@ var title: String = "Some Default Title" %>
<html>
<head>
  <title>${title}</title>
</head>
<body>
  <p>layout header goes here...</p>

  ${unescape(body)}

  <p>layout footer goes here...</p>
</body>
</html>

<% attributes("layout") = "/WEB-INF/layouts/custom.ssp" %>
<% attributes("title") = "This is the custom title" %>
<h3>Custom page</h3>
<p>This is some text</p>

<% attributes("layout") = "" %>
<html>
<body>
  <h1>No Layout</h1>
  <p>This page does not use the layout</p>
</body>
</html>

<%@ val body: String = "Bar" %>
<table>
 <tr>
   <th>Some Header</th>
 </tr>
 <tr>
   <td><%= body %></td>
 </tr>
</table>

<% render("foo.ssp", Map("body" -> "Foo")) %>
等价于
<% layout("foo.ssp") {%>
Foo
<%}%>
等价于
#do( layout("foo.ssp") )
Foo
#end

<% val foo = capture { %>
  hello there ${user.name} how are you?
<%}%>
...
${foo}
...
${foo}

object Cheese {
  def foo(productId: Int) =
    <a href={"/products/" + productId} title="Product link">My Product</a>
}

<% import Cheese._  %>
${foo(123)}

<% val people = List(Person("James", "Strachan"), Person("Hiram", "Chirino")) %>
<% collection(people, "index", "<hr/>")  %>

<% val user = new User("foo") %>
<p>Something...</p>
<% view(user) %>
<p>... more stuff </p>

<% val user = new User("foo") %>
${view(user, "edit")}