03: 自定义异步非阻塞tornado框架
目录:Tornado其他篇
目录:
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
03: 自定义异步非阻塞tornado框架的更多相关文章
- 200行自定义异步非阻塞Web框架
Python的Web框架中Tornado以异步非阻塞而闻名.本篇将使用200行代码完成一个微型异步非阻塞Web框架:Snow. 一.源码 本文基于非阻塞的Socket以及IO多路复用从而实现异步非阻塞 ...
- Tornado----自定义异步非阻塞Web框架:Snow
Python的Web框架中Tornado以异步非阻塞而闻名.本篇将使用200行代码完成一个微型异步非阻塞Web框架:Snow. 一.源码 本文基于非阻塞的Socket以及IO多路复用从而实现异步非阻塞 ...
- 150行代码搭建异步非阻塞Web框架
最近看Tornado源码给了我不少启发,心血来潮决定自己试着只用python标准库来实现一个异步非阻塞web框架.花了点时间感觉还可以,一百多行的代码已经可以撑起一个极简框架了. 一.准备工作 需要的 ...
- Tornado之自定义异步非阻塞的服务器和客户端
一.自定义的异步非阻塞的客户端 #!/usr/bin/env python # -*- coding: utf8 -*- # __Author: "Skiler Hao" # da ...
- python-自定义异步非阻塞爬虫框架
api import socket import select class MySock: def __init__(self, sock, data): self.sock = sock self. ...
- Tornado异步非阻塞的使用以及原理
Tornado 和现在的主流 Web 服务器框架(包括大多数 Python 的框架)有着明显的区别:它是非阻塞式服务器,而且速度相当快.得利于其 非阻塞的方式和对 epoll 的运用,Tornado ...
- 异步非阻塞IO的Python Web框架--Tornado
Tornado的全称是Torado Web Server,从名字上就可知它可用作Web服务器,但同时它也是一个Python Web的开发框架.最初是在FriendFeed公司的网站上使用,FaceBo ...
- Python web框架 Tornado(二)异步非阻塞
异步非阻塞 阻塞式:(适用于所有框架,Django,Flask,Tornado,Bottle) 一个请求到来未处理完成,后续一直等待 解决方案:多线程,多进程 异步非阻塞(存在IO请求): Torna ...
- Python web框架 Tornado异步非阻塞
Python web框架 Tornado异步非阻塞 异步非阻塞 阻塞式:(适用于所有框架,Django,Flask,Tornado,Bottle) 一个请求到来未处理完成,后续一直等待 解决方案: ...
随机推荐
- ubuntu16.04下安装artoolkit5
目前对AR技术的常见理解就是CV(Computer Vision)+CG(Computer Graphic).CV的方法很多,简单些比如FREAK+ICP(ARToolKit中的NFT),复杂些就是S ...
- idea启动java Maven项目,出现" java: 程序包xxxx不存在"
今天运行Maven项目的时候,出现了,Error:(19, 17) java: 程序包tracetool不存在的情况 本人的解决办法: (1)首先确保maven pom文件不能报错,即文件上面不能有 ...
- BZOJ5056 OI游戏 最短路+组合数学
链接接接接接! 正解:最短路+小学奥数 乘法原理 解题报告: 首先读懂题意(,,,我觉得我吃枣死于语文太差读不懂题目QAQ 大意就是港,要求从第一个点到其他各点的长度都是最短的方案有多少个(ummm, ...
- mvc debug无法进入controller
可能原因为,工程更改名称 进入工程bin目录下,删除所有文件即可
- struts2 错误:Dispatcher initialization failed java.lang.RuntimeException
严重: Dispatcher initialization failed java.lang.RuntimeException: java.lang.reflect.InvocationTargetE ...
- 共享访问在.NET中的编程实现
转载:http://blog.csdn.net/zhzuo/article/details/1732937 共享访问在.NET中的编程实现 发布日期:2007-08-08 | 更新日期:2009-03 ...
- (3.10)mysql基础深入——mysqld 服务器与客户端连接过程 源码分析【待写】
(3.10)mysql基础深入——mysqld 服务器与客户端连接过程 源码分析[待写]
- MSMQ研究
开发过程记录如下: 1. 本机配置MSMQ ------控制面板-------启动或者关闭Windows功能----默认安装MSMQ即可 注意:本地安装后再VS中才能引用System.Messag ...
- 【论文阅读】Sliding Line Point Regression for Shape Robust Scene Text Detection
一.整体网络结构 二.细节 n=7,(7+7)*2+4=32个channel 三.结果 ...
- FDR错误发现率-P值校正学习[转载]
转自:https://baike.baidu.com/item/FDR/16312044?fr=aladdin https://blog.csdn.net/taojiea1014/article/d ...