150行代码搭建异步非阻塞Web框架
最近看Tornado源码给了我不少启发,心血来潮决定自己试着只用python标准库来实现一个异步非阻塞web框架。花了点时间感觉还可以,一百多行的代码已经可以撑起一个极简框架了。
一、准备工作
需要的相关知识点:
- HTTP协议的请求和响应
- IO多路复用
- asyncio
掌握上面三个点的知识就完全没有问题,不是很清楚的同学我也推荐几篇参考文章
HTTP协议详细介绍(https://www.geek-share.com/detail/2720689160.html)
Python篇-IO多路复用详解(https://www.jianshu.com/p/818f27379a5e)
Python异步IO之协程(一):从yield from到async的使用(https://blog.csdn.net/SL_World/article/details/86597738)
实验环境:
python 3.7.3
由于在框架中会使用到async/await关键字,所以只要确保python版本在3.5以上即可。
二、框架功能目标
我们的框架要实现最基本的几个功能:
- 封装HTTP请求响应
- 路由映射
- 类视图和函数视图
- 协程支持
当然一个完善的web框架需要实现的远远不止这些,这里我们现在只需要它能跑起来就足够了。
三、封装HTTP协议
HTTP是基于TCP/IP通信协议来实现数据传输,与一般的C/S相比,它的特点在于当客户端(浏览器)向服务端发起HTTP请求,服务端响应数据后双方立马断开连接,服务端无法主动向客户端发送数据。HTTP协议数据传输内容分为请求头和请求体,请求头和请求体之间使用"\r\n\r\n"进行分隔。在请求头中,第一行包含了请求方式,请求路径和HTTP协议,此后每一行以key: value的形式传输数据。
对于我们的web服务端来说,需要的就是解析http请求和处理http响应。
我们通过写两个类,HttpRequest和HttpResponse来实现。
3.1 HttpRequest
HttpRequest设计目标是解析从socket接收request数据
class HttpRequest(object): def __init__(self, content: bytes): self.content = content.decode('utf-8') self.headers = {} self.GET = {} self.url = '' self.full_path = '' self.body = '' try: header, self.body = self.content.split('\r\n\r\n') temp = header.split('\r\n') first_line = temp.pop(0) self.method, self.url, self.protocol = first_line.split(' ') self.full_path = self.url for t in temp: k, v = t.split(': ', 1) self.headers[k] = v except Exception as e: print(e) if len(self.url.split('?')) > 1: # 解析GET参数 self.url = self.full_path.split('?')[0] # 把url中携带的参数去掉 parms = self.full_path.split('?')[1].split('&') for p in parms: # 将GET参数添加到self.GET字典 k, v = p.split('=') self.GET[k] = v
在类中,我们实现解析http请求的headers、method、url和GET参数,其实还有很多事情没有做,比如使用POST传输数据时,数据是在请求体中,针对这部分内容我并没有开始写,原因在于本文主要目的还是异步非阻塞框架,目前的功能已经足以支持我们进行下一步实验了。
3.2 HttpResponse
HTTP响应也可以分为响应头和响应体,我们可以很简单的实现一个response:
class HttpResponse(object): def __init__(self, data: str): self.status_code = 200 # 默认响应状态 200 self.headers = 'HTTP/1.1 %s OK\r\n' self.headers += 'Server:AsyncWeb' self.headers += '\r\n\r\n' self.data = data @property def content(self): return bytes((self.headers + self.data) % self.status_code, encoding='utf8')
HttpResponse中并没有做太多的事情,接受一个字符串,并使用content返回一个满足HTTP响应格式的bytes。
从用户调用角度,可以使用return HttpResponse("欢迎来到AsynicWeb")来返回数据。
我们也可以简单的定义一个404页面:
Http404 = HttpResponse('<html><h1>404</h1></html>') Http404.status_code = 404
四、路由映射
路由 3ff8 映射简单理解就是从一个URL地址找到对应的逻辑函数。举个例子,我们访问http://127.0.0.1:8000这个页面,在http请求中它的url是"/",在web服务器中有一个函数index,web服务器能够由url地址"/"找到函数index,这就是一个路由映射。
其实路由映射实现起来非常简单。我们只要定义一个映射列表,列表中的每个元素包含url和逻辑处理(视图函数)两部分,当一个http请求到达的时候,遍历映射列表,使用正则匹配每一个url,如果请求的url和映射表中的相同,我们就可以取出对应的视图函数。
路由映射表是完全由用户来定义映射关系的,它应该使用一个我们定义的标准结构,比如:
routers = [ ('/$', IndexView), ('/home', asy) ]
五、类视图和函数视图
视图是指能够根据一个请求,执行某些逻辑运算,最终返回响应的模块。说到这里,一个web框架的运行流程就出来了:
http请求——路由映射表——视图——执行视图获取返回值——http响应
在我们的框架中,借鉴Django的设计,我们让它支持类视图(CBV)和函数视图(FBV)两种模式。
对于函数视图,完全由用户自己定义,只要至少能够接受一个request参数即可
对于类视图,我们需要做一些预处理,确保用户按我们的规则来实现类视图。
定义一个View类:
class View(object): # CBV应继承View类 def dispatch(self, request): method = request.method.lower() if hasattr(self, method): return getattr(self, method)(request) else: return Http404
在View类中,我们只写了一个dispatch方法,其实就做了一件事:反射。当我们在路由映射表中找对应的视图时,如果判断视图属于类,我们就调用dispatch方法。
从用户角度来看,实现一个CBV只需要继承View类,然后通过定义get、post、delete等方法来实现不同的处理。
六、socket和多路复用
上面几个小节实现了web框架的大体执行路径,从这节开始我们实现web服务器的核心。
通过IO多路复用可以达到单线程实现高并发的效果,一个标准的IO多路复用写法:
server = socket(AF_INET, SOCK_STREAM) server.bind(("127.0.0.1", 8000)) server.setblocking(False) # 设置非阻塞 server.listen(128) Future_Task_Wait = {} rlist = [server, ] while True: r, w, x = select.select(rlist, [], [], 0.1) for o in r: if o == server: '''判断o是server还是conn''' conn, addr = o.accept() conn.setblocking(False) # 设置非阻塞 rlist.append(conn) # 客户连接 加入轮询列表 else: data = b"" while True: # 接收客户传输数据 try: chunk = o.recv(1024) data = data + chunk except Exception as e: chunk = None if not chunk: break dosomething(o, data, routers) # 拿到数据干点啥
通过这段代码我们可以获得所有的请求了,下一步就是处理这些请求。
我们就定义一个dosomething函数
import re import time from types import FunctionType def dosomething(o, data, routers): '''解析http请求,寻找映射函数并执行得到结果
:param o: socket连接对象 :param data: socket接收数据 :return: 响应结果 ''' request = HttpRequest(data) print(time.strftime("【%Y-%m-%d %X】",time.localtime()), o.getpeername()[0], request.method, request.url) flag = False for router in routers: if re.match(router[0], request.url): target = router[1] flag = True break if flag: # 判断targe是函数还是类 if isinstance(target, FunctionType): result = target(request) elif issubclass(target, View): result = target().dispatch(request) else: result = Http404 else: result = Http404 return result
这段代码做了这么几件事。1.实例化HttpRequest;2.使用正则遍历路由映射表;3.将request传入视图函数或类视图的dispatch方法;4.拿到result结果
我们通过result = dosomething(o, data, routers)可以拿到结果,接下来我们只需要把结果发回给客户端并断开连接就可以了
o.sendall(result.content) # 由于result是一个HttpResponse对象 我们使用content属性 rlist.remove(o) # 从轮询中删除连接 o.close() # 关闭连接
至此,我们的web框架已经搭建好了。
但它还是一个同步的框架,在我们的服务端中,其实一直通过while循环在监听select是否变化,假如我们在视图函数中添加IO操作,其他连接依然会阻塞等待,接下来让我们的框架实现对协程的支持。
七、协程支持
在实现协程之前,我们先聊聊Tornado的Future对象。可以说Tornado异步非阻塞的实现核心就是Future。
Future对象内部维护了一个重要属性_result,这是一个标记位,一个刚实例化的Future内部的_result=None,我们可以通过其他操作来更改_result的状态。另一方面,我们可以一直监听每个Future对象的_result状态,如果发生变化就执行某些特定的操作。
我们在第六节定义的dosomething函数中拿到了一个result,它应当是一个HttpResponse对象,那么能不能返回一个Future对象呢。
假如result是一个Future对象,我们的服务端不立马返回结果,而是把Future放进另一个轮询列表中,当Future内的_result改变时再返回结果,就达到了异步的效果。
我们也可以定义一个Future类,这个类维护只一个变量result:
class Future(object): def __init__(self): self.result = None
对于框架使用者来说,在视图函数要么返回一个HttpResponse对象代表立即返回,要么返回一个Future对象说你先别管我,我把事情干完了再通知你返回结果。
既然视图函数返回的可能不只是HttpResponse对象,那么我们就需要对第六步的代码增加额外的处理:
Future_Task_Wait = {} # 定义一个异步Future字典 result = dosomething() # 拿到结果后执行下面判断 if isinstance(result, Future): Future_Task_Wait[o] = result # Futre对象则加入字典 else: o.sendall(result.content) # 非Future对象直接返回结果并断开连接 rlist.remove(o) o.close()
在while True轮询内再增加一段代码,遍历Future_Task_Wait字典:
rm_conn = [] # 需要移除列表的conn for conn, future in Future_Task_Wait.items(): if future.result: try: conn.sendall(HttpResponse(data=future.result).content) # 返回result finally: rlist.remove(conn) conn.close() rm_conn.append(conn) for conn in rm_conn: # 在字典中删除conn del Future_Task_Wait[conn]
这样,我们就可以返回一个Future来告诉服务器这是将来才返回的对象。
那回归正题,我们到底该如何使用协程?这里我用的方法是创建一个子线程来执行协程事件循环,主线程永远在监听s 1760 ocket。
from threading import Thread def start_loop(loop): asyncio.set_event_loop(loop) loop.run_forever() coroutine_loop = asyncio.new_event_loop() # 创建协程事件循环 run_loop_thread = Thread(target=start_loop, args=(coroutine_loop,)) # 新起线程运行事件循环, 防止阻塞主线程 run_loop_thread.start() # 运行线程,即运行协程事件循环
当我们要把asyncdo方法添加作为协程任务时
asyncio.run_coroutine_threadsafe(asyncdo(), coroutine_loop)
好了,异步非阻塞的核心代码分析的差不多了,将六七节的代码整合写成一个类
import re import time import select import asyncio from socket import * from threading import Thread from types import FunctionType from http.response import Http404, HttpResponse from http.request import HttpRequest from views import View from core.future import Future class App(object): # web应用程序 coroutine_loop = None def __new__(cls, *args, **kwargs): # 使用单例模式 if not hasattr(cls, '_instance'): App._instance = super().__new__(cls) return App._instance def listen(self, host, port, routers): # IO多路复用监听连接 server = socket(AF_INET, SOCK_STREAM) server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) server.bind((host, port)) server.setblocking(False) server.listen(128) Future_Task_Wait = {} rlist = [server, ] while True: r, w, x = select.select(rlist, [], [], 0.01) for o in r: 35 if o == server: '''判断o是server还是conn''' conn, addr = o.accept() conn.setblocking(False) rlist.append(conn) else: data = b"" while True: try: chunk = o.recv(1024) data = data + chunk except Exception as e: chunk = None if not chunk: break try: request = HttpRequest(data, o) print(time.strftime("【%Y-%m-%d %X】",time.localtime()), o.getpeername()[0], request.method, request.url) flag = False for router in routers: if re.match(router[0], request.url): target = router[1] flag = True break if flag: # 判断targe是函数还是类 if isinstance(target, FunctionType): result = target(request) elif issubclass(target, View): result = target().dispatch(request) else: result = Http404 else: result = Http404 # 判断result是不是future if isinstance(result, Future): Future_Task_Wait[o] = result else: o.sendall(result.content) rlist.remove(o) o.close() except Exception as e: print(e) rm_conn = [] for conn, future in Future_Task_Wait.items(): if future.result: 82 try: conn.sendall(HttpResponse(data=future.result).content) finally: rlist.remove(conn) conn.close() rm_conn.append(conn) for conn in rm_conn: del Future_Task_Wait[conn] def run(self, host='127.0.0.1', port=8000, routers=()): # 主线程select多路复用,处理http请求和响应 # 给协程单独创建一个子线程,负责处理View函数提交的协程 def start_loop(loop): asyncio.set_event_loop(loop) loop.run_forever() self.coroutine_loop = asyncio.new_event_loop() # 创建协程事件循环 run_loop_thread = Thread(target=start_loop, args=(self.coroutine_loop,)) # 新起线程运行事件循环, 防止阻塞主线程 run_loop_thread.start() # 运行线程,即运行协程事件循环 self.listen(host, port, routers)
八、框架测试
现在,可以测试我们的web框架了。
import asyncio from core.server import App from views import View from http.response import * from core.future import Future class IndexView(View): def get(self, request): return HttpResponse('欢迎来到首页') def post(self, request): return HttpResponse('post') def asy(request): future = Future() print('异步调用') wait = request.url.split('/')[-1] try: wait = int(wait) except: wait = 5 asyncio.run_coroutine_threadsafe(dosomething(future, wait), app.coroutine_loop) print('返回Future') return future async def dosomething(future, wait): # 异步函数 await asyncio.sleep(wait)# 模拟异步操作 future.result = '等待了%s秒' % wait routers = [ ('/$', IndexView), ('/home', asy) ] # 从用户角度只需使用run() app = App() app.r 15d1 un('127.0.0.1', 8080, routers=routers)
浏览器访问http://127.0.0.1:8080,返回没有问题,如果有同学使用Chrome可能会乱码,那是因为我们的HttpResponse没有返回指定编码,添加一个响应头即可。
浏览器访问http://127.0.0.1:8080/home,这时候会执行协程,默认等待5s后返回结果,你可以在多个标签页访问这个地址,通过等待时间来验证我们的异步框架是否正常工作。
九、其他
至此,我们要实现的异步非阻塞web框架已经完成了。当然这个框架说到底还是太简陋,后续完全可以优化HttpRequest和HttpResponse、增加对数据库、模板语言等等组件的扩展。
完整源码已经上传至https://github.com/sswest/AsyncWeb
- 异步非阻塞IO的Python Web框架--Tornado
- 200行自定义异步非阻塞Web框架
- 200行自定义异步非阻塞Web框架
- Python web框架 Tornado(二)异步非阻塞
- 200行自定义异步非阻塞Web框架
- 200行自定义异步非阻塞Web框架
- Python Web框架Tornado的异步处理代码示例
- Tornado----自定义异步非阻塞Web框架:Snow
- Python Web框架Tornado的异步处理代码演示样例
- 200行自定义异步非阻塞Web框架
- 基于react16 webpack3 搭建前端spa基础框架 react-router的4种异步加载方式
- 从零开始搭建Electron+Vue+Webpack项目框架,一套代码,同时构建客户端、web端(一)
- nodejs - webpack - ReactJS - AntDesign 项目搭建环境并运用到thinkphp5框架代码中
- 200行自定义python异步非阻塞Web框架
- 200行自定义异步非阻塞Web框架
- 基于react16 webpack3 搭建前端spa基础框架 react-router的4种异步加载方式
- 代码搭建记事本框架(二)
- mocha框架下,异步测试代码错误造成的问题----用例超时错误
- 从零开始写javaweb框架笔记15-搭建轻量级JAVAWEB框架-实现依赖注入功能