python模块之aioHttp 异步请求

python模块之aioHttp 异步请求
一、简介

aiohttp 是一个基于异步的 Python HTTP 客户端/服务器框架，它允许你编写高性能的异步网络应用程序。它建立在 Python 的协程和异步 I/O 模型上，并利用了 Python 3.5+ 中引入的 asyncio 库。官网：https://docs.aiohttp.org
1. 异步支持：aiohttp 基于 asyncio 库，充分利用了 Python 的协程和异步 I/O 模型，可以处理大量并发请求而不阻塞其他任务。这使得它非常适合编写高性能的网络应用程序。
  客户端功能：aiohttp 提供了一个强大的异步 HTTP 客户端，可以发送各种类型的 HTTP 请求（GET、POST、PUT、DELETE 等）。它支持自定义请求头、查询参数、请求体，并可以处理响应的文本、字节、JSON 等格式。
2. 服务器功能：aiohttp 还提供了一个异步 HTTP 服务器框架，可以用于构建高性能的 Web 应用程序。你可以定义路由、处理请求和响应、处理表单数据、设置静态文件等。
3. WebSocket 支持：aiohttp 提供了对 WebSocket 协议的支持，可以轻松地建立双向通信的实时应用程序。
  中间件支持：aiohttp 具有中间件机制，你可以编写自定义中间件来处理请求和响应，例如身份验证、日志记录、错误处理等。
4. Cookie 和会话管理：aiohttp 提供了对 Cookie 的支持，可以方便地设置和处理 Cookie。此外，它还支持会话管理，可以跟踪用户的会话状态。
5. SSL/TLS 支持：aiohttp 支持使用 SSL/TLS 加密进行安全的 HTTPS 通信。
6. 扩展性：aiohttp 具有模块化的设计，允许你使用插件和扩展来增加功能，例如模板引擎、数据库集成等
二、安装
```
pip install aiohttp
1
```
三、ClientSession 类的方法和属性
1. aiohttp.ClientSession()：异步 HTTP 客户端会话，用于管理与服务器的连接池，返回ClientSession对象
- connector：连接器对象，用于管理连接池和处理底层的网络连接。
- loop：事件循环对象。
- cookies：CookieJar 对象，用于管理会话的 Cookie。
- headers：默认的请求头部信息，可以是字典。
- skip_auto_headers：不自动添加的默认头部信息，可以是列表。
- auth：默认的身份验证信息，可以是 aiohttp.BasicAuth 或 aiohttp.DigestAuth 对象。
- json_serialize：JSON 序列化函数，默认为 json.dumps。
- version：HTTP 版本，默认为 aiohttp.HttpVersion11。
- cookie_jar：CookieJar 对象，用于管理会话的 Cookie。
- read_timeout：读取超时时间（秒）。
- conn_timeout：连接超时时间（秒）。
- raise_for_status：是否在收到非 2xx 响应时引发异常。
- trust_env：是否信任环境变量中的代理设置。
- ws_response_class：WebSocket 响应类，默认为 aiohttp.ClientResponse。
1. ClientSession.request(method, url, **kwargs)：发送自定义的 HTTP 请求，并返回一个 ClientResponse 对象。
- method：请求的方法，如 ‘GET’、‘POST’ 等。
- url：请求的 URL。
- params：URL 查询参数，可以是字典。
- data：请求的数据，可以是字符串或字节。
- json：JSON 数据，会自动设置请求的 ‘Content-Type’ 为 ‘application/json’。
- headers：请求的头部信息，可以是字典。
- skip_auto_headers：不自动添加的头部信息，可以是列表
- cookies：请求的 Cookie，可以是字典或 http.cookies.SimpleCookie 对象。
- auth：身份验证信息，可以是 aiohttp.BasicAuth 或
  aiohttp.DigestAuth 对象。
