drf9

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

1.内置认证类

BasicAuthentication
RemoteUserAuthentication
SessionAuthentication：session认证，建议自己写
- 如果前端带着cookie过来，经过session的中间件，如果登录了，在request.user中就有当前登录用户
- drf没有限制是否登录
- 加了这个认证，如果没有登录，就不允许往后访问了
TokenAuthentication：jwt认证，建议自己写
建议自己写

2.内置权限类

BasePermission：所有的基类
AllowAny：允许所有
IsAuthenticated：是否登录，登录了才有权限
- 认证类，如果登录了，返回(当前登录用户,None), 如果没有登录返回 None
IsAdminUser：auth的user表中is_staff字段是否为True，对后台管理有没有权限

3.内置频率类

BaseThrottle：所有的基类
SimpleRateThrottle：咱们写频率类都继承它，少写代码
AnonRateThrottle：如果你想按ip地址限制，只需要在配置文件中配置
```
'DEFAULT_THROTTLE_RATES': {
    'anon': '3/m',
}
```
UserRateThrottle:如果你想按用户id限制，只需要在配置文件中配置
```
'DEFAULT_THROTTLE_RATES': {
    'user': '3/m',
}
```

二、django的配置文件每个配置项的作用

必须大写才是配置项
django项目要启动，要先加载配置文件，如果配置文件报错，项目运行不起来

from pathlib import Path
# 项目根路径
BASE_DIR = Path(__file__).resolve().parent.parent

# 密钥，自动生成的，很复杂，django中涉及到加密的都使用它，没有不行
SECRET_KEY = 'django-insecure-4i$6azd399fl$vh9%*7#oald(i&ik(5#i_-y)v&z3g+cxsd$@-'

# 如果是True，项目是调试模式，好处是抛异常在浏览器直接能看到,如果路径不存在，也会提示有哪些路径
DEBUG = True
# 允许项目部署的地址（后期项目上线，这里写服务器的地址），debug是False，这个必须加，不加就报错
ALLOWED_HOSTS = ['*']


# 所有的app，django大而全，就是因为它提供了很多内置的app
INSTALLED_APPS = [
    'django.contrib.admin', # 后台管理admin
    'django.contrib.auth', # 权限，6个表
    'django.contrib.contenttypes',
    'django.contrib.sessions',# session认证相关 ---》django_session表
    'django.contrib.messages', # 消息框架（不了解）
    'django.contrib.staticfiles',# 静态文件
    'app01.apps.App01Config', # app01
    'rest_framework',
]

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


# 根路由，所有请求进来，先去根路由匹配---》内部可能有路由分发
ROOT_URLCONF = 'drf_day08.urls'

# 模板相关
TEMPLATES = [
]

# 后期项目项目上线，uwsgi运行这个application，测试阶段使用manage.py 运行项目
WSGI_APPLICATION = 'drf_day08.wsgi.application'

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

# auth的认证相关

# 国际化
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True

# 静态文件相关
STATIC_URL = '/static/'

# 所有的自增主键都用BigAutoField
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

三、过滤类的其它使用

1.第三方：django-filter

下载：
```
pip3 install django-filter
```

配置在视图类中配置：

filter_backends = [DjangoFilterBackend, ]

配置搜索字段：
```
filterset_fields = ['name', 'publish']
```

支持的搜索方式：

精准搜索，条件是并且关系

http://127.0.0.1:8008/books/?name=三国演义&publish=南京出版社

2.自定义过滤类

写一个类，继承BaseFilterBackend

重写某个方法：filter_queryset，在该方法中实现过滤，返回qs对象

def filter_queryset(self, request, queryset, view):
    # 在这里面实现过滤，一定要返回qs对象，过滤后的数据
    name = request.query_params.get('name', None)
    publish = request.query_params.get('publish', None)
    qs = queryset.filter(name__icontains=name, publish__icontains=publish)
    return qs

配置在视图类上
```
filter_backends = [MyFilter, ]
```

注意：多个过滤类和排序类可以共用，filter_backends=[],可以配置多个，执行顺序是从做往右，所以，放在最左侧的尽量先过滤掉大部分数据

# 面试官问你，你在工作中遇到的问题及如何解决的？

我在写xx接口的时候，因为我们过滤条件很多，搜索数据库很慢，写了很多搜索类，之前时候搜索类的排序是随意的，搜索效率比较低，后来，读了drf搜索类的源码，发现执行顺序是从左往右，我就想到了，最左侧的搜索类，尽量搜索速度快，并且过滤掉的数据多，后续再搜索就会更快，所有我调整了一下搜索类的配置顺序，发现该接口的效率有所提升

四、全局异常处理

drf中无论在三大认证还是视图类的方法中执行，只要报错(主动抛异常)，都能执行一个函数（异常处理的函数）
只要除了异常在APIView的dispatch中捕获了，执行了配置文件中配置的：'EXCEPTION_HANDLER': 'rest_framework.views.exception_handler'
自己写一个函数，配置在配置文件中，以后出了异常，它就走咱们写的函数了
1. 统一返回格式：
2. 记录日志

