如何避免在play2中到处传递参数?

时间:2012-03-09 05:14:46

标签: playframework-2.0

在play1中,我通常会在操作中获取所有数据,直接在视图中使用它们。由于我们不需要在视图中显式声明参数,因此非常容易。

但是在play2中,我发现我们必须在视图的头部声明所有参数(包括request),在操作中获取所有数据并将它们传递给视图将非常无聊。

例如,如果我需要在首页显示从数据库加载的菜单,我必须在main.scala.html中定义它:

@(title: String, menus: Seq[Menu])(content: Html)    

<html><head><title>@title</title></head>
<body>
    <div>
    @for(menu<-menus) {
       <a href="#">@menu.name</a>
    }
    </div>
    @content
</body></html>

然后我必须在每个子页面中声明它:

@(menus: Seq[Menu])

@main("SubPage", menus) {
   ...
}

然后我必须得到菜单并将其传递给每个动作查看:

def index = Action {
   val menus = Menu.findAll()
   Ok(views.html.index(menus))
}

def index2 = Action {
   val menus = Menu.findAll()
   Ok(views.html.index2(menus))
}

def index3 = Action {
   val menus = Menu.findAll()
   Ok(views.html.index(menus3))
}

现在它只是main.scala.html中的一个参数,如果有很多参数呢?

最后,我决定直接查看所有Menu.findAll()

@(title: String)(content: Html)    

<html><head><title>@title</title></head>
<body>
    <div>
    @for(menu<-Menu.findAll()) {
       <a href="#">@menu.name</a>
    }
    </div>
    @content
</body></html>

我不知道它是好还是推荐,有没有更好的解决方案?

5 个答案:

答案 0 :(得分:228)

在我看来,模板静态输入的事实实际上是一个的事情:保证调用模板在编译时不会失败。

然而,它确实在呼叫站点上添加了一些样板。但是你可以减少它(不会失去静态类型优势)。

在Scala中,我看到了两种实现它的方法:通过动作组合或使用隐式参数。在Java中,我建议使用Http.Context.args映射来存储有用的值,并从模板中检索它们,而不必显式传递为模板参数。

使用隐式参数

menus参数放在main.scala.html模板参数的末尾,并将其标记为“隐式”:

@(title: String)(content: Html)(implicit menus: Seq[Menu])    

<html>
  <head><title>@title</title></head>
  <body>
    <div>
      @for(menu<-menus) {
        <a href="#">@menu.name</a>
      }
    </div>
    @content
  </body>
</html>

现在,如果您有调用此主模板的模板,则可以通过Scala编译器将menus参数隐式传递给main模板,如果它在这些模板中声明为隐式参数以及:

@()(implicit menus: Seq[Menu])

@main("SubPage") {
  ...
}

但是如果你想从你的控制器中隐式传递它,你需要将它作为一个隐式值提供,在你调用模板的范围内可用。例如,您可以在控制器中声明以下方法:

implicit val menu: Seq[Menu] = Menu.findAll

然后在您的行动中,您将能够写下以下内容:

def index = Action {
  Ok(views.html.index())
}

def index2 = Action {
  Ok(views.html.index2())
}

您可以在this blog postthis code sample中找到有关此方法的更多信息。

更新:一篇展示此模式的精彩博文也已撰写here

使用动作合成

实际上,将RequestHeader值传递给模板通常很有用(参见例如this sample)。这不会为控制器代码添加太多样板,因为您可以轻松编写接收隐式请求值的操作:

def index = Action { implicit request =>
  Ok(views.html.index()) // The `request` value is implicitly passed by the compiler
}

因此,由于模板通常至少会收到此隐式参数,因此您可以将其替换为包含更多值的更丰富的值。你的菜单。您可以使用Play 2的actions composition机制来完成此操作。

要做到这一点,你必须定义你的Context类,包装一个基础请求:

case class Context(menus: Seq[Menu], request: Request[AnyContent])
        extends WrappedRequest(request)

然后您可以定义以下ActionWithMenu方法:

def ActionWithMenu(f: Context => Result) = {
  Action { request =>
    f(Context(Menu.findAll, request))
  }
}

可以这样使用:

def index = ActionWithMenu { implicit context =>
  Ok(views.html.index())
}

您可以将上下文作为模板中的隐式参数。例如。 main.scala.html

@(title: String)(content: Html)(implicit context: Context)

<html><head><title>@title</title></head>
  <body>
    <div>
      @for(menu <- context.menus) {
        <a href="#">@menu.name</a>
      }
    </div>
    @content
  </body>
</html>

使用动作组合可以将模板所需的所有隐含值聚合为单个值,但另一方面,您可能会失去一些灵活性......

使用Http.Context(Java)

由于Java没有Scala的implicits机制或类似机制,如果您想避免显式传递模板参数,可能的方法是将它们存储在Http.Context对象中,该对象仅在请求期间存在。此对象包含args类型Map<String, Object>的值。

因此,您可以从编写拦截器开始,如the documentation

中所述
public class Menus extends Action.Simple {

