老男孩IT教育Python培训教你如何使用python web框架
Python的Web框架中Tornado以异步非阻塞而闻名。本篇将使用200行代码完成一个微型异步非阻塞Web框架：Snow。
本文基于非阻塞的Socket以及IO多路复用从而实现异步非阻塞的Web框架，其中便是众多异步非阻塞Web框架内部原理。
#!/usr/bin/env python# -*- coding:utf-8 -*-import reimport socketimport selectimport timeclass 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] = vclass 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._readyclass 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._readyclass 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)
1. 基本使用
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | from snow import Snow from snow import HttpResponse
def index(request): return HttpResponse('OK')
routes = [ (r'/index/', index), ]
app = Snow(routes) app.run(port=8012) |
2.异步非阻塞：超时
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | 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=8012) |
3.异步非阻塞：等待
基于等待模式可以完成自定制操作
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | 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=8012) |
更多精彩请关注老男孩教育官网：www.oldboyedu.com
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
