Overview
FriendFeed使用了一款使用 Python 编写的，相对简单的 非阻塞式 Web 服务器。其应用程序使用的 Web 框架看起来有些像 web.py 或者 Google 的 webapp， 不过为了能有效利用非阻塞式服务器环境，这个 Web 框架还包含了一些相关的有用工具 和优化。javascript
Tornado 就是咱们在 FriendFeed 的 Web 服务器及其经常使用工具的开源版本。Tornado 和如今的主流 Web 服务器框架（包括大多数 Python 的框架）有着明显的区别：它是非阻塞式服务器，并且速度至关快。得利于其 非阻塞的方式和对 epoll 的运用，Tornado 每秒能够处理数以千计的链接，所以 Tornado 是实时 Web 服务的一个 理想框架。咱们开发这个 Web 服务器的主要目的就是为了处理 FriendFeed 的实时功能 ——在 FriendFeed 的应用里每个活动用户都会保持着一个服务器链接。（关于如何扩容 服务器，以处理数以千计的客户端的链接的问题，请参阅 The C10K problem ）css
如下是经典的 “Hello, world” 示例：html
import tornado.ioloop
import tornado.web
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write("Hello, world")
application = tornado.web.Application([
(r"/", MainHandler),
])
if __name__ == "__main__":
application.listen(8888)
tornado.ioloop.IOLoop.instance().start()
查看下面的 Tornado 攻略以了解更多关于 tornado.web 包 的细节。前端
咱们清理了 Tornado 的基础代码，减小了各模块之间的相互依存关系，因此理论上讲， 你能够在本身的项目中独立地使用任何模块，而不须要使用整个包。java
下载和安装
自动安装： Tornado 已经列入 PyPI ，所以能够经过 pip 或者 easy_install 来安装。若是你没有安装 libcurl 的话，你须要将其单独安装到系统中。请参见下面的安装依赖一节。注意一点，使用 pip 或 easy_install 安装的 Tornado 并无包含源代码中的 demo 程序。node
手动安装： 下载 tornado-2.0.tar.gzpython
tar xvzf tornado-2.0.tar.gz cd tornado-2.0 python setup.py build sudo python setup.py install
Tornado 的代码托管在 GitHub 上面。对于 Python 2.6 以上的版本，由于标准库中已经包括了对 epoll 的支持，因此你能够不用 setup.py 编译安装，只要简单地将 tornado 的目录添加到 PYTHONPATH 就可使用了。jquery
安装需求
Tornado 在 Python 2.5, 2.6, 2.7 中都通过了测试。要使用 Tornado 的全部功能，你须要安装 PycURL (7.18.2 或更高版本) 以及 simplejson (仅适用于Python 2.5，2.6 之后的版本标准库当中已经包含了对 JSON 的支持)。为方便起见，下面将列出 Mac OS X 和 Ubuntu 中的完整安装方式：ios
Mac OS X 10.6 (Python 2.6+)nginx
sudo easy_install setuptools pycurl
Ubuntu Linux (Python 2.6+)
sudo apt-get install python-pycurl
Ubuntu Linux (Python 2.5)
sudo apt-get install python-dev python-pycurl python-simplejson
模块索引
最重要的一个模块是web， 它就是包含了 Tornado 的大部分主要功能的 Web 框架。其它的模块都是工具性质的， 以便让 web 模块更加有用 后面的 Tornado 攻略 详细讲解了 web 模块的使用方法。
主要模块
web- FriendFeed 使用的基础 Web 框架，包含了 Tornado 的大多数重要的功能escape- XHTML, JSON, URL 的编码/解码方法database- 对MySQLdb的简单封装，使其更容易使用template- 基于 Python 的 web 模板系统httpclient- 非阻塞式 HTTP 客户端，它被设计用来和web及httpserver协同工做auth- 第三方认证的实现（包括 Google OpenID/OAuth、Facebook Platform、Yahoo BBAuth、FriendFeed OpenID/OAuth、Twitter OAuth）locale- 针对本地化和翻译的支持options- 命令行和配置文件解析工具，针对服务器环境作了优化
底层模块
httpserver- 服务于web模块的一个很是简单的 HTTP 服务器的实现iostream- 对非阻塞式的 socket 的简单封装，以方便经常使用读写操做ioloop- 核心的 I/O 循环
Tornado 攻略
请求处理程序和请求参数
Tornado 的 Web 程序会将 URL 或者 URL 范式映射到 tornado.web.RequestHandler 的子类上去。在其子类中定义了 get() 或 post() 方法，用以处理不一样的 HTTP 请求。
下面的代码将 URL 根目录 / 映射到 MainHandler，还将一个 URL 范式 /story/([0-9]+) 映射到 StoryHandler。正则表达式匹配的分组会做为参数引入 的相应方法中：
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write("You requested the main page")
class StoryHandler(tornado.web.RequestHandler):
def get(self, story_id):
self.write("You requested the story " + story_id)
application = tornado.web.Application([
(r"/", MainHandler),
(r"/story/([0-9]+)", StoryHandler),
])
你可使用 get_argument() 方法来获取查询字符串参数，以及解析 POST 的内容：
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write('<html><body><form action="/" method="post">'
'<input type="text" name="message">'
'<input type="submit" value="Submit">'
'</form></body></html>')
def post(self):
self.set_header("Content-Type", "text/plain")
self.write("You wrote " + self.get_argument("message"))
上传的文件能够经过 self.request.files 访问到，该对象将名称（HTML元素 <input type="file">的 name 属性）对应到一个文件列表。每个文件都以字典的形式 存在，其格式为 {"filename":..., "content_type":..., "body":...}。
若是你想要返回一个错误信息给客户端，例如“403 unauthorized”，只须要抛出一个 tornado.web.HTTPError 异常：
if not self.user_is_logged_in():
raise tornado.web.HTTPError(403)
请求处理程序能够经过 self.request 访问到表明当前请求的对象。该 HTTPRequest 对象包含了一些有用的属性，包括：
arguments- 全部的GET或POST的参数files- 全部经过multipart/form-dataPOST 请求上传的文件path- 请求的路径（?以前的全部内容）headers- 请求的开头信息
你能够经过查看源代码 httpserver 模组中 HTTPRequest 的定义，从而了解到它的 全部属性。
重写 RequestHandler 的方法函数
除了 get()/post()等之外，RequestHandler 中的一些别的方法函数，这都是 一些空函数，它们存在的目的是在必要时在子类中从新定义其内容。对于一个请求的处理 的代码调用次序以下：
- 程序为每个请求建立一个 RequestHandler 对象
- 程序调用
initialize()函数，这个函数的参数是Application配置中的关键字 参数定义。（initialize方法是 Tornado 1.1 中新添加的，旧版本中你须要 重写__init__以达到一样的目的）initialize方法通常只是把传入的参数存 到成员变量中，而不会产生一些输出或者调用像send_error之类的方法。 - 程序调用
prepare()。不管使用了哪一种 HTTP 方法，prepare都会被调用到，所以 这个方法一般会被定义在一个基类中，而后在子类中重用。prepare能够产生输出 信息。若是它调用了finish（或send_error` 等函数），那么整个处理流程 就此结束。 - 程序调用某个 HTTP 方法：例如
get()、post()、put()等。若是 URL 的正则表达式模式中有分组匹配，那么相关匹配会做为参数传入方法。
下面是一个示范 initialize() 方法的例子：
class ProfileHandler(RequestHandler):
def initialize(self, database):
self.database = database
def get(self, username):
...
app = Application([
(r'/user/(.*)', ProfileHandler, dict(database=database)),
])
其它设计用来被复写的方法有：
get_error_html(self, status_code, exception=None, **kwargs)- 以字符串的形式 返回 HTML，以供错误页面使用。get_current_user(self)- 查看下面的用户认证一节get_user_locale(self)- 返回locale对象，以供当前用户使用。get_login_url(self)- 返回登陆网址，以供@authenticated装饰器使用（默认位置 在Application设置中）get_template_path(self)- 返回模板文件的路径（默认是Application中的设置）
重定向(redirect)
Tornado 中的重定向有两种主要方法：self.redirect，或者使用 RedirectHandler。
你能够在使用 RequestHandler （例如 get）的方法中使用 self.redirect，将用户 重定向到别的地方。另外还有一个可选参数 permanent，你能够用它指定此次操做为永久性重定向。
该参数会激发一个 301 Moved Permanently HTTP 状态，这在某些状况下是有用的， 例如，你要将页面的原始连接重定向时，这种方式会更有利于搜索引擎优化（SEO）。
permanent 的默认值是 False，这是为了适用于常见的操做，例如用户端在成功发送 POST 请求 之后的重定向。
self.redirect('/some-canonical-page', permanent=True)
RedirectHandler 会在你初始化 Application 时自动生成。
例如本站的下载 URL，由较短的 URL 重定向到较长的 URL 的方式是这样的：
application = tornado.wsgi.WSGIApplication([
(r"/([a-z]*)", ContentHandler),
(r"/static/tornado-0.2.tar.gz", tornado.web.RedirectHandler,
dict(url="http://github.com/downloads/facebook/tornado/tornado-0.2.tar.gz")),
], **settings)
RedirectHandler 的默认状态码是 301 Moved Permanently，不过若是你想使用 302 Found 状态码，你须要将 permanent 设置为 False。
application = tornado.wsgi.WSGIApplication([
(r"/foo", tornado.web.RedirectHandler, {"url":"/bar", "permanent":False}),
], **settings)
注意，在 self.redirect 和 RedirectHandler 中，permanent 的默认值是不一样的。 这样作是有必定道理的，self.redirect 一般会被用在自定义方法中，是由逻辑事件触发 的（例如环境变动、用户认证、以及表单提交）。而 RedirectHandler 是在每次匹配到请求 URL 时被触发。
模板
你能够在 Tornado 中使用任何一种 Python 支持的模板语言。可是相较于其它模板而言， Tornado 自带的模板系统速度更快，而且也更灵活。具体能够查看 template 模块的源码。
Tornado 模板其实就是 HTML 文件（也能够是任何文本格式的文件），其中包含了 Python 控制结构和表达式，这些控制结构和表达式须要放在规定的格式标记符(markup)中：
<html>
<head>
<title>{{ title }}</title>
</head>
<body>
<ul>
{% for item in items %}
<li>{{ escape(item) }}</li>
{% end %}
</ul>
</body>
</html>
若是你把上面的代码命名为 "template.html"，保存在 Python 代码的同一目录中，你就能够 这样来渲染它：
class MainHandler(tornado.web.RequestHandler):
def get(self):
items = ["Item 1", "Item 2", "Item 3"]
self.render("template.html", title="My title", items=items)
Tornado 的模板支持“控制语句”和“表达语句”，控制语句是使用 {% 和 %} 包起来的 例如 {% if len(items) > 2 %}。表达语句是使用 {{ 和 }} 包起来的，例如 {{ items[0] }}。
控制语句和对应的 Python 语句的格式基本彻底相同。咱们支持 if、for、while 和 try，这些语句逻辑结束的位置须要用 {% end %} 作标记。咱们还经过 extends 和 block 语句实现了模板继承。这些在 template 模块 的代码文档中有着详细的描述。
表达语句能够是包括函数调用在内的任何 Python 表述。模板中的相关代码，会在一个单独 的名字空间中被执行，这个名字空间包括了如下的一些对象和方法。（注意，下面列表中 的对象或方法在使用 RequestHandler.render 或者 render_string 时才存在的 ，若是你在 RequestHandler 外面直接使用 template 模块，则它们中的大部分是不存在的）。
escape:tornado.escape.xhtml_escape的別名xhtml_escape:tornado.escape.xhtml_escape的別名url_escape:tornado.escape.url_escape的別名json_encode:tornado.escape.json_encode的別名squeeze:tornado.escape.squeeze的別名linkify:tornado.escape.linkify的別名datetime: Python 的datetime模组handler: 当前的RequestHandler对象request:handler.request的別名current_user:handler.current_user的別名locale:handler.locale的別名_:handler.locale.translate的別名static_url: forhandler.static_url的別名xsrf_form_html:handler.xsrf_form_html的別名reverse_url:Application.reverse_url的別名Application设置中ui_methods和ui_modules下面的全部项目- 任何传递给
render或者render_string的关键字参数
当你制做一个实际应用时，你会须要用到 Tornado 模板的全部功能，尤为是 模板继承功能。全部这些功能均可以在 template 模块 的代码文档中了解到。（其中一些功能是在 web 模块中实现的，例如 UIModules）
从实现方式来说，Tornado 的模板会被直接转成 Python 代码。模板中的语句会逐字复制到一个 表明模板的函数中去。咱们不会对模板有任何限制，Tornado 模板模块的设计宗旨就是要比 其余模板系统更灵活并且限制更少。因此，当你的模板语句里发生了随机的错误，在执行模板时 你就会看到随机的 Python 错误信息。
全部的模板输出都已经经过 tornado.escape.xhtml_escape 自动转义(escape)，这种默认行为， 能够经过如下几种方式修改：将 autoescape=None 传递给 Application 或者 TemplateLoader、 在模板文件中加入 {% autoescape None %}、或者在简单表达语句 {{ ... }} 写成 {% raw ...%}。另外你能够在上述位置将 autoescape 设为一个自定义函数，而不只仅是 None。
Cookie 和安全 Cookie
你可使用 set_cookie 方法在用户的浏览中设置 cookie：
class MainHandler(tornado.web.RequestHandler):
def get(self):
if not self.get_cookie("mycookie"):
self.set_cookie("mycookie", "myvalue")
self.write("Your cookie was not set yet!")
else:
self.write("Your cookie was set!")
Cookie 很容易被恶意的客户端伪造。加入你想在 cookie 中保存当前登录用户的 id 之类的信息，你须要对 cookie 做签名以防止伪造。Tornado 经过 set_secure_cookie 和 get_secure_cookie 方法直接支持了这种功能。 要使用这些方法，你须要在建立应用时提供一个密钥，名字为 cookie_secret。 你能够把它做为一个关键词参数传入应用的设置中：
application = tornado.web.Application([
(r"/", MainHandler),
], cookie_secret="61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=")
签名过的 cookie 中包含了编码过的 cookie 值，另外还有一个时间戳和一个 HMAC 签名。若是 cookie 已通过期或者 签名不匹配，get_secure_cookie 将返回 None，这和没有设置 cookie 时的 返回值是同样的。上面例子的安全 cookie 版本以下：
class MainHandler(tornado.web.RequestHandler):
def get(self):
if not self.get_secure_cookie("mycookie"):
self.set_secure_cookie("mycookie", "myvalue")
self.write("Your cookie was not set yet!")
else:
self.write("Your cookie was set!")
用户认证
当前已经认证的用户信息被保存在每个请求处理器的 self.current_user 当中， 同时在模板的 current_user 中也是。默认状况下，current_user 为 None。
要在应用程序实现用户认证的功能，你须要复写请求处理中 get_current_user() 这 个方法，在其中断定当前用户的状态，好比经过 cookie。下面的例子让用户简单地使用一个 nickname 登录应用，该登录信息将被保存到 cookie 中：
class BaseHandler(tornado.web.RequestHandler):
def get_current_user(self):
return self.get_secure_cookie("user")
class MainHandler(BaseHandler):
def get(self):
if not self.current_user:
self.redirect("/login")
return
name = tornado.escape.xhtml_escape(self.current_user)
self.write("Hello, " + name)
class LoginHandler(BaseHandler):
def get(self):
self.write('<html><body><form action="/login" method="post">'
'Name: <input type="text" name="name">'
'<input type="submit" value="Sign in">'
'</form></body></html>')
def post(self):
self.set_secure_cookie("user", self.get_argument("name"))
self.redirect("/")
application = tornado.web.Application([
(r"/", MainHandler),
(r"/login", LoginHandler),
], cookie_secret="61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=")
对于那些必需要求用户登录的操做，可使用装饰器 tornado.web.authenticated。 若是一个方法套上了这个装饰器，可是当前用户并无登录的话，页面会被重定向到 login_url（应用配置中的一个选项），上面的例子能够被改写成：
class MainHandler(BaseHandler):
@tornado.web.authenticated
def get(self):
name = tornado.escape.xhtml_escape(self.current_user)
self.write("Hello, " + name)
settings = {
"cookie_secret": "61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
"login_url": "/login",
}
application = tornado.web.Application([
(r"/", MainHandler),
(r"/login", LoginHandler),
], **settings)
若是你使用 authenticated 装饰器来装饰 post() 方法，那么在用户没有登录的状态下， 服务器会返回 403 错误。
Tornado 内部集成了对第三方认证形式的支持，好比 Google 的 OAuth 。参阅 auth 模块 的代码文档以了解更多信息。 for more details. Checkauth 模块以了解更多的细节。在 Tornado 的源码中有一个 Blog 的例子，你也能够从那里看到 用户认证的方法（以及如何在 MySQL 数据库中保存用户数据）。
跨站伪造请求的防范
跨站伪造请求(Cross-site request forgery)， 简称为 XSRF，是个性化 Web 应用中常见的一个安全问题。前面的连接也详细讲述了 XSRF 攻击的实现方式。
当前防范 XSRF 的一种通用的方法，是对每个用户都记录一个没法预知的 cookie 数据，而后要求全部提交的请求中都必须带有这个 cookie 数据。若是此数据不匹配 ，那么这个请求就多是被伪造的。
Tornado 有内建的 XSRF 的防范机制，要使用此机制，你须要在应用配置中加上 xsrf_cookies 设定：
settings = {
"cookie_secret": "61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
"login_url": "/login",
"xsrf_cookies": True,
}
application = tornado.web.Application([
(r"/", MainHandler),
(r"/login", LoginHandler),
], **settings)
若是设置了 xsrf_cookies，那么 Tornado 的 Web 应用将对全部用户设置一个 _xsrf 的 cookie 值，若是 POST PUT DELET 请求中没有这 个 cookie 值，那么这个请求会被直接拒绝。若是你开启了这个机制，那么在全部 被提交的表单中，你都须要加上一个域来提供这个值。你能够经过在模板中使用 专门的函数 xsrf_form_html() 来作到这一点：
<form action="/new_message" method="post">
{{ xsrf_form_html() }}
<input type="text" name="message"/>
<input type="submit" value="Post"/>
</form>
若是你提交的是 AJAX 的 POST 请求，你仍是须要在每个请求中经过脚本添加上 _xsrf 这个值。下面是在 FriendFeed 中的 AJAX 的 POST 请求，使用了 jQuery 函数来为全部请求组东添加 _xsrf 值：
function getCookie(name) {
var r = document.cookie.match("\\b" + name + "=([^;]*)\\b");
return r ? r[1] : undefined;
}
jQuery.postJSON = function(url, args, callback) {
args._xsrf = getCookie("_xsrf");
$.ajax({url: url, data: $.param(args), dataType: "text", type: "POST",
success: function(response) {
callback(eval("(" + response + ")"));
}});
};
对于 PUT 和 DELETE 请求（以及不使用将 form 内容做为参数的 POST 请求） 来讲，你也能够在 HTTP 头中以 X-XSRFToken 这个参数传递 XSRF token。
若是你须要针对每个请求处理器定制 XSRF 行为，你能够重写 RequestHandler.check_xsrf_cookie()。例如你须要使用一个不支持 cookie 的 API， 你能够经过将 check_xsrf_cookie() 函数设空来禁用 XSRF 保护机制。然而若是 你须要同时支持 cookie 和非 cookie 认证方式，那么只要当前请求是经过 cookie 进行认证的，你就应该对其使用 XSRF 保护机制，这一点相当重要。
静态文件和主动式文件缓存
你能经过在应用配置中指定 static_path 选项来提供静态文件服务：
settings = {
"static_path": os.path.join(os.path.dirname(__file__), "static"),
"cookie_secret": "61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
"login_url": "/login",
"xsrf_cookies": True,
}
application = tornado.web.Application([
(r"/", MainHandler),
(r"/login", LoginHandler),
(r"/(apple-touch-icon\.png)", tornado.web.StaticFileHandler, dict(path=settings['static_path'])),
], **settings)
这样配置后，全部以 /static/ 开头的请求，都会直接访问到指定的静态文件目录， 好比 http://localhost:8888/static/foo.png 会从指定的静态文件目录中访问到 foo.png 这个文件。同时 /robots.txt 和 /favicon.ico 也是会自动做为静态文件处理（即便它们不是以 /static/ 开头）。
在上述配置中，咱们使用 StaticFileHandler 特别指定了让 Tornado 从根目录伺服 apple-touch-icon.png 这个文件，尽管它的物理位置仍是在静态文件目录中。（正则表达式 的匹配分组的目的是向 StaticFileHandler 指定所请求的文件名称，抓取到的分组会以 方法参数的形式传递给处理器。）经过相同的方式，你也能够从站点的更目录伺服 sitemap.xml 文件。固然，你也能够经过在 HTML 中使用正确的 <link /> 标签来避免这样的根目录 文件伪造行为。
为了提升性能，在浏览器主动缓存静态文件是个不错的主意。这样浏览器就不须要发送 没必要要的 If-Modified-Since 和 Etag 请求，从而影响页面的渲染速度。 Tornado 能够经过内建的“静态内容分版(static content versioning)”来直接支持这种功能。
要使用这个功能，在模板中就不要直接使用静态文件的 URL 地址了，你须要在 HTML 中使用 static_url() 这个方法来提供 URL 地址：
<html>
<head>
<title>FriendFeed - {{ _("Home") }}</title>
</head>
<body>
<div><img src="{{ static_url("images/logo.png") }}"/></div>
</body>
</html>
static_url() 函数会将相对地址转成一个相似于 /static/images/logo.png?v=aae54 的 URI，v 参数是 logo.png 文件的散列值， Tornado 服务器会把它发给浏览器，并以此为依据让浏览器对相关内容作永久缓存。
因为 v 的值是基于文件的内容计算出来的，若是你更新了文件，或者重启了服务器 ，那么就会获得一个新的 v 值，这样浏览器就会请求服务器以获取新的文件内容。 若是文件的内容没有改变，浏览器就会一直使用本地缓存的文件，这样能够显著提升页 面的渲染速度。
在生产环境下，你可能会使用nginx这样的更有利于静态文件 伺服的服务器，你能够将 Tornado 的文件缓存指定到任何静态文件服务器上面，下面 是 FriendFeed 使用的 nginx 的相关配置：
location /static/ {
root /var/friendfeed/static;
if ($query_string) {
expires max;
}
}
本地化
无论有没有登录，当前用户的 locale 设置能够经过两种方式访问到：请求处理器的 self.locale 对象、以及模板中的 locale 值。Locale 的名称（如 en_US）能够 经过 locale.name 这个变量访问到，你可使用 locale.translate 来进行本地化 翻译。在模板中，有一个全局方法叫 _()，它的做用就是进行本地化的翻译。这个 翻译方法有两种使用形式：
_("Translate this string")
它会基于当前 locale 设置直接进行翻译，还有一种是：
_("A person liked this", "%(num)d people liked this", len(people)) % {"num": len(people)}
这种形式会根据第三个参数来决定是使用单数或是复数的翻译。上面的例子中，若是 len(people) 是 1 的话，就使用第一种形式的翻译，不然，就使用第二种形式 的翻译。
经常使用的翻译形式是使用 Python 格式化字符串时的“固定占位符(placeholder)”语法，（例如上面的 %(num)d），和普通占位符比起来，固定占位符的优点是使用时没有顺序限制。
一个本地化翻译的模板例子：
<html>
<head>
<title>FriendFeed - {{ _("Sign in") }}</title>
</head>
<body>
<form action="{{ request.path }}" method="post">
<div>{{ _("Username") }} <input type="text" name="username"/></div>
<div>{{ _("Password") }} <input type="password" name="password"/></div>
<div><input type="submit" value="{{ _("Sign in") }}"/></div>
{{ xsrf_form_html() }}
</form>
</body>
</html>
默认状况下，咱们经过 Accept-Language 这个头来断定用户的 locale，若是没有， 则取 en_US 这个值。若是但愿用户手动设置一个 locale 偏好，能够在处理请求的 类中复写 get_user_locale 方法：
class BaseHandler(tornado.web.RequestHandler):
def get_current_user(self):
user_id = self.get_secure_cookie("user")
if not user_id: return None
return self.backend.get_user_by_id(user_id)
def get_user_locale(self):
if "locale" not in self.current_user.prefs:
# Use the Accept-Language header
return None
return self.current_user.prefs["locale"]
若是 get_user_locale 返回 None，那么就会再去取 Accept-Language header 的值。
你可使用 tornado.locale.load_translations 方法获取应用中的全部已存在的翻 译。它会找到包含有特定名字的 CSV 文件的目录，如 es_GT.csv fr_CA.csv 这 些 csv 文件。而后从这些 CSV 文件中读取出全部的与特定语言相关的翻译内容。典型的用例 里面，咱们会在 Tornado 服务器的 main() 方法中调用一次该函数：
def main():
tornado.locale.load_translations(
os.path.join(os.path.dirname(__file__), "translations"))
start_server()
你可使用 tornado.locale.get_supported_locales() 方法获得支持的 locale 列表。Tornado 会依据用户当前的 locale 设置以及已有的翻译，为用户选择 一个最佳匹配的显示语言。好比，用户的 locale 是 es_GT 而翻译中只支持了 es， 那么 self.locale 就会被设置为 es。若是找不到最接近的 locale 匹配，self.locale 就会就会取备用值 es_US。
查看 locale 模块 的代码文档以了解 CSV 文件的格式，以及其它的本地化方法函数。
UI 模块
Tornado 支持一些 UI 模块，它们能够帮你建立标准的，易被重用的应用程序级的 UI 组件。 这些 UI 模块就跟特殊的函数调用同样，能够用来渲染页面组件，而这些组件能够有本身的 CSS 和 JavaScript。
例如你正在写一个博客的应用，你但愿在首页和单篇文章的页面都显示文章列表，你能够建立 一个叫作 Entry 的 UI 模块，让他在两个地方分别显示出来。首选须要为你的 UI 模块 建立一个 Python 模组文件，就叫 uimodules.py 好了:
class Entry(tornado.web.UIModule):
def render(self, entry, show_comments=False):
return self.render_string(
"module-entry.html", entry=entry, show_comments=show_comments)
而后经过 ui_modules 配置项告诉 Tornado 在应用当中使用 uimodules.py：
class HomeHandler(tornado.web.RequestHandler):
def get(self):
entries = self.db.query("SELECT * FROM entries ORDER BY date DESC")
self.render("home.html", entries=entries)
class EntryHandler(tornado.web.RequestHandler):
def get(self, entry_id):
entry = self.db.get("SELECT * FROM entries WHERE id = %s", entry_id)
if not entry: raise tornado.web.HTTPError(404)
self.render("entry.html", entry=entry)
settings = {
"ui_modules": uimodules,
}
application = tornado.web.Application([
(r"/", HomeHandler),
(r"/entry/([0-9]+)", EntryHandler),
], **settings)
在 home.html 中，你不须要写繁复的 HTML 代码，只要引用 Entry 就能够了：
{% for entry in entries %}
{% module Entry(entry) %}
{% end %}
在 entry.html 里面，你须要使用 show_comments 参数来引用 Entry 模块，用来 显示展开的 Entry 内容：
{% module Entry(entry, show_comments=True) %}
你能够为 UI 模型配置本身的 CSS 和 JavaScript ，只要复写 embedded_css、 embedded_javascript、javascipt_files、css_files 就能够了：
class Entry(tornado.web.UIModule):
def embedded_css(self):
return ".entry { margin-bottom: 1em; }"
def render(self, entry, show_comments=False):
return self.render_string(
"module-entry.html", show_comments=show_comments)
即便一页中有多个相同的 UI 组件，UI 组件的 CSS 和 JavaScript 部分只会被渲染一次。 CSS 是在页面的 <head> 部分，而 JavaScript 被渲染在页面结尾 </body> 以前的位 置。
在不须要额外 Python 代码的状况下，模板文件也能够当作 UI 模块直接使用。 例如前面的例子能够如下面的方式实现，只要把这几行放到 module-entry.html 中就能够了：
{{ set_resources(embedded_css=".entry { margin-bottom: 1em; }") }}
<!-- more template html... -->
这个修改过的模块式模板能够经过下面的方法调用：
{% module Template("module-entry.html", show_comments=True) %}
set_resources 函数只能在 {% module Template(...) %} 调用的模板中访问到。 和 {% include ... %} 不一样，模块式模板使用了和它们的上级模板不一样的命名 空间——它们只能访问到全局模板命名空间和它们本身的关键字参数。
非阻塞式异步请求
当一个处理请求的行为被执行以后，这个请求会自动地结束。由于 Tornado 当中使用了 一种非阻塞式的 I/O 模型，因此你能够改变这种默认的处理行为——让一个请求一直保持 链接状态，而不是立刻返回，直到一个主处理行为返回。要实现这种处理方式，只须要 使用 tornado.web.asynchronous 装饰器就能够了。
使用了这个装饰器以后，你必须调用 self.finish() 已完成 HTTTP 请求，不然 用户的浏览器会一直处于等待服务器响应的状态：
class MainHandler(tornado.web.RequestHandler):
@tornado.web.asynchronous
def get(self):
self.write("Hello, world")
self.finish()
下面是一个使用 Tornado 内置的异步请求 HTTP 客户端去调用 FriendFeed 的 API 的例 子：
class MainHandler(tornado.web.RequestHandler):
@tornado.web.asynchronous
def get(self):
http = tornado.httpclient.AsyncHTTPClient()
http.fetch("http://friendfeed-api.com/v2/feed/bret",
callback=self.on_response)
def on_response(self, response):
if response.error: raise tornado.web.HTTPError(500)
json = tornado.escape.json_decode(response.body)
self.write("Fetched " + str(len(json["entries"])) + " entries "
"from the FriendFeed API")
self.finish()
例子中，当 get() 方法返回时，请求处理尚未完成。在 HTTP 客户端执行它的回 调函数 on_response() 时，从浏览器过来的请求仍然是存在的，只有在显式调用了 self.finish() 以后，才会把响应返回到浏览器。
关于更多异步请求的高级例子，能够参阅 demo 中的 chat 这个例子。它是一个使用 long polling 方式 的 AJAX 聊天室。若是你使用到了 long polling，你可能须要复写on_connection_close()， 这样你能够在客户链接关闭之后作相关的清理动做。（请查看该方法的代码文档，以防误用。）
异步 HTTP 客户端
Tornado 包含了两种非阻塞式 HTTP 客户端实现：SimpleAsyncHTTPClient 和 CurlAsyncHTTPClient。前者是直接基于 IOLoop 实现的，所以无需外部依赖关系。 后者做为 Curl 客户端，须要安装 libcurl 和 pycurl 后才能正常工做，可是对于使用 到 HTTP 规范中一些不经常使用内容的站点来讲，它的兼容性会更好。为防止碰到 旧版本中异步界面的 bug，咱们建议你安装最近的版本的 libcurl 和 pycurl。
这些客户端都有它们本身的模组(tornado.simple_httpclient 和 tornado.curl_httpclient)，你能够经过 tornado.httpclient 来指定使用哪种 客户端，默认状况下使用的是 SimpleAsyncHTTPClient，若是要修改默认值，只要 在一开始调用 AsyncHTTPClient.configure 方法便可：
AsyncHTTPClient.configure('tornado.curl_httpclient.CurlAsyncHTTPClient')
第三方认证
Tornado 的 auth 模块实现了如今不少流行站点的用户认证方式，包括 Google/Gmail、Facebook、Twitter、Yahoo 以及 FriendFeed。这个模块可让用户使用 这些站点的帐户来登录你本身的应用，而后你就能够在受权的条件下访问原站点的一些服 务，好比下载用户的地址薄，在 Twitter 上发推等。
下面的例子使用了 Google 的帐户认证，Google 帐户的身份被保存到 cookie 当中，以便 之后的访问使用：
class GoogleHandler(tornado.web.RequestHandler, tornado.auth.GoogleMixin):
@tornado.web.asynchronous
def get(self):
if self.get_argument("openid.mode", None):
self.get_authenticated_user(self._on_auth)
return
self.authenticate_redirect()
def _on_auth(self, user):
if not user:
self.authenticate_redirect()
return
# Save the user with, e.g., set_secure_cookie()
请查看 auth 模块的代码文档以了解更多的细节。
调试模式和自动重载
若是你将 debug=True 传递给 Application 构造器，该 app 将以调试模式 运行。在调试模式下，模板将不会被缓存，而这个 app 会监视代码文件的修改， 若是发现修改动做，这个 app 就会被从新加载。在开发过程当中，这会大大减小 手动重启服务的次数。然而有些问题（例如 import 时的语法错误）仍是会让服务器 下线，目前的 debug 模式还没法避免这些状况。
调试模式和 HTTPServer 的多进程模式不兼容。在调试模式下，你必须将 HTTPServer.start 的参数设为不大于 1 的数字。
调试模式下的自动重载功能能够经过独立的模块 tornado.autoreload 调用， 做为测试运行器的一个可选项目，tornado.testing.main 中也有用到它。
性能
一个 Web 应用的性能表现，主要看它的总体架构，而不只仅是前端的表现。 和其它的 Python Web 框架相比，Tornado 的速度要快不少。
咱们在一些流行的 Python Web 框架上（Django、 web.py、CherryPy）， 针对最简单的 Hello, world 例子做了一个测试。对于 Django 和 web.py，咱们使用 Apache/mod_wsgi 的方式来带，CherryPy 就让它本身裸跑。这也是在生产环境中各框架经常使用 的部署方案。对于咱们的 Tornado，使用的部署方案为前端使用 nginx 作反向代理，带动 4 个线程模式的 Tornado，这种方案也是咱们推荐的在生产环境下的 Tornado 部署方案（根据具体的硬件状况，咱们推荐一个 CPU 核对应一个 Tornado 伺服实例， 咱们的负载测试使用的是四核处理器）。
咱们使用 Apache Benchmark (ab)，在另一台机器上使用了以下指令进行负载测试：
ab -n 100000 -c 25 http://10.0.1.x/
在 AMD Opteron 2.4GHz 的四核机器上，结果以下图所示：
在咱们的测试当中，相较于第二快的服务器，Tornado 在数据上的表现也是它的 4 倍之 多。即便只用了一个 CPU 核的裸跑模式，Tornado 也有 33% 的优点。
这个测试不见得很是科学，不过从大致上你能够看出，咱们开发 Tornado 时对于性能 的注重程度。和其余的 Python Web 开发框架相比，它不会为你带来多少延时。
生产环境下的部署
在 FriendFeed 中，咱们使用 nginx 作负载均衡和静态文件伺服。 咱们在多台服务器上，同时部署了多个 Tornado 实例，一般，一个 CPU 内核 会对应一个 Tornado 线程。
由于咱们的 Web 服务器是跑在负载均衡服务器（如 nginx）后面的，因此须要把 xheaders=True 传到 HTTPServer 的构造器当中去。这是为了让 Tornado 使用 X-Real-IP 这样的的 header 信息来获取用户的真实 IP地址，若是使用传统 的方法，你只能获得这台负载均衡服务器的 IP 地址。
下面是 nginx 配置文件的一个示例，总体上与咱们在 FriendFeed 中使用的差很少。 它假设 nginx 和 Tornado 是跑在同一台机器上的，四个 Tornado 服务跑在 8000-8003 端口上：
user nginx;
worker_processes 1;
error_log /var/log/nginx/error.log;
pid /var/run/nginx.pid;
events {
worker_connections 1024;
use epoll;
}
http {
# Enumerate all the Tornado servers here
upstream frontends {
server 127.0.0.1:8000;
server 127.0.0.1:8001;
server 127.0.0.1:8002;
server 127.0.0.1:8003;
}
include /etc/nginx/mime.types;
default_type application/octet-stream;
access_log /var/log/nginx/access.log;
keepalive_timeout 65;
proxy_read_timeout 200;
sendfile on;
tcp_nopush on;
tcp_nodelay on;
gzip on;
gzip_min_length 1000;
gzip_proxied any;
gzip_types text/plain text/html text/css text/xml
application/x-javascript application/xml
application/atom+xml text/javascript;
# Only retry if there was a communication error, not a timeout
# on the Tornado server (to avoid propagating "queries of death"
# to all frontends)
proxy_next_upstream error;
server {
listen 80;
# Allow file uploads
client_max_body_size 50M;
location ^~ /static/ {
root /var/www;
if ($query_string) {
expires max;
}
}
location = /favicon.ico {
rewrite (.*) /static/favicon.ico;
}
location = /robots.txt {
rewrite (.*) /static/robots.txt;
}
location / {
proxy_pass_header Server;
proxy_set_header Host $http_host;
proxy_redirect false;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Scheme $scheme;
proxy_pass http://frontends;
}
}
}
WSGI 和 Google AppEngine
Tornado 对 WSGI 只提供了有限的支持，即便如此，由于 WSGI 并不支持非阻塞式的请求，因此若是你使用 WSGI 代替 Tornado 本身的 HTTP 服务的话，那么你将没法使用 Tornado 的异步非阻塞式的请求处理方式。 好比 @tornado.web.asynchronous、httpclient 模块、auth 模块， 这些将都没法使用。
你能够经过 wsgi 模块中的 WSGIApplication 建立一个有效的 WSGI 应用（区别于 咱们用过的 tornado.web.Application）。下面的例子展现了使用内置的 WSGI CGIHandler 来建立一个有效的 Google AppEngine 应用。
import tornado.web
import tornado.wsgi
import wsgiref.handlers
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write("Hello, world")
if __name__ == "__main__":
application = tornado.wsgi.WSGIApplication([
(r"/", MainHandler),
])
wsgiref.handlers.CGIHandler().run(application)
请查看 demo 中的 appengine 范例，它是一个基于 Tornado 的完整的 AppEngine 应用。
注意事项和社区支持
由于 FriendFeed 以及其余 Tornado 的主要用户在使用时都是基于 nginx或者 Apache 代理以后的。因此如今 Tornado 的 HTTP 服务部分并不完整，它没法处理多行的 header 信息，同时对于一 些非标准的输入也无能为力。
你能够在 Tornado 开发者邮件列表 中讨论和提交 bug。