drf之内置认证，权限，频率类，全局异常捕获

---

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

1.认证类

# 我们之前在写认证类的时候都是继承的BaseAuthentication然后我们查看源码的时候有几个认证类也是继承的BaseAuthentication并且也是重写了authenticate方法 所以我们看看有几个内置认证类

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

2.权限类

# 权限类也是一样的
    -BasePermission：所有的基类
    -AllowAny：允许所有
    -IsAuthenticated：是否登录，登录了才有权限
        -认证类，如果登录了，返回(当前登录用户,None), 如果没有登录返回 None
　　　　    这个时候如果认证类没有登录也会往后走，这个时候IsAuthenticated就会验证用户是否登录
    -IsAdminUser：auth的user表中is_staff字段是否为True，对后台管理有没有权限

3.频率类

# 内置的频率类：
    -BaseThrottle：所有的基类
    -SimpleRateThrottle：咱们写频率类都继承它，少写代码
    -AnonRateThrottle：如果你想按ip地址限制，只需要在配置文件中配置
      # 就是该类中帮我们配置了scope了是 'anon'
      'DEFAULT_THROTTLE_RATES': {
        'anon': '3/m',
        }
    -UserRateThrottle:如果你想按用户id限制，只需要在配置文件中配置
　　# 就是该类中帮我们配置了scope了是 'user'
     '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',  # 消息框架
    '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的认证相关
AUTH_PASSWORD_VALIDATORS = []

# 国际化
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.第三方模块配置过滤

# 内置的过滤类可以通过?search=水浒传 不能像这样指定查找 ?name=水浒传&publish=上海出版社 这样有点局限

# 第三方模块帮助了我们可以这样查找
    pip3 install django-filter
    
# 然后在视图类配置上即可
from django_filters.rest_framework import DjangoFilterBackend

