引言
回想Django的部署方式
以Django為代表的python web應用部署時采用wsgi協議與服務器對接（被服務器托管），而這類服務器通常都是基於多線程的，也就是說每一個網絡請求服務器都會有一個對應的線程來用web應用（如Django）進行處理。
考慮兩類應用場景
-
用戶量大，高並發
如秒殺搶購、雙十一某寶購物、春節搶火車票
-
大量的HTTP持久連接
使用同一個TCP連接來發送和接收多個HTTP請求/應答，而不是為每一個新的請求/應答打開新的連接的方法。
對於HTTP 1.0，可以在請求的包頭（Header）中添加Connection: Keep-Alive。
對於HTTP 1.1，所有的連接默認都是持久連接。
對於這兩種場景，通常基於多線程的服務器很難應對。
C10K問題
對於前文提出的這種高並發問題，我們通常用C10K這一概念來描述。C10K—— Concurrently handling ten thousand connections，即並發10000個連接。對於單台服務器而言，根本無法承擔，而采用多台服務器分布式又意味着高昂的成本。如何解決C10K問題？
Tornado
Tornado在設計之初就考慮到了性能因素，旨在解決C10K問題，這樣的設計使得其成為一個擁有非常高性能的解決方案（服務器與框架的集合體）。
1 關於Tornado
知識點
- 了解什么是Tornado框架
- 了解Tornado與Django的區別
1.1 Tornado是為何物
Tornado全稱Tornado Web Server，是一個用Python語言寫成的Web服務器兼Web應用框架，由FriendFeed公司在自己的網站FriendFeed中使用，被Facebook收購以后框架在2009年9月以開源軟件形式開放給大眾。
特點：
- 作為Web框架，是一個輕量級的Web框架，類似於另一個Python web框架Web.py，其擁有異步非阻塞IO的處理方式。
- 作為Web服務器，Tornado有較為出色的抗負載能力，官方用nginx反向代理的方式部署Tornado和其它Python web應用框架進行對比，結果最大瀏覽量超過第二名近40%。
性能： Tornado有着優異的性能。它試圖解決C10k問題，即處理大於或等於一萬的並發，下表是和一些其他Web框架與服務器的對比:
Tornado框架和服務器一起組成一個WSGI的全棧替代品。單獨在WSGI容器中使用tornado網絡框架或者tornaod http服務器，有一定的局限性，為了最大化的利用tornado的性能，推薦同時使用tornaod的網絡框架和HTTP服務器
1.2 Tornado與Django
Django
Django是走大而全的方向，注重的是高效開發，它最出名的是其全自動化的管理后台：只需要使用起ORM，做簡單的對象定義，它就能自動生成數據庫結構、以及全功能的管理后台。
Django提供的方便，也意味着Django內置的ORM跟框架內的其他模塊耦合程度高，應用程序必須使用Django內置的ORM，否則就不能享受到框架內提供的種種基於其ORM的便利。
- session功能
- 后台管理
- ORM
Tornado
Tornado走的是少而精的方向，注重的是性能優越，它最出名的是異步非阻塞的設計方式。
- HTTP服務器
- 異步編程
- WebSockets
2 初識Tornado
知識點
- Tornado的安裝
- 了解Tornado的原理
- 掌握Tornado的基本寫法
- 掌握Tornado的基本模塊
- tornado.web
- tornado.ioloop
- tornado.httpserver
- tornado.options
2.1 安裝
自動安裝
1.查看自己當前的環境是否已安裝
$ pip list
2.安裝
$ pip install tornado
手動安裝
- 下載安裝包tornado-4.3.tar.gz（https://pypi.python.org/packages/source/t/tornado/tornado-4.3.tar.gz）
$ tar xvzf tornado-4.3.tar.gz $ cd tornado-4.3 $ python setup.py build $ sudo python setup.py install
關於使用平台的說明
Tornado should run on any Unix-like platform, although for the best performance and scalability only Linux (with epoll) and BSD (with kqueue) are recommended for production deployment (even though Mac OS X is derived from BSD and supports kqueue, its networking performance is generally poor so it is recommended only for development use). Tornado will also run on Windows, although this configuration is not officially supported and is recommended only for development use.
Tornado應該運行在類Unix平台，在線上部署時為了最佳的性能和擴展性，僅推薦Linux和BSD（因為充分利用Linux的epoll工具和BSD的kqueue工具，是Tornado不依靠多進程/多線程而達到高性能的原因）。
對於Mac OS X，雖然也是衍生自BSD並且支持kqueue，但是其網絡性能通常不太給力，因此僅推薦用於開發。
對於Windows，Tornado官方沒有提供配置支持，但是也可以運行起來，不過僅推薦在開發中使用。
2.2 Hello Itcast
上代碼
新建文件hello.py，代碼如下：
# coding:utf-8 import tornado.web import tornado.ioloop class IndexHandler(tornado.web.RequestHandler): """主路由處理類""" def get(self): """對應http的get請求方式""" self.write("Hello Itcast!") if __name__ == "__main__": app = tornado.web.Application([ (r"/", IndexHandler), ]) app.listen(8000) tornado.ioloop.IOLoop.current().start()
執行如下命令，開啟tornado：
$ python hello.py打開瀏覽器，輸入網址127.0.0.1:8000（或localhost:8000），查看效果：
代碼講解
1. tornado.web
tornado的基礎web框架模塊
-
RequestHandler
封裝了對應一個請求的所有信息和方法，write(響應信息)就是寫響應信息的一個方法；對應每一種http請求方式（get、post等），把對應的處理邏輯寫進同名的成員方法中（如對應get請求方式，就將對應的處理邏輯寫在get()方法中），當沒有對應請求方式的成員方法時，會返回“405: Method Not Allowed”錯誤。
我們將代碼中定義的get()方法更改為post()后，再用瀏覽器重新訪問（瀏覽器地址欄中輸入網址訪問的方式為get請求方式），演示如下：
# coding:utf-8 import tornado.web import tornado.ioloop class IndexHandler(tornado.web.RequestHandler): """主路由處理類""" def post(self): # 我們修改了這里 """對應http的post請求方式""" self.write("Hello Itcast!") if __name__ == "__main__": app = tornado.web.Application([ (r"/", IndexHandler), ]) app.listen(8000) tornado.ioloop.IOLoop.current().start()
-
Application
Tornado Web框架的核心應用類，是與服務器對接的接口，里面保存了路由信息表，其初始化接收的第一個參數就是一個路由信息映射元組的列表；其listen(端口)方法用來創建一個http服務器實例，並綁定到給定端口（注意：此時服務器並未開啟監聽）。
2. tornado.ioloop
tornado的核心io循環模塊，封裝了Linux的epoll和BSD的kqueue，tornado高性能的基石。 以Linux的epoll為例，其原理如下圖：
-
IOLoop.current()
返回當前線程的IOLoop實例。
-
IOLoop.start()
啟動IOLoop實例的I/O循環,同時服務器監聽被打開。
總結Tornado Web程序編寫思路
- 創建web應用實例對象，第一個初始化參數為路由映射列表。
- 定義實現路由映射列表中的handler類。
- 創建服務器實例，綁定服務器端口。
- 啟動當前線程的IOLoop。
2.3 httpserver
上一節我們說在tornado.web.Application.listen()（示例代碼中的app.listen(8000)）的方法中，創建了一個http服務器示例並綁定到給定端口，我們能不能自己動手來實現這一部分功能呢？
現在我們修改上一示例代碼如下：
# coding:utf-8 import tornado.web import tornado.ioloop import tornado.httpserver # 新引入httpserver模塊 class IndexHandler(tornado.web.RequestHandler): """主路由處理類""" def get(self): """對應http的get請求方式""" self.write("Hello Itcast!") if __name__ == "__main__": app = tornado.web.Application([ (r"/", IndexHandler), ]) # ------------------------------ # 我們修改這個部分 # app.listen(8000) http_server = tornado.httpserver.HTTPServer(app) http_server.listen(8000) # ------------------------------ tornado.ioloop.IOLoop.current().start()
在這一修改版本中，我們引入了tornado.httpserver模塊，顧名思義，它就是tornado的HTTP服務器實現。
我們創建了一個HTTP服務器實例http_server，因為服務器要服務於我們剛剛建立的web應用，將接收到的客戶端請求通過web應用中的路由映射表引導到對應的handler中，所以在構建http_server對象的時候需要傳出web應用對象app。http_server.listen(8000)將服務器綁定到8000端口。
實際上一版代碼中app.listen(8000)正是對這一過程的簡寫。
單進程與多進程
我們剛剛實現的都是單進程，可以通過命令來查看：
$ ps -ef | grep hello.py
我們也可以一次啟動多個進程，修改上面的代碼如下：
# coding:utf-8 import tornado.web import tornado.ioloop import tornado.httpserver class IndexHandler(tornado.web.RequestHandler): """主路由處理類""" def get(self): """對應http的get請求方式""" self.write("Hello Itcast!") if __name__ == "__main__": app = tornado.web.Application([ (r"/", IndexHandler), ]) http_server = tornado.httpserver.HTTPServer(app) # -----------修改---------------- http_server.bind(8000) http_server.start(0) # ------------------------------ tornado.ioloop.IOLoop.current().start()
http_server.bind(port)方法是將服務器綁定到指定端口。
http_server.start(num_processes=1)方法指定開啟幾個進程，參數num_processes默認值為1，即默認僅開啟一個進程；如果num_processes為None或者<=0，則自動根據機器硬件的cpu核芯數創建同等數目的子進程；如果num_processes>0，則創建num_processes個子進程。
本例中，我們使用http_server.start(0)，而我的虛擬機設定cpu核數為2，演示結果：
我們在前面寫的http_server.listen(8000)實際上就等同於：
http_server.bind(8000)
http_server.start(1)
說明
1.關於app.listen()
app.listen()這個方法只能在單進程模式中使用。
對於app.listen()與手動創建HTTPServer實例
http_server = tornado.httpserver.HTTPServer(app)
http_server.listen(8000)
這兩種方式，建議大家先使用后者即創建HTTPServer實例的方式，因為其對於理解tornado web應用工作流程的完整性有幫助，便於大家記憶tornado開發的模塊組成和程序結構；在熟練使用后，可以改為簡寫。
2.關於多進程
雖然tornado給我們提供了一次開啟多個進程的方法，但是由於：
- 每個子進程都會從父進程中復制一份IOLoop實例，如過在創建子進程前我們的代碼動了IOLoop實例，那么會影響到每一個子進程，勢必會干擾到子進程IOLoop的工作；
- 所有進程是由一個命令一次開啟的，也就無法做到在不停服務的情況下更新代碼；
- 所有進程共享同一個端口，想要分別單獨監控每一個進程就很困難。
不建議使用這種多進程的方式，而是手動開啟多個進程，並且綁定不同的端口。
2.4 options
在前面的示例中我們都是將服務端口的參數寫死在程序中，很不靈活。
tornado為我們提供了一個便捷的工具，tornado.options模塊——全局參數定義、存儲、轉換。
tornado.options.define()
用來定義options選項變量的方法，定義的變量可以在全局的tornado.options.options中獲取使用，傳入參數：
- name 選項變量名，須保證全局唯一性，否則會報“Option 'xxx' already defined in ...”的錯誤；
- default 選項變量的默認值，如不傳默認為None；
- type 選項變量的類型，從命令行或配置文件導入參數的時候tornado會根據這個類型轉換輸入的值，轉換不成功時會報錯，可以是str、float、int、datetime、timedelta中的某個，若未設置則根據default的值自動推斷，若default也未設置，那么不再進行轉換。可以通過利用設置type類型字段來過濾不正確的輸入。
- multiple 選項變量的值是否可以為多個，布爾類型，默認值為False，如果multiple為True，那么設置選項變量時值與值之間用英文逗號分隔，而選項變量則是一個list列表（若默認值和輸入均未設置，則為空列表[]）。
- help 選項變量的幫助提示信息，在命令行啟動tornado時，通過加入命令行參數 --help 可以查看所有選項變量的信息（注意，代碼中需要加入tornado.options.parse_command_line()）。
tornado.options.options
全局的options對象，所有定義的選項變量都會作為該對象的屬性。
tornado.options.parse_command_line()
轉換命令行參數，並將轉換后的值對應的設置到全局options對象相關屬性上。追加命令行參數的方式是--myoption=myvalue
新建opt.py，我們用代碼來看一下如何使用：
# coding:utf-8 import tornado.web import tornado.ioloop import tornado.httpserver import tornado.options # 新導入的options模塊 tornado.options.define("port", default=8000, type=int, help="run server on the given port.") # 定義服務器監聽端口選項 tornado.options.define("itcast", default=[], type=str, multiple=True, help="itcast subjects.") # 無意義，演示多值情況 class IndexHandler(tornado.web.RequestHandler): """主路由處理類""" def get(self): """對應http的get請求方式""" self.write("Hello Itcast!") if __name__ == "__main__": tornado.options.parse_command_line() print tornado.options.options.itcast # 輸出多值選項 app = tornado.web.Application([ (r"/", IndexHandler), ]) http_server = tornado.httpserver.HTTPServer(app) http_server.listen(tornado.options.options.port) tornado.ioloop.IOLoop.current().start()
執行如下命令開啟程序：
$ python opt.py --port=9000 --itcast=python,c++,java,php,ios
效果如下：
tornado.options.parse_config_file(path)
從配置文件導入option，配置文件中的選項格式如下：
myoption = "myvalue" myotheroption = "myothervalue"
我們用代碼來看一下如何使用，新建配置文件config，注意字符串和列表按照python的語法格式：
port = 8000 itcast = ["python","c++","java","php","ios"]
修改opt.py文件：
# coding:utf-8 import tornado.web import tornado.ioloop import tornado.httpserver import tornado.options # 新導入的options模塊 tornado.options.define("port", default=8000, type=int, help="run server on the given port.") # 定義服務器監聽端口選項 tornado.options.define("itcast", default=[], type=str, multiple=True, help="itcast subjects.") # 無意義，演示多值情況 class IndexHandler(tornado.web.RequestHandler): """主路由處理類""" def get(self): """對應http的get請求方式""" self.write("Hello Itcast!") if __name__ == "__main__": tornado.options.parse_config_file("./config") # 僅僅修改了此處 print tornado.options.options.itcast # 輸出多值選項 app = tornado.web.Application([ (r"/", IndexHandler), ]) http_server = tornado.httpserver.HTTPServer(app) http_server.listen(tornado.options.options.port) tornado.ioloop.IOLoop.current().start()
說明
1. 日志
當我們在代碼中調用parse_command_line()或者parse_config_file()的方法時，tornado會默認為我們配置標准logging模塊，即默認開啟了日志功能，並向標准輸出（屏幕）打印日志信息。
如果想關閉tornado默認的日志功能，可以在命令行中添加--logging=none 或者在代碼中執行如下操作:
from tornado.options import options, parse_command_line options.logging = None parse_command_line()
2. 配置文件
我們看到在使用prase_config_file()的時候，配置文件的書寫格式仍需要按照python的語法要求，其優勢是可以直接將配置文件的參數轉換設置到全局對象tornado.options.options中；然而，其不方便的地方在於需要在代碼中調用tornado.options.define()來定義選項，而且不支持字典類型，故而在實際應用中大都不使用這種方法。
在使用配置文件的時候，通常會新建一個python文件（如config.py），然后在里面直接定義python類型的變量（可以是字典類型）；在需要配置文件參數的地方，將config.py作為模塊導入，並使用其中的變量參數。
如config.py文件：
# conding:utf-8 # Redis配置 redis_options = { 'redis_host':'127.0.0.1', 'redis_port':6379, 'redis_pass':'', } # Tornado app配置 settings = { 'template_path': os.path.join(os.path.dirname(__file__), 'templates'), 'static_path': os.path.join(os.path.dirname(__file__), 'statics'), 'cookie_secret':'0Q1AKOKTQHqaa+N80XhYW7KCGskOUE2snCW06UIxXgI=', 'xsrf_cookies':False, 'login_url':'/login', 'debug':True, } # 日志 log_path = os.path.join(os.path.dirname(__file__), 'logs/log')
使用config.py的模塊中導入config，如下：
# conding:utf-8 import tornado.web import config if __name__ = "__main__": app = tornado.web.Application([], **config.settings) ...
2.5 練習
-
嘗試解釋清Tornado利用epoll機制實現支持高並發的原因。
-
能夠不參考課件熟練默寫出Tornado的基本代碼案例。
3 深入Tornado
知識點
- Application設置
- debug模式
- 路由設置擴展
- RequestHandler的使用
- 輸入方法
- 輸出方法
- 可重寫接口
3.1 Application
settings
前面的學習中，我們在創建tornado.web.Application的對象時，傳入了第一個參數——路由映射列表。實際上Application類的構造函數還接收很多關於tornado web應用的配置參數，在后面的學習中我們用到的地方會為大家介紹。
我們先來學習一個參數：
debug，設置tornado是否工作在調試模式，默認為False即工作在生產模式。當設置debug=True 后，tornado會工作在調試/開發模式，在此種模式下，tornado為方便我們開發而提供了幾種特性：
- 自動重啟，tornado應用會監控我們的源代碼文件，當有改動保存后便會重啟程序，這可以減少我們手動重啟程序的次數。需要注意的是，一旦我們保存的更改有錯誤，自動重啟會導致程序報錯而退出，從而需要我們保存修正錯誤后手動啟動程序。這一特性也可單獨通過autoreload=True設置；
- 取消緩存編譯的模板，可以單獨通過compiled_template_cache=False來設置；
- 取消緩存靜態文件hash值，可以單獨通過static_hash_cache=False來設置；
- 提供追蹤信息，當RequestHandler或者其子類拋出一個異常而未被捕獲后，會生成一個包含追蹤信息的頁面，可以單獨通過serve_traceback=True來設置。
使用debug參數的方法：
import tornado.web app = tornado.web.Application([], debug=True)
路由映射
先前我們在構建路由映射列表的時候，使用的是二元元組，如：
[(r"/", IndexHandler),]
對於這個映射列表中的路由，實際上還可以傳入多個信息，如：
[ (r"/", Indexhandler), (r"/cpp", ItcastHandler, {"subject":"c++"}), url(r"/python", ItcastHandler, {"subject":"python"}, name="python_url") ]
對於路由中的字典，會傳入到對應的RequestHandler的initialize()方法中：
from tornado.web import RequestHandler class ItcastHandler(RequestHandler): def initialize(self, subject): self.subject = subject def get(self): self.write(self.subject)
對於路由中的name字段，注意此時不能再使用元組，而應使用tornado.web.url來構建。name是給該路由起一個名字，可以通過調用RequestHandler.reverse_url(name)來獲取該名子對應的url。
# coding:utf-8 import tornado.web import tornado.ioloop import tornado.httpserver import tornado.options from tornado.options import options, define from tornado.web import url, RequestHandler define("port", default=8000, type=int, help="run server on the given port.") class IndexHandler(RequestHandler): def get(self): python_url = self.reverse_url("python_url") self.write('<a href="%s">itcast</a>' % python_url) class ItcastHandler(RequestHandler): def initialize(self, subject): self.subject = subject def get(self): self.write(self.subject) if __name__ == "__main__": tornado.options.parse_command_line() app = tornado.web.Application([ (r"/", Indexhandler), (r"/cpp", ItcastHandler, {"subject":"c++"}), url(r"/python", ItcastHandler, {"subject":"python"}, name="python_url") ], debug = True) http_server = tornado.httpserver.HTTPServer(app) http_server.listen(options.port) tornado.ioloop.IOLoop.current().start()
3.2 輸入
下面幾節主要講解tornado.web.RequestHandler。
回想一下，利用HTTP協議向服務器傳參有幾種途徑？
- 查詢字符串（query string)，形如key1=value1&key2=value2；
- 請求體（body）中發送的數據，比如表單數據、json、xml；
- 提取uri的特定部分，如/blogs/2016/09/0001，可以在服務器端的路由中用正則表達式截取；
- 在http報文的頭（header）中增加自定義字段，如X-XSRFToken=itcast。
我們現在來看下tornado中為我們提供了哪些方法來獲取請求的信息。
1. 獲取查詢字符串參數
從請求的查詢字符串中返回指定參數name的值，如果出現多個同名參數，則返回最后一個的值。
default為設值未傳name參數時返回的默認值，如若default也未設置，則會拋出tornado.web.MissingArgumentError異常。
strip表示是否過濾掉左右兩邊的空白字符，默認為過濾。
get_query_arguments(name, strip=True)
從請求的查詢字符串中返回指定參數name的值，注意返回的是list列表（即使對應name參數只有一個值）。若未找到name參數，則返回空列表[]。
strip同前，不再贅述。
2. 獲取請求體參數
get_body_argument(name, default=_ARG_DEFAULT, strip=True)
從請求體中返回指定參數name的值，如果出現多個同名參數，則返回最后一個的值。
default與strip同前，不再贅述。
get_body_arguments(name, strip=True)
從請求體中返回指定參數name的值，注意返回的是list列表（即使對應name參數只有一個值）。若未找到name參數，則返回空列表[]。
strip同前，不再贅述。
說明
對於請求體中的數據要求為字符串，且格式為表單編碼格式（與url中的請求字符串格式相同），即key1=value1&key2=value2，HTTP報文頭Header中的"Content-Type"為application/x-www-form-urlencoded 或 multipart/form-data。對於請求體數據為json或xml的，無法通過這兩個方法獲取。
3. 前兩類方法的整合
get_argument(name, default=_ARG_DEFAULT, strip=True)
從請求體和查詢字符串中返回指定參數name的值，如果出現多個同名參數，則返回最后一個的值。
default與strip同前，不再贅述。
get_arguments(name, strip=True)
從請求體和查詢字符串中返回指定參數name的值，注意返回的是list列表（即使對應name參數只有一個值）。若未找到name參數，則返回空列表[]。
strip同前，不再贅述。
說明
對於請求體中數據的要求同前。 這兩個方法最常用。
用代碼來看上述六中方法的使用：
# coding:utf-8 import tornado.web import tornado.ioloop import tornado.httpserver import tornado.options from tornado.options import options, define from tornado.web import RequestHandler, MissingArgumentError define("port", default=8000, type=int, help="run server on the given port.") class IndexHandler(RequestHandler): def post(self): query_arg = self.get_query_argument("a") query_args = self.get_query_arguments("a") body_arg = self.get_body_argument("a") body_args = self.get_body_arguments("a", strip=False) arg = self.get_argument("a") args = self.get_arguments("a") default_arg = self.get_argument("b", "itcast") default_args = self.get_arguments("b") try: missing_arg = self.get_argument("c") except MissingArgumentError as e: missing_arg = "We catched the MissingArgumentError!" print e missing_args = self.get_arguments("c") rep = "query_arg:%s<br/>" % query_arg rep += "query_args:%s<br/>" % query_args rep += "body_arg:%s<br/>" % body_arg rep += "body_args:%s<br/>" % body_args rep += "arg:%s<br/>" % arg rep += "args:%s<br/>" % args rep += "default_arg:%s<br/>" % default_arg rep += "default_args:%s<br/>" % default_args rep += "missing_arg:%s<br/>" % missing_arg rep += "missing_args:%s<br/>" % missing_args self.write(rep) if __name__ == "__main__": tornado.options.parse_command_line() app = tornado.web.Application([ (r"/", IndexHandler), ]) http_server = tornado.httpserver.HTTPServer(app) http_server.listen(options.port) tornado.ioloop.IOLoop.current().start()
注意：以上方法返回的都是unicode字符串
思考
- 什么時候設置default，什么時候不設置default？
- default的默認值_ARG_DEFAULT是什么？
- 什么時候使用strip，亦即什么時候要截斷空白字符，什么時候不需要？
4. 關於請求的其他信息
RequestHandler.request 對象存儲了關於請求的相關信息，具體屬性有：
- method HTTP的請求方式，如GET或POST;
- host 被請求的主機名；
- uri 請求的完整資源標示，包括路徑和查詢字符串；
- path 請求的路徑部分；
- query 請求的查詢字符串部分；
- version 使用的HTTP版本；
- headers 請求的協議頭，是類字典型的對象，支持關鍵字索引的方式獲取特定協議頭信息，例如：request.headers["Content-Type"]
- body 請求體數據；
- remote_ip 客戶端的IP地址；
- files 用戶上傳的文件，為字典類型，型如：
{ "form_filename1":[<tornado.httputil.HTTPFile>, <tornado.httputil.HTTPFile>], "form_filename2":[<tornado.httputil.HTTPFile>,], ... }
tornado.httputil.HTTPFile是接收到的文件對象，它有三個屬性：- filename 文件的實際名字，與form_filename1不同，字典中的鍵名代表的是表單對應項的名字；
- body 文件的數據實體；
- content_type 文件的類型。 這三個對象屬性可以像字典一樣支持關鍵字索引，如request.files["form_filename1"][0]["body"]。
我們來實現一個上傳文件並保存在服務器本地的小程序upload.py：
# coding:utf-8
import tornado.web import tornado.ioloop import tornado.httpserver import tornado.options from tornado.options import options, define from tornado.web import RequestHandler define("port", default=8000, type=int, help="run server on the given port.") class IndexHandler(RequestHandler): def get(self): self.write("hello itcast.") class UploadHandler(RequestHandler): def post(self): files = self.request.files img_files = files.get('img') if img_files: img_file = img_files[0]["body"] file = open("./itcast", 'w+') file.write(img_file) file.close() self.write("OK") if __name__ == "__main__": tornado.options.parse_command_line() app = tornado.web.Application([ (r"/", IndexHandler), (r"/upload", UploadHandler), ]) http_server = tornado.httpserver.HTTPServer(app) http_server.listen(options.port) tornado.ioloop.IOLoop.current().start()
5. 正則提取uri
tornado中對於路由映射也支持正則提取uri，提取出來的參數會作為RequestHandler中對應請求方式的成員方法參數。若在正則表達式中定義了名字，則參數按名傳遞；若未定義名字，則參數按順序傳遞。提取出來的參數會作為對應請求方式的成員方法的參數。
# coding:utf-8 import tornado.web import tornado.ioloop import tornado.httpserver import tornado.options from tornado.options import options, define from tornado.web import RequestHandler define("port", default=8000, type=int, help="run server on the given port.") class IndexHandler(RequestHandler): def get(self): self.write("hello itcast.") class SubjectCityHandler(RequestHandler): def get(self, subject, city): self.write(("Subject: %s<br/>City: %s" % (subject, city))) class SubjectDateHandler(RequestHandler): def get(self, date, subject): self.write(("Date: %s<br/>Subject: %s" % (date, subject))) if __name__ == "__main__": tornado.options.parse_command_line() app = tornado.web.Application([ (r"/", IndexHandler), (r"/sub-city/(.+)/([a-z]+)", SubjectCityHandler), # 無名方式 (r"/sub-date/(?P<subject>.+)/(?P<date>\d+)", SubjectDateHandler), # 命名方式 ]) http_server = tornado.httpserver.HTTPServer(app) http_server.listen(options.port) tornado.ioloop.IOLoop.current().start()
建議：提取多個值時最好用命名方式。
3.3 輸出
1. write(chunk)
將chunk數據寫到輸出緩沖區。如我們在之前的示例代碼中寫的：
class IndexHandler(RequestHandler): def get(self): self.write("hello itcast!")
想一想，可不可以在同一個處理方法中多次使用write方法？
下面的代碼會出現什么效果？
class IndexHandler(RequestHandler): def get(self): self.write("hello itcast 1!") self.write("hello itcast 2!") self.write("hello itcast 3!")
write方法是寫到緩沖區的，我們可以像寫文件一樣多次使用write方法不斷追加響應內容，最終所有寫到緩沖區的內容一起作為本次請求的響應輸出。
想一想，如何利用write方法寫json數據？
import json class IndexHandler(RequestHandler): def get(self): stu = { "name":"zhangsan", "age":24, "gender":1, } stu_json = json.dumps(stu) self.write(stu_json)
實際上，我們可以不用自己手動去做json序列化，當write方法檢測到我們傳入的chunk參數是字典類型后，會自動幫我們轉換為json字符串。
class IndexHandler(RequestHandler): def get(self): stu = { "name":"zhangsan", "age":24, "gender":1, } self.write(stu)
兩種方式有什么差異？
對比一下兩種方式的響應頭header中Content-Type字段，自己手動序列化時為Content-Type:text/html; charset=UTF-8，而采用write方法時為Content-Type:application/json; charset=UTF-8。
write方法除了幫我們將字典轉換為json字符串之外，還幫我們將Content-Type設置為application/json; charset=UTF-8。
2. set_header(name, value)
利用set_header(name, value)方法，可以手動設置一個名為name、值為value的響應頭header字段。
用set_header方法來完成上面write所做的工作。
import json class IndexHandler(RequestHandler): def get(self): stu = { "name":"zhangsan", "age":24, "gender":1, } stu_json = json.dumps(stu) self.write(stu_json) self.set_header("Content-Type", "application/json; charset=UTF-8")
3. set_default_headers()
該方法會在進入HTTP處理方法前先被調用，可以重寫此方法來預先設置默認的headers。注意：在HTTP處理方法中使用set_header()方法會覆蓋掉在set_default_headers()方法中設置的同名header。
class IndexHandler(RequestHandler): def set_default_headers(self): print "執行了set_default_headers()" # 設置get與post方式的默認響應體格式為json self.set_header("Content-Type", "application/json; charset=UTF-8") # 設置一個名為itcast、值為python的header self.set_header("itcast", "python") def get(self): print "執行了get()" stu = { "name":"zhangsan", "age":24, "gender":1, } stu_json = json.dumps(stu) self.write(stu_json) self.set_header("itcast", "i love python") # 注意此處重寫了header中的itcast字段 def post(self): print "執行了post()" stu = { "name":"zhangsan", "age":24, "gender":1, } stu_json = json.dumps(stu) self.write(stu_json)
終端中打印出的執行順序：
get請求方式的響應header:
post請求方式的響應header:
4. set_status(status_code, reason=None)
為響應設置狀態碼。
參數說明：
- status_code int類型，狀態碼，若reason為None，則狀態碼必須為下表中的。
- reason string類型，描述狀態碼的詞組，若為None，則會被自動填充為下表中的內容。
| Code | Enum Name | Details |
|---|---|---|
| 100 | CONTINUE | HTTP/1.1 RFC 7231, Section 6.2.1 |
| 101 | SWITCHING_PROTOCOLS | HTTP/1.1 RFC 7231, Section 6.2.2 |
| 102 | PROCESSING | WebDAV RFC 2518, Section 10.1 |
| 200 | OK | HTTP/1.1 RFC 7231, Section 6.3.1 |
| 201 | CREATED | HTTP/1.1 RFC 7231, Section 6.3.2 |
| 202 | ACCEPTED | HTTP/1.1 RFC 7231, Section 6.3.3 |
| 203 | NON_AUTHORITATIVE_INFORMATION | HTTP/1.1 RFC 7231, Section 6.3.4 |
| 204 | NO_CONTENT | HTTP/1.1 RFC 7231, Section 6.3.5 |
| 205 | RESET_CONTENT | HTTP/1.1 RFC 7231, Section 6.3.6 |
| 206 | PARTIAL_CONTENT | HTTP/1.1 RFC 7233, Section 4.1 |
| 207 | MULTI_STATUS | WebDAV RFC 4918, Section 11.1 |
| 208 | ALREADY_REPORTED | WebDAV Binding Extensions RFC 5842, Section 7.1 (Experimental) |
| 226 | IM_USED | Delta Encoding in HTTP RFC 3229, Section 10.4.1 |
| 300 | MULTIPLE_CHOICES | HTTP/1.1 RFC 7231, Section 6.4.1 |
| 301 | MOVED_PERMANENTLY | HTTP/1.1 RFC 7231, Section 6.4.2 |
| 302 | FOUND | HTTP/1.1 RFC 7231, Section 6.4.3 |
| 303 | SEE_OTHER | HTTP/1.1 RFC 7231, Section 6.4.4 |
| 304 | NOT_MODIFIED | HTTP/1.1 RFC 7232, Section 4.1 |
| 305 | USE_PROXY | HTTP/1.1 RFC 7231, Section 6.4.5 |
| 307 | TEMPORARY_REDIRECT | HTTP/1.1 RFC 7231, Section 6.4.7 |
| 308 | PERMANENT_REDIRECT | Permanent Redirect RFC 7238, Section 3 (Experimental) |
| 400 | BAD_REQUEST | HTTP/1.1 RFC 7231, Section 6.5.1 |
| 401 | UNAUTHORIZED | HTTP/1.1 Authentication RFC 7235, Section 3.1 |
| 402 | PAYMENT_REQUIRED | HTTP/1.1 RFC 7231, Section 6.5.2 |
| 403 | FORBIDDEN | HTTP/1.1 RFC 7231, Section 6.5.3 |
| 404 | NOT_FOUND | HTTP/1.1 RFC 7231, Section 6.5.4 |
| 405 | METHOD_NOT_ALLOWED | HTTP/1.1 RFC 7231, Section 6.5.5 |
| 406 | NOT_ACCEPTABLE | HTTP/1.1 RFC 7231, Section 6.5.6 |
| 407 | PROXY_AUTHENTICATION_REQUIRED | HTTP/1.1 Authentication RFC 7235, Section 3.2 |
| 408 | REQUEST_TIMEOUT | HTTP/1.1 RFC 7231, Section 6.5.7 |
| 409 | CONFLICT | HTTP/1.1 RFC 7231, Section 6.5.8 |
| 410 | GONE | HTTP/1.1 RFC 7231, Section 6.5.9 |
| 411 | LENGTH_REQUIRED | HTTP/1.1 RFC 7231, Section 6.5.10 |
| 412 | PRECONDITION_FAILED | HTTP/1.1 RFC 7232, Section 4.2 |
| 413 | REQUEST_ENTITY_TOO_LARGE | HTTP/1.1 RFC 7231, Section 6.5.11 |
| 414 | REQUEST_URI_TOO_LONG | HTTP/1.1 RFC 7231, Section 6.5.12 |
| 415 | UNSUPPORTED_MEDIA_TYPE | HTTP/1.1 RFC 7231, Section 6.5.13 |
| 416 | REQUEST_RANGE_NOT_SATISFIABLE | HTTP/1.1 Range Requests RFC 7233, Section 4.4 |
| 417 | EXPECTATION_FAILED | HTTP/1.1 RFC 7231, Section 6.5.14 |
| 422 | UNPROCESSABLE_ENTITY | WebDAV RFC 4918, Section 11.2 |
| 423 | LOCKED | WebDAV RFC 4918, Section 11.3 |
| 424 | FAILED_DEPENDENCY | WebDAV RFC 4918, Section 11.4 |
| 426 | UPGRADE_REQUIRED | HTTP/1.1 RFC 7231, Section 6.5.15 |
| 428 | PRECONDITION_REQUIRED | Additional HTTP Status Codes RFC 6585 |
| 429 | TOO_MANY_REQUESTS | Additional HTTP Status Codes RFC 6585 |
| 431 | REQUEST_HEADER_FIELDS_TOO_LARGE Additional | HTTP Status Codes RFC 6585 |
| 500 | INTERNAL_SERVER_ERROR | HTTP/1.1 RFC 7231, Section 6.6.1 |
| 501 | NOT_IMPLEMENTED | HTTP/1.1 RFC 7231, Section 6.6.2 |
| 502 | BAD_GATEWAY | HTTP/1.1 RFC 7231, Section 6.6.3 |
| 503 | SERVICE_UNAVAILABLE | HTTP/1.1 RFC 7231, Section 6.6.4 |
| 504 | GATEWAY_TIMEOUT | HTTP/1.1 RFC 7231, Section 6.6.5 |
| 505 | HTTP_VERSION_NOT_SUPPORTED | HTTP/1.1 RFC 7231, Section 6.6.6 |
| 506 | VARIANT_ALSO_NEGOTIATES | Transparent Content Negotiation in HTTP RFC 2295, Section 8.1 (Experimental) |
| 507 | INSUFFICIENT_STORAGE | WebDAV RFC 4918, Section 11.5 |
| 508 | LOOP_DETECTED | WebDAV Binding Extensions RFC 5842, Section 7.2 (Experimental) |
| 510 | NOT_EXTENDED | An HTTP Extension Framework RFC 2774, Section 7 (Experimental) |
| 511 | NETWORK_AUTHENTICATION_REQUIRED | Additional HTTP Status Codes RFC 6585, Section 6 |
class Err404Handler(RequestHandler): """對應/err/404""" def get(self): self.write("hello itcast") self.set_status(404) # 標准狀態碼，不用設置reason class Err210Handler(RequestHandler): """對應/err/210""" def get(self): self.write("hello itcast") self.set_status(210, "itcast error") # 非標准狀態碼，設置了reason class Err211Handler(RequestHandler): """對應/err/211""" def get(self): self.write("hello itcast") self.set_status(211) # 非標准狀態碼，未設置reason，錯誤
5. redirect(url)
告知瀏覽器跳轉到url。
class IndexHandler(RequestHandler): """對應/""" def get(self): self.write("主頁") class LoginHandler(RequestHandler): """對應/login""" def get(self): self.write('<form method="post"><input type="submit" value="登陸"></form>') def post(self): self.redirect("/")
6. send_error(status_code=500, **kwargs)
拋出HTTP錯誤狀態碼status_code，默認為500，kwargs為可變命名參數。使用send_error拋出錯誤后tornado會調用write_error()方法進行處理，並返回給瀏覽器處理后的錯誤頁面。
class IndexHandler(RequestHandler): def get(self): self.write("主頁") self.send_error(404, content="出現404錯誤")
注意：默認的write\_error()方法不會處理send\_error拋出的kwargs參數，即上面的代碼中content="出現404錯誤"是沒有意義的。
嘗試下面的代碼會出現什么問題？
class IndexHandler(RequestHandler): def get(self): self.write("主頁") self.send_error(404, content="出現404錯誤") self.write("結束") # 我們在send_error再次向輸出緩沖區寫內容
注意：使用send_error()方法后就不要再向輸出緩沖區寫內容了！
7. write_error(status_code, **kwargs)
用來處理send_error拋出的錯誤信息並返回給瀏覽器錯誤信息頁面。可以重寫此方法來定制自己的錯誤顯示頁面。
class IndexHandler(RequestHandler): def get(self): err_code = self.get_argument("code", None) # 注意返回的是unicode字符串，下同 err_title = self.get_argument("title", "") err_content = self.get_argument("content", "") if err_code: self.send_error(err_code, title=err_title, content=err_content) else: self.write("主頁") def write_error(self, status_code, **kwargs): self.write(u"<h1>出錯了，程序員GG正在趕過來！</h1>") self.write(u"<p>錯誤名：%s</p>" % kwargs["title"]) self.write(u"<p>錯誤詳情：%s</p>" % kwargs["content"])
3.4 接口與調用順序
下面的接口方法是由tornado框架進行調用的，我們可以選擇性的重寫這些方法。
1. initialize()
對應每個請求的處理類Handler在構造一個實例后首先執行initialize()方法。在講輸入時提到，路由映射中的第三個字典型參數會作為該方法的命名參數傳遞，如：
class ProfileHandler(RequestHandler): def initialize(self, database): self.database = database def get(self): ... app = Application([ (r'/user/(.*)', ProfileHandler, dict(database=database)), ])
此方法通常用來初始化參數（對象屬性），很少使用。
2. prepare()
預處理，即在執行對應請求方式的HTTP方法（如get、post等）前先執行，注意：不論以何種HTTP方式請求，都會執行prepare()方法。
以預處理請求體中的json數據為例：
import json class IndexHandler(RequestHandler): def prepare(self): if self.request.headers.get("Content-Type").startswith("application/json"): self.json_dict = json.loads(self.request.body) else: self.json_dict = None def post(self): if self.json_dict: for key, value in self.json_dict.items(): self.write("<h3>%s</h3><p>%s</p>" % (key, value)) def put(self): if self.json_dict: for key, value in self.json_dict.items(): self.write("<h3>%s</h3><p>%s</p>" % (key, value))
用post方式發送json數據時：
用put方式發送json數據時：
3. HTTP方法
| 方法 | 描述 |
|---|---|
| get | 請求指定的頁面信息，並返回實體主體。 |
| head | 類似於get請求，只不過返回的響應中沒有具體的內容，用於獲取報頭 |
| post | 向指定資源提交數據進行處理請求（例如提交表單或者上傳文件）。數據被包含在請求體中。POST請求可能會導致新的資源的建立和/或已有資源的修改。 |
| delete | 請求服務器刪除指定的內容。 |
| patch | 請求修改局部數據。 |
| put | 從客戶端向服務器傳送的數據取代指定的文檔的內容。 |
| options | 返回給定URL支持的所有HTTP方法。 |
4. on_finish()
在請求處理結束后調用，即在調用HTTP方法后調用。通常該方法用來進行資源清理釋放或處理日志等。注意：請盡量不要在此方法中進行響應輸出。
5. set_default_headers()
6. write_error()
7. 調用順序
我們通過一段程序來看上面這些接口的調用順序。
class IndexHandler(RequestHandler): def initialize(self): print "調用了initialize()" def prepare(self): print "調用了prepare()" def set_default_headers(self): print "調用了set_default_headers()" def write_error(self, status_code, **kwargs): print "調用了write_error()" def get(self): print "調用了get()" def post(self): print "調用了post()" self.send_error(200) # 注意此出拋出了錯誤 def on_finish(self): print "調用了on_finish()"
在正常情況未拋出錯誤時，調用順序為：
- set_defautl_headers()
- initialize()
- prepare()
- HTTP方法
- on_finish()
在有錯誤拋出時，調用順序為：
- set_default_headers()
- initialize()
- prepare()
- HTTP方法
- set_default_headers()
- write_error()
- on_finish()