我最近搬到了Play framework 2.0,关于控制器实际上如何工作,我有一些问题.
在游戏文档中提到:
由于Play 2.0的工作方式,动作代码必须尽可能快(即非阻塞).
但是在另一部分文档中:
/actions {
router = round-robin
nr-of-instances = 24
}
和
actions-dispatcher = {
fork-join-executor {
parallelism-factor = 1.0
parallelism-max = 24
}
}
似乎有24个演员分配给控制器处理.我猜每个请求都会在请求的生命周期中分配其中一个actor.是对的吗？
什么是parallelism-factor意味着什么,有什么fork-join-executor不同thread-pool？
另外 - 文档应该说Async应该用于长时间的计算.有什么资格作为长期计算？100ms的？300ms的？5秒？10秒？我的猜测会超过一秒,但如何确定呢？
这种质疑的原因是测试异步控制器调用比常规调用更难.您必须启动虚假应用程序并执行完整的请求,而不是仅调用方法并检查其返回值.
即使情况并非如此,我怀疑将所有内容包装在内Async 并且Akka.future是方法.
我已经在#playframework IRC频道中提出了这个要求,但没有答案,似乎我不是唯一一个不确定应该怎么做的人.
只是重申:
parallelism-factor意思,为什么是1？fork-join-executor什么不同thread-pool-executor？Async？提前致谢.
编辑:来自IRC的一些东西
来自IRC的一些东西.
<imeredith> arturaz: i cant be boethered …我正在使用sbt 0.10和Scala 2.9.1.
但是我不想要一个巨大的罐子.我只是希望依赖jar在target/scala-2.9.1.final/lib目录中结束.
之所以我不想要一个巨大的jar,那个项目使用了很多lib,而且通常只有应用程序.jar会发生变化.然而,由于这是多语言项目,并非所有团队成员都有scala或sbt,因此jars只是提交给git.拥有一个巨大的dar更新规则将膨胀回购规模.
我该如何复制这些依赖项？;)
我想将F有界多态转换为抽象类型成员.
trait FBoundedMovable[Self <: FBoundedMovable[Self]] {
def moveTo(pos: Vect2): Self
}
至
trait Movable { self =>
type Self <: (Movable { type Self = self.Self })
def moveTo(pos: Vect2): Self
}
到现在为止还挺好.
让我们定义一个实例:
case class Ship(pos: Vect2) extends Movable {
type Self = Ship
def moveTo(pos: Vect2) = copy(pos = pos)
}
并尝试使用它:
// [error] found : a.Self
// [error] required: A
def move[A <: Movable](a: A, to: Vect2): A = a.moveTo(to)
F有界版本工作正常.
def moveF[A <: FBoundedMovable[A]](a: A, to: …
scala abstract-type parametric-polymorphism f-bounded-polymorphism
我想定义一个任务,它调用compile和packageBin任务,然后完成它的工作.我怎么做？目前这只是第二部分,并跳过编译和packageBin任务.
lazy val dist = TaskKey[Unit](
"dist", "Creates a project distribution in dist/ folder."
)
def distTask = {
dist <<= dist.dependsOn(compile, packageBin)
dist <<= (update, crossTarget).map { case (updateReport, out) =>
updateReport.allFiles.foreach { srcPath =>
val destPath = out / "lib" / srcPath.getName
IO.copyFile(srcPath, destPath, preserveLastModified=true)
}
}
}
我有以下SBT/Play2多项目设置:
import sbt._
import Keys._
import PlayProject._
object ApplicationBuild extends Build {
val appName = "traveltime-api"
val appVersion = "1.0"
val appDependencies = Seq(
// Google geocoding library
"com.google.code.geocoder-java" % "geocoder-java" % "0.9",
// Emailer
"org.apache.commons" % "commons-email" % "1.2",
// CSV generator
"net.sf.opencsv" % "opencsv" % "2.0",
"org.scalatest" %% "scalatest" % "1.7.2" % "test",
"org.scalacheck" %% "scalacheck" % "1.10.0" % "test",
"org.mockito" % "mockito-core" % "1.9.0" % "test"
)
val lib = RootProject(file("../lib"))
val chiShape = RootProject(file("../chi-shape"))
lazy val …让我们说我们有一个特征,它有一些价值观和一些操作.
trait Foo {
type Self <: Foo
val x: Int
def withX(x: Int): Self
}
这是使用抽象类型实现的.我们在Self上有一个绑定类型,可以像这样实现它:
case class Foo1(x: Int) extends Foo {
type Self = Foo1
def withX(x: Int) = copy(x = x)
}
那样就好.我们可以使用该方法,我们看到该类型是静态保留的.
scala> Foo1(10).withX(5)
res0: Foo1 = Foo1(5)
当我们想要具有特征类型的操作而不是具体类型时,问题开始:
object Foo {
//Error:(13, 43) type mismatch;
//found : f.Self
//required: A
// def setFive[A <: Foo](f: A): A = f.withX(5)
}
好吧,我们做不到,因为编译器不知道Foo#Self将被分配给什么类型.但我们知道它是同一类型.
当然使用丑陋的方法工作正常:
object Foo {
// Ugly type signature
def setFiveValid[A <: Foo](f: A): …type Some = (WarpableStats with WarpableCompanion[A]) forSome { type A <: Warpable }
type Of[A <: Warpable] = WarpableStats with WarpableCompanion[A]
为什么[_]和某些人不一样？