python后台——aiohttp入门

全栈工程师开发手册 （作者：栾鹏）
架构系列文章

aiohttp是python中基于asyncio技术实现的。asyncio可参考https://luanpeng.blog.csdn.net/article/details/81461277

注意: python的异步返回有时是通过异常expection向上冒泡的, 在异步函数中使用try catch有时无法捕获某些异常的, 异常会作为返回结果直接返回给上一层

aiohttp服务器

下面是aiohttp作为服务器端的一个简单的demo。

#!/usr/bin/env python3
import argparse
from aiohttp import web
import asyncio
import base64
import logging
import uvloop
import time,datetime
import json
import requests

asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())


routes = web.RouteTableDef()


@routes.get('/')
async def hello(request):
    return web.Response(text="Hello, world")


# 定义一个路由映射，接收网址参数，post方式
@routes.post('/demo1/{name}')
async def demo1(request):   # 异步监听，只要一有握手就开始触发，此时网址参数中的name就已经知道了，但是前端可能还没有完全post完数据。
    name = request.match_info.get('name', "Anonymous")  # 获取name
    print(datetime.datetime.now())   # 触发视图函数的时间
    data = await request.post()    # 等待post数据完成接收，只有接收完成才能进行后续操作.data['key']获取参数
    print(datetime.datetime.now())   # 接收post数据完成的时间
    logging.info('safety dect request start %s' % datetime.datetime.now())
    result = {'name':name,'key':data['key']}
    logging.info('safety dect request finish %s, %s' % (datetime.datetime.now(),json.dumps(result)))
    return web.json_response(result)


# 定义一个路由映射，设计到io操作
@routes.post('/demo2')
async def demo2(request):   # 异步监听，只要一有握手就开始触发，此时网址参数中的name就已经知道了，但是前端可能还没有完全post完数据。
    data = await request.post()    # 等待post数据完成接收，只有接收完成才能进行后续操作.data['key']获取参数
    logging.info('safety dect request start %s' % datetime.datetime.now())
    res = requests.post('http://www.baidu.com')   # 网路id，会自动切换到其他协成上
    logging.info('safety dect request finish %s' % res.test)
    return web.Response(text="welcome")




if __name__ == '__main__':

    logging.info('server start')
    app = web.Application()
    app.add_routes(routes)
    web.run_app(app,host='0.0.0.0',port=8080)
    logging.info('server close')
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

aiohttp客户端

aiohttp的另一个主要作用是作为异步客户端，用来解决高并发请求的情况。比如现在我要模拟一个高并发请求来测试我的服务器负载情况。所以需要在python里模拟高并发。高并发可以有多种方式，比如多线程，但是由于python本质上是没有多线程的，通过底层线程锁实现的多线程。在模型高并发时，具有线程切换和线程开销的损耗。所以我们就可以使用多协成来实现高并发。

我们就可以使用aiohttp来模拟高并发客户端。demo如下，用来模拟多个客户端向指定服务器post图片。

# 异步并发客户端
class Asyncio_Client(object):

    def __init__(self):
        self.loop=asyncio.get_event_loop()
        self.tasks=[]

    # 将异步函数介入任务列表。后续参数直接传给异步函数
    def set_task(self,task_fun,num,*args):
        for i in range(num):
            self.tasks.append(task_fun(*args))

    # 运行，获取返回结果
    def run(self):
        back=[]
        try:
            f = asyncio.wait(self.tasks)   # 创建future
            self.loop.run_until_complete(f)  # 等待future完成
        finally:
            pass




