125

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

但是在play2中,我发现我们必须在viewrequest的头部声明所有参数(包括),在action中获取所有数据并将它们传递到view中会很无聊。

例如,如果我需要在首页显示从数据库加载的菜单,我必须在以下位置定义它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>

不知道好用还是推荐,有没有更好的解决方法?

4

5 回答 5

229

在我看来,模板是静态类型的这一事实实际上是一件好事:你可以保证调用你的模板在编译时不会失败。

但是,它确实在调用站点上添加了一些样板。但是您可以减少它(不会失去静态类型的优势)。

在 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())
}

您可以在此博客文章此代码示例中找到有关此方法的更多信息。

更新:这里也写了一篇很好的博客文章来展示这种模式。

使用动作组合

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

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

因此,由于模板通常至少接收此隐式参数,因此您可以将其替换为包含例如您的菜单的更丰富的值。您可以通过使用Play 2的动作组合机制来做到这一点。

为此,您必须定义您的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>

使用动作组合可以让您将模板所需的所有隐式值聚合为一个值,但另一方面您可能会失去一些灵活性……</p>

使用 Http.Context (Java)

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

因此,您可以从编写拦截器开始,如文档中所述

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>
于 2012-03-09T09:58:31.243 回答
19

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

所以你可以定义你的NavController

object NavController extends Controller {

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

  def nav = views.html.nav(navList)

}

导航.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>
于 2012-04-04T16:42:25.340 回答
14

我支持斯蒂安的回答。这是获得结果的一种非常快速的方法。

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

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

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()

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

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

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

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

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

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

这不会导致这种副作用。

于 2012-12-17T07:02:16.240 回答
13

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

例如,如果您需要模板中可用的变量,您可以将其添加到 HTTP 上下文中:

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

然后,您可以从模板访问它:

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

显然,如果你用 Http.Context.current().args.put("","") 乱扔你的方法,你最好使用拦截器,但对于简单的情况,它可能会奏效。

于 2012-12-12T10:14:04.147 回答
6

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

在 JAVA 代码中

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] } 

并使用

@if(isOk) {
   <div>OK</div>
}
于 2013-03-24T00:42:04.480 回答