• 2.1.1. 获取代码
• 2.1.2. 编写逻辑
• • 1. async_viewsets.py
  • 2. serializer
  • 3. views.py
• 2.1.3. 测试

• 2.2.1 daphne启动 同步函数
• 2.2.2 runserver启动同步函数
• 2.2.3 dephne启动异步函数

• 3.1. daphne
• 3.2. pycharm配置方式(windows)

1. adrf库

链接: pypi

1. 介绍
   Async support for Django REST framework
   对 Django REST 框架的异步支持
2. 要求
   Requirements
   Python 3.8+
   Django 4.1+

2. django

2.1. django3.2(此版本只能普通函数实现异步，连接数据库操作不支持异步)

2.1.1. 获取代码

2.1.2. 编写逻辑

1. async_viewsets.py

from apps.adrf.viewsets import ViewSet as AsyncViewSet
from rest_framework import generics, mixins, views
class AsyncGenericViewSet(AsyncViewSet, generics.GenericAPIView):
    # 以后凡是用GenericViewSet的地方都可以用此类替换
2. serializer
 
 
文件位置：apps/app1/serializers.py
 
from apps.adrf.serializers import Serializer as AsyncSerializer
class QASerializer(AsyncSerializer):
    """知识问答历史记录格式"""
    role = serializers.CharField(required=True, max_length=32, allow_null=False, allow_blank=False,
                                 help_text='角色')
    content = serializers.CharField(required=True, max_length=1024, allow_null=False, allow_blank=False,
                                    help_text='内容')
    class Meta:
        fields = ['role', 'content']
3. views.py
 
 
文件位置：apps/app1/views.py
 
import asyncio
from asgiref.sync import sync_to_async
from apps.adrf.async_viewsets import AsyncGenericViewSet  # 2.1中自己写的
class DataKnowledgeViewSet(mixins.RetrieveModelMixin, AsyncGenericViewSet):
    queryset = DataKnowledge.objects.all()
    serializer_class = DataKnowledgeModelSerializer
    def get_serializer_class(self):
        if self.action in ['qa1']:
            self.serializer_class = QASerializer
        return self.serializer_class
	@swagger_auto_schema(operation_description="知识问答",
                         operation_summary='知识问答',
                         tags=['知识'],
                         responses={**SWAGGER_RESPONSE_MESSAGE, 200: 'ok'})
    @action(methods=['POST'], detail=False, url_path='qa1', url_name='qa1')
    async def qa1(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data, many=True)
        serializer.is_valid(raise_exception=True)
        data = await serializer.adata  # data = serializer.data 响应时间差不多
        await asyncio.sleep(2)
        return Response(data)
    @swagger_auto_schema(operation_description="知识问答",
                         operation_summary='知识问答',
                         tags=['知识'],
                         responses={**SWAGGER_RESPONSE_MESSAGE, 200: 'ok'})
    @action(methods=['POST'], detail=False, url_path='qa2', url_name='qa2')
    async def qa2(self, request, *args, **kwargs):
    	msg = random.randint(0,99)
        await asyncio.sleep(2)
        return Response(msg)
    @swagger_auto_schema(operation_description="知识问答",
                         operation_summary='知识问答',
                         tags=['知识'],
                         responses={**SWAGGER_RESPONSE_MESSAGE, 200: 'ok'})
    @action(methods=['POST'], detail=False, url_path='qa3', url_name='qa3')
    def qa3(self, request, *args, **kwargs):
    	msg = random.randint(0, 99)
        return




    
 Response(msg)
2.1.3. 测试
 
不能用requests测不出来。。
 