class BookView(ViewSetMixin, ListAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    # 配置过滤类
    filter_backends = [DjangoFilterBackend, ]
    # 配置以什么字段过滤
    filterset_fields = ['title', 'publish']

# 然后就可以以这样的路径匹配
    http://127.0.0.1:8000/books/?title=三国演义&publish=上海出版社
# 这个是精确查找不能模糊查找， 如果是两个以上的条件 那么是and的关系

2.自定义过滤

# 我们自己写一个类然后继承BaseFilterBackend再重写filter_queryset方法

# class MyFilter(BaseFilterBackend):
    def filter_queryset(self, request, queryset, view):
        title = request.query_params.get('title')
        publish = request.query_params.get('publish')
        if title and publish:
            qs = queryset.filter(title__icontains=title, publish__icontains=publish)  # queryest就是传入的数据 icontains是模糊查询
            return qs
        else:
            return None


# 视图类配置
from .filters import MyFilter

class BookView(ViewSetMixin, ListAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    # 配置过滤类
    filter_backends = [MyFilter, ]
    # 配置以什么字段过滤
    filterset_fields = ['title', 'publish']  # 还是按照title和publish过滤
# 这个时候就可以模糊查询了

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

 

 

 四、全局异常处理

1.异常捕获源码分析

# 我们在读APIView源码的时候 我们知道了APIView的dispatch中写了全局异常捕获只要是三大认证或则是视图类代码出错 都会被捕获到

# 然后我们可以看一下它是怎么捕获的
def dispatch(self, request, *args, **kwargs):
    try:
        self.initial(request, *args, **kwargs)
        if request.method.lower() in self.http_method_names:
            handler = getattr(self, request.method.lower(),
                              self.http_method_not_allowed)
        else:
            handler = self.http_method_not_allowed

        response = handler(request, *args, **kwargs)
    except Exception as exc:
        response = self.handle_exception(exc)  # 上面只要出错都会返回错误 然后我们可以看一下handle_exception写了啥
        # 然后通过查找顺序 最后还是在APIView中找到了该方法
        

def handle_exception(self, exc):
    exception_handler = self.get_exception_handler()
    response = exception_handler(exc, context)  
    return response  
    # 我们可以知道该方法返回了response 然后我们就可以看到上面的最后的是get_exception_handler赋值给了response
    # 然后根据名称的查找顺序最后又是在APIVIew中找到了该方法 所以我们看一下get_exception_handler该方法写了啥

def get_exception_handler(self):
    return self.settings.EXCEPTION_HANDLER  
    # 该方法返回了配置文件中的EXCEPTION_HANDLER 
    # 然后根据查找顺序我们要去rest_framework中的settings中查找EXCEPTION_HANDLER是什么
    # 最后是这个 'EXCEPTION_HANDLER': 'rest_framework.views.exception_handler' 可以知道是这个
    # 那么我们可以看一下exception_handler该方法写了啥
    from rest_framework.views import exception_handler
    
def exception_handler(exc, context):
    if isinstance(exc, Http404):  # 这个处理404异常
        exc = exceptions.NotFound()
    elif isinstance(exc, PermissionDenied):  # 这个是权限异常
        exc = exceptions.PermissionDenied()
    if isinstance(exc, exceptions.APIException):  
    # 这个是我们在写认证类抛异常的类AuthenticationFailed继承的类  可以理解为认证异常
        headers = {}
        if getattr(exc, 'auth_header', None):
            headers['WWW-Authenticate'] = exc.auth_header
        if getattr(exc, 'wait', None):
            headers['Retry-After'] = '%d' % exc.wait

        if isinstance(exc.detail, (list, dict)):
            data = exc.detail
        else:
            data = {'detail': exc.detail}
        set_rollback()
        return Response(data, status=exc.status_code, headers=headers)
        
    return None  # 这个None 就是除了drf的错误 其他错误没有处理
# 该方法就是全局异常最后调用的方法  

# 总结
    -只要出了异常在APIView的dispatch中捕获了，执行了配置文件中配置的：'EXCEPTION_HANDLER': 'rest_framework.views.exception_handler'

2.自定义异常函数

# 所以我们可以自己写一个函数 然后配置在配置文件上 之后除了异常 都会先走我们的函数处理

# 然后我们统一返回格式 这样会好看一点
        -1 统一返回格式 {'code':101,'msg':错误信息}
        -2 记录日志

2.1代码演示

from rest_framework.views import exception_handler
from rest_framework.response import Response


def common_exception_handler(exc, context):
    response = exception_handler(exc, context)  # 内置的这个异常处理函数，只处理了drf的异常，没有处理其他的异常
    if response:  # 如果有值，说明被处理了(Http404,PermissionDenied,APIException)
        return Response({'code': 101, 'msg': 'drf错误,错误原因是%s' % response.data.get('detail', '未知错误')})  # 这个获取的就是drf处理的错误
    else:  # 如果没有值，那么就是不是drf的错误，没有被处理，是django或是代码的错误
        return Response({'code': 102, 'msg': '系统错误,错误原因是%s' % str(exc)})  


# 然后在配置文件中配置
    REST_FRAMEWORK = {
        'EXCEPTION_HANDLER': 'app01.exctptions.common_exception_handler'
    }


# 模仿错误  django错误
class PublishView(APIView):
    def get(self, request):
        l = [1, 2, 3]
        print(l[9])
        # raise Exception('出错了')  # 自动抛异常肯定也是Django的错误
        return Response({})
# 模仿错误 drf错误
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
class LoginAuth(BaseAuthentication):
    def authenticate(self, request):
        raise AuthenticationFailed('您没有登入')
# 视图类
class PublishView(APIView):
    authentication_classes = [LoginAuth]
    def get(self, request):
        return Response({})

 

2.2日志处理

# 我们后期一旦出现错误 肯定是要记录日志的 这样方便查看排查

from rest_framework.views import exception_handler
from rest_framework.response import Response
import datetime

def common_exception_handler(exc, context):
    # 一旦加入这个函数 那么肯定出错了 那么我们就要记录日志  现在我们用打印代替先
    request = context.get('request')
    username = request.user.username  # 因为我们都没有登入所以这个是匿名用户
    ctime = datetime.datetime.now()
    path = request.path
    method_type = request.method
    print('%s用户，在%s时间，访问%s接口,通过%s请求访问，出了错误：%s' % (username, str(ctime), path, method_type, str(exc)))
    # 用户，在2022-10-11 16:58:55.764560时间，访问/publish/接口,通过GET请求访问，出了错误：您没有登入
    response = exception_handler(exc, context)  # 内置的这个异常处理函数，只处理了drf的异常，没有处理其他的异常
    if response:  # 如果有值，说明被处理了(Http404,PermissionDenied,APIException)
        return Response({'code': 101, 'msg': 'drf错误,错误原因是%s' % response.data.get('detail', '未知错误')})  # 这个获取的就是drf处理的错误
    else:  # 如果没有值，那么就是不是drf的错误，没有被处理，是django或是代码的错误
        return Response({'code': 102, 'msg': '系统错误,错误原因是%s' % str(exc)})

五、接口文档

# 接口编写已经写完了,需要编写接口文档，给前端的人使用 因为前端在调用这个接口的时候需要知道这个接口需要传什么参数
    -请求地址
    -请求方式
    -支持的编码格式
    -请求参数(get,post参数)
    -返回格式示例
    
    
# 在公司里的写法
    -1 直接使用word或者md写
    -2 使用接口文档平台，在接口文档平台录入(Yapi（百度开源的自己搭建）,第三方平台(收费)，自己开发接口文档平台)
        -https://www.showdoc.com.cn/item/index
        - 不想花钱，没有能力开发，就使用开源的YAPI，https://zhuanlan.zhihu.com/p/366025001-3 项目自动生成：swagger，coreapi
        -1 下载：pip3 install coreapi
        -2 路由中配置：
        from rest_framework.documentation import include_docs_urls
        urlpatterns = [
            path('docs/', include_docs_urls(title='站点页面标题'))
        ]
        -3 在视图类中加注释
        -4 在配置文件中配置
        REST_FRAMEWORK = {
         'DEFAULT_SCHEMA_CLASS': 'rest_framework.schemas.coreapi.AutoSchema',
        }
        
        # 注意：
            -直接在视图类中写注释
            -在序列化类上写help_text

1.代码演示

# 视图类
class BookView(ViewSetMixin, ListAPIView, CreateModelMixin):
    # 接口有几个就会显示几个，还要注释才行
    """
    create:
        新增书籍
    list:
        获取全部

    """
    queryset = Book.objects.all()
    serializer_class = BookSerializer

    # 配置过滤类
    filter_backends = [MyFilter, ]
    # 配置以什么字段过滤
    filterset_fields = ['title', 'publish']

# 序列化类
from rest_framework.serializers import ModelSerializer
from .models import Book

class BookSerializer(ModelSerializer):
    class Meta:
        model = Book
        fields = '__all__'
        extra_kwargs = {
            'title': {'help_text': '书名'}
        }

# 路径
from rest_framework.documentation import include_docs_urls

urlpatterns = [
    path('docs/', include_docs_urls(title='路飞'))
]

 作业

1.使用django_filters写模糊查询

1.1filter.py

import django_filters
from .models import Book
class BookFileter(django_filters.FilterSet):
    title = django_filters.CharFilter(lookup_expr='icontains')  # title字段按照模糊查询
    publish = django_filters.CharFilter(lookup_expr='icontains')  # publish字段按照模糊查询

    class Meta:
        model = Book
        fields = ['title', 'publish']

2.view.py

from django_filters.rest_framework import DjangoFilterBackend
from .filters import BookFileter
class BookView(ViewSetMixin, ListAPIView, CreateModelMixin):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    # 配置过滤类
    filter_backends = [DjangoFilterBackend, ]
    # 按照我们写的过滤类过滤
    filterset_class = BookFileter