Python每日一包：aiohttp

aiohttp详解：异步网络请求的强大利器

hello，今天我们来认识一位Python异步编程的好帮手------aiohttp。别看名字带个'async'就觉得高深，其实它就是个能让网络请求变得超高效的秘密武器！它不仅是一个强大的异步HTTP客户端/服务器框架，更是构建高性能Web应用的得力助手。今天，我们就来一起深入了解这个库，看看它如何帮助我们构建更快速、更高效的网络应用。

什么是aiohttp？

aiohttp是一个基于asyncio的异步HTTP客户端/服务器框架。它利用Python 3.5+引入的async/await语法，提供了一种编写异步网络代码的简洁方式。

简单来说，aiohttp有两大核心功能：

作为HTTP客户端发送请求
作为HTTP服务器处理请求

这种双重身份使它成为全栈异步开发的理想选择。

为什么选择aiohttp？

在众多Python HTTP库中，aiohttp凭什么脱颖而出？

完全异步：基于asyncio，支持非阻塞I/O操作
高性能：能够处理大量并发连接
功能丰富：既是客户端也是服务器，支持WebSocket
易于使用：API设计简洁直观
灵活扩展：中间件、信号和路由系统支持灵活定制

安装aiohttp

安装非常简单：

bash 复制代码

pip install aiohttp

如果需要加速JSON处理，可以额外安装：

bash 复制代码

pip install aiohttp[speedups]

aiohttp作为客户端

基本请求

使用aiohttp发送请求比传统的requests库要求写法不同，因为需要在异步环境中执行：

python 复制代码

import aiohttp
import asyncio

async def fetch_data():
    async with aiohttp.ClientSession() as session:
        async with session.get('https://www.baidu.com') as response:
            print(f"状态码: {response.status}")
            data = await response.json()
            return data

# 运行异步函数
asyncio.run(fetch_data())

注意几个关键点：

使用async with上下文管理器
创建ClientSession对象来发送请求
响应方法如json()、text()、read()都是协程，需要使用await

会话复用

aiohttp强烈建议复用同一个会话，这样可以利用连接池提高性能：

python 复制代码

async def main():
    async with aiohttp.ClientSession() as session:
        # 复用session发送多个请求
        task1 = asyncio.create_task(fetch(session, 'https://api.github.com/events'))
        task2 = asyncio.create_task(fetch(session, 'https://python.org'))

        # 并发执行
        results = await asyncio.gather(task1, task2)
        return results

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

请求参数和头信息

发送带参数的请求：

python 复制代码

async def fetch_with_params():
    async with aiohttp.ClientSession() as session:
        # GET请求带查询参数
        params = {'q': 'python', 'sort': 'stars'}
        async with session.get('https://api.github.com/search/repositories',
                              params=params,
                              headers={'Accept': 'application/vnd.github.v3+json'}) as resp:
            data = await resp.json()
            return data

        # POST请求带JSON数据
        data = {'name': 'John', 'age': 30}
        async with session.post('https://httpbin.org/post',
                               json=data,  # 使用json参数会自动设置Content-Type
                               headers={'Custom-Header': 'value'}) as resp:
            result = await resp.json()
            return result

超时处理

aiohttp默认没有超时设置，建议总是设置超时：

python 复制代码

async def fetch_with_timeout():
    timeout = aiohttp.ClientTimeout(total=10)  # 10秒总超时
    async with aiohttp.ClientSession(timeout=timeout) as session:
        try:
            async with session.get('https://slow.example.com') as response:
                return await response.text()
        except asyncio.TimeoutError:
            print("请求超时!")
            return None

也可以为单个请求设置超时：

python 复制代码

async with session.get('https://example.com', timeout=5) as response:
    # 这个请求5秒超时
    pass

aiohttp作为服务器

创建一个简单的HTTP服务器：

python 复制代码

from aiohttp import web

# 处理函数
async def handle(request):
    name = request.match_info.get('name', "Anonymous")
    return web.Response(text=f"Hello, {name}")

# 异步JSON响应
async def handle_json(request):
    data = {'name': 'John', 'age': 30}
    return web.json_response(data)

# 创建应用
app = web.Application()
app.add_routes([
    web.get('/', handle),
    web.get('/hello/{name}', handle),
    web.get('/api/data', handle_json)
])

# 启动服务
if __name__ == '__main__':
    web.run_app(app, host='127.0.0.1', port=8080)

路由系统

aiohttp提供了灵活的路由系统：

python 复制代码

# 方式1：使用add_routes添加路由列表
app.add_routes([
    web.get('/users', get_users),
    web.post('/users', create_user),
    web.get('/users/{id}', get_user),
    web.delete('/users/{id}', delete_user)
])

# 方式2：使用装饰器（需要先创建路由对象）
routes = web.RouteTableDef()

@routes.get('/api/items')
async def get_items(request):
    return web.json_response([{'id': 1, 'name': 'Item 1'}])

app.add_routes(routes)

中间件

中间件允许你在请求处理前后执行代码：

python 复制代码

@web.middleware
async def error_middleware(request, handler):
    try:
        response = await handler(request)
        return response
    except web.HTTPException as ex:
        return web.json_response({'error': str(ex)}, status=ex.status)
    except Exception:
        return web.json_response({'error': 'Internal server error'}, status=500)

# 应用中间件
app = web.Application(middlewares=[error_middleware])

静态文件服务

提供静态文件服务非常简单：

python 复制代码