# 写一个函数
def common_exception_handler(exc, context):
    # 记录日志：只要进入到这里面，一定是出了异常，只要出异常就要记录日志
    request = context.get('request')  # 当此请求的request
    try:
        username = request.user.username
    except:
        username = '没有登录'
    ctime = time.time()
    path = request.path
    method_type = request.method
    print('%s用户，在%s时间，访问%s接口,通过%s请求访问，出了错误：%s' % (username, str(ctime), path, method_type, str(exc)))
    # 后期以上的代码要写到日志中
    
    
    response = exception_handler(exc, context)  # 内置的这个异常处理函数，只处理了drf自己的异常(继承了了APIException的异常)
    if response:  # 如果response有值，说明错误被处理了(Http404,PermissionDenied,APIException)
        return Response({'code': 888, 'msg': 'drf错误,错误原因是:%s' % response.data.get('detail', '未知错误')})
    else:  # 如果是None，这个错误没有被处理，说明这个错误不是drf的错误，而是django的或代码的错误
        return Response({'code': 999, 'msg': '系统错误，错误原因是：%s' % str(exc)})
    
    
# 配置在配置文件中
REST_FRAMEWORK = {
    'EXCEPTION_HANDLER': 'app01.exctptions.common_exception_handler'
}

五、接口文档

接口编写已经写完了,需要编写接口文档，给前端的人使用

请求地址
请求方式
支持的编码格式
请求参数（get，post参数）
返回格式示例

公司里的写法：

直接word或md写
使用接口文档平台，在接口文档平台录入（Yapi（百度开源的自己搭建）,第三方平台（收费），自己开发接口文档平台）
- Yapi：不想花钱，没有能力开发，就使用开源的YAPI（参考文档：https://zhuanlan.zhihu.com/p/366025001）
- 第三方平台（收费）：https://www.showdoc.com.cn/item/index

项目自动生成：swagger，coreapi

下载：
```
pip3 install coreapi
```

路由配置：

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

在视图类中加注释

在配置文件中配置

REST_FRAMEWORK = {
    'DEFAULT_SCHEMA_CLASS': 'rest_framework.schemas.coreapi.AutoSchema',
}

注意：

直接在视图类中写注释
在序列化类写help_text

作业

settings.py

REST_FRAMEWORK = {
    'EXCEPTION_HANDLER': 'app01.exceptions.common_exception_handler'
}

views.py

import uuid

# Create your views here.
from rest_framework.decorators import action
from rest_framework.generics import ListAPIView
from rest_framework.response import Response
from rest_framework.viewsets import ViewSetMixin, ViewSet

from app01.auth import LoginAuth
from app01.models import Book, User, UserToken
from app01.serializer import BookSerializer
from app01.filter import DiyFilter


class BookView(ViewSetMixin, ListAPIView):
    authentication_classes = [LoginAuth, ]
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    filter_backends = [DiyFilter, ]


class UserView(ViewSet):
    @action(methods=['POST', ], detail=False, url_path='login')
    def login(self, request):
        username = request.data.get('username')
        password = request.data.get('password')
        user = User.objects.filter(username=username, password=password).first()
        if user:
            token = str(uuid.uuid4())
            UserToken.objects.update_or_create(defaults={'token': token}, user=user)
            return Response({'code': 100, 'msg': '登录成功', 'token': token})
        else:
            return Response({'code': 101, 'msg': '用户名或密码错误'})

serializer.py

from rest_framework import serializers

from app01.models import Book


class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = "__all__"

models.py

from django.db import models


# Create your models here.
class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.IntegerField()
    author = models.CharField(max_length=32)
    publish = models.CharField(max_length=32)


class User(models.Model):
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=32)

    def __str__(self):
        return self.username


class UserToken(models.Model):
    user = models.OneToOneField(to='User', on_delete=models.CASCADE)
    token = models.CharField(max_length=64, null=True)

exceptions.py

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 = request.user.username
    except:
        username = '没有登录'
    ctime = time.time()
    path = request.path
    method_type = request.method
    print('%s用户，在%s时间，访问%s接口，通过%s请求访问，出了错误：%s' % (username, str(ctime), path, method_type, str(exc)))
    response = exception_handler(exc, context)
    if response:
        return Response({'code': 888, 'msg': 'drf错误,错误原因是:%s' % response.data.get('detail', '未知错误')})
    else:
        return Response({'code': 999, 'msg': '系统错误，错误原因是：%s' % str(exc)})

auth.py

from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed

from app01.models import UserToken


class LoginAuth(BaseAuthentication):
    def authenticate(self, request):
        token = request.META.get('HTTP_TOKEN')
        user_token = UserToken.objects.filter(token=token).first()
        if user_token:
            return user_token.user, token
        else:
            raise AuthenticationFailed('您没有登录')

filter.py

from django.db.models import Q
from rest_framework.filters import BaseFilterBackend


class DiyFilter(BaseFilterBackend):
    def filter_queryset(self, request, queryset, view):
        name = request.query_params.get('name', None)
        author = request.query_params.get('author', None)
        queryset = queryset.filter(Q(name__contains=name) | Q(author__contains=author))
        return queryset

urls.py

from django.contrib import admin
from django.urls import path
from app01 import views
from rest_framework.routers import SimpleRouter


router = SimpleRouter()
router.register('books', views.BookView, 'books')
router.register('user', views.UserView, 'user')

urlpatterns = [
    path('admin/', admin.site.urls),
]
urlpatterns += router.urls

posted on 2022-10-11 21:24 念白SAMA 阅读(48) 评论(0) 收藏举报

刷新页面返回顶部