全局异步处理、接口文档与Django中配置文件配置项的作用

继承APIView分页

class BookView(APIView):

    def get(self, request):
        # 获取所有数据
        qs = Book.objects.all()
        # 实例化得到分页类的对象
        page = YouPageNumberPagination()
        # 调用分页类对象的paginate_queryset方法，完成分页
        # 分页就是切片获取qs[(page-1)*size:page*size]
        res = page.paginate_queryset(qs, request)
        ser = BookSerializer(instance=res, many=True)
        # 调用分页类对象的get_paginated_response方法返回
        return page.get_paginated_response(ser.data)

内置认证类、权限类、频率类

1.内置的认证类
from rest_framework import authentication
'authentication中有内置的认证类'
1.1BasicAuthentication
-所有的基类
1.2RemoteUserAuthentication
-用户登录相关
1.3SessionAuthentication
-session认证(如果没有登录，就不允许访问)
1.4TokenAuthentication
-jwt认证

2.内置的权限类
from rest_framework import permissions
'permissions中有内置的认证类'
2.1BasePermission
-所有的基类
2.2AllowAny
-允许所有
2.3IsAuthenticated
-是否登录了，登录了才有权限
-如果登录了，就返回两个值(当前登录用户，None)，如果没有登录返回None，这时没登录就会被拦截
2.4IsAdminUser
auth的user表中is_staff是否为True(是不是超级管理员)，也就是对后台管理有没有权限

3.内置的频率类
from rest_framework import throttling
'throttling中有内置的认证类'
3.1BaseThrottle
-所有的基类
3.2SimpleRateThrottle
-我们写的频率类都继承它，帮我们少些代码
3.3AnonRateThrottle
-如果你想按IP地址做限制，只需要在配置文件中配置
'DEFAULT_THROTTLE_RATES': {
    'anon': '3/m',
}
3.4UserRateThrottle
-如果你想按用户ID做限制，只需要在配置文件中配置
'DEFAULT_THROTTLE_RATES': {
    'user': '3/m',
}

Django中配置文件配置项的作用

'大写的就是配置项'
-django项目要启动，要先加载配置文件，如果配置文件报错，项目就无法运行

# 项目根路径
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

# 这个是秘钥，自动生成，django中涉及到加密的都使用它，不能为空
SECRET_KEY = ')q9_bynar!mx)vau($i10ju1gn04oaw75$6v(!)ylh0xa@=c-c'

# 如果是True表示是调试模式，调试模式时，抛异常可以在浏览器中看到，如果路径不存在，会提示有哪些可以匹配的路径
DEBUG = True

# 允许项目部署的地址(项目上线后这里写服务器的地址)，debug是False，这个必须加
ALLOWED_HOSTS = []

# 所有app和django提供的内置app
INSTALLED_APPS = [
    # 后台admin
    'django.contrib.admin',
    # 6个权限表
    'django.contrib.auth',
    'django.contrib.contenttypes',
    # 生成django_session表，用于session认证
    'django.contrib.sessions',
    # 消息框架
    'django.contrib.messages',
    # 静态文件
    'django.contrib.staticfiles',
    # 注册app
    'app01.apps.App01Config',
    'rest_framework',
]

# 中间件
MIDDLEWARE = [
    # 与秘钥搭配的安全限制
    'django.middleware.security.SecurityMiddleware',
    # session相关
    'django.contrib.sessions.middleware.SessionMiddleware',
    # 把路径跟路由匹配，如果匹配不成功将路径后加'/'再匹配，如果匹配成功则将该请求重定向到加'/'的地址
    'django.middleware.common.CommonMiddleware',
    # csrf相关
    'django.middleware.csrf.CsrfViewMiddleware',
    # 认证相关
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    # 消息框架，与flask的闪现相同的功能
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

# 根路由，所有请求都会去根路由匹配
ROOT_URLCONF = 'djangoProject01.urls'

# 模板相关
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        # 这个一定要是列表，2.X必须要用os.path.join(BASE_DIR, 'templates')
        'DIRS': [BASE_DIR / 'templates'],
    },
]
# 后期项目上线，使用uwsgi运行这个application，测试阶段使用manage.py运行项目
WSGI_APPLICATION = 'djangoProject01.wsgi.application'

