目錄：Tornado其他篇
01: tornado基礎篇
02: tornado進階篇
03: 自定義異步非阻塞tornado架構
04: 打開tornado源碼剖析處理過程
目錄：
- 1.1 源碼
- 1.2 tornado架構核心代碼分析（Snow類注釋）
- 1.3 剖析Future()對象 實作異步非阻塞原理
- 1.4 自定義架構使用
1.1 源碼 傳回頂部
1. Python的Web架構中Tornado以異步非阻塞而聞名。本篇将使用200行代碼完成一個微型異步非阻塞Web架構：Snow。
2. 本文基于非阻塞的Socket以及IO多路複用進而實作異步非阻塞的Web架構，其中便是衆多異步非阻塞Web架構内部原理。
3. 參考部落格： http://www.cnblogs.com/wupeiqi/p/6536518.html
import re
import socket
import select
import time
class HttpResponse(object):
"""
封裝響應資訊
"""
def __init__(self, content=''):
self.content = content
self.headers = {}
self.cookies = {}
def response(self):
return bytes(self.content, encoding='utf-8')
class HttpNotFound(HttpResponse):
"""
404時的錯誤提示
"""
def __init__(self):
super(HttpNotFound, self).__init__('404 Not Found')
class HttpRequest(object):
"""
使用者封裝使用者請求資訊
"""
def __init__(self, conn):
self.conn = conn
self.header_bytes = bytes()
self.header_dict = {}
self.body_bytes = bytes()
self.method = ""
self.url = ""
self.protocol = ""
self.initialize()
self.initialize_headers()
def initialize(self):
header_flag = False
while True:
try:
received = self.conn.recv(8096)
except Exception as e:
received = None
if not received:
break
if header_flag:
self.body_bytes += received
continue
temp = received.split(b'\r\n\r\n', 1)
if len(temp) == 1:
self.header_bytes += temp
else:
h, b = temp
self.header_bytes += h
self.body_bytes += b
header_flag = True
@property
def header_str(self):
return str(self.header_bytes, encoding='utf-8')
def initialize_headers(self):
headers = self.header_str.split('\r\n')
first_line = headers[0].split(' ')
if len(first_line) == 3:
self.method, self.url, self.protocol = headers[0].split(' ')
for line in headers:
kv = line.split(':')
if len(kv) == 2:
k, v = kv
self.header_dict[k] = v
class Future(object):
"""
異步非阻塞模式時封裝回調函數以及是否準備就緒
"""
def __init__(self, callback):
self.callback = callback
self._ready = False
self.value = None
def set_result(self, value=None):
self.value = value
self._ready = True
@property
def ready(self):
return self._ready
class TimeoutFuture(Future):
"""
異步非阻塞逾時
"""
def __init__(self, timeout):
super(TimeoutFuture, self).__init__(callback=None)
self.timeout = timeout
self.start_time = time.time()
@property
def ready(self):
current_time = time.time()
if current_time > self.start_time + self.timeout:
self._ready = True
return self._ready
class Snow(object):
"""
微型Web架構類
"""
def __init__(self, routes):
self.routes = routes
self.inputs = set()
self.request = None
self.async_request_handler = {}
def run(self, host='localhost', port=9999):
"""
事件循環
:param host:
:param port:
:return:
"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind((host, port,))
sock.setblocking(False)
sock.listen(128)
sock.setblocking(0)
self.inputs.add(sock)
try:
while True:
readable_list, writeable_list, error_list = select.select(self.inputs, [], self.inputs,0.005)
for conn in readable_list:
if sock == conn:
client, address = conn.accept()
client.setblocking(False)
self.inputs.add(client)
else:
gen = self.process(conn)
if isinstance(gen, HttpResponse):
conn.sendall(gen.response())
self.inputs.remove(conn)
conn.close()
else:
yielded = next(gen)
self.async_request_handler[conn] = yielded
self.polling_callback()
except Exception as e:
pass
finally:
sock.close()
def polling_callback(self):
"""
周遊觸發異步非阻塞的回調函數
:return:
"""
for conn in list(self.async_request_handler.keys()):
yielded = self.async_request_handler[conn]
if not yielded.ready:
continue
if yielded.callback:
ret = yielded.callback(self.request, yielded)
conn.sendall(ret.response())
self.inputs.remove(conn)
del self.async_request_handler[conn]
conn.close()
def process(self, conn):
"""
處理路由系統以及執行函數
:param conn:
:return:
"""
self.request = HttpRequest(conn)
func = None
for route in self.routes:
if re.match(route[0], self.request.url):
func = route[1]
break
if not func:
return HttpNotFound()
else:
return func(self.request) snow.py 源碼
1.2 tornado架構核心代碼分析（Snow類注釋） 傳回頂部
1．每個請求過來就會建立一個socket對象，并調用select去監聽連接配接，select會将所有請求放到readable_list清單中
2．使用while不斷執行for循環周遊readable_list，如果是新連接配接請求過來就加入inputs清單中
3．如果已經連接配接就調用self.process來擷取請求頭和請求體，如果已經擷取到了正常的傳回内容，就會傳回一個
HttpResponse類型，直接傳回response傳回值即可
4．如果沒有處理完成就會傳回一個future對象，将這個future對象加入async_request_handler字典中，程式會繼續
向下走，不會阻塞
5．每次執行完for循環後就會調用self.polling_callback()方法，在這個方法中再使用for循環周遊async_request_handler
字典中的future對象，隻要future對象有response,就将response傳回，并将這個future對象從字典中删除
class Snow(object):
def __init__(self, routes):
self.routes = routes
self.inputs = set()
self.request = None
self.async_request_handler = {}
def run(self, host='localhost', port=9999):
"""
事件循環
:param host:
:param port:
"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind((host, port,))
sock.setblocking(False)
sock.listen(128)
sock.setblocking(0)
self.inputs.add(sock)
try:
while True:
readable_list, writeable_list, error_list = select.select(self.inputs, [], self.inputs,0.005)
for conn in readable_list:
if sock == conn: #1.表示有新連接配接請求過來
client, address = conn.accept() #接收請求對象
client.setblocking(False)
self.inputs.add(client) #加入inputs中
else: #2. 連上後執行這裡并判斷連接配接類型
gen = self.process(conn) # 擷取請求頭請求體
if isinstance(gen, HttpResponse): #2.1如果傳回的HttpResponse類型，就直接傳回response
conn.sendall(gen.response())
self.inputs.remove(conn)
conn.close()
else: #2.2如果傳回的是一個future類型，加入字典，并hold住
yielded = next(gen)
# 将future對象放到字典中，hold住這個請求，就繼續向下執行
self.async_request_handler[conn] = yielded
self.polling_callback() #3. 每次for循環結束就會調用這個方法
except Exception as e:
pass
finally:
sock.close()
def polling_callback(self):
"""
周遊觸發異步非阻塞的回調函數
:return:
"""
for conn in list(self.async_request_handler.keys()):
# conn是： socket對象
# yield是： future對象
yielded = self.async_request_handler[conn]
# 若果future對象有傳回值就會執行future.set_result()
# 如果有人執行future.set_result()就會自動将ready改成true，才會向下走
if not yielded.ready:
continue
if yielded.callback:
ret = yielded.callback(self.request, yielded)
conn.sendall(ret.response()) #傳回資料
self.inputs.remove(conn) #将inputs中删除這個連結
del self.async_request_handler[conn] #在字典中删除這個future對象
conn.close()
def polling_callback(self):
"""
4. 周遊觸發異步非阻塞的回調函數，當future對象有傳回就結束，并從字典中删除
:return:
"""
for conn in list(self.async_request_handler.keys()):
# conn是： socket對象
# yield是： future對象
yielded = self.async_request_handler[conn]
# 若果future對象有傳回值就會執行future.set_result()
# 如果有人執行future.set_result()就會自動将ready改成true，才會向下走
if not yielded.ready:
continue
if yielded.callback:
ret = yielded.callback(self.request, yielded)
conn.sendall(ret.response()) # 傳回資料
self.inputs.remove(conn) # 将inputs中删除這個連結
del self.async_request_handler[conn] # 在字典中删除這個future對象
conn.close()
def process(self, conn):
"""
處理路由系統以及執行函數
:param conn:
:return:
"""
self.request = HttpRequest(conn)
func = None
for route in self.routes:
if re.match(route[0], self.request.url):
func = route[1]
break
if not func:
return HttpNotFound()
else:
return func(self.request) tornado核心處理類 Snow 代碼注釋
1.3 剖析Future()對象 實作異步非阻塞原理 傳回頂部
1．原理說明
1、當發送GET請求時，由于方法被@gen.coroutine裝飾且yield 一個 Future對象，那麼Tornado會等待
2、等待使用者向future對象中放置資料或者發送信号，如果擷取到資料或信号之後，就開始執行doing方法。
3、等待使用者向future對象中放置資料或者發送信号，如果擷取到資料或信号之後，就開始執行doing方法。
4、注意：在等待使用者向future對象中放置資料或信号時，此連接配接是不斷開的。
2．驗證方法
1、首先通路：http://127.0.0.1:8888/async 會阻塞，并且不斷開，頁面一直在轉，說明非阻塞
2、然後通路：http://127.0.0.1:8888/login 可以直接通路，證明可以實作異步
3、最後通路：http://127.0.0.1:8888/stop /index頁面立刻就會傳回了
import tornado.ioloop
import tornado.web
from tornado import gen
from tornado.concurrent import Future
'''1. 通路：http://127.0.0.1:8888/async 會阻塞'''
future = None
class AsyncHandler(tornado.web.RequestHandler):
@gen.coroutine
def get(self):
global future
future = Future()
future.add_done_callback(self.doing)
yield future
# from tornado import httpclient
# http = httpclient.AsyncHTTPClient()
# # 下載下傳完成後，自動執行 future.set_result()
# yield http.fetch("http://www.google.com", self.doing)
def doing(self, *args, **kwargs):
self.write('async')
self.finish()
'''2. 但是通路http://127.0.0.1:8888/login可以通路'''
class LoginHandler(tornado.web.RequestHandler):
def get(self):
self.write('login')
'''3. 當我們去通路http://127.0.0.1:8888/stop時就可以結束/async的阻塞'''
class StopHandler(tornado.web.RequestHandler):
def get(self, *args, **kwargs):
future.set_result('...')
self.write('結束阻塞')
settings = {}
application = tornado.web.Application([
(r"/login", LoginHandler),
(r"/async", AsyncHandler),
(r"/stop", StopHandler),
],**settings)
if __name__ == "__main__":
application.listen(8888)
print('直接通路會阻塞：http://127.0.0.1:8888/async')
print('阻塞時還能通路login證明實作異步：http://127.0.0.1:8888/login')
print('通路sotp會結束async的阻塞：http://127.0.0.1:8888/stop')
tornado.ioloop.IOLoop.instance().start() future對象實作阻塞 與 結束阻塞
1.4 自定義架構使用 傳回頂部
1、基本使用
1. 在Linux下執行： python3 app.py
2. 使用Linux中的Firefox通路：http://1.1.1.3:8888/index/
from snow import Snow
from snow import HttpResponse
def index(request):
print('aafdsfsfdf')
return HttpResponse('OK')
routes = [
(r'/index/', index),
]
app = Snow(routes)
app.run(host='1.1.1.3',port=8888) app.py
2、異步非阻塞：逾時
1. 通路： http://127.0.0.1:8888/home/ 可以直接傳回
2. 通路：http://127.0.0.1:8888/async/ 頁面會轉5s後逾時
from snow import Snow
from snow import HttpResponse
from snow import TimeoutFuture
request_list = []
def async(request):
obj = TimeoutFuture(5)
yield obj
def home(request):
return HttpResponse('home')
routes = [
(r'/home/', home),
(r'/async/', async),
]
app = Snow(routes)
app.run(port=8888) app.py
3、異步非阻塞：等待
1. 通路： http://127.0.0.1:8888/req/ 會一直處于長連接配接的阻塞狀态，由于異步是以可以阻塞也可以處理其他請求
2. 通路：http://127.0.0.1:8888/stop/ 會執行 obj.set_result('done') 結束阻塞
from snow import Snow
from snow import HttpResponse
from snow import Future
request_list = []
def callback(request, future):
return HttpResponse(future.value)
def req(request):
obj = Future(callback=callback)
request_list.append(obj)
yield obj
def stop(request):
obj = request_list[0]
del request_list[0]
obj.set_result('done')
return HttpResponse('stop')
routes = [
(r'/req/', req),
(r'/stop/', stop),
]
app = Snow(routes)
app.run(port=8888) app.py
轉載于:https://www.cnblogs.com/xiaonq/p/8041325.html
![TestLink導出用例轉換工具(XML2Excel)[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)