Play框架教程

P l a y f r a m e w o r k框架 1
一、P l a y框架介绍 1
二、初学者入门 6
安装 Play Framework 6 接下来创建一个新的应用程序7来看看 Play 框架是怎么工作的 ? 9
增加一个新的页面10
结论11
三、P l a y F r a m e w o r k框架路由(R o u te)11
三、P l a y F r a m e w o r k框架的控制器(C o n tr o ll er)14
四、P l a y F r a m e w o r k框架的模板27
五、P l a y框架中的A j ax32
六、P l a y框架使用缓存33
七、P l a y!1.1框架中的S ca l a模块37
Controllers composition using traits 39
How to define and access Models 39 Main differences 39
Running queries against Scala Models from Scala classes 40
Running queries against Java Models from Scala classes 41 Unit Testing 42
八、使用P l a y发送邮件42
九、Play framework的问题47
十、P l a y F r a m e w o r k平台的性能比较49
十一、P l a y F r a m e w o r k平台所用到的j a r 包一览52 十二、P l a y F r a m e w o r d生成的w a r 包里有什么内容52
P l a y f r a m e w o r k框架
一、P l a y框架介绍
Play框架概述
Play框架是臃肿的企业级Java之外的另一个选择，它关注的是开发的效率和提供REST式的架构风格， Play是“敏捷软件开发”的绝佳伴侣。

Play是一个使用纯Java开发的框架，它可以让你继续使用你喜欢的开发环境或类库。

如果你已经是一个Java平台的开发者，那么你不需要切换到另一种语言，其他IDE或者其他类库，只是切换到了另一个更有效率的java环境。

修改bug，然后Play会自动载入Java平台在开发效率方面已经是声名狼藉了，可能的原因就是重复“编译-打包-部署”的循环。

这就是为什么我们重新考虑开发周期，让使用Play开发变得更有效率。

框架自动编译Java源代码，然后直接热加载到JVM中而不需要重启服务器，你可以编辑，
重新加载
然后直接看到修改后的结果，就像在LAMP或者Rails环境中一样。

而且更有趣的是你按自己的爱好，仅仅使用
一个简单的文本编辑器而避免使用全功能的当有错误发生时，
框架努力辨别，然后直接显示出你的错误。

甚至堆栈被分析优化使错误更容易的被解决，看模板执行时如何完美地指出错
误所在地的.
简单的无状态的MVC架构你一边有一个数据库另一边有一个浏览器，为什么你要在
此之间需要一个状态呢,以有状态和组件式为基础的Java web框架使之容易的自动
保存页面状态，但是这带来了很多其他问题，如果用户打开了第二个窗口时会发
生什么，如果用户单击了浏览器的后退按钮呢？ PHP，Ruby on Rails和Django等
许多web应用框架促进了“无共享”架构。

随着浏览器越来越强大，现在很容易使
用Ajax,或者离线存储去解决客户端的状态问题。

我们不需要再去hack HTTP模型，在web上重建一个虚假的状态。

另一方面，
“无共享”使渲染幀部页面，相似的页面，或者部分页面更新变的更容易。

HTTP
到代码映帄如果你已经使用了另外一种Java web框架，例如Servlet API或者
Struts框架，你已经使用了把HTTP协议和Java API抽象的联绻起来的奇怪的观念。

(好难翻译啊) 我们不是这么想的。

一个web应用框架应该给你完全的，直达的对
Http进行操作，这是Play和其他Java web框架的一个根本不同。

Http，Request, Response,REST架构，类型识别，URI都是Play框架主要的思想。

例如，绑定一个URI 参数到Java中踃用就像下面一样: GET /clients/{id}
Clients.show 如果Ajax，REST和在页面之间维护前进、后退操作是你每天开发
web项目时都会遇到的问题，那么请帝试一下play吧。

高效的模板引擎我们很喜欢JSP和JSTL表达式语。

但是为什么我们需要这么多的
配置文件去创
建一个标签库，为什么我们不能对象模型进行完全的接触呢？(有点别扭)
jSP有很多的限制也是令人溮丧的原因。

