来玩Play框架-JavaScript-火龙果软件工程

来玩Play框架

作者：Vamei 来源：博客园发布于 2015-12-3

5989 次浏览

说到网络框架，Ruby的Ruby on Rail和Python的Django都相当轻巧好用，但Java下的框架，则要沉重很多。有人因此质疑Java语言本身是否符合网络时代的需求。Java大神们对这一问题嗤之以鼻。想要轻巧好用的框架？写一个给你就是了。Java程序员Guillaume Bort在JVM上创造了一个全新的框架Play framework。Play拥有ROR或Django那样的灵巧，又不失Java的稳定，更有JVM这一强大的运行平台。魔鬼身材，天使脸蛋。让我们来玩玩Play吧。

下载与安装

Play的安装相当简单。在Play官网下载，我下载的是2.2.1版本。该版本的API文档为2.2.1API。

把下载的.zip文件解压缩，并将解压缩后的文件夹放到某个位置。比如/home/vamei/Util。

unzip play-2.2.1.zip
mv play-2.2.1 /home/vamei/Util/

文件夹里重要的是可执行文件play。我一般是在/home/vamei/Util/下创建一个bin文件夹，并在该文件夹中创建play的软链接。

mkdir -p /home/vamei/Util/bin
cd /home/vamei/Util/bin
ln -s /home/vamei/Util/play-2.2.1/play .

最后，将新建的bin文件夹放入系统路径。

echo "export PATH=/home/vamei/Util/bin:$PATH" >> /home/vamei/.bashrc
source /home/vamei/.bashrc

在命令行输入play，将显示：

 _
 _ __ | | __ _ _  _
| '_ \| |/ _' | || |
|  __/|_|\____|\__ /
|_|            |__/

play 2.2.1 built with Scala 2.10.2 (running Java 1.7.0_51), http://www.playframework.com

This is not a play application!

Use `play new` to create a new Play application in the current directory,
or go to an existing application and launch the development console using `play`.

You can also browse the complete documentation at http://www.playframework.com.

注：

上面是Ubuntu下的安装过程。Linux系统都类似。

在Mac OS下，选择合适的路径安装play，过程也相同。

对于Windows下的安装，没有探索。欢迎补充。

创建与运行

切换到/home/vamei，创建一个网络应用test，

play new test

跟随指示，输入项目的必要信息。应用名和编程语言，分别为test和Java。

将有一个新的文件夹/home/vamei/test出现在当前路径。它包含该项目的所有文件。

test
├── README
├── app
│   ├── controllers
│   │   └── Application.java
│   └── views
│       ├── index.scala.html
│       └── main.scala.html
├── build.sbt
├── conf
│   ├── application.conf
│   └── routes
├── project
│   ├── build.properties
│   └── plugins.sbt
├── public
│   ├── images
│   │   └── favicon.png
│   ├── javascripts
│   │   └── jquery-1.9.0.min.js
│   └── stylesheets
│       └── main.css
└── test
    ├── ApplicationTest.java
    └── IntegrationTest.java

上面最重要的文件夹是app，里面包含了项目的MVC定义。Play采用MVC架构(model-view-control)。新建项目已经创建好了controllers和views，包含有控制器(controller)和视图(view)模板。如果有必要，可以在app下创建models文件夹，用来定义数据模型(model)。

application.conf包含了项目的各个设置参数。

routes记录了url请求和控制器的对应关系。当有http请求进入时，Play将根据该文件的设置，调用特定的控制器行动。

现在，切换到/home/vamei/test，并运行项目。输入命令：

play run

Play自己包含有一个网络服务器模块，所以不需要和apache衔接，就可以作为网络服务器，直接工作。

打开浏览器，访问localhost:9000，将看到运行的test应用。

这一页面是新建项目自带的页面。

解析

Play框架的主要功能是动态生成http响应。http协议按照“请求-响应”(request-response)的方式工作。http通信的相关介绍，可参考http协议。

Play是MVC架构，分步骤生成响应，而每一步由不同的模块负责。上面的一个简单页面，是如下过程产生的：

