drf从入门到飞升仙界 07

认证组件

## 认证组件逻辑

# 1.登录认证的限制:

    - 访问接口，有的需要登陆后才能访问，有的接口，不登录就能访问

# 2.准备：

    -User表 : 存储用户名，密码

    -UserToken表：存储用户登录状态

"""

UserToken表可以没有，如果没有，把字段直接写在User表上也可以

"""

# 3.登录接口：

    -写个登录接口，返回token

    -之后只要带着token过来，就是登录，不带，就没有登录。

# 4.查询所有，不需要登录就能访问

# 5.查询单个，需要登录才能访问

## 认证组件的使用步骤

# 1.写一个认证类，继承BaseAuthentication

# 2.重写authenticate方法，在该方法中实现登录认证

# 3.如果认证成功，返回两个值【返回None或两个值】

# 4.认证不通过，抛异常AuthenticationFailed

# 5.局部使用和全局使用

    - 局部：只在某个视图类中使用【当前视图类管理的所有接口】

     class BookDetailView(ViewSetMixin, RetrieveAPIView):

         authentication_classes = [LoginAuth]

    - 全局：全局所有接口都生效(登录接口不要)

     REST_FRAMEWORK = {

         'DEFAULT_AUTHENTICATION_CLASSES':['app01.authenticate.LoginAuth']

     }

    - 局部禁用：

     class BookDetailView(ViewSetMixin, RetrieveAPIView):

         authentication_classes = [] 

"""
   注意：不要在配置文件中乱导入不使用的东西，否则会报错
"""

BookSerizlizer

## serizlizers.py

from rest_framework import serializers

from .models import Book

class BookSerializer(serializers.ModelSerializer):

    class Meta:

        model = Book

        fields = ['name','price','publish_detail','author_list','publish','authors']

        extra_kwargs = {'name':{'max_length': 8},

                        'publish_detail': {'read_only':True},

                        'author_list': {'read_only':True},

                        'publish': {'write_only': True},

                        'authors': {'write_only': True},}

登录接口

## 表模型

class User(models.Model):

    username = models.CharField(max_length=32)

    password = models.CharField(max_length=32)

class UserToken(models.Model):  # 跟User是一对一

    token = models.CharField(max_length=32)

    user = models.OneToOneField(to='User', on_delete=models.CASCADE, null=True)

    # user :反向，表名小写，所有有user字段

## 路由

from django.contrib import admin

from django.urls import path, include

from app01 import views

from rest_framework.routers import SimpleRouter

router = SimpleRouter()

router.register('user',views.UserView,'user')  # 路径: api/v1/user/login  向此发送post请求

router.register('books',views.BookView,'books')

urlpatterns = [

    path('admin/',admin.site.urls),

    path('api/v1/',include(router.urls))

]

## 视图函数

from rest_framework.viewsets import ViewSet

from rest_framework.decorators import action

from .models import User,UserToken

import uuid

from rest_framework.response import Response

## 登录接口 自动生成路由，因为登录功能不用序列化，直接继承viewset

class UserView(ViewSet):

    # 1.action装饰器 写在视图类的方法上，可以自动生成路由

    @action(methods=['POST'],detail=False)

    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:

            # 用户存在,登录成功，生成一个随机字符串，使用uuid生成

            token = str(uuid.uuid4())  # 生成一个永不重复的随机字符串

            # 在user_token表中存一下

            # 1.从来没有登录过，插入一条记录 / 2.登陆过，修改记录

            # 有就修改，没有新增

            # 1.update_or_create内部： def update_or_create(self, defaults=None, **kwargs)

            # 通过kwargs传入的东西查找，能找到使用defaults的更新，否则新增一个

            UserToken.objects.update_or_create(user=user, defaults={'token':token})

            return Response({'code':'100','msg':'登录成功','token':token})

        else:

            return Response({'code':'101','msg':'用户名或密码错误'})

查询单个和查询所有视图类的

## 路由