这就是为什么我们需要创建一个通用
的模板绻统，由JSP激发的灵感，但是溡有它的限制。

你和其他人可能会疲倦
的写类似这样的代码
<%@ taglib uri="/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="/jsp/jstl/functions" prefix="fn"
%>
<c:choose>
<c:when test="${emails.unread != null && fn:size(emails. unread)}">
You have ${fn:size(emails.unread)} unread email(s)!
</c:when>
<c:otherwise>
You have no unread emails!
</c:otherwise>
</c:choose>
我们认为你应该更倾向于这样写
bc. You have ${emails.unread ?: 'no'} ${emails.unread?.
pluralize('email')} !
Play模板使用的表达式语言是Groovy，它和Java语滕一致， Play使用这些模板绻统区渲染HTML请求，你可以使用它去产生其他格式的文档例如 email信息，JSON输出等。

.
JPA绑定 JPA是一个Java的ORM框架，如果你已经知道它的话，你会惊讶于它和Play 的集成。

不需要任何配置，Play会自动启动JPA实体管理器，并神奇的同步，在代码重新载入时。

而且如果你使用提供的 **play.db.jpa.Model** 超类时，它会帮助你把代码变的更漂亮。

来看一下。

bc. public void messages(int page) {
User connectedUser = User.find("byEmail", connected());
List<Message> messages = Message.find(
"user = ? and read = false order by date desc",
connectedUser
).from(page * 10).fetch(10);
render(connectedUser, messages);
}
测试驱动开发（如果你喜欢它的话）集成的测试可以让你更容易的去进行测试驱动开发，你可以写下所有类型的测试，从简单的集成测试到完整
的acceptance 测试，然后直接在浏览器中使用Selenium运行。

代码覆盖率也
会考虑到。

全栈的应用开发框架
Play框架的灵感来自我们自己的Java应用，它包含了创建现代 web应用所需的
一切。

它包含：
通过JDBC的关绻数据库支持
使用hibernate管理对象关绻映帄(使用了JPA API) 集成的缓存支持，容易使用的分布式缓存绻统(如果需要的话) 使用JSON和XML的简单web service(我们说的是’真正‘的web service，不是
SOAP)
支持使用OpenID进行分布式的身份认证
你的web 应用可以部署到任何支持的地方(应用服务器，GAE，云等)
Play模块化的结构使你可以把web 应用和其他结合在一起，感踢模块，你可以以一种非常简单的方式重用你的Java 代码，模板，静态资源(如JavaScript和CSS 文件等).
请帝试一下吧安装、启动你
的第一个应用
2、初学者入门
Play！是一个full-stack（全栈的）Java Web应用框架，包括一个简单的无状
态MVC模型，具有Hibernate的对象持续，一个基于Groovy的模板引擎，以及建
立一个现代Web应用所需的所有东西。

Play！的关键特性：
1、一个非常简单的开发周期。

此框架自动编译和重新装载源文件的任何改
变。

2、智能捆绑HTTP参数到Java方法参数。

3、基于Apache Mina的快速HTTP服务器。

4、一个基于Groovy的强大的模板引擎，具有多幂继承，定制用户标签的能力，等。

5、优秀的错误报告功能：当发生异常，此框架会直接显示出错代码，甚至是
模板代码。

6、集成很多常用的组件包括Hibernate、OpenID、Memcached 等一些热门框
架
在本文中，我们把利用一个简单的 Hello world 应用来了解 Play 框架的基本
开发。

安装Play Framework
安装前确认 Java 的版本必须是 5.0 或者更新的版本，下载 Play 框架：
/action/project/go?id=6101&p=download. 目前最新版是 1.0.3 ，下载完解压并设置以下环境变量：
在 Ubuntu 10.04, 我们可以通过以下命令进行设置
PLAY_HOME=/usr/share/apps/play/
PATH=$PATH:$PLAY_HOME
chmod+x PLAY_HOME/play
这些配置值根据你解压的具体路径而定。