# 数据库配置，可以使用多数据库
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

# auth的认证相关
AUTH_PASSWORD_VALIDATORS = [
]

# 国际化
LANGUAGE_CODE = 'zh-hans'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = False
USE_TZ = True

# 静态文件相关
STATIC_URL = '/static/'
# 所有的自增主键都用BigAutoField
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

过滤类的其他使用

#限制条件:内置的过滤类，只能通过'?search=搜索条件'方法搜索，不能指定'name=三国&publish=出版社'
1.使用django-filter模块
1.1 pip3 install django-filter
1.2配置在视图类中的配置
-filter_backends = [DjangoFilterBackend]
1.3支持的搜索方式
http://127.0.0.1:8008/books/?name=西游记&price=90
-精准搜索，条件是and关系
        
2.使用
class BookView(ModelViewSet):
    # pagination_class = YouPageNumberPagination  # 必须继承GenericAPIView才有这个属性
    # 指定过滤类:第三方过滤类django-filter
    filter_backends = [DjangoFilterBackend]
    # 指定过滤字段:准确匹配，只能按'?name=西游记&price=90'，两个条件是and关系
    filterset_fields = ['name', 'price']
    serializer_class = BookSerializer
    queryset = Book.objects.all()

3.自定义过滤类
3.1写一个类，继承
3.2重写filter_queryset方法，在该方法中实现过滤，返回qs对象
3.3使用
class BookView(ModelViewSet):
    # 自定义过滤类
    filter_backends = [RewriteFilter]
    serializer_class = BookSerializer
    queryset = Book.objects.all()

4.过滤类
class RewriteFilter(BaseFilterBackend):
    def filter_queryset(self, request, queryset, view):
        # 在这里实现过滤，要返回qs对象，过滤后的数据
        print(request.query_params)
        name = request.query_params.get('name', None)
        author = request.query_params.get('author', None)
        # 只要名字中有传过来的name并且作者中有传过来的author即可
        qs = queryset.filter(name__icontains=name, author__icontains=author)
        return qs

'多个过滤类和排序类可以共用，在filter_backends = []中配置，从左往右执行，所以把过滤掉大部分数据的过滤尽可能放在最左侧'

全局异步处理

1.drf中无论在三大认证还是视图类的方法中，只要报错，都能执行一个异常处理的函数
-只要报错，就在APIView的dispatch中捕获，执行了配置文件中的配置
'EXCEPTION_HANDLER': 'rest_framework.views.exception_handler'

2.自己写一个函数，配置在配置文件中，这样出了异常就会返回我们的函数
2.1统一返回格式:{'code':101, 'msg': 错误信息}
2.2记录日志，方便以后排查问题

3.异常函数
import time
from rest_framework.response import Response
from rest_framework.views import exception_handler


def common_exception_handler(exc, context):
    # 记录日志:出了异常才会走这个函数，出了异常就要记录日志
    request = context.get('request')
    try:
        # username可能不存在
        username = request.user.username
    except:
        username = '没有登录'
    # 报错时间
    ctime = time.strftime('%Y-%m-%d %H:%M:%S')
    # 访问接口
    path = request.path
    # 请求类型
    method_type = request.method
    print(f'{username}用户，在{ctime}时间，访问{path}接口，通过{method_type}请求访问，出了错误:{exc}')
    '''以上代码是写到日志中的'''

    # 内置的异常处理函数，只处理了drf的异常(继承了APIException的异常)
    response = exception_handler(exc, context)
    # 如果response有值，说明错误被处理了：Http404(404的)、PermissionDenied(没有权限)、APIException(没有登录)
    if response:
        # 返回drf的错误原因，如果取不到detail，返回未知错误
        return Response({'code': 800, 'msg': 'drf错误，错误原因是:%s' % response.data.get('detail', '未知错误')})
    # 如果是None，说明错误没有被处理，这个错误不是drf的错误，而是django或代码的错误，返回错误对象
    return Response({'code': 900, 'msg': '系统错误，错误原因是:%s' % str(exc)})