from django.contrib import admin

from django.urls import path, include

from app01 import views

from rest_framework.routers import SimpleRouter

router = SimpleRouter()

router.register('books',views.BookView,'books')

router.register('books',views.BookDetailView,'books')

urlpatterns = [

    path('admin/',admin.site.urls),

    path('api/v1/',include(router.urls))

]

## 视图函数

from .models import Book

from .serializer import BookSerializer

from rest_framework.generics import ListAPIView,RetrieveAPIView

from rest_framework.viewsets import ViewSetMixin

from rest_framework.mixins import RetrieveModelMixin  # 查询单个

# 方式一:分开写，查询所有+查询单个

class BookView(ViewSetMixin,ListAPIView):

    queryset = Book.objects.all()

    serializer_class = BookSerializer

class BookDetailView(ViewSetMixin,RetrieveAPIView):

    queryset = Book.objects.all()

    serializer_class = BookSerializer

# 方式二:合并写，查询单个+所有

class BookView(ViewSetMixin,ListAPIView,RetrieveModelMixin):

    queryset = Book.objects.all()

    serializer_class = BookSerializer

认证类的编写与使用

## 路由urls.py

from django.contrib import admin

from django.urls import path, include

from app01 import views

from rest_framework.routers import SimpleRouter

router = SimpleRouter()

router.register('books',views.BookView,'books')

router.register('books',views.BookDetailView,'books')

router.register('user',views.UserView,'user')

# 路径: api/v1/user/login  向此发送post请求

urlpatterns = [

    path('admin/',admin.site.urls),

    path('api/v1/',include(router.urls))

]

## 视图类views.py

from rest_framework.viewsets import ViewSet

from rest_framework.decorators import action

from .models import User,UserToken

import uuid

from rest_framework.response import Response

## 登录接口 自动生成路由，因为登录功能不用序列化，直接继承viewset

class UserView(ViewSet):

    @action(methods=['POST'],detail=False)

    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:

            # 用户存在,登录成功，生成一个随机字符串，使用uuid生成

            token = str(uuid.uuid4())  # 生成一个永不重复的随机字符串

            # 在user_token表中存一下

            # 1.从来没有登录过，插入一条记录 / 2.登陆过，修改记录

            # 有就修改，没有新增

            # 1.update_or_create内部： def update_or_create(self, defaults=None, **kwargs)

            # 通过kwargs传入的东西查找，能找到使用defaults的更新，否则新增一个

            UserToken.objects.update_or_create(user=user, defaults={'token':token})

            return Response({'code':'100','msg':'登录成功','token':token})

        else:

            return Response({'code':'101','msg':'用户名或密码错误'})

from .models import Book

from .serializer import BookSerializer

from rest_framework.generics import ListAPIView,RetrieveAPIView

from rest_framework.viewsets import ViewSetMixin

from .authenticate import LoginAuth

# 查询所有+查询单个

class BookView(ViewSetMixin,ListAPIView):

    queryset = Book.objects.all()

    serializer_class = BookSerializer

class BookDetailView(ViewSetMixin,RetrieveAPIView):

    queryset = Book.objects.all()

    serializer_class = BookSerializer

    # 登录需要写一个认证类，自己写

    authentication_classes = [LoginAuth]

## 自己写的认证类

# 自己写的认证类，需要继承某个类

from rest_framework.authentication import BaseAuthentication

from rest_framework.exceptions import AuthenticationFailed

from .models import UserToken

# 继承之后需要重写里面的方法,BaseAuthentication内的方法（authenticate，authenticate_header）

class LoginAuth(BaseAuthentication):

    def authenticate(self, request):

        # 在这里实现认证，如果是登陆的，继续往后执行返回两个值，如果不是抛出异常

        # 请求中是否携带token，判断是否登录 【get请求请求体不能携带数据，排除】,放在地址栏中

        token = request.query_params.get('token',None)

        if token: # 前端传入token,去表中查,如果能查到,登陆了返回两个值[当前登录用户,token]固定的

            user_token = UserToken.objects.filter(token=token).first()

            if user_token:

                return user_token.user,token

            else:

                # 没有登录,抛异常[认证失败]

                raise AuthenticationFailed('token认证失败')

        else:

            raise AuthenticationFailed('没有传入token')