设置完毕后，正常的情况下，输入 play 命令可得到下面的输出：
oschina@Linux-Desktop:~$play
~_ _
~_ __ | | __ _ _ _| |
~| '_\||/_'| || |_|
~| __/|_|\____|\__(_)
~|_| |__/
~
~play! 1.0.3,
~
~Usage:play cmd[app_path][--options]
~
~with,new Create a new application
~run Run the application in the current shell
~help Show play help
~
oschina@Linux-Desktop:~$
接下来创建一个新的应用程序
Play 的做滕很像Rails，要创建一个新应用请使用下面命令：
play new app_name
这个命令必须在 play 的目录下执行，例如创建一个名为 hello 的应用如下：oschina@Linux-Desktop:~/dev/play$play new hello
~_ _
~_ __ | | __ _ _ _| |
~| '_\||/_'| || |_|
~| __/|_|\____|\__(_)
~|_| |__/
~
~play! 1.0.3,
~
~The new application will be created in
/home/wichtounet/dev/play/hello
~What is the application name?H e ll o W o r l d
~
~OK,the application is created.
~Start it with:play run hello
~Have fun!
~
oschina@Linux-Desktop:~/dev/play$
在创建过程中，Play 会询问应用名称，这里我们输入了Hello world 作为项目名，进入刚创建的 hello 目录，你可以看到如下的几个子目录：
app : 存放应用本身，包括 java 文件和 html 文件
conf : 存放配置文件
lib : 包含一些java的jar包
public : 存放一些静态文件，例如图片、js和css文件
test : 存放测试文件 (JUnit or Selenium)
接下来我们就可以运行这个应用了，输入 play run hello ，运行结果如下所示：
oschina@Linux-Desktop:~/dev/play$play run hello
~_ _
~_ __ | | __ _ _ _| |
~| '_\||/_'| || |_|
~| __/|_|\____|\__(_)
~|_| |__/
~
~play! 1.0.3,
~
~Ctrl+C to stop
~
Listening for transport dt_socket at address:8000
17:49:56,395INFO~Starting/home/wichtounet/dev/play/hello
17:49:56,889WARN~You're running Play!in DEV mode
17:49:56,958INFO~Listening for HTTP on port9000(Waiting a
first request to start)...
17:50:01,670INFO~Application'Hello World' is now started!
应用启动成功了，打开浏览器访问地址：http://localhost:9000/. 你就可以看到一个运行页面如下：
Play Framework 示例页面
来看看Play 框架是怎么工作的?
打开 conf 目录下的 routes 文件，你可以看到这么一行：
GET / Application.index
该配置表示当请求 / 时，会踃用 Application 类的 index 方法，接下来我们
打开 app/controllers/Application.java ，就可以看到源码如下：
package controllers;
import play.mvc.*;
public class Application extends Controller{
public static void index(){
render();
}
}
这个代码中 index 方法输出了默认的模板，模板文件位于
app/views/Application/index.html ，与类名和方法名完全对应。

模板文件如
下所示：
#{extends'main.html'/}
#{set title:'Home'/}
#{welcome/}
该模板扩幕了 main.html 模板，并设置了页面标题为 Home，然后输出欢迎信息。

这些都是 Play 框架为我们提供的一些标签，我们可以稍加修改如下：
#{extends'main.html'/}
#{set title:'Hello World'/}
<h3>Hello the world!</h3>
刷新页面就可以看到浏览器上输出了 Hello the world ! 的信息。

接下来我
们再在控制器 Application 的 index 方法中增加一些我们自己的代码，如
下所示：
public static void index()
{ System.out.println("render()");
render();
}
再次刷新页面的时候，我们可以在控制台中看到如下输出信息：
17:50:01,670INFO~Application'Hello World' is now started! render()
render()
render()
render()
render()
增加一个新的页面
假设我们要新增一个页面 /bye ，我们首先要在 conf/routes 文件中增加如下一行：
GET/bye Application.bye
然后在 Application.java 中增加一个新的方法 bye，如下所示：
package controllers;
import play.mvc.*;
public class Application extends Controller{
public static void index(){
render();
}
public static void bye(){
render();
}
}
最后就是新增模板文件 bye.html ，存放于 app/views/Application 目录
下，模板内容如下：
#{extends'main.html'/}
#{set title:'Bye'/}
<h3>Bye bye!</h3>
用浏览器访问 http://localhost:9000/bye 可看到如下输出：
Bye 页面的输出
结论
入门结束，5分钟左右吧？轻松创建应用骨架，轻松增加自己的代码，太轻松了！思路似足Ruby on Rails 框架。

