drf知识-08

Django之了解DRF框架

# 介绍:DRF全称 django rest framework

# 背景:

        在序列化与反序列化时,虽然操作的数据不尽相同,但是执行的过程却是相似的,也就是说这部分代码是可以复用简化编写
        增:校验请求数据 -> 执行反序列化过程 -> 保存数据库 -> 将保存的对象序列化并返回
        删:判断要删除的数据是否存在 -> 执行数据库删除
        改:判断要修改的数据是否存在 -> 校验请求的数据 -> 执行反序列化过程 -> 保存数据库 -> 将保存的对象序列化并返回
        查:查询数据库 -> 将数据序列化并返回
# 作用:Django REST framework可以帮助我们简化上述两部分的代码编写,大大提高REST API的开发速度

# DRF特点:

        1.提供了定义序列化器Serializer的方法,可以快速根据 Django ORM 或者其它库自动序列化/反序列化;
        2.提供了丰富的类视图、Mixin扩展类,简化视图的编写;
        3.丰富的定制层级:函数视图、类视图、视图集合到自动生成 API,满足各种需要;
        4.多种身份认证和权限认证方式的支持;
        5.内置了限流系统;
        6.直观的 API web 界面;
        7.可扩展性,插件丰富

# 环境安装与配置:

1、安装DRF

pip install djangorestframework

2、在settings.py的INSTALLED_APPS中添加’rest_framework’

INSTALLED_APPS = [
    ...
    'rest_framework',
]

# DRF牛刀小试:

1、创建序列化器,在books应用中新建serializers.py用于保存该应用的序列化器,创建一个类用于序列化与反序列化:

from rest_framework import serializers
from books.models import Book

class BookInfoSerializer(serializers.ModelSerializer):
    """图书数据序列化器"""
    class Meta:
        model = Book
        fields = '__all__'

        model 指明该序列化器处理的数据字段从模型类Book参考生成
        fields 指明该序列化器包含模型类中的哪些字段,'all’指明包含所有字段

2、编写视图,在books应用的views.py中创建视图BookViewSet,这是一个视图集合:

from rest_framework.viewsets import ModelViewSet
from .serializers import BookSerializer
from .models import Book