    public Result call(Http.Context ctx) throws Throwable {
        ctx.args.put("menus", Menu.find.all());
        return delegate.call(ctx);
    }

    public static List<Menu> current() {
        return (List<Menu>)Http.Context.current().args.get("menus");
    }
}

静态方法只是从当前上下文中检索菜单的简写。 然后注释您的控制器与Menus动作拦截器混合:

@With(Menus.class)
public class Application extends Controller {
    // …
}

最后,从模板中检索menus值,如下所示:

@(title: String)(content: Html)
<html>
  <head><title>@title</title></head>
  <body>
    <div>
      @for(menu <- Menus.current()) {
        <a href="#">@menu.name</a>
      }
    </div>
    @content
  </body>
</html>

答案 1 :(得分:19)

我这样做的方法是为我的导航/菜单创建一个新的控制器并从视图中调用它

因此,您可以定义NavController

object NavController extends Controller {

  private val navList = "Home" :: "About" :: "Contact" :: Nil

  def nav = views.html.nav(navList)

}

<强> nav.scala.html

@(navLinks: Seq[String])

@for(nav <- navLinks) {
  <a href="#">@nav</a>
}

然后在我的主视图中,我可以调用NavController

@(title: String)(content: Html)
<!DOCTYPE html>
<html>
  <head>
    <title>@title</title>
  </head>
  <body>
     @NavController.nav
     @content
  </body>
</html>

答案 2 :(得分:14)

我支持stian的回答。这是获得结果的快速方法。

我刚从Java + Play1.0迁移到Java + Play2.0,模板是迄今为止最难的部分,我发现实现基本模板(标题,头等等)的最佳方法是使用Http.Context。

使用标签可以实现非常好的语法。

views
  |
  \--- tags
         |
         \------context
                  |
                  \-----get.scala.html
                  \-----set.scala.html

其中get.scala.html是:

@(key:String)
@{play.mvc.Http.Context.current().args.get(key)}

和set.scala.html是:

@(key:String,value:AnyRef)
@{play.mvc.Http.Context.current().args.put(key,value)}

表示您可以在任何模板中编写以下内容

@import tags._
@context.set("myKey","myValue")
@context.get("myKey")

因此它非常易读且美观。

这是我选择的方式。 stian - 好建议。证明向下滚动以查看所有答案非常重要。 :)

传递HTML变量

我还没想出如何传递Html变量。

@(标题:字符串,内容:HTML)

然而,我知道如何将它们作为块传递。

@(标题:字符串)(含量:HTML)

所以你可能想用

替换set.scala.html
@(key:String)(value:AnyRef)
@{play.mvc.Http.Context.current().args.put(key,value)}

这样你可以像这样传递Html块

@context.set("head"){ 
     <meta description="something here"/> 
     @callSomeFunction(withParameter)
}

编辑:我的“设置”实施的副作用

一个常见的用例 - 它在Play中的模板继承。

你有一个base_template.html然后你有扩展base_template.html的page_template.html。

base_template.html可能看起来像

<html> 
    <head>
        <title> @context.get("title")</title>
    </head>
    <body>
       @context.get("body")
    </body>
</html>

页面模板可能看起来像

@context.set("body){
    some page common context here.. 
    @context.get("body")
}
@base_template()

然后你有一个看起来像

的页面(让我们假设为login_page.html)
@context.set("title"){login}
@context.set("body"){
    login stuff..
}

@page_template()

这里要注意的重要一点是你设置了两次“身体”。进入“login_page.html”然后进入“page_template.html”。

似乎这会触发副作用,只要你像我上面建议的那样实现set.scala.html。

@{play.mvc.Http.Context.current().put(key,value)}

因为页面会显示“登录内容...”两次,因为put会返回第二次放入相同键时弹出的值。 (请参阅java docs中的签名)。

scala提供了一种更好的方法来修改地图

@{play.mvc.Http.Context.current().args(key)=value}

不会引起这种副作用。

答案 3 :(得分:13)

如果您正在使用Java并且只需要最简单的方法而不必编写拦截器并使用@With注释,您也可以直接从模板访问HTTP上下文。

E.g。如果需要模板中的变量,可以使用以下命令将其添加到HTTP上下文中:

Http.Context.current().args.put("menus", menus)

然后,您可以使用以下命令从模板访问它:

@Http.Context.current().args.get("menus").asInstanceOf[List<Menu>]

显然,如果你使用Http.Context.current()。args.put(“”,“”)丢弃你的方法,你最好使用一个拦截器,但对于简单的情况,它可以做到这一点。

答案 4 :(得分:6)

从Stian的回答中,我尝试了另一种方法。这对我有用。

IN JAVA CODE

import play.mvc.Http.Context;
Context.current().args.put("isRegisterDone", isRegisterDone);

在HTML模板头中

@import Http.Context
@isOk = @{ Option(Context.current().args.get("isOk")).getOrElse(false).asInstanceOf[Boolean] } 

AND USE LIKE

@if(isOk) {
   <div>OK</div>
}