4.配置在配置文件
REST_FRAMEWORK = {
    'EXCEPTION_HANDLER': 'app01.exctptions.common_exception_handler',
}

接口文档

1.接口编写好后，就要编写接口文档，给前端人员使用
-请求地址
-请求范式
-支持的编码格式
-请求参数(get、post参数)
-返回格式实例

2.接口文档
2.1直接使用word或者md写
2.2使用接口平台，在接口文档平台录入Yapi(百度开源的要自己搭建)
https://zhuanlan.zhihu.com/p/366025001
'''
https://www.liuqingzheng.top:3000/
输入邮箱：306334678@qq.com
输入密码：admin
'''
2.3第三方平台(是收费的)
https://www.showdoc.com.cn/item/index
2.4自己开发接口文档平台
2.5项目自动生成
-swagger，coreapi
-下载
pip3 install coreapi

-路由中配置
from rest_framework.documentation import include_docs_urls
urlpatterns = [
    path('docs/', include_docs_urls(title='站点页面标题')),
]

-在视图类中加注释
-在序列化类中加注释
class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = '__all__'
        # 必须是help_text
        extra_kwargs = {'name': {'help_text': '图书名'}}

-在配置文件中配置
REST_FRAMEWORK = {
    'DEFAULT_SCHEMA_CLASS': 'rest_framework.schemas.coreapi.AutoSchema',
}

作业

# 自定义一个过滤类，实现可以通过图书名或作者模糊匹配
from rest_framework.filters import BaseFilterBackend
from django.db.models import Q
class RewriteFilter(BaseFilterBackend):
    def filter_queryset(self, request, queryset, view):
        # 在这里实现过滤，要返回qs对象，过滤后的数据
        print(request.query_params)
        name = request.query_params.get('name', None)
        author = request.query_params.get('author', None)
        # 只要名字中有传过来的name或作者中有传过来的author即可
        qs = queryset.filter(Q(name__icontains=name) | Q(author__icontains=author))
        return qs

# 编写一个全局异常处理，让它生效
from rest_framework.response import Response
from rest_framework.views import exception_handler
def common_exception_handler(exc, context):
    # 内置的异常处理函数，只处理了drf的异常(继承了APIException的异常)
    response = exception_handler(exc, context)
    # 如果response有值，说明错误被处理了：Http404(404的)、PermissionDenied(没有权限)、APIException(没有登录)
    if response:
        # 返回drf的错误原因，如果取不到detail，返回未知错误
        return Response({'code': 800, 'msg': 'drf错误，错误原因是:%s' % response.data.get('detail', '未知错误')})
    # 如果是None，说明错误没有被处理，这个错误不是drf的错误，而是django或代码的错误，返回错误对象
    return Response({'code': 900, 'msg': '系统错误，错误原因是:%s' % str(exc)})

--------有能力的写------
使用django-filter实现模糊匹配
1.视图类
class BookView(ModelViewSet):
    filter_backends = [DjangoFilterBackend]
    filterset_class = QueryFilter
    serializer_class = BookSerializer
    queryset = Book.objects.all()


2.过滤类
import django_filters


class QueryFilter(django_filters.FilterSet):
    # 指定name字段的过滤条件为icontains
    name = django_filters.CharFilter(lookup_expr='icontains')
    # 指定author字段的过滤条件为icontains
    author = django_filters.CharFilter(lookup_expr='icontains')

    class Meta:
        model = Book
        fields = {'name', 'author'}