图中的黑色字体表明了这些功能在项目中所在的具体文件。

routes负责将url导向正确的行动(action)。action是生成http响应的核心。一个action会经过一系列的运算，产生一个响应。而控制器controller只是一个action的集合。在Java编程中，action是controller类的一个方法。action的响应可以传给某个视图，比如上面的index.scala.html，从而更好的控制显示效果。最后的结果，就是一个http响应，也就是我们所看到的页面。

通过个性化上述过程，我们可以设计出功能更丰富的网络应用。

持续运行

Play自带的服务器可以持续运行。将Play安装在目标服务器，比如云上后，在Play项目的根目录下，用：

play start

来持续运行服务器。此后你可以按Ctrl-D来返回命令行。此时的Play不依赖于Shell，即使退出服务器的登陆，Play还是会持续运行。

使用其它端口运行：

play "start -Dhttp.port=8080"

停止运行。切换到项目的根目录下，使用命令：

play stop

来玩Play框架02 响应

我上一章总结了Play框架的基本使用。这一章里，我将修改和增加响应。

HTTP协议是按照“请求-响应”的方式工作。Play框架的核心是用动作(Action)来完成“请求-响应”。一个动作负责处理一种请求。一个项目可能要定义许多动作。复杂的网站，可能要定义上百个动作。所以，Play使用控制器(Controller)和URL路由(URL routing)来组织管理动作。控制器用于给动作分类。URL路由(routes)记录了URL和动作的对应关系。

IDE

在开发代码之前，先简单介绍如何使用Eclipse，开发Play项目。

在项目的根目录下，使用命令：

play eclipse

成功后，打开Eclipse，在File->Import中，选择General->Existing Projects into Workspace。在Select root directory中，选择项目的根目录。随后，项目被引入Eclipse。

Java是静态语言，可以在编译时就决定对象的类型，因此能方便的实现代码自动提示补齐、自动寻找类所在的包并import。在写程序的过程中，也能有很多友好提示。

后面的代码中，如果没有写明import的包，可以在Eclipse环境下自动寻找。

理解响应

我先来介绍控制器和URL路由。我以Play默认生成的动作为例讲解。你可以在Play项目中找到下面文件。

一个请求进入服务器后，由URL路由引导到正确的动作来处理。URL路由根据请求的方法和URL来识别这一请求，再寻找对应动作。

URL路由是一个文件，即项目根目录下的conf/routes。文件的每一行是一条记录，规定了某个URL的对应动作。比如：

# Home page
GET   /   controllers.Application.index()

#开始的行是注释

记录分为三个部分。第一部分为请求的方法，第二个部分为请求的URL，第三个是请求的对应动作。这里Application是一个控制器，位于app/controllers/Application.java中。一个控制器也是一个Java类。而动作index()是类的一个方法。

我对默认生成的Application.java略作修改。新的app/controllers/Application.java为：

package controllers;

import play.*;
import play.mvc.*;

import views.html.*;

public class Application extends Controller {

public static Result index() {
return ok("Hello World!");
}

}

可以注意到，作为控制器的Application，需要继承自Controller类。

一个动作必须是一个静态(static)的方法。一个动作返回一个Result类型的对象。ok("Hello World!")返回的就是这么一个Result对象，代表了一个HTTP响应。ok()返回的响应都是200状态，即ok（正常回复）。在这个例子中，响应的主体内容为"Hello World!"。

你可以启动Play服务器，访问上面的URL(localhost:9000/)。使用Chrome的network工具监视回复。页面如下：

根据network工具的监视，响应的状态码为200。响应的类型为text/plain。这是ok()生成Result对象时自动决定的。我可以手动控制响应类型，比如将index()的返回语句改为：

return ok("Hello World!").as("text/html");

这样，响应的主体类型为html。

其它状态的响应

除了ok()之外，Play还提供了其他的一些便捷方法，用以生成不同状态的响应。这些方法的名字和状态的名字相同，比如：

return badRequest("bad request"); // 400, 坏请求
return unauthorized("You are forbidden"); // 401, 未授权
return redirect("/new");    // 303, 重新定向