权限组件

# 1.即便登录成功了，有些接口，还是不能访问，因为没有权限

# 2.登录后，有的接口有权限访问，有的没有权限访问

# 3.查询单个和查询所有，都要登录才能访问----》全局认证

    - 查询单个需要超级管理员才能访问

    - 查询所有，所有登录用户都能访问

# 4.权限是一个字段，在User表中，加入user_type字段，做表迁移
    - user_type = models.IntegerField(choices=((1,'超级管理员'),(2,'普通用户'),(3,'匿名用户')

权限类的编写和使用

## 模型类中

user表新增：

user_type = models.IntegerField(choices=((1,'超级管理员'),(2,'普通用户'),(3,'匿名用户')

## 视图views.py

from .permissions import CommonPermission

class BookDetailView(ViewSetMixin,RetrieveAPIView):

    queryset = Book.objects.all()

    serializer_class = BookSerializer

    # 登录需要写一个认证类，自己写

    authentication_classes = [LoginAuth]

    # 查询单个要权限类

    permission_classes = [CommonPermission]

## 重写权限类permissions.py

# 写一个类,继承基类BasePermission,重写has_permission[读源码]方法,在方法中实现权限认证,如果有权限return Ture,没有权限return False

from rest_framework.permissions import BasePermission

class CommonPermission(BasePermission):

    def has_permission(self, request, view):

        # 实现权限控制 ---> 知道当前登录用户是request.user

        if request.user.user_type==1:

            return True

        else:

            # 没有权限,向对象中放一个属性

            # 如果表模型中使用了choice,就可以通过get_字段名_display() 拿到choice对应的中文

            self.message = '您是%s,您没有权限' %request.user.get_user_type_display()

            return False

权限的使用步骤

# 1 写一个权限类，继承BasePermission

# 2 重写has_permission方法，在该方法在中实现权限认证，在这方法中，request.user就是当前登录用户

# 3 如果有权限，返回True

# 4 没有权限，返回False，定制返回的中文： self.message='中文'

# 5 局部使用和全局使用

    -局部：只在某个视图类中使用【当前视图类管理的所有接口】

        class BookDetailView(ViewSetMixin, RetrieveAPIView):

            permission_classes = [CommonPermission]

    -全局：全局所有接口都生效

        REST_FRAMEWORK = {

            'DEFAULT_PERMISSION_CLASSES': [

                'app01.permissions.CommonPermission',

             ],}

    -局部禁用：

        class BookDetailView(ViewSetMixin, RetrieveAPIView):

            permission_classes = []

频率组件

控制某个接口访问频率(次数)

# 查询所有接口，同一个ip一分钟只能访问5次

## 视图类views.py

from .throttling import CommonThrottle

# 方式一:分开写，查询所有+查询单个

class BookView(ViewSetMixin,ListAPIView):

    queryset = Book.objects.all()

    serializer_class = BookSerializer

class BookDetailView(ViewSetMixin,RetrieveAPIView):

    queryset = Book.objects.all()

    serializer_class = BookSerializer

    # 登录需要写一个认证类，自己写

    authentication_classes = [LoginAuth]

    # 查询单个要权限类

    permission_classes = [CommonPermission]

    # 限制访问频率次数频率类

    throttle_classes = [CommonThrottle]

## 频率类throttling.py

# 频率类,不继承BaseThrottle,继承SimpleRateThrottle,写的代码少

from rest_framework.throttling import SimpleRateThrottle

# 继承SimpleRateThrottle必须重写get_cache_key

class CommonThrottle(SimpleRateThrottle):

    # 配合类属性

    scope = 'book_5_m'

    # 配置文件中配置，要在settings.py里面配置一些配置

    def get_cache_key(self, request, view):

        # 返回什么,就以什么做频率限制(一般以ip或者用户id作为限制)

        # 客户端ip地址从哪里拿? >>>: request.META:是一个标准的python字典,包含http请求头 >>>:REMOTE_ADDR :客户端ip地址

        # return request.META.get('REMOTE_ADDR')   # 以IP做限制

        return request.user.pk          # 以用户id做限制

控制访问频率次数的步骤

# 1 写一个频率类，继承SimpleRateThrottle

# 2 重写get_cache_key方法，返回什么，就以什么做限制----》ip，用户id做限制

# 3 配置一个类属性：scope = 'book_5_m'

# 4 在配置文件中配置

  'DEFAULT_THROTTLE_RATES': {

        'book_5_m': '5/m',

    },

# 5 局部使用和全局使用

    -局部：只在某个视图类中使用【当前视图类管理的所有接口】

      class BookDetailView(ViewSetMixin, RetrieveAPIView):

          throttle_classes = [CommonThrottle]

    -全局：全局所有接口都生效

      REST_FRAMEWORK = {

          'DEFAULT_THROTTLE_CLASSES':

               ['app01.throttling.CommonThrottle'],

           }

    -局部禁用：

      class BookDetailView(ViewSetMixin, RetrieveAPIView):

          throttle_classes = []

过滤排序

继承APIView自定义【伪代码，未补齐】

# 继承APIView后，过滤完全需要自己写，会更麻烦，但是清晰

class BookView(APIView):

    def get(self,request):

        search=request.query_params.get('search')

        books=Book.objects.filter()

内置过滤类的使用【继承GenericAPIView】

# restful规范中，要求了，请求地址中带过滤条件

   - 5个接口中，只有查询所有接口  接口需要有过滤和排序

## views.py

"""注掉之前代码，避免影响"""

# 过滤,必须继承GenericAPIView及其子类,才可以使用这种方式[配置过滤类的方式]

# 导入过滤排序类,过滤类SearchFilter,排序类OrderingFilter

from rest_framework.filters import SearchFilter,OrderingFilter

class BookView(ViewSetMixin,ListAPIView):

    queryset = Book.objects.all()

    serializer_class = BookSerializer

    authentication_classes = []

    permission_classes = []

    throttle_classes = []

    # 内置的filter_backends,是GenericAPIView的,配上过滤类就有了过滤功能

    filter_backends =[SearchFilter]

    # 过滤有三层:内置,第三方,自己写的

    # 可以按名字模糊去匹配

    search_fields = ['name']

    # 可以按名字或价格模糊去匹配

    search_fields=['name','price']

# 可以使用的搜索方式

    http://127.0.0.1:8000/api/v1/books/?search=h

# search=h 代表name或price中只要有h就会搜出来

使用第三方django-filter实现过滤

# 1.安装 django-filter

   pip install django-filter

# 2.代码

from django_filters.rest_framework import DjangoFilterBackend

class BookView(ViewSetMixin, ListAPIView):

    queryset = Book.objects.all()

    serializer_class = BookSerializer

    permission_classes = []

    authentication_classes = []

    throttle_classes = []

    filter_backends = [DjangoFilterBackend]

    filterset_fields = ['name','price']  # 支持完整匹配  name=xx11&price=xxx

 # 支持的查询方式

http://127.0.0.1:8000/api/v1/books/?price=939

http://127.0.0.1:8000/api/v1/books/?price=939&name=红楼梦

自定义定制过滤类实现过滤

#第一步； 定义一个过滤类，继承BaseFilterBackend，重写filter_queryset方法

class CommonFilter(BaseFilterBackend):

    def filter_queryset(self, request, queryset, view):

        # 在里面实现过滤，返回qs对象，就是过滤后的数据

        price_gt = request.query_params.get('price_gt', None)

        if price_gt:

            qs = queryset.filter(price__gt=int(price_gt))

            return qs

        else:

            return queryset

#第二步：这里要吧模型类models.py内的Book表price字段做修改

   - 将CharField变为IntegerField后迁移

# 第三步：配置在视图类views.py上

class BookView(ViewSetMixin, ListAPIView):

    queryset = Book.objects.all()

    serializer_class = BookSerializer

    filter_backends = [CommonFilter]  # 可以定制多个，从左往右，依次执行

排序的使用

## 排序使用内置的就够了

from rest_framework.filters import OrderingFilter

# 需要配置在filter_backends上

class BookView(ViewSetMixin, ListAPIView):

    queryset = Book.objects.all()

    serializer_class = BookSerializer

    filter_backends = [OrderingFilter]

    ordering_fields = ['price']

# 支持的查询方法：

 - http://127.0.0.1:8000/api/v1/books/?ordering=price

 - http://127.0.0.1:8000/api/v1/books/?ordering=-price

 - http://127.0.0.1:8000/api/v1/books/?ordering=-id,price

分页

# 1.分页·：只有查询所有的接口，才有分页

# 2.drf内置了三个分页器，对应了三种分页方式

# 3.内置的分页类不可以直接使用，需要继承，定制一些参数后才可以使用

#4.分页使用三种方法：

## 分页类： page.py

from rest_framework.pagination import LimitOffsetPagination,PageNumberPagination,CursorPagination

# 方法一：

class CommonPageNumberPagination(PageNumberPagination):

    page_size = 2  # 每页显示2条

    page_query_param = 'page'  # page=10  查询第10页的数据，每页显示2条

    page_size_query_param = 'size'  # page=10&size=5    查询第10页，每页显示5条

    max_page_size = 5  # 每页最大显示10条

# 方式二：LimitOffset

class CommonLimitOffsetPagination(LimitOffsetPagination):

    default_limit = 3  # 每页显示2条

    limit_query_param = 'limit'  # limit=3   取3条

    offset_query_param = 'offset'  # offset=1  从第一个位置开始，取limit条

    max_limit = 5

    # offset=3&limit=2      0  1 2 3 4 5

## 方法三：app 用下面的类

class CommonCursorPagination(CursorPagination):

    cursor_query_param = 'cursor'  # 查询参数

    page_size = 2  # 每页多少条

    ordering = 'id'  # 排序字段

## 视图类views.py

# 分页功能,必须是继承GenericAPIView,如果继承APIView要自己写

from .page import CommonPageNumberPagination as PageNumberPagination\

    ,CommonCursorPagination as CommonCursorPagination,\

    CommonLimitOffsetPagination as LimitOffsetPagination

class BookView(ViewSetMixin,ListAPIView):

    queryset = Book.objects.all()

    serializer_class = BookSerializer

    authentication_classes = []

    permission_classes = []

    throttle_classes = []

    # 自己定义分页类,内置的分页类不能直接使用,需要继承,定制一些参数后才能使用

    # 偏移分页 http://127.0.0.1:8000/api/v1/books/?limit=4&offset=1   : 从第一条开始，取4条

    pagination_class = LimitOffsetPagination

    # 游标分页，只能下一页，上一页，不能跳到中间，但它的效率最高，大数据量分页，使用这种较好

    pagination_class = CommonCursorPagination

    #

    pagination_class = PageNumberPagination

巴特西

drf从入门到飞升仙界 07

认证组件

BookSerizlizer

登录接口

查询单个和查询所有视图类的

认证类的编写与使用

权限组件

权限类的编写和使用

权限的使用步骤

频率组件

控制某个接口访问频率(次数)

控制访问频率次数的步骤

过滤排序

继承APIView自定义【伪代码，未补齐】

内置过滤类的使用【继承GenericAPIView】

使用第三方django-filter实现过滤

自定义定制过滤类实现过滤

排序的使用

分页

最新文章

热门文章