# 服务器高并发压力测试
class Test_Load():

    total_time=0  # 总耗时
    total_payload=0  # 总负载
    total_num=0  # 总并发数
    all_time=[]

    # 创建一个异步任务，本地测试，所以post和接收几乎不损耗时间，可以等待完成，主要耗时为算法模块
    async def task_func1(self,session):

        begin = time.time()
        # print('开始发送：', begin)
        file=open(self.image, 'rb')
        fsize = os.path.getsize(self.image)
        self.total_payload+=fsize/(1024*1024)

        data = {"image_id": "2", 'image':file}
        r = await session.post(self.url,data=data)  #只post，不接收
        result = await r.json()
        self.total_num+=1
        # print(result)
        end = time.time()
        # print('接收完成：', end,',index=',self.total_num)
        self.all_time.append(end-begin)

    # 负载测试
    def test_safety(self):
        print('test begin')
        async_client = Asyncio_Client()  # 创建客户端
        session = aiohttp.ClientSession()
        for i in range(10):  # 执行10次
            self.all_time=[]
            self.total_num=0
            self.total_payload=0
            self.image = 'xxxx.jpg'  # 设置测试nayizhang
            print('测试图片：', self.image)
            begin = time.time()
            async_client.set_task(self.task_func1,self.num,session)  # 设置并发任务
            async_client.run()   # 执行任务

            end=time.time()
            self.all_time.sort(reverse=True)
            print(self.all_time)
            print('并发数量(个)：',self.total_num)
            print('总耗时(s)：',end-begin)
            print('最大时延(s)：',self.all_time[0])
            print('最小时延(s)：', self.all_time[len(self.all_time)-1])
            print('top-90%时延(s)：', self.all_time[int(len(self.all_time)*0.1)])
            print('平均耗时(s/个)：',sum(self.all_time)/self.total_num)
            print('支持并发率(个/s):',self.total_num/(end-begin))
            print('总负载(MB)：',self.total_payload)
            print('吞吐率(MB/S)：',self.total_payload/(end-begin))   # 吞吐率受上行下行带宽，服务器带宽，服务器算法性能诸多影响

            time.sleep(3)


        session.close()
        print('test finish')
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

aiohttp服务器mvc（静态网页，模板，数据库，log）

aiohttp之添加静态资源路径

所谓静态资源，是指图片、js、css等文件。

以一个小项目来说明，下面是项目的目录结构：

.
├── static
│   ├── css
│   │   ├── base.css
│   │   ├── bootstrap.min.css
│   │   └── font-awesome.min.css
│   ├── font
│   │   ├── FontAwesome.otf
│   │   ├── fontawesome-webfont.eot
│   │   ├── fontawesome-webfont.svg
│   │   ├── fontawesome-webfont.ttf
│   │   └── fontawesome-webfont.woff
│   └── index.html
└── proxy_server.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在proxy_server.py给2个静态文件目录static/css和static/font添加路由：

app.router.add_static('/css/',
                       path='static/css',
                       name='css')
 app.router.add_static('/font/',
                       path='static/font',
                       name='font')
1
2
3
4
5
6

必需的2个参数：

prefix：是静态文件的url的前缀，以/开始，在浏览器地址栏上显示在网站host之后，也用于index.html静态页面进行引用
path：静态文件目录的路径，可以是相对路径，上面代码使用的static/css就是相对路径——相对于proxy_server.py所在路径。

加载的是index.html，下面是它引用静态资源的代码：

<!-- Bootstrap CSS -->
<link href="css/bootstrap.min.css" rel="stylesheet">

<!-- Base CSS -->
<link href="css/base.css" rel="stylesheet">

<!-- FA CSS -->
<link href="css/font-awesome.min.css" rel="stylesheet">
1
2
3
4
5
6
7
8

添加font的路径是因为/font-awesome.min.css需要使用：

如果修改前缀：

 app.router.add_static('/css2017/',
                       path='static/css',
                       name='css')
1
2
3

虽然目录本身还是css，但通过add_static已经将它视为了css2017，在文件和浏览器中要想链接到css下的文件，必须使用css2017/xx.css来链接。

此外，如果加上show_index=True，就可以显示静态资源的目录索引了——默认是禁止访问的：

app.router.add_static('/css2017/',
                       path='static/css',
                       name='css',
                       show_index=True)
1
2
3
4