这些方法返回对应的状态码。浏览器根据状态码和回复的内容，做出反应。比如收到303时，重新定向到新的URL。

此外，我还可以直接使用status()来说明数字形式的状态码

return status(200, "good");

更多的响应生成方式可参考Results

练习

在上面的控制器Application中，增加一个新的动作，用于显示

<p>See you!</p>

修改routes，并验证效果。

URL路由

URL路由是由一行一行的记录组成的。上面我们看到了GET方法，还可以是其它HTTP方法，比如POST：

POST /somePost  controllers.Application.somePost()

我要在Application类中增加somePost()动作来处理该请求，比如：

public static Result somePost() {
    return ok("posted");
}

POST方法常用于向服务器提交数据。我将在以后深入。

url还可以有用户定义的变量，从而让一行记录对应不止一个请求，比如：

GET   /record/:id  controllers.Application.record(id: Long)

上面的:id是一个名为id的变量。":"是一个提示符。id将从":"开始，直到结束或者另一个"/"。

当我们访问/record/1234时，id就是1234。对应的动作包含有一个参数，来接收id变量。我这里把参数类型定义为Long。Play将负责类型的转换。

相应的record()动作为：

public static Result record(Long id) {
    return ok("record:" + id.toString());
}

可以看到，该动作与之前的动作有点不一样，它接受一个参数，即来自url的变量。

除了":"之外，还有另一个提示符"*"。与":"不同，"*"表示的区间不受"/"限制。