3、P l a y F r a m e w o r k框架路由(R ou t e)
路由路由组件负责把H TT P请求交给对应的a c t i on处理(一个控制器的静态公共方
法) 一个H TT P请求在M V C框架里被当做一个事件看待。

事件包含2个方面的信息
请求的路径(例如/c l i e n t s/1524,/p h o t o s/l i s t)，包含查询字符串(参数字符串)
H TT P方法(G E T，P O S T,P U T,D E L E T E)
关于R E S T 表述性状态转移(R E S T)是一种类似互联网的分布式超媒体软件架构
风格，R E S T的几个关键性地方设计准则：
应用功能分散在资源中每个资源使
用一个唯一的U R I来寻址
所有资源在客户端和资源之间使用一个统一的接口来转移状态
如果你使用过H TT P，这些接口定义了一些可用的H TT P方法。

这
些协议用于访问资源的状态：
*客户端-服务端
*无状态
*缓存
*分幂如果一个应用遵循了R E S T的主要设计准则，那么这个应用就是R E S T风
格的。

P l a y框架使构建R E S T风格的应用变得更容易：
*P l a y的路由解释U R I和H TT P方法，把一个请求匹配给一个J a v a踃用。

基于正则表达式的U R I模式匹配给你更过的灵活性。

*协议时无状态的，意味着你不能在2次成功的请求之间在服务器上保存任何状态。

*P l a y把H TT P当做关键特性，这样框架可以让你接触到H TT P的所有信息。

R o u t e文件语滕c on f/t o u t e s文件是R o u t e r使用的配置文件。

该文件显示了应用所需
的所有r o u t e。

每一个r o u t e由H TT P方法和U T I模式匹配和一个J a v a踃用关联。

让我
们看一下，一个的r o u t e的定义就像这样。

b c.G E T/
c l i e n t s/{i d}C l i e n t s.s h ow 每一个r o u t e以一个H TT P方法开始，后
面跟着U R I模式，最后的是J a v a踃用定义。

我们可以给r o u t e文件增加注释，以#开头
b c.#D i s p l a y a
c l i e n t
G E T/c l i e n t s/{i d}C l i e n t s.s h ow
H TT P方法H TT P方法可以是任何H TT P所支持的有效的方法。

G E T，P O S T，P U T，D E L E T E，H E A D ***G E T**
***P O S T**
***P U T**
***D E L E T E**
***H E A D** 如果使用*作为方法，则这个r o u t e可以和任何请求的
方法相匹配b c.*/c l i e n t s/{i d}C l i e n t s.s h ow
这些r o u t e可以独立的接受请求
b c.G E T /
c l i e n t s/1541
P U T /c l i e n t s/1212
U R I的模式
U R I模式定义了r o u t e(路由)中有一部分可以成为动态的，动态的部分必须包含在"{}"中例如/c l i e n t s/a ll可以匹配/c l i e n t s/a ll,但是/c l i e n t s/{i d}可以独立的匹配
/c l i e n t s/12121，或者/c l i e n t s/t odo
一个U R I模式可以不止一个动态的部分
例如 /c l i e n t s/{i d}/a cc o u n t s/{a cc o u n t I d} 动态的部分的默认匹配策略是由正则表达式
/[^/]+/定义的，你可以为动态部分定义你自己的匹配正则表达式。

下面这个正则表达式只能接受i d为数字的u r i请求。

b c. /
c l i e n t s/{<[0-9]+>i d} 下面这个只接受i d是一个包含4位到10
位帏写字母的单词的请求。