import time
import asyncio
import aiohttp
import json
async def fetch(session):
    payload = json.dumps([
            "role": "user",
            "content": "dsm出现了红色错误"
    headers = {
        'Content-Type': 'application/json'
    url1 = "http://127.0.0.1:8001/cn/api/data-knowledge/qa1/"
    url2 = "http://127.0.0.1:8001/cn/api/data-knowledge/qa2/"
    url3 = "http://127.0.0.1:8001/cn/api/data-knowledge/qa3/"
    async with session.post(url1, data=payload, headers=headers) as response:
        return await response.text()
async def xxx():
    async with aiohttp.ClientSession() as session:
        html = await fetch(session)
        print(html)
async def main(req_count=10):
    tasks = []
    for i in range(0, req_count):
        task = asyncio.create_task(xxx())
        tasks.append(task)
    await asyncio.wait(tasks)
# 运行异步任务
x1 = time.time()
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
x2 = time.time()
print(x2 - x1)
###结果
# url1
{"message":"OK","code":200,"results":[{"role":"user","content":"dsm出现了红色错误"}]}
{"message":"OK","code":200,"results":[{"role":"user","content":"dsm出现了红色错误"}]}
{"message":"OK","code":200,"results":[{"role":"user","content":"dsm出现了红色错误"}]}
{"message":"OK","code":200,"results":[{"role":"user","content":"dsm出现了红色错误"}]}
{"message":"OK","code":200,"results":[{"role":"user","content":"dsm出现了红色错误"}]}
{"message":"OK","code":200,"results":[{"role":"user","content":"dsm出现了红色错误"}]}
{"message":"OK","code":200,"results":[{"role":"user","content":"dsm出现了红色错误"}]}
{"message":"OK","code":200,"results":[{"role":"user","content":"dsm出现了红色错误"}]}
{"message":"OK","code":200,"results":[{"role":"user","content":"dsm出现了红色错误"}]}
{"message":"OK","code":200,"results":[{"role":"user","content":"dsm出现了红色错误"}]}
2.2377092838287354
# url2
{"message":"OK","code":200,"results":92}
{"message":"OK","code":200,"results":95}
{"message":"OK","code":200,"results":55}
{"message":"OK","code":200,"results":64}
{"message":"OK","code":200,"results":13}
{"message":"OK","code":200,"results":81}
{"message":"OK","code":200,"results":83}
{"message":"OK","code":200,"results":28}
{"message":"OK","code":200,"results":2}
{"message":"OK","code":200,"results":8}
2.2307043075561523
# url3同步函数正常返回
2.2 django4.2及以上
 
连接数据库自带异步？？？adrf存在的意义？
 
普通函数还是可以通过adrf进行异步返回
 
async def qa2(self, request, *args, **kwargs):
	msg = random.randint(0,99)
    await asyncio.sleep(2)
    return Response(msg)
2.2.1 daphne启动 同步函数
 
ModelSerializer
def retrieve(self, request, *args, **kwargs):
     return super().retrieve(request, *args, **kwargs)
单个请求：0.8s
 
 50个请求：2.4s
 
 
2.2.2 runserver启动同步函数
 
ModelSerializer
def retrieve(self, request, *args, **kwargs):
     return super().retrieve(request, *args, **kwargs)
1个请求：0.8s
 50个请求：1.8s
 
2.2.3 dephne启动异步函数
 
AsyncModelSerializer
async def retrieve(self, request, *args, **kwargs):
    instance = await self.aget_object()
    serializer = self.get_serializer(instance)
    data = await serializer.adata
    return Response(data)
单个请求：0.8s
 50个请求：2.4s
 
3. 启动项目
 
runserver开发阶段支持异步，如果想同步那么把下面INSTALLED_APPS 中的daphne注释
 
3.1. daphne
 
 
安装：pip install daphne
 
配置：settings.py
 
INSTALLED_APPS = [
     ...
     'daphne',  # 需要靠前位置
     ...
...
ASYNC_MODE = 'django'  # 不知道啥用
ASGI_APPLICATION = 'service_brain_model.asgi.application'
 
启动：daphne service_brain_model.asgi:application -h 0.0.0.0 -p 8001
 
3.2. pycharm配置方式(windows)
 
如有问题欢迎指正
 
				
大家好，这是皮爷给大家带来的最新的学习Python能干啥？之Django教程的进阶版。
在之前《用Django全栈开发》系列专辑里面，皮爷详细的阐述了如何编写一个完整的网站，具体效果可以浏览线上网站：Peekpa.com
从进阶篇开始，每一篇文章都是干货满满，干的不行。这一节，我们来说：如何让我们的网站对用户更加友好，不需要等待时间，利用Django REST Framework和Ajax实现。
Peekpa.com的官方地址：http://peekpa.com
获取整套教程源码唯一途径，关注『皮爷撸码』，
				
前面我们使用了dwebsocket并使用gunicorn来将其部署在服务器上，但运行几天，我发现了个问题
我有个业务逻辑是前端用户点击某个文件夹的下载按钮，会同时触发两个函数，
第一个函数是服务端接收到该文件夹路径并开始将其压缩成zip然后返回该zip包实现用户下载功能，
第二个函数是后端开始压缩的时候前端要去连接一个ws服务，连接成功后后端实时将压缩进度通过ws发送到前端展示
问题出在这两个函数竟然不是同时进行的，我本以为是多进程问题，添加了log功能后发现这两个函数同时触发的，只是在某个函数开
www.django-rest-framework.org第三方的插件
pip install djangorestframework
settings.py,添加app,rest_framework
导入django.restframework
首先创建一个serializers.py文件
需要导入rest_framework.serializers
class继承serializers.ModelSerializer
把查的模型数据传入序列化（Queryset,many=True）.
upstream daphne{
   # nginx通过socket在环回接口地址的9000端口与本地的daphne进程通信
   # 支持ip:port模式以及socket file模式
   server 127.0.0.1:9000;
upstream uwsgi{
   # nginx通过socket在环回接口地址的9001端口与本地的uWSGI进程通信
   # 支持ip:port模式以及socket 
<script src="https://cdn.jsdelivr.net/npm/vue"></script>
2.django 和vue语法冲突处理需要增加一个标签{% verbatim %}
{% verbatim %}
<div id="app">
    {{ text }} <br><br>
    <button v-on:click="create_server"&..
				
在本章中，我们要大家介绍为什么学习Django REST framework，它能帮助我们做哪些事情。
我们从分析现在流行的前后端分离Web应用模式说起，然后介绍如何设计REST API，通过使用Django来实现一个REST API为例，明确后端开发REST API要做的最核心工作，然后介绍Django REST framework能帮助我们简化开发REST API的工作。
1 Web应用模...
				
Celery文档参考：http://docs.jinkan.org/docs/celery/
参考博客：https://blog.csdn.net/bbwangj/article/details/89312355
Django中异步任务---django-celery
Celery简单介绍：
celery使用场景：
耗时任务 定时任务
	请求结果不怎么重要的
	耗时任务比如：发送短信验证码我们可以先发送给客户任务状态（请求成功或失败）
		请求结果重要的建议使用django实现 比如：支付
在上一篇文章中，链接如下：https://www.cnblogs.com/xiao987334176/p/14361893.html
开发了一个django channles websocket 项目，用的是asgi。官方推荐使用asgi服务器daphne，来处理websocket请求
daphne
Daphne 是一个纯Python编写的应用于UNIX环境的由Django项目维护的ASGI服务器。它扮演着ASGI参考服务器的角色。
安装 Daphne
你可以通过 pip 来安装 Daphne