GET    /newRecord/*name  controllers.Application.newRecord(name: String)

如果我们访问/newRecord/abc/def，那么name将对应字符串"abc/def"

来玩Play框架03 模板

在上一章节中，我把字符串通过ok()返回给客户。我可以把一个完整的html页面放入字符串中返回。然而，现代的框架都提供了更好的方法——模板。模板将视图和数据分开。服务器可以把不同的数据传递给同一个模板，从而产生不同的页面。 Play同样也有一套模板系统。模板的大部分内容都可以用html写，作为视图，而在一些特别的地方，预留给数据参数。在模板中，用Scala语言来调用参数。

使用模板

我首先创建一个模板，纯粹起视图功能。在app/views文件夹中，新建文件index.scala.html （如果已有，则删除并重新创建）。

<!DOCTYPE html>
<html>
  <header>
    <title>Play</title>
  </header>

<body>
<p>Hello World! Start using the Template.</p>
</body>
</html>

这个模板是个纯粹的html文件，是最简单的模板形式。

修改app/controllers/Application.java：

package controllers;

import play.*;
import play.mvc.*;

public class Application extends Controller {
public static Result index() {
return ok(views.html.index.render());
}
}

ok()中接收的是views.html.index.render()，实际上就是app/views/index.scala.html这一模板的render()方法。Play会根据模板，自动生成相应的类。

*** 也可以用import引入views.html.index，而不是使用完整的类路径。

访问页面：

模板语言

这一部分，我把对象作为参数传给模板，然后在模板中显示对象中包含的数据。修改index.scala.html：

@(title: String, content: String)

<!DOCTYPE html>
<html>
<header>
<title>@title</title>
</header>

<body>
<p>@(content) Start using the template.</p>
</body>
</html>

上面的第一行，以@符号开头，说明了该模板所接收的两个参数，即String类型的title和content。在模板中，用@符号和参数名，来调用参数。参数名周围可以用括号"()"，以区分正文。

修改动作：

public static Result index() {
    return ok(views.html.index.render("Play", "Hello World! Parameters passed. "));
}

这里传递两个字符串给模板。最终显示的结果中，两个字符串将填充在模板中的适当位置。

上面把一个对象传递给模板。我们还可以在模板中调用对象的属性或方法：

@object.method()

@object.field

模板控制

我还可以用Scala的语法，在模板中实现更复杂的逻辑。比如下面的模板中使用循环：

@(title: String, content: String, lines: List[String])

<!DOCTYPE html>
<html>
<header>
<title>@title</title>
</header>

<body>
<p>@(content) Start using the template.</p>
<ul>
@for(line <- lines) {
<li>@line</li>
}
</ul>
</body>
</html>

循环是@for实现的。@后面不仅可以是一个对象，还可以是一个完整的Scala语法。

修改动作，把一个字符串类型的表作为参数传递给模板：

package controllers;

import play.*;
import play.mvc.*;

import java.util.List;
import java.util.ArrayList;

public class Application extends Controller {
public static Result index() {
List<String> lines = new ArrayList<String>();
lines.add("a");
lines.add("b");
lines.add("c");
return ok(views.html.index.render("Play", "Hello World!", lines));
}
}

得到下面的页面：

模板中还可以有if选择结构，比如

@if(item) {
  <p>True</p>
} else {
  <p>False</p>
}

根据参数item的真假，if结构显示不同的内容。

来玩Play框架04 表单

表单(form)是最常见的从客户往服务器传递数据的方式。Play框架提供了一些工具。它们可以从表单中提取数据，验证提交数据的合法性，或者在视图中显示表单。我先来介绍最简单的使用表单提交数据的方式。

增加表单

我可以用纯粹html的方式产生一个表单。在app/views下增加模板form.scala.html:

<!DOCTYPE html>
<html>
  <body>
    <form method="POST" action="/postForm">
      <input type="text" name="content"></input>
      <input type="submit"></input>
    </form>
  </body>
</html>

在Application控制器中，增加一个动作form()，显示模板:

public static Result form() {
    return ok(views.html.form.render());
}

在routes中增加导航

GET     /form                       controllers.Application.form()

页面如下：

数据提取

在文本框中输入任意字符，点击submit后，表单将以POST方法提交到/postForm这一URL。增添负责处理该URL的动作，Application.postForm()

public static Result postForm() {
    DynamicForm in   = Form.form().bindFromRequest();
    String result    = in.get("content");
    return ok(result);
}

DynamicForm和Form都来自play.data。Form.form().bindFormRequest()从请求中提取表单信息，并放入到DynamicForm类型的in对象中。

我上面用get()方法，来提取表单中不同名字的输入栏。比如上面的"content"。postForm()动作把表单中填写的内容直接显示。

增加routes记录

POST    /postForm                   controllers.Application.postForm()

在/form的页面下输入任意字符串并提交，查看效果。

我介绍了表单最基本的使用方式。下面了解Play框架提供的其它的表单工具。

表单对象

在动作内部，可以创建一个对象来指代表单。表单的每个输入栏为表单对象的一个属性。我可以通过增加标注(annotation)的方法，验证表单的输入(Form Validation)。

首先修改app/views/form.scala.html

<!DOCTYPE html>
<html>
  <body>
    <form method="POST" action="/postForm">
      <label>Email</label>
      <input type="email" name="email">
      <label>Password</label>
      <input type="password" name="password">
      <label>Comment</label>
      <input type="text" name="comment">
      <input type="submit">
    </form>
  </body>
</html>

这个表单有三个输入栏，名字分别为email, password和comment。

创建app/util/文件夹，在其中创建User.java。User类用于在Play内部指代上面的表单：

package util;

import play.data.validation.Constraints.Email;
import play.data.validation.Constraints.Required;

public class User {
@Email
public String email;
@Required
public String password;
public String comment;
}

User类指代一个表单的数据。我还为两个属性增加了标注。Play服务器可以据此验证输入的合法性。比如@Email的限定就要求输入为"*@*"的形式。@Required则要求输入栏不为空。如果违反这些限定，那么Play将抛出异常。

修改动作postForm()。User类的对象user用来保存表单数据。

public static Result postForm() {
    Form<User> userForm = Form.form(User.class);
    User user = userForm.bindFromRequest().get();
    return ok(user.email + " " + user.password);
}

最后的ok()中调用了表单对象中保存的数据。

分别输入合法和不合法的数据，观察Play返回的页面。

表单模板

我上面手动创建模板中的表单，并保持视图中的表单和表单对象一致。我还可以在模板中直接调用表单对象。这样做，能让视图中的表单和表单对象自动的保持一致。

修改form.scala.html为

@(userForm: Form[util.User])

<!DOCTYPE html>
<html>
<body>
@helper.form(action = routes.Application.postForm()) {
@helper.inputText(userForm("email"))
@helper.inputPassword(userForm("password"))
@helper.inputText(userForm("comment"))
<input type="submit">
}
</body>
</html>

这里使用了Play所提供的helper工具。helper可以在表单中增加表单form，再加入不同类型的输入栏，比如inputText和inputPassword。

修改原有的动作form()

public static Result form() {
    Form<User> userForm = Form.form(User.class);
    return ok(views.html.form.render(userForm));
}

这里，表单对象作为参数传递给模板。最后的html页面中的表单，将由Play自动生成。

来玩Play框架05 数据库

数据库是整个站点的数据储藏室。用户提交的数据可以存储在数据库中，以便未来使用。Play可以通过JDBC和数据库通信。我讲介绍Play和mysql数据库的连接。

Play 2.*版本的默认操作数据库的方式是通过Ebean。Play提供Finder这一帮助类型，可以实现一些简单的数据库查询。

数据库准备

在mysql中增加数据库testing。增加用户"player"，密码为"player"。为用户player增加适当的权限。

CREATE DATABASE testing DEFAULT CHARACTER SET utf8;
CREATE USER 'player'@'localhost' IDENTIFIED BY 'player';
GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, INDEX, 
ALTER, CREATE TEMPORARY TABLES, LOCK TABLES ON testing.* TO 'player'@'localhost';

为了在Play中使用mysql数据库，需要在conf/application.conf中增加设置：

# Database configuration

db.default.driver=com.mysql.jdbc.Driver
db.default.url="jdbc:mysql://127.0.0.1:3306/testing"
db.default.user="player"
db.default.password="player"

# Ebean configuration
ebean.default="models.*"

还需要修改build.sbt为：

name := "test"

version := "1.0-SNAPSHOT"

libraryDependencies ++= Seq(
javaJdbc,
javaEbean,
cache,
"mysql" % "mysql-connector-java" % "5.1.18"
)

play.Project.playJavaSettings

上面的改动完成后，使用play run来运行服务器。

创建模型

下面，我在模型中增加一个实体(entity)，即一个Person类。放入models/Person.java

package models;

import java.util.List;

import javax.persistence.Entity;
import javax.persistence.Id;

import play.db.ebean.Model;
import play.db.ebean.Model.Finder;

@Entity
public class Person extends Model {
@Id
public Integer id;
public String name;

// Query
public static Finder<Integer,Person> find =
new Finder<Integer,Person>(Integer.class, Person.class);

public static List<Person> findAll() {
return find.all();
}

public static Person findByName (String name) {
return find.where().eq("name", name).findUnique();
}
}

Person类继承自Model类，并有一个@Entity的注解，从而说明它是模型中的一个实体。实体有两个场，整数的id和字符串的name，用来保存数据。

@id注解下，id将不为空，不重复，并自动增加。

Person还有一个静态的场find。find是Play提供的Finder类型，用于数据库查询。而Person类中得findAll()和findByName()的静态方法中，就调用了find，从而在数据库中查询条目。

Play有evolution模块，管理数据库的表。写好Person.java后，访问项目。Play这时会生成在mysql中建立表格的脚本。运行该脚本即可。

增加数据库条目

增加一个动作。这个动作向数据库增加条目：

public static Result addPerson() {
    Person p1 = new Person();
    Person p2 = new Person();
    p1.name = "vamei";
    p2.name = "play";
    p1.save();
    p2.save();
    return ok("Saved");
}

*** 上面的代码要import models.Person。

将/addPerson这一URL对应该动作。访问后，数据库将增加条目：

练习根据表单一讲的内容，增加一个向数据库添加条目的表单。

数据库查询

我可以在动作中调用刚才定义的查询方法findAll()和findByName()，比如增加allPerson()动作：

public static Result allPerson() {
    List<Person> persons = Person.findAll();
    return ok(views.html.personList.render(persons));
}

上面查询得到的Person类型的表，传递给模板views/personList.scala.html:

@(personList: List[models.Person])

<!DOCTYPE html>
<html>
<body>
<ul>
@for(person <- personList) {
<li>@person.name</li>
}
</ul>
</body>
</html>

修改routes，增加对应的URL为/allPerson，页面如下：

事实上，我也可以在动作中直接调用Person.find，来组成查询语句。这将让动作内部有更大的查询自由度。比如上面的动作可以改写成：

public static Result allPerson() {
    List<Person> persons = Person.find.all();
    return ok(views.html.personList.render(persons));
}

来玩Play框架06 用户验证

用户验证(User Authentification)复合的使用Play框架的数个功能，包括前面已经了解的表单和数据库，以及这篇文章里要提到的加密和会话。根据应用或站点的复杂程度，用户验证也可以随之变化。这里将介绍用户验证的一个基本实现方式。

加密

为了信息安全，用户密码需要加密，而不是保存为明文。Bcrypt算法可以对明文密码进行哈希(Hash)转换。我保存在数据库中的密码，是经过转换后的文本。

JBcrypt是一个外部的包，提供了Bcrypt功能。要在build.sbt中说明这个包的来源和版本：

name := "test"

version := "1.0-SNAPSHOT"

libraryDependencies ++= Seq(
javaJdbc,
javaEbean,
cache,
"mysql" % "mysql-connector-java" % "5.1.18",
"org.mindrot" % "jbcrypt" % "0.3m"
)

play.Project.playJavaSettings

即上面新增的jbcrypt行。重新运行Play后即可使用。为了Eclipse能自动补齐该包的相关调用，可以使用play eclipse，并重新在Eclipse引入项目。

我下面用一个小例子，来说明该Bcrypt的哈希转换。在Play中增加动作：

public static Result bcrypt() {
    String passwordHash = BCrypt.hashpw("Hello",BCrypt.gensalt());
    boolean correct = BCrypt.checkpw("Hello", passwordHash);
    boolean wrong = BCrypt.checkpw("World", passwordHash);
    return ok(passwordHash + " " + correct + " " + wrong);
}

上面程序需引入org.mindrot.jbcrypt.BCrypt。动作中对"Hello"字符串进行了哈希转换，并验证"Hello"和"World"是否为原始的明文文本。

在routes增加对应URL，/bcrypt

GET     /bcrypt                     controllers.Application.bcrypt()

访问页面：

用户注册

有了表单、数据库和加密的基础，用户注册很容易实现。首先建立数据模型app/models/User.java：

package models;

import javax.persistence.*;
import play.db.ebean.Model;
import org.mindrot.jbcrypt.BCrypt;

@Entity
public class User extends Model {
@Id
private String email;
private String password;

// Constructor
public User(String email, String password) {
String passwordHash = BCrypt.hashpw(password, BCrypt.gensalt());
this.email = email;
this.password = passwordHash;
}
}

这段代码创建了User类，包含两个属性email和password。在构造器中，我对密码进行了哈希转换。

下面修改控制器Application(app/controllers/Application.java)。控制器中包含两个动作和一个表单类Registration。一个动作register()用于显示注册页面，另一个动作postRegister处理表单提交的信息，并增加相应的数据库记录。Registration则对应注册页面所显示的表格：

package controllers;

import play.*;
import play.mvc.*;
import play.data.Form;
import play.data.validation.Constraints.*;import models.User;

public class Application extends Controller {
public static class Registration {
@Email
public String email;
@Required
public String password;
}

public static Result register() {
Form<Registration> userForm = Form.form(Registration.class);
return ok(views.html.register.render(userForm));
}

public static Result postRegister() {
Form<Registration> userForm =
Form.form(Registration.class).bindFromRequest();
User user = new User(userForm.get().email, userForm.get().password);
user.save();
return ok("registered");
}
}

@(userForm: Form[controllers.Application.Registration])

<!DOCTYPE html>
<html>
<body>
<h1> Registration </h1>
@helper.form(action = routes.Application.postRegister()) {
@helper.inputText(userForm("email"))
@helper.inputPassword(userForm("password"))
<input type="submit">
}
</body>
</html>

在routes中为两个动作增加对应的URL：

GET     /register                   controllers.Application.register()
POST    /register                   controllers.Application.postRegister()

访问页面：

输入用户名和密码，可以看到数据库中增加的记录：

用户验证

将用户验证的主要逻辑放入到模型User中。修改User类，为User类增加authenticate()方法：

package models;

import javax.persistence.*;
import play.db.ebean.Model;
import org.mindrot.jbcrypt.BCrypt;

// Query
public static Model.Finder<Integer, User> find =
new Model.Finder<>(Integer.class, User.class);

// Authentification
public static User authenticate(String email, String password) {
User user = find.where()
.eq("email", email)
.findUnique();
if (user == null) {
return user;
} else if (BCrypt.checkpw(password, user.password)) {
return user;
} else {
return null;
}
}
}

authenticate()接收的是明文密码。上面的验证中，首先检查用户邮箱是否存在。如果存在，则检查密码是否符合数据库的记录。如果邮箱或者密码错误，将返回null。否则返回正确的用户对象。

我进一步修改控制器Application。这一次还是增加两个动作和一个表单类。动作login()用于显示登录页面，动作postLogin()用于处理登录表单填写的信息，并根据信息决定是否登入用户。Login类对应登录页面的表单。

package controllers;

import play.*;
import play.mvc.*;

import play.data.Form;
import play.data.validation.Constraints.*;

import models.User;

public class Application extends Controller {

public static class Registration {
@Email
public String email;
@Required
public String password;
}

public static Result register() {
Form<Registration> userForm = Form.form(Registration.class);
return ok(views.html.register.render(userForm));
}

public static class Login {
@Email
public String email;
@Required
public String password;

public String validate() {
if (User.authenticate(email, password) == null) {
return "Invalid user or password";
}
return null;
}
}

public static Result login() {
Form<Login> userForm = Form.form(Login.class);
return ok(views.html.login.render(userForm));
}

public static Result postLogin() {
Form<Login> userForm = Form.form(Login.class).bindFromRequest();
if (userForm.hasErrors()) {
return badRequest("Wrong user/password");
} else {
return ok("Valid user");
}
}
}

上面的表单类Login中，增加了validate()方法，并在其中调用User的验证逻辑。正如postLogin()中所示，表单的hasErrors()方法将自动检查validate()方法的返回值。如果validate()方法返回为null，则说明表单无误。postLogin()的if结构，将根据登录是否合法，来返回不同的结果。

为新增的动作增加对应的URL：

GET     /login                      controllers.Application.login()
POST    /login                      controllers.Application.postLogin()

访问/login页面，并尝试登录。

会话

HTTP协议是无状态的。即使我在/login登录成功，但下一次访问时，服务器又会忘记我是谁。HTTP协议可以用会话(Session)的方式，来记录用户的登录信息。在会话有效期内，服务器可以识别相应客户的访问。Play实现会话相当方便。

提交登录表格时，如果登录合法，我将让服务器开启和该客户的会话，记录客户的信息。因此，修改postLogin()为：

public static Result postLogin() {
        Form<Login> userForm = Form.form(Login.class).bindFromRequest();
        if (userForm.hasErrors()) {
            return badRequest(views.html.login.render(userForm));
        } else {
            session().clear();
            session("email",userForm.get().email);
            return redirect("/");
        }
    }

这里用户登录成功后，将启动一个会话。在会话中，可放入键值对(key-value pair)形式的信息。这里的键名为"email"，对应值为登录用户的邮箱地址。登录成功后将重新定向到/。

增加index()动作，对应/这一URL。在该动作中，我调用session中保存的用户信息：

public static Result index() {
        String email = session("email");
        if (email != null) {
            return ok(email);
        } else {
            return ok("not login");
        }
    }

增加routes中对应的URL：

GET     /                           controllers.Application.index()

访问/login，并登录。成功登录后重新定向到/，页面为：

可以看到，会话中的信息可以持续到以后的页面访问。为了销毁会话，可以在某个动作中调用：

session().clear();

5989 次浏览