- allow_redirects：是否允许重定向。
- max_redirects：最大重定向次数。
- encoding：请求的编码方式。
- compress：是否启用压缩。
- chunked：是否启用分块传输编码。
- expect100：是否启用 “Expect: 100-continue”。
- read_until_eof：是否读取直到响应结束。
- proxy：代理 URL。
- proxy_auth：代理身份验证信息，可以是 aiohttp.BasicAuth 或 aiohttp.DigestAuth 对象。
- timeout：请求超时时间（秒）。
- ssl：SSL/TLS 配置。
- proxy_headers：代理请求的头部信息，可以是字典。
- trace_request_ctx：请求上下文。
1. ClientSession.get(url, **kwargs)：发送 GET 请求，参数与 request() 方法相同，返回一个 ClientResponse 对象
2. ClientSession.post(url, **kwargs)：发送 POST 请求，参数与 request() 方法相同，返回一个 ClientResponse 对象
3. ClientSession.options(url, **kwargs)：发送 OPTIONS 请求。参数与 request() 方法相同，返回一个 ClientResponse 对象
4. ClientSession.head(url, **kwargs、s)：发送 HEAD 请求。参数与 request() 方法相同，返回一个 ClientResponse 对象
5. ClientSession.put(url, **kwargs)：发送 PUT 请求。参数与 request() 方法相同，返回一个 ClientResponse 对象
6. ClientSession.patch(url, **kwargs)：发送 PATCH 请求。参数与 request() 方法相同，返回一个 ClientResponse 对象
7. ClientSession.delete(url, **kwargs)：发送 DELETE 请求。参数与 request() 方法相同，返回一个 ClientResponse 对象
8. ClientSession.ws_connect(url, **kwargs)：创建一个 WebSocket 连接。
- url：WebSocket 的 URL。
- protocols：协议列表。
- timeout：连接超时时间（秒）。
- max_msg_size：最大消息大小。
- autoclose：是否自动关闭连接。
- autoping：是否自动发送心跳。
- heartbeat：心跳间隔时间（秒）。
- headers：请求的头部信息，可以是字典。
- proxy：代理 URL。
- proxy_auth：代理身份验证信息，可以是 aiohttp.BasicAuth 或 aiohttp.DigestAuth 对象。
- ssl：SSL/TLS 配置。
- origin：请求的来源。
- compress：是否启用压缩。
- method：请求的方法，默认为 ‘GET’。
- auth：身份验证信息，可以是 aiohttp.BasicAuth 或
- aiohttp.DigestAuth 对象。
- loop：事件循环对象
1. ClientSession.close()：关闭 ClientSession 对象，释放与服务器的连接。
2. ClientSession.cookie_jar：一个 CookieJar 对象，用于管理 Cookie。
3. ClientSession.headers：一个 CIMultiDictProxy 对象，表示请求的头部信息。
4. ClientSession.cookies：默认的 Cookie。
5. ClientSession.connector：一个 TCPConnector 对象，用于管理与服务器的连接。
6. ClientSession.timeout：一个 Timeout 对象，用于设置请求的超时时间。
7. ClientSession.get_connector(self)：获取连接器对象。
8. ClientSession.loop：事件循环对象。
9. ClientSession.auth：默认的身份验证信息。
10. ClientSession.raise_for_status：是否在收到非 2xx 响应时引发异常。
11. ClientSession.trust_env：是否信任环境变量中的代理设置。
四、ClientResponse 类的方法和属性
1. ClientResponse.status：响应的状态码。
2. ClientResponse.reason：响应的原因短语。
3. ClientResponse.headers：响应的头部信息，一个 CIMultiDictProxy 对象。
4. ClientResponse.cookies：响应的 Cookie，一个 CookieJar 对象。
5. ClientResponse.content：响应的内容，以字节形式返回
- content.read()：读取响应内容的原始字节。await response.content.read()
- content.readany()：读取响应内容的原始字节，返回一个 bytes 对象。await response.content.readany()
- content.readline()：读取响应内容的原始字节，返回一个 bytes 对象。await response.content.readline()
1. ClientResponse.read()：读取响应的内容，以字节形式返回。
2. ClientResponse.text()：以文本形式返回响应的内容。
3. ClientResponse.json()：将响应的内容解析为 JSON 格式，并返回解析后的对象。
4. ClientResponse.raise_for_status()：如果响应的状态码表明请求失败（4xx 或 5xx），则引发一个异常。
5. ClientResponse.raw_headers：响应的原始头部信息，以元组列表的形式返回。
6. ClientResponse.url：响应的 URL。
7. ClientResponse.release()：释放响应对象的资源。
8. ClientResponse.close()：关闭响应对象。
9. ClientResponse.get_encoding()：获取响应的编码方式。
10. ClientResponse.get_content_type()：获取响应的内容类型。
11. ClientResponse.get_links()：获取响应中的链接信息。
12. ClientResponse.get_history()：获取重定向历史记录。
13. ClientResponse.get_request_info()：获取请求信息对象。
14. ClientResponse.get_writer()：获取写入器对象。
15. ClientResponse.get_task()：获取任务对象。
16. ClientResponse.get_loop()：获取事件循环对象。
17. ClientResponse.get_traces()：获取跟踪信息。
18. ClientResponse.get_timer()：获取计时器对象。
19. ClientResponse.get_continue()：检查是否收到 “100 Continue” 响应。
20. ClientResponse.ok：布尔值，表示响应是否成功（状态码为 2xx）。
21. ClientResponse.reason_phrase：响应的状态原因短语。
22. ClientResponse.content_type：响应的内容类型。
23. ClientResponse.content_length：响应的内容长度。
24. ClientResponse.charset：响应的字符编码。
25. ClientResponse.history：重定向历史记录。
26. ClientResponse.request_info：请求信息对象。
27. ClientResponse.writer：写入器对象。
28. ClientResponse.task：任务对象。
29. ClientResponse.loop：事件循环对象。
30. ClientResponse.traces：跟踪信息。
31. ClientResponse.timer：计时器对象。
32. ClientResponse.continue100：是否收到 “100 Continue” 响应。
33. ClientResponse.connection：响应的连接对象。
34. ClientResponse.is_eof()：检查响应是否已经结束。
五、ClientRequest 类的方法和属性
1. aiohttp.ClientRequest()：异步 HTTP 客户端的请求对象，用于构建和发送 HTTP 请求，返回ClientRequest对象
- method：请求的方法，如 ‘GET’、‘POST’ 等。
- url：请求的 URL。
- params：URL 查询参数，可以是字典。
- headers：请求的头部信息，可以是字典。
- skip_auto_headers：不自动添加的头部信息，可以是列表。
- data：请求的数据，可以是字符串或字节。
- json：JSON 数据，会自动设置请求的 ‘Content-Type’ 为 ‘application/json’。
- cookies：请求的 Cookie，可以是字典或 http.cookies.SimpleCookie 对象。
- auth：身份验证信息，可以是 aiohttp.BasicAuth 或
- aiohttp.DigestAuth 对象。
- allow_redirects：是否允许重定向。
- max_redirects：最大重定向次数。
- encoding：请求的编码方式。
- compress：是否启用压缩。
- chunked：是否启用分块传输编码。
- expect100：是否启用 “Expect: 100-continue”。
- read_until_eof：是否读取直到响应结束。
- proxy：代理 URL。
- proxy_auth：代理身份验证信息，可以是 aiohttp.BasicAuth 或
  aiohttp.DigestAuth 对象。