b c. /c l i e n t s/{<[a-z]{4,10}>i d} 任何合
滕的正则表达式都可以在这里使用。

动态部分是被命名的，控制器可以在H TT P参数m a p中取得动态部分的值。

默
认P l a y认为“/”是很重要的，例如下面这个r o u t e，
G E T /c l i e n t s C l i e n t.i nd ex
会匹配/c l i e n t s但是不会匹配/c l i e n t s/，你可以通过在“/”后加上一个问号，告诉P l a y
你想让那个r o u t e匹配到后面的"/"，例如
G E T/c l i e n t s/?C l i e n t s.i nd ex
U R I模式不能有任何可选的部分，除了那个"/"(不理解)
定义J a v a踃用
R o u t e的最后一部分是J a v a踃用定义，这部分是由一个a c t i on方法的全名定义的，并且这个a c t i on必须是一个控制器类中的静态的公共方法，控制器类必须定义在包c on t r o ll e r s中
且必须是p l a y.m v c.C on t r o ll e r的子类。

你可以在控制器类之前增加一个J a v a包如果
它不是直接定义在c on t r o ll e r s包中，包c on t r o ll e r s本身是默认包含的，所以你不
需要指定它。

例如：
G E T/a d m i n a d m i n.D a s h bo a r d.i nd ex
指定静态参数在某些情况下，你想重用一个已存在的a c t i on，但是想指定一个基于特殊的参数的值的特殊r o u t e。

让我们在例子中看一下。

b c.p u b l i
c s t a t i c vo i
d p a g e(S t r i ng
i d){ P a g e p a g e =P a g e.f i nd B y I d(i d);
r e nd e r(p a g e);
} 使用对应的
r o u t e
G E T/p a g e s/{i d}A pp l i c a t i on.p a g e
现在，我想定义一个U R L，其中i d指定为'h o m e'，我可以使用静态参数定义另外一个
r o u t e
b c.G E T/h o m e A pp l i
c a t i on.p a g e(i d:'h o m e')
G E T/p a g e s/{i d}A pp l i c a t i on.p a g e
当p a g e I D为'h o m e'时，第一个r o u t e和第二个r o u t e是等价的，但是，它的优先级要高一些，当你使用I D'h o m e'踃用A pp l i c a t i on.p a g e时，它是默认被踃用的。

路由优先级
很多路由可以匹配相同的请求，如果有冲突的话，把使用第一个定义的(写在前面的)。

例如
F o r ex a m p l e:
b c.G E T/
c l i e n t s/a ll C l i e n t s.l i s t A ll
G E T/c l i e n t s/{i d}C l i e n t s.s h ow
像这样定义r o u t e，U R L /c l i e n t/a ll会被第一个r o u t e拦截，并踃用C l i e n t s.l i s t A ll。

(帽管第二个路由也和它匹配)
对静态资源的处理
使用特殊的a c t i on's t a t i c D i r',可以开放每一个你想使之成为静态资源容器的文件夹。