app.add_routes([web.static('/static/', '/path/to/static/directory')])

高级特性

WebSocket支持

aiohttp对WebSocket提供了原生支持：

python 复制代码

# 服务端
async def websocket_handler(request):
    ws = web.WebSocketResponse()
    await ws.prepare(request)

    async for msg in ws:
        if msg.type == aiohttp.WSMsgType.TEXT:
            if msg.data == 'close':
                await ws.close()
            else:
                await ws.send_str(f"Echo: {msg.data}")
        elif msg.type == aiohttp.WSMsgType.ERROR:
            print(f'WebSocket连接错误: {ws.exception()}')

    return ws

app.add_routes([web.get('/ws', websocket_handler)])

# 客户端
async def websocket_client():
    async with aiohttp.ClientSession() as session:
        async with session.ws_connect('ws://localhost:8080/ws') as ws:
            await ws.send_str("Hello, WebSocket!")
            async for msg in ws:
                if msg.type == aiohttp.WSMsgType.TEXT:
                    print(f"收到消息: {msg.data}")
                    if msg.data == 'close':
                        await ws.close()
                        break
                elif msg.type == aiohttp.WSMsgType.CLOSED:
                    break
                elif msg.type == aiohttp.WSMsgType.ERROR:
                    break

文件上传

处理文件上传：

python 复制代码

async def file_upload(request):
    reader = await request.multipart()

    # 读取每个字段
    field = await reader.next()
    while field:
        if field.name == 'file':
            # 处理文件
            filename = field.filename
            size = 0
            with open(os.path.join('/tmp', filename), 'wb') as f:
                while True:
                    chunk = await field.read_chunk()
                    if not chunk:
                        break
                    size += len(chunk)
                    f.write(chunk)

            return web.Response(text=f'文件"{filename}"上传成功，大小{size}字节')

        field = await reader.next()

    return web.Response(text='没有找到上传的文件')

实际项目中的最佳实践

1. 合理组织代码结构

对于中大型项目，建议按功能模块组织代码：

bash 复制代码

my_app/
  ├── main.py           # 应用入口
  ├── routes.py         # 路由定义
  ├── middlewares.py    # 中间件
  ├── handlers/         # 请求处理器
  ├── models/           # 数据模型
  ├── utils/            # 工具函数
  └── config.py         # 配置

2. 使用ClientSession注意事项

python 复制代码

# ❌ 错误方式: 频繁创建和销毁会话
async def wrong_way():
    for i in range(100):
        async with aiohttp.ClientSession() as session:
            # 这种方式对每个请求都创建一个新会话，效率低下
            async with session.get(f'https://api.example.com/{i}') as resp:
                pass

# ✅ 正确方式: 复用会话
async def right_way():
    async with aiohttp.ClientSession() as session:
        tasks = []
        for i in range(100):
            tasks.append(session.get(f'https://api.example.com/{i}'))

        responses = await asyncio.gather(*tasks)
        for resp in responses:
            async with resp:
                # 处理响应
                pass

3. 异常处理与错误重试

python 复制代码

async def fetch_with_retry(url, max_retries=3):
    async with aiohttp.ClientSession() as session:
        for attempt in range(max_retries):
            try:
                async with session.get(url) as response:
                    if response.status == 200:
                        return await response.json()
                    elif response.status >= 500:  # 服务器错误可以重试
                        if attempt < max_retries - 1:
                            await asyncio.sleep(2 ** attempt)  # 指数退避
                            continue
                    return None  # 其他状态码不重试
            except (aiohttp.ClientError, asyncio.TimeoutError) as e:
                if attempt < max_retries - 1:
                    await asyncio.sleep(2 ** attempt)  # 指数退避
                    continue
                else:
                    print(f"最终错误: {e}")
                    return None

常见问题与解决方案

1. SSL证书验证问题

有时你可能需要关闭SSL验证（不推荐在生产环境中）：

python 复制代码

import ssl
ssl_context = ssl.create_default_context()
ssl_context.check_hostname = False
ssl_context.verify_mode = ssl.CERT_NONE

async with session.get('https://example.com', ssl=ssl_context) as resp:
    pass

2. 并发控制

防止过多并发请求压垮服务器：

python 复制代码

# 使用信号量限制并发
async def fetch_all(urls):
    semaphore = asyncio.Semaphore(10)  # 最多10个并发请求

    async def fetch_with_semaphore(url):
        async with semaphore:
            async with aiohttp.ClientSession() as session:
                async with session.get(url) as response:
                    return await response.text()

    tasks = [fetch_with_semaphore(url) for url in urls]
    return await asyncio.gather(*tasks)

总结

aiohttp是一个强大而灵活的异步HTTP客户端/服务器框架，特别适合构建高性能的Web应用和API服务。通过利用Python的异步特性，它能够处理大量并发连接，同时保持代码的可读性和可维护性。

从简单的HTTP请求到复杂的WebSocket应用，aiohttp都能胜任。不过，使用aiohttp需要对Python的异步编程有基本了解，尤其是async/await语法和asyncio库的使用。

随着异步编程在Python世界中越来越流行，掌握aiohttp将成为构建高性能网络应用的重要技能。开始尝试将你的同步代码转换为异步模式，体验异步带来的性能提升吧！

记住，异步不是万能的，它主要解决I/O密集型问题，对于CPU密集型任务，可能需要结合其他方案。合理使用aiohttp，让你的应用更快、更强大！