- timeout：请求超时时间（秒）。
- ssl：SSL/TLS 配置。
- proxy_headers：代理请求的头部信息，可以是字典。
- trace_request_ctx：请求上下文。
六、web之aiohttp.web.Application()
1. aiohttp.web.Application(**kwargs) 创建 Web 应用程序，app = aiohttp.web.Application()
- router：指定应用程序的路由表对象。默认为 None，表示将创建一个新的路由表对象。
- middlewares：指定应用程序的中间件列表。中间件是在请求处理过程中执行的额外操作，例如身份验证、日志记录等。默认为一个空列表。
- default_host：指定应用程序的默认主机名。默认为 None，表示没有默认主机。
- default_port：指定应用程序的默认端口号。默认为 None，表示没有默认端口。
- client_max_size：指定应用程序接受的请求体的最大大小（以字节为单位）。默认为 1024^2（1MB）。
- loop：指定应用程序使用的事件循环。默认为 None，表示使用 * asyncio.get_event_loop() 获取默认事件循环。
- handler_args：指定传递给请求处理函数的额外参数。默认为一个空字典。
- debug：指定是否启用调试模式。调试模式下，应用程序会提供更详细的错误信息。默认为 False
1. app.router：获取应用程序的路由表对象，用于定义和管理应用程序的路由。
2. app.add_routes(routes)：向应用程序添加一组路由。routes 参数可以是 aiohttp.web.RouteTableDef 对象或包含路由的可迭代对象。
3. app.on_startup(callback, *args, **kwargs)：注册应用程序启动时要调用的回调函数。callback 是要注册的回调函数，*args 和 **kwargs 是传递给回调函数的额外参数。
4. app.on_shutdown(callback, *args, **kwargs)：注册应用程序关闭时要调用的回调函数。callback 是要注册的回调函数，args 和 **kwargs 是传递给回调函数的额外参数。
5. app.cleanup()：清理应用程序的资源。这将依次调用已注册的关闭回调函数。
6. app.make_handler(,access_log_class=AccessLogger, access_log_format=DEFAULT_ACCESS_LOG_FORMAT, access_log=DEFAULT_ACCESS_LOG_FORMAT, **kwargs)：创建一个 aiohttp.web.RequestHandler 对象，用于处理 HTTP 请求。
- access_log_class：指定访问日志的记录器类。默认为 AccessLogger，用于记录请求的访问日志。
- access_log_format：指定访问日志的格式。默认为 DEFAULT_ACCESS_LOG_FORMAT，包含常见的访问日志字段。
- access_log：指定访问日志的格式。默认为 DEFAULT_ACCESS_LOG_FORMAT，与 access_log_format 参数相同。
1. app.middlewares：应用程序的中间件列表。中间件可以在请求处理过程中执行额外的操作，例如身份验证、日志记录等。
- app.middlewares.append(middleware_handler)：添加中间件
- app.middlewares.remove(middleware_handler)：移除中间件
- app.middlewares.clear()：清空中间件列表
1. app.on_startup：应用程序启动时要调用的回调函数列表。
2. app.on_shutdown：应用程序关闭时要调用的回调函数列表。
3. app.route：获取应用程序的路由器对象
- app.route.add_route(method, path, handler, *, name=None)：添加一个路由
- method：HTTP 方法，指定该路由匹配的请求方法。可以是字符串或字符串列表。
  - path：URL 路径模式，指定该路由匹配的 URL 路径。
  - handler：处理该路由的处理程序。可以是一个函数、一个类的方法，或者是一个 web.View 的子类。
  - name：可选，路由的名称，用于在应用程序中引用该路由。