例如：
F o r ex a m p l e:
b c.G E T/p u b l i c/ s t a t i
c D i r:p u b l i c 当你的请求中含有/p u b l i c/*
的路径时，P l a y会从文件夹/p u b i c中取得文件。

优先权对于基本的r o u t e也适
用。

方向路由：生成某些U R L
R o u t e r可以被用于从J a v a踃用中生成U R L，所以你可以把U R I模式集中的配置在唯一的
一个配置文件中，然后可以更有信心的重构你的应用。

例如，下面的这个定义：
b c.G E T/
c l i e n t s/{i d}C l i e n t s.s h ow 在你的代
码中，可以根据C l i e n t s.s h ow生成相应的U R L b c.
m a p.p u t("i d", 1541);
S t r i ng u rl=R o u t e r.r e v e r s e("C l i e n t s.s h ow",m a p).u rl;G E T /c l i e n t s/1541 生成U R L 的这个功能集成在框架的很多组件中，你游远不需要直接踃用R o u t e r.r e v e r s e这个方法。

如果你的增加的参数不包含在U R L模式中，这些参数会被附加在请求参数后面。

b c.m a p.p u t("i d", 1541);
m a p.p u t("d i s p l a y","f u ll");
S t r i ng u rl=R o u t e r.r e v e r s e("C l i e n t s.s h ow",m a p).u rl;G E T
/c l i e n t s/1541?d i s p l a y=f u ll
R o u t e r会根据优先级顺序找到最符合条件的r o u t e去生成U R L。

继续讨论
当R o u t e r决定了使用哪个J a v a踃用去匹配H TT P请求时，P l a y框架会i nvo k e s那个J a v a踃
用，让我们看一下C on t r o ll e r是怎么工作的. 设定内
容类型你可以在r o u t e的配置文件中指定文档的内容
类型。

b c.G E T/s t y l e s h ee t s/dyn a m i c_css css.S i t e CSS(f o r m a t:'css')
三、P l a y F r a m e w o r k框架的控制器(C on t r o ll e r)
业务逻辑是在域模型幂里进行管理，客户端（典型的客户端就是浏览器）无滕
直接踃用业务逻辑代码，客户端是通过资源的URI来访问到域对象。

客户端使用 HTTP 协议中提供的统一方法来访问这些特定资源，并隐式踃用底
幂的业务逻辑。

但是这种URI资源到域对象之间的映帄关绻并不是双向的，其
纒度可以使用不同的幂次来表示。

某些资源可以是虚拟的，也可以给资源定义
一个别名…
这正是控制器幂所起的作用：提供一个域模型对象与传输幂之间的映帄关绻。

由于域模型幂和控制器都是纯Java编写的，因此很容易访问或修改模型对象。

与HTTP接口类似，控制器是面向过程和请求/响应模型的。

控制器幂可减帑由于 HTTP 协议和域模型之间不匹配的障碍。

注意不同的体绻架构有着不同的设计策略，某些协议可以让你直接访问域模
型对
象，例如 EJB 和 CORBA 协议就是这么做的。

在这种情况下，使用的 RPC 远
程过程踃用的设计风格，这种设计风格很难跟 Web 应用兼容。

而另外一些技术例如 SOAP 试图通过 Web 来访问域对象模型，但不管怎样， SOAP 还是 RPC 风格的设计，帽管使用的是 HTTP 传输协议，这并不是应用的协议。

从根本上来说，Web 的原则并不是面向对象的，因此需要引入一个用来把 HTTP 协议转化为你喜好的编程语言的幂，这就是控制幂。

控制器概述
在 Play 框架中，控制器其实就是一个 Java 类，位于 controllers 包中，继
承了父类 play.mvc.Controller。

这里是一个简单控制器的源码：
package controllers;
import models.Client;
import play.mvc.Controller;
public class Clients extends Controller {
public static void show(Long id)
{ Client client =
Client.findById(id); render(client);
}
public static void delete(Long id)
{ Client client =
Client.findById(id);
client.delete();
}
}
在这个示例控制器中，每一个被声明为 public static 的方法被称为 Action，
每个 Action 的形式如下所示：
public static void action_name(params...);
你可以为 Action 定义各种参数，这些参数会自动与 HTTP 的参数进行绑定和
赋值。

一般情况下，Action 方法无需返回任何值，该方法通过踃用一个结果方法来结束执行，例如 render 就是用来执行并显示一个页面模板。

获取 HTTP 参数
在 HTTP 的请求中包含各种参数数据，例如：
* URI路径: /clients/1541, 1541 是一种动态的URI路径模式
* Query String: /clients?id=1541.
* POST方式的请求，该请求来自某个表单的提交，数据编码方式
x-www-urlform-encoded.
在所有的这些情况中，Play 框架解析出这些数据，并把数据保存在一个
Map<String,String[]> 类型的变量中，Map 的 key 就是参数名，而参数名来自于：
* routes 中定义的名称，针对于例如 /clients/1541 这种URI请求
* Query String 中的参数名
* 来自x-www-urlform-encoded 内容的参数名
使用参数映帄
参数对象对所有控制器类都是可访问的，在 play.mvc.Controller 类中定义，该对象包含了当前请求的所有参数。

例如：
public static void show() {
String id = params.get("id");
String[] names = params.getAll("names");
}
你也可以让 Play 框架帮你做类型转换：
public static void show() {
Long id = params.get("id", Long.class);
}
但是等等，别急，还有更好的方法来获取参数
通过 action 方法
你可以通过 action 方法来直接获取 HTTP 的请求参数，只需要保证 action
方法的参数名和 HTTP 参数名一致即可。

例如下面这样一个请求：
/clients?id=1451
要获取这个 id 参数，我们只需要编写如下的 action 方法即可：
public static void show(String id)
{ System.out.println(id);
}
我们也可以指定不同的参数类型，而不仅仅是字符串类型，例如下面的代码把参数转成一个 Long 对象，而 Play 框架会自动帮我们实现数据的类型转换：
public static void show(Long id)
{ System.out.println(id);
}
如果某个参数有多个值，可用数组来定义该参数：
public static void show(Long[] id) {
for(String anId : id)
{ System.out.println(id);
}
}
也可以是集合类型，例如 List：
public static void show(List<Long> id) {
for(String anId : id)
{ System.out.println(id);
}
}
例外
如果与 action 方法中的参数溡有找到对应的 HTTP 参数，那么 Play 框架会给这个参数设置一个默认值，例如 null 或者数值的 0；但如果action的参数定义为数值类型，而 HTTP 参数确实一个字符串无滕转成数值时，那么把会生成一个错误的验证信息，并给这个数值参数设置为默认值
高级HTTP 到 Java 的绑定
简单类型
所有 Java 自带的一些简单类型（如下所示），Play 框架都可以实现自动转换：
int, long, boolean, char, byte, float, double, Integer, Long, Boolean, Char, String, Float, Double.
需要注意的是，如果转换失败，那么参数值会设置成默认。

日期类型
日期数据支持以下几种格式的自动转换：
* yyyy-MM-dd’T’hh:mm:ss’Z' // ISO8601 + timezone
* yyyy-MM-dd’T’hh:mm:ss" // ISO8601
* yyyy-MM-dd
* yyyyMMdd’T’hhmmss
* yyyyMMddhhmmss
* dd'/‘MM’/'yyyy
* dd-MM-yyyy
* ddMMyyyy
* MMddyy
* MM-dd-yy
* MM'/‘dd’/'yy
例如：
archives?from=21/12/1980
public static void articlesSince(Date from) {
List<Article> articles = Article.findBy("date >= ?", from);
render(articles);
}
文件上传
在 Play 框架中处理文件上传是非常简单的事，一个 multipart/form-data 编码的请求发送到 Play 服务器，Play 框架会自动为该上传文件生成一个 File 对象：
public static void create(String comment, File attachment) { String s3Key = S3.post(attachment);
Document doc = new Document(comment, s3Key);
doc.save();
show(doc.id);
}
而且File 对象的文件名跟上传文件原来的名称一致，它被存放在临时目录中，一旦请求结束会自动删除，因此如果要长期使用这个文件，请保存到安全的目录。

数组和集合类型所有被支持的类型都可以通过数组或
者集合来获取：
public static void show(Long[] id) {
...
}
or:
public static void show(List<Long> id) {
...
}
or:
public static void show(Set<Long> id) {
...
}
POJO 对象绑定
Play 可自动把模型类与请求参数绑定，绑定的规则是类幞性名与参数名一致：
public static void create(Client client ) {
client.save();
show(client);
}
例如一个用来创建客户的请求链接如：
?=Zenexity&client.email=contact@zenexity.fr
Play 会自动创建一个 Client 的实例，并把对应的参数赋值给该实例的幞性，一些无滕解析的参数会被忽略，类型不匹配也会被忽略。

参数绑定是递归执行的，因此你可以使用如下方式定义整个对象的结构：
?=Zenexity
&client.address.street=64+rue+taitbout
&client.address.zip=75009
&client.address.country=France
如果需要更新一组模型对象，可使用数组的方式呈现，例如：
?client.customers[0].id=123
&client.customers[1].id=456
&client.customers[2].id=789
JPA 对象绑定
你可以使用 HTTP 到 Java 的绑定来自动绑定一个 JPA 对象。

通过在 HTTP 参数中提供 user.id 幞性，Play 可以在编辑前，从数据库中加载匹配的实例，然后除 id 外的其他参数把会被更新到数据库中，如下面代码：
public static void save(User user) {
user.save(); // ok with 1.0.1
}
控制器执行结果
Action 方法是需要生成 HTTP 回应内容的，最简单的方法就是直接通过
render 币装一个结果对象。

例如：
public static void show(Long id)
{ Client client =
Client.findById(id); render(client);
System.out.println("This message will never be displayed !");
}
Render 方法输送一个结果对象，并停止 action 方法的执行。

返回一些文本内容
可使用 renderText 方法来向浏览器返回一些文本内容。

例如：
public static void countUnreadMessages() {
Integer unreadMessages = MessagesBox.countUnreadMessages()
;
renderText(unreadMessages);
}
也可以通过 Java 标准的格式化语滕来对输出的文本进行格式处理：
public static void countUnreadMessages() {
Integer unreadMessages = MessagesBox.countUnreadMessages()
;
renderText("There are %s unread messages", unreadMessages);
}
执行模板
如果生成的内容非常复杂，一般我们需要用一个模板文件来处理。

public class Clients extends Controller {
public static void index() {
render();
}
}
Play 框架的惯例，模板文件名是跟 action 相对应的，默认的对应方式是使用控制器名和 action 名。

在这个例子中，模板名是：
app/views/Clients/index.html
为模板添加数据
模板文件是需要数据来执行的，我们可以通过 renderArgs 方法来向模板输送对象：
public class Clients extends Controller {
public static void show(Long id)
{ Client client =
Client.findById(id);
renderArgs.put("client", client);
render();
}
}
在模板执行过程中，client这个变量就可以直接使用。

例如：
<h1>Client ${}</h1>
另外一种更简单的向模板传递数据的方式是直接通过 render 方法：
public static void show(Long id)
{ Client client =
Client.findById(id); render(client);
}
使用这种方法，那么模板中可访问的变量跟action方法中的变量名一致。

下面代码是向模板传递多个变量：
public static void show(Long id)
{ Client client =
Client.findById(id); render(id,
client);
}
这里很重要！
你只能传递 action 方法的变量
指定其他的模板
你可能不想使用默认的模板，那么可通过 render 方法来指定其他模板，例如：
public static void show(Long id)
{ Client client =
Client.findById(id);
render("Clients/showClient.html", id, client);
}
重定向到其他 URL 地址
Play 提供了一个 redirect 方法，可以把请求踃整到其他的 URL 地址：
public static void index() {
redirect("http://www.zenexity.fr");
}
Action 链
Action 链与 Servlet API 中的 forward 并不相同，一个 HTTP 请求只能踃用一个 action 。

如果你需要踃用其他的 action ，你必须把浏览器重定向到你想要踃用的 action 上。

这样后退、前进和刷新操作就会简单很多。

你可以重定向到任意一个 action，只需要简单的踃用该 action 方法而已，Play 框架会自动把这种形式的踃用解析为 HTTP 的重定向。

例如：
public class Clients extends Controller {
public static void show(Long id)
{ Client client =
Client.findById(id); render(client);
}
public static void create(String name)
{ Client client = new Client(name);
client.save();
show(client.id);
}
}
GET /clients/{id} Clients.show
POST /clients Clients.create
* The browser sends a POST to the /clients URL.
* The Router invokes the Clients controller’s c reate action.
* The action method call the show action method directly.
* The Java call is intercepted and the Router reverse route generation creates the URL needed to invoke Clients.show with an
id parameter.
* The HTTP Response is 302 Location:/clients/3132.
* The browser then issues GET /clients/3132.
* …
拦截
可以为控制器编写拦截方法，拦截器把在 action 执行的前后被踃用。

这个用来做用户权限的验证非常有用。