class BookViewSet(ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

        queryset 指明该视图集在查询数据时使用的查询集
        serializer_class 指明该视图在进行序列化或反序列化时使用的序列化器

3、定义路由,在books应用的urls.py中定义路由信息

from . import views
from rest_framework.routers import DefaultRouter

router = DefaultRouter()  # 可以处理视图的路由器
router.register(r'books', views.BookViewSet, 'books')  # 向路由器中注册视图集
urlpatterns = [
]
urlpatterns += router.urls  # 将路由器中的所以路由信息追到到django的路由列表中

三大认证组件回顾

# 认证类的编写
用户登录后,会有登录标识,早期直接写入到浏览器中了

session['name']='lqz'
obj.set_cookie()

写认证类的目的:校验它携带的登录标识,是否合法,是否在库中存着
只需要按照固定规则去写即可:
  1、写一个类,继承 BaseAuthentication
  2、重写 authenticate 方法
  3、在方法中完成校验--》用户标识

             用户标识带在请求头 / 请求地址 / 请求体
            校验携带的标识正不正确---> 去数据库查
            查到返回俩值:第一个值会给后续的request.user,第二个值给request.auth
            校验失败:抛异常

class LoginAuth(BaseAuthentication):   # 不一定继承BaseAuthentication
    def authenticate(self, request):   # 目的是重写authenticate,有authenticate就是认证类
        token = request.query_params.get('token') or request.META.get('HTTP_TOKEN')
        user_token = UserToken.objects.filter(token=token).first()
        if user_token:
            user = user_token.user      # 重写是因为源码里在一个个调用这个方法,在方法中完成校验
            return user, user_token     # 返回两个值,第一个值会给request.user,第二个给了request.auth
        else:                           # 标识一般带到请求头、请求地址和请求体中,由后端决定
            raise AuthenticationFailed("您没有登录")

  4、放在视图类上,局部禁用:
            authentication_classes=[ ]
 5、放在配置文件中--drf配置文件中找 :         

 REST_FRAMEWORK = {
                'DEFAULT_AUTHENTICATION_CLASSES': ['app01.auth.LoginAuth'],
            }

#  权限类
  用户登录了,有没有权限访问接口
  权限放在了认证之后,request.user :当前登录用户,根据是谁来做权限
  编写规则:
 1、写一个类类,继承 BasePermission
 2、 重写 has_permission 方法
 3、在方法中完成权限校验--》当前登录用户
            能有用户,就能取出用户的权限
            如果有,返回True,没有返回False
            前端看到中文提示:self.message

class CommonPermission(BasePermission):
    def has_permission(self, request, view):
        try:
            user_type = request.user.user_type
            if user_type == 2:
                return True
            else:
                # user.get_字段名_display()  返回这个字段的choice对应的文字
                self.message = '您是:%s,您没有权限操作这个' % request.user.get_user_type_display()
                return False
        except Exception as e:
            # 未登录用户也没有权限
            if 'login' in request.path:
                return True
            else:
                self.message = '您没有登录,您没有权限操作这个'
                return False

  4、放在视图类上(可以配多个),局部禁用:
            permission_classes=[ ]
 5、放在配置文件中--drf配置文件中找:

 REST_FRAMEWORK = {
                'DEFAULT_permission_CLASSES': [''],
            }

# 频率类使用
限制用户访问频次:用户登录或不登录都可能会限制
限制条件:ip,用户id
编写步骤:
    1、写一个类类,继承 SimpleRateThrottle
    2、重写 get_cache_key 方法
           返回什么就以什么做限制:ip或id号
            类上写个属性:rate = '5/d'    # s m h d 

class CommonThrottle(SimpleRateThrottle):
    rate = '3/m'
    def get_cache_key(self, request, view):
        ip = request.META.get('REMOTE_ADDR')
        return ip

  3、放在视图类上(可以配多个),局部禁用:
            throttle_classes=[ ]
  4、 放在配置文件中--drf配置文件中找:            

REST_FRAMEWORK = {
                'DEFAULT_throttle_CLASSES': [''],
            }

排序之继承GenericAPIView

# 1 只有查询所有需要排序
# 2 如何使用
     1 必须是继承 GenericAPIView 及其子类
    2 在类中配置类属性
        filter_backends = [OrderingFilter]
    3 类中写属性
        ordering_fields = ['price','id']  # 必须表的字段        
    4 以后再前端,就可以访问
        http://127.0.0.1:8000/api/v1/books/?ordering=price 按price升序排
        http://127.0.0.1:8000/api/v1/books/?ordering=-price 按price降序排
        http://127.0.0.1:8000/api/v1/books/?ordering=-price,id

from .models import Book
from rest_framework.viewsets import ViewSetMixin
from rest_framework.generics import ListAPIView
from .serializer import BookSerializer

# 排序之继承 GenericAPIView
from rest_framework.filters import OrderingFilter
class BookView(ViewSetMixin,ListAPIView):     # 改路径和查询所有
    queryset = Book.objects.all()
    serializer_class = BookSerializer   # 序列类映射
    filter_backends = [OrderingFilter]  # 排序
    ordering_fields = ['price','id']
    # http://127.0.0.1:8000/api/v1/books/?ordering=-price,id

drf知识-08_第1张图片

drf知识-08_第2张图片

排序之继承APIview

# 如果继承APIView,过滤规则自己写

# 单条排序:

# 排序之继承 APIView
from rest_framework.views import APIView
from rest_framework.response import Response
class BookView(ViewSetMixin, APIView):
    def list(self, request):
        # 从地址兰中取出用户过滤条件
        # http://127.0.0.1:7000/api/v1/books/?ordering=-price
        query_params = request.query_params  #< QueryDict: {'ordering': ['-price']}>
        obj_list = Book.objects.all().order_by(query_params.get('ordering'))
        ser = BookSerializer(instance=obj_list, many=True)
        return Response(ser.data)

# 多条排序:

# 排序之继承 APIView
from rest_framework.views import APIView
from rest_framework.response import Response
class BookView(ViewSetMixin, APIView):
    def list(self, request):
        # 从地址兰中取出用户过滤条件
        # http://127.0.0.1:7000/api/v1/books/?ordering=-price,id
        query_params = request.query_params  #
        print(query_params)
        if ',' in query_params.get('ordering'):
            query = query_params.get('ordering').split(',')
        obj_list = Book.objects.all().order_by(*query)
        ser = BookSerializer(instance=obj_list, many=True)
        return Response(ser.data)

过滤之使用drf内置过滤类

#  restful规范中有一条是请求地址中带过滤条件,查询所有数据,只查询出我们想要的

# 如何使用
     1 必须是继承 GenericAPIView 及其子类
     2 在类中配置类属性
        filter_backends = [SearchFilter]
     3 类中写属性
       search_fields = ['price','id']  # 必须表的字段        
    4 以后再前端,就可以访问
        http://127.0.0.1:7000/api/v1/books/?search=风

        http://127.0.0.1:7000/api/v1/books/?search=摆

# 过滤之使用drf内置过滤类
from rest_framework.filters import SearchFilter
class BookView(ViewSetMixin,ListAPIView):     # 改路径和查询所有
    queryset = Book.objects.all()
    serializer_class = BookSerializer   # 序列类映射
    filter_backends = [SearchFilter]  # 排序
    search_fields = ['name']
    # http://127.0.0.1:7000/api/v1/books/?search=风

drf知识-08_第3张图片

drf知识-08_第4张图片

过滤之使用djagno-filter过滤

# 下载  pip3 install django-filter

# 导入  from django_filters.rest_framework import DjangoFilterBackend
# 3 使用

# 过滤之使用djagno-filter过滤
from django_filters.rest_framework import DjangoFilterBackend
class BookView(ViewSetMixin,ListAPIView):     # 改路径和查询所有
    queryset = Book.objects.all()
    serializer_class = BookSerializer   # 序列类映射
    filter_backends = [DjangoFilterBackend]  # 排序
    filterset_fields = ['name','price']
    # http://127.0.0.1:7000/api/v1/books/?name=摆渡人&price=34
    # 查询书名为摆渡人且价格为34的

drf知识-08_第5张图片

drf知识-08_第6张图片

过滤之自定制过滤类

# 写个类,继承BaseFilterBackend重写filter_queryset,在内部完成过滤

# filter
from rest_framework.filters import BaseFilterBackend
class CommonFilter(BaseFilterBackend):
    def filter_queryset(self, request, queryset, view):
        # queryset 是之前所有数据 Book.object.all()
        # request 当次请求request
        name = request.query_params.get('name')
        price = request.query_params.get('price')
        if name:
            queryset = queryset.filter(name__contains=name)
        if price:
            queryset = queryset.filter(price=price)
        return queryset
# views.py
# 过滤之自定制过滤类,重写了类里方法,再引用
from .filter import CommonFilter
class BookView(ViewSetMixin,ListAPIView):     # 改路径和查询所有
    queryset = Book.objects.all()
    serializer_class = BookSerializer   # 序列类映射
    filter_backends = [CommonFilter]  # 排序
    # http://127.0.0.1:7000/api/v1/books/?name=追&price=31.2
    # 书名用了模糊查法,价格是精准查法

drf知识-08_第7张图片

自定义过滤+排序

# 自定义过滤+排序
from .filter import CommonFilter
from rest_framework.filters import OrderingFilter
class BookView(ViewSetMixin,ListAPIView):     # 改路径和查询所有
    queryset = Book.objects.all()
    serializer_class = BookSerializer   # 序列类映射
    filter_backends = [CommonFilter,OrderingFilter]  # 过滤,排序
    ordering_fields = ['price']
    # http://127.0.0.1:7000/api/v1/books/?name=渡&ordering=-price
    # 查询书名含渡的且按照价格降序

drf知识-08_第8张图片

分页之基础分页

# 查询所有接口,分页

# 使用drf内置了三种分页方式:

        PageNumberPagination, LimitOffsetPagination, CursorPagination

1、写个类,继承基础分页类,重写类属性       

# pagination.py  基本分页PageNumberPagination
from rest_framework.pagination import PageNumberPagination
class CommonPageNumberPagination(PageNumberPagination):
    page_size = 1      # 默认显示,每页大小,一页显示多少条
    page_query_param = 'page'    # 分页查询条件  ?page=1
    page_size_query_param = 'size'  #每页最多显示多少条的查询条件  &size=2
    max_page_size = 3   # 每页最多显示多少条
    # http://127.0.0.1:7000/api/v1/books/?search=34&size=2
    # 过滤查询价格为34且一页显示2条数据的(不写size默认显示1条)

2、在继承自 GenericAPIView及其子类, 在视图类配置分页类即可

# 分页之基础分页
# 在内置过滤器的条件下分页
from rest_framework.filters import SearchFilter
from .pagination import CommonPageNumberPagination
class BookView(ViewSetMixin,ListAPIView):     # 改路径和查询所有
    queryset = Book.objects.all()
    serializer_class = BookSerializer   # 序列类映射
    filter_backends = [SearchFilter]  # 过滤,排序
    search_fields = ['price']
    pagination_class = CommonPageNumberPagination

drf知识-08_第9张图片

drf知识-08_第10张图片

分页之偏移分页

 # 查询所有接口,分页

# 使用drf内置了三种分页方式:

        PageNumberPagination, LimitOffsetPagination, CursorPagination

1、写个类,继承基础分页类,重写类属性       

# pagination.py  基本分页LimitOffsetPagination
from rest_framework.pagination import LimitOffsetPagination
class CommonLimitOffsetPagination(LimitOffsetPagination):
    default_limit = 1   # 默认显示,每页显示的条数
    limit_query_param = 'limit'  # 分页查询条件  ?limit=1
    offset_query_param = 'offset'   # # 偏移量 从第2条开始,拿2条 offset=2&limit=2
    max_limit = 3   # # 每页最多显示多少条
    # http://127.0.0.1:7000/api/v1/books/?limit=1&page=3  显示第三页的一条数据
    # http://127.0.0.1:7000/api/v1/books/?offset=1&limit=2  从第一条数据开始显示2条数据

2、在继承自 GenericAPIView及其子类, 在视图类配置分页类即可

# 分页之基础分页
# 在内置过滤器的条件下分页
from rest_framework.filters import SearchFilter
from .pagination import CommonPageNumberPagination
from .pagination import CommonLimitOffsetPagination
class BookView(ViewSetMixin,ListAPIView):     # 改路径和查询所有
    queryset = Book.objects.all()
    serializer_class = BookSerializer   # 序列类映射
    filter_backends = [SearchFilter]  # 过滤,排序
    search_fields = ['price']
    pagination_class = CommonPageNumberPagination
    pagination_class = CommonLimitOffsetPagination

drf知识-08_第11张图片

drf知识-08_第12张图片

分页之游标分页

# 特点:只能从第一页开始,只能上一页和下一页,不能自定义哪页,但是效率高很多

1、写个类,继承基础分页类,重写类属性       

# pagination.py 游标分页  CursorPagination
from rest_framework.pagination import CursorPagination
class CommonCursorPagination(CursorPagination):
    cursor_query_param = 'cursor'   # 分页查询条件  ?cursor=1
    page_size = 2    # 每页显示的条数
    ordering = 'id'  # 排序规则,必须是表中字段
    # http://127.0.0.1:7000/api/v1/books/
    # 内部已经写死,从第一页查起,显示2条,只能上下翻页

2、在继承自 GenericAPIView及其子类, 在视图类配置分页类即可

# views.py
# 分页之基础分页
# 在内置过滤器的条件下分页
from rest_framework.filters import SearchFilter
from .pagination import CommonPageNumberPagination
from .pagination import CommonLimitOffsetPagination
from .pagination import CommonCursorPagination

class BookView(ViewSetMixin,ListAPIView):     # 改路径和查询所有
    queryset = Book.objects.all()
    serializer_class = BookSerializer   # 序列类映射
    filter_backends = [SearchFilter]  # 过滤,排序
    search_fields = ['price']
    pagination_class = CommonPageNumberPagination
    pagination_class = CommonLimitOffsetPagination
    pagination_class = CommonCursorPagination

drf知识-08_第13张图片

全局异常处理

# 三大认证和视图类的方法中出现了异常,都会被try捕获,做全局异常处理

# 捕获到统一处理,无论我是否出异常,返回的格式都是固定的

        {code:100,msg:成功}
# 新建py文件,写一个函数,在函数中处理异常

# exceptions.py
# drf的异常处理是exception_handler处理,没处理非drf的异常
# 自己写个函数,处理drf异常和自己的异常
from rest_framework.views import exception_handler
from rest_framework.response import Response

def common_exception_handler(exc, context):
    res = exception_handler(exc, context)  # 处理drf异常处理
    if res:
        # data = {'detail': exc.detail},错误信息
        # return Response(data)
        # {code: 100, msg: 成功}
        detail = res.data.get('detil') or "drf异常,请联系系统管理员"
        return Response({'code': 101, 'msg': detail})
    else:
        return Response({'code': 102, 'msg': '系统异常,请联系系统管理员:%s'%str(exc)})

# 把函数配置在配置文件中,setting.py

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

#  只要三大认证或视图类的方法出了异常,就会走这个函数

# 全局异常处理
# 无论我是否出异常,返回的格式都是固定的
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.exceptions import AuthenticationFailed,ValidationError,APIException

class UserView(ViewSetMixin, APIView):
    def create(self, request):  # post--->create
        # l = [1, 2, 3]
        # print(l[9])
        # raise Exception("你出错了")

        # drf  默认能处理自己的异常:继承自APIException的异常
        raise APIException('认证失败')
        return Response({'code': 100, 'msg': '成功'})

今日思维导图:

你可能感兴趣的:(sqlite,数据库,python,django)