重定向(redirect) Tornado 中的重定向有两种主要方法：self.redirect，或者使用RedirectHandler。
你可以在使用RequestHandler（例如get）的方法中使用self.redirect，将用户 重定向到别的地方。另外还有一个可选参数permanent，你可以用它指定这次操作为永久性重定向。
该参数会激发一个301 Moved PermanentlyHTTP 状态，这在某些情况下是有用的， 例如，你要将页面的原始链接重定向时，这种方式会更有利于搜索引擎优化（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)中：
{{ title }}
{% for item in items %}
{{ escape(item) }}
{% end %}
如果你把上面的代码命名为 "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('')
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 值，如果POSTPUTDELET请求中没有这 个 cookie 值，那么这个请求会被直接拒绝。如果你开启了这个机制，那么在所有 被提交的表单中，你都需要加上一个域来提供这个值。你可以通过在模板中使用 专门的函数xsrf_form_html()来做到这一点：
如果你提交的是 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 中使用正确的
为了提高性能，在浏览器主动缓存静态文件是个不错的主意。这样浏览器就不需要发送 不必要的If-Modified-Since和Etag请求，从而影响页面的渲染速度。 Tornado 可以通过内建的“静态内容分版(static content versioning)”来直接支持这种功能。
要使用这个功能，在模板中就不要直接使用静态文件的 URL 地址了，你需要在 HTML 中使用static_url()这个方法来提供 URL 地址：
FriendFeed - {{ _("Home") }}
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），和普通占位符比起来，固定占位符的优势是使用时没有顺序限制。
一个本地化翻译的模板例子：
FriendFeed - {{ _("Sign in") }}
默认情况下，我们通过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-Languageheader 的值。
你可以使用tornado.locale.load_translations方法获取应用中的所有已存在的翻 译。它会找到包含有特定名字的 CSV 文件的目录，如es_GT.csvfr_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 是在页面的
在不需要额外 Python 代码的情况下，模板文件也可以当做 UI 模块直接使用。 例如前面的例子可以以下面的方式实现，只要把这几行放到module-entry.html中就可以了：
{{ set_resources(embedded_css=".entry { margin-bottom: 1em; }") }}
这个修改过的模块式模板可以通过下面的方法调用：
{% 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）。下面的例子展示了使用内置的 WSGICGIHandler来创建一个有效的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。