- app.route.add_get(path, handler, *, name=None)：添加一个 GET 请求方法的路由。
- app.route.add_post(path, handler, *, name=None)：添加一个 POST 请求方法的路由。
- app.route.add_put(path, handler, *, name=None)：添加一个 PUT 请求方法的路由。
- app.route.add_delete(path, handler, *, name=None)：添加一个 DELETE 请求方法的路由。
- app.route.add_static(prefix, path, *, name=None)：添加一个静态文件路由
  - prefix：URL 前缀，用于匹配静态文件请求的 URL。
  - path：静态文件目录的路径。
  - name：可选，路由的名称，用于在应用程序中引用该路由
- app.route.add_view(path, handler, *, name=None)：添加一个基于类的视图路由。
  - path：URL 路径模式，指定该路由匹配的 URL 路径。
  - handler：处理该路由的视图类。
  - name：可选，路由的名称，用于在应用程序中引用该路由。
七、web之 web.RouteTableDef()路由表
1. web.RouteTableDef() 创建路由表，routes = web.RouteTableDef()
2. @routes.route(method,path, **kwargs)
3. routes.get(path, **kwargs)
4. @routes.post(path, **kwargs)
5. @routes.put(path, **kwargs)
6. @routes.patch(path, **kwargs)
7. @routes.delete(path, **kwargs)
8. @routes.options(path, **kwargs)
9. @routes.head(path, **kwargs)
10. @routes.trace(path, **kwargs)
11. routes.static() 装饰器添加静态文件路由
八、web之 web.Response 创建并返回给客户端的 HTTP 响应对象
1. web.Response() 创建并返回给客户端的 HTTP 响应对象，reponse = web.Response()
- body：响应体的内容。可以是字符串、字节串或文件对象。默认为 None。
- status：响应的状态码。默认为 200。
- reason：响应状态码的原因短语。默认为 None，将根据状态码自动确定原因短语。
- text：响应体的内容，以字符串形式。与 body 参数互斥，只能选择其中一个。
- content_type：响应的内容类型。默认为 None，表示不指定内容类型。
- charset：响应的字符集。默认为 None。
- headers：响应的自定义头部。可以是一个字典或 aiohttp 的 CIMultiDict 对象。
- content_encoding：响应体的内容编码。默认为 None。
- zlib_executor_size：指定用于压缩响应体的线程池的大小。它是一个整数值，表示线程池中的线程数量。默认为 None，表示不使用线程池压缩响应体。
- zlib_executor：指定用于压缩响应体的线程池。它是一个 * concurrent.futures.Executor 对象，用于执行压缩操作。默认为 None。
1. body：响应体的内容。可以是字符串、字节串或文件对象。
2. status：响应的状态码。
3. reason：响应状态码的原因短语。
4. text：响应体的内容，以字符串形式。
5. content_type：响应的内容类型。
6. charset：响应的字符集。
7. headers：响应的头部，一个 aiohttp 的 CIMultiDict 对象。
8. content_encoding：响应体的内容编码。
9. cookies：响应的 cookie，一个 aiohttp 的 CIMultiDict 对象。
10. chunked：表示响应是否使用分块传输编码。
九、web之 web.Request 获取请求相关的信息和属性，路由中参数都会有一个request
1. request.method：请求的 HTTP 方法，如 GET、POST 等。
2. request.path：请求的路径部分。
3. request.query_string：请求的查询字符串部分。
4. request.headers：请求的头部，一个 aiohttp 的 CIMultiDict 对象。
5. request.cookies：请求的 cookie，一个 aiohttp 的 CIMultiDict 对象。
6. request.content_type：请求的内容类型。
7. request.charset：请求的字符集。
8. request.query：解析后的查询参数，一个 MultiDictProxy 对象。
9. request.match_info：URL 匹配的信息，一个 MatchInfo 对象。
10. request.version：HTTP 版本。
11. request.host：请求的主机名。
12. request.scheme：请求的协议方案，如 “http” 或 “https”。
13. request.remote：请求的远程地址信息。
14. request.app：请求所属的 Application 对象。
十、web之 web.WebSocketResponse，处理 WebSocket 连接，提供了与客户端进行双向通信的接口
1. web.WebSocketResponse() 创建socket对象，ws = web.WebSocketResponse()
2. ws.prepare(request): 准备 WebSocket 连接。在处理 WebSocket 连接之前，需要先调用这个方法进行准备。
3. ws.send_str(data): 发送文本消息给客户端。
4. ws.send_bytes(data): 发送二进制消息给客户端。
5. ws.receive(): 接收客户端发送的消息。返回一个 WSMessage 对象，其中包含消息的类型和数据。
6. ws.close(): 关闭 WebSocket 连接。
7. ws.closed: WebSocket 连接是否已关闭。
8. ws.exception(): 如果 WebSocket 连接因异常而关闭，返回关闭时的异常对象。
十一、web之 aiohttp.CookieJar 管理 Cookie
1. aiohttp.CookieJar(unsafe=True)：创建cookiejar，cookie_jar = aiohttp.CookieJar(unsafe=True)
2. cookie_jar.update_cookies(cookies, response_url=None)：从字典或 http.cookies.SimpleCookie 对象中更新 Cookie。可以通过指定 response_url 参数来限制 Cookie 的作用域。
3. cookie_jar.filter_cookies(url)：根据给定的 URL 过滤并返回适用于该 URL 的 Cookie。返回一个 http.cookies.SimpleCookie 对象。
4. cookie_jar.clear()：清除所有的 Cookie。
5. cookie_jar.load(filename)：从文件中加载 Cookie。
6. cookie_jar.save(filename)：将 Cookie 保存到文件中。
十二、案例
1. 爬取英雄联盟官方皮肤
```
'''网址：https://101.qq.com/#/hero'''import aiohttp
import asyncio
import json
import os

class LOL:

    request_url = {
        'hero_info': 'https://game.gtimg.cn/images/lol/act/img/js/heroList/hero_list.js?ts=2822604',
        'skin': 'https://game.gtimg.cn/images/lol/act/img/skin/big{}00{}.jpg'    }

    headers = {
        'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36'    }

    def __init__(self):
        pass    async def get_hero(self):
        async with aiohttp.ClientSession() as request:
            response = await request.get(self.request_url['hero_info'],headers=self.headers)
            hero_json_str = await response.text()
            task_list = []
            for item in json.loads(hero_json_str)['hero']:
                task = asyncio.create_task(self.get_skin(request,item))
                task_list.append(task)
            await asyncio.wait(task_list)

    async def get_skin(self,request,hero_info):
        if not os.path.exists(hero_info["name"]):
            os.mkdir(hero_info["name"])
        for nu in range(30):
            response = await request.get(self.request_url['skin'].format(hero_info['heroId'], nu))
            if response.status == 200:
                skin_info = await response.read()
                with open(f'{hero_info["name"]}{os.sep}{nu}.jpg', 'wb') as file:
                    file.write(skin_info)
                    print('英雄皮肤已下载')
            else:
                breakif __name__ == '__main__':
    lol = LOL()
    asyncio.run(lol.get_hero())
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
```
2. 创建web应用程序之web.RouteTableDef()
```
from aiohttp import web
import os

routes = web.RouteTableDef()

@routes.get('/') #访问http://localhost:8009/
def index(request):
    response = web.Response(text="Hello, world!")
    return response

@routes.route('GET','/test') #访问http://localhost:8009/test
def test(request):
    response = web.Response(text="测试")
    return response

routes.static('/skin',path=os.path.join(os.getcwd(),'img')) #访问http://localhost:8009/skin/万花通灵/0.jpg
web.static('/skin',path=os.path.join(os.getcwd(),'img')) #访问http://localhost:8009/skin/万花通灵/0.jpg

app = web.Application()
app.add_routes(routes)
web.run_app(app,host='localhost',port=8009)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
```
3. 创建web应用程序之app.router
```
from aiohttp import web
import os


def index(request):
    response = web.Response(text="Hello, world!")
    return response

def test(request):
    response = web.Response(text="测试")
    return response

app = web.Application()

app.router.add_get('/',index)#访问http://localhost:8009/
app.router.add_route('GET','/test',test) #访问http://localhost:8009/test
app.router.add_static('/skin',path=os.path.join(os.getcwd(),'img')) #访问http://localhost:8009/skin/万花通灵/0.jpg
web.static('/skin',path=os.path.join(os.getcwd(),'img')) #访问http://localhost:8009/skin/万花通灵/0.jpg


web.run_app(app,host='localhost',port=8009)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
```
4. 创建web应用程序之中间件
```
from aiohttp import web

# 定义全局中间件函数
@web.middleware
async def middleware_handler(request, handler):
    # 在请求处理之前执行的代码
    print('全局请求处理之前执行的代码')

    # 调用下一个中间件或请求处理函数
    response = await handler(request)

    # 在请求处理之后执行的代码
    print('全局请求处理之后执行的代码')

    return response

# 定义test路由中间件函数
@web.middleware
async def test_handler(request, handler):
    # 在请求处理之前执行的代码
    print('test路由在请求处理之前执行的代码')

    # 调用下一个中间件或请求处理函数
    response = await handler(request)

    # 在请求处理之后执行的代码
    print('test路由在请求处理之后执行的代码')

    return response



# 创建应用程序
app = web.Application()
routes = web.RouteTableDef()

@routes.get('/')
async def index(request):
    return web.Response(text='首页')


# 定义处理函数
async def test_response(request):
    return web.Response(text='测试')

@routes.get('/test')
async def test(request):
    response = await test_handler(request,test_response)
    return  response


# 将中间件添加到应用程序
app.middlewares.append(middleware_handler)
app.add_routes(routes)

web.run_app(app,host='localhost',port=8009)
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
```
5. websocket案例
```
from aiohttp import web

# WebSocket 处理函数
async def websocket_handler(request):
    ws = web.WebSocketResponse()  # 创建 WebSocketResponse 对象
    await ws.prepare(request)  # 准备 WebSocket 连接

    async for msg in ws:  # 处理 WebSocket 的消息
        if msg.type == web.WSMsgType.TEXT:
            if msg.data == 'close':
                await ws.close()
            else:
                await ws.send_str('You said: ' + msg.data)
        elif msg.type == web.WSMsgType.ERROR:
            print('WebSocket connection closed with exception %s' % ws.exception())

    return ws

# 创建应用程序
app = web.Application()

# 将 WebSocket 处理函数添加到路由中
app.router.add_get('/ws', websocket_handler)

# 运行应用程序
web.run_app(app)

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
```
相关阅读:
【多线程进阶】死锁问题
 除了中国知网和谷歌文学还有哪些好的有权威的资源站？
vue3中使用百度地图
 JavaScript 数组
 3.4 延迟渲染
 设计模式：备忘录模式（C#、JAVA、JavaScript、C++、Python、Go、PHP）
初学C#必须要掌握的基础例题
 【洛谷 P1152】欢乐的跳题解（枚举+位集合）
【JavaScript】Math对象知识全解
 【C语言】新类型，结构体篇-----深入理解结构体，结构体成员的访问，结构体的大小和新概念偏移量！【图文详解】
原文地址：https://blog.csdn.net/randy521520/article/details/132712183

一、简介

二、安装

三、ClientSession 类的方法和属性

四、ClientResponse 类的方法和属性

五、ClientRequest 类的方法和属性

六、web之aiohttp.web.Application()

七、web之 web.RouteTableDef()路由表

八、web之 web.Response 创建并返回给客户端的 HTTP 响应对象

九、web之 web.Request 获取请求相关的信息和属性，路由中参数都会有一个request

十、web之 web.WebSocketResponse，处理 WebSocket 连接，提供了与客户端进行双向通信的接口

十一、web之 aiohttp.CookieJar 管理 Cookie

十二、案例