DRF视图类、认证组件、权限、限流、过滤、排序、分页、异常处理、自动生成接口文档、Xadmin

DRF视图类

基于GenericAPIView的视图接口

GenericAPIView介绍

继承自APIVIew，主要增加了操作序列化器和数据库查询的方法，作用是为下面Mixin扩展类的执行提供方法支持。通常在使用时，可搭配一个或多个Mixin扩展类。

GenericAPIView需要引入：

from rest_framework.generics import GenericAPIView

GenericAPIView视图类中的属性和方法

• `serializer_class：
  • 属性：serializer_class指明视图使用的序列化器
  • 方法：get_serializer_class(self) 当出现一个视图类中调用多个序列化器时,那么可以通过条件判断在get_serializer_class方法中通过返回不同的序列化器类名就可以让视图方法执行不同的序列化器对象了。返回序列化器类，默认返回serializer_class，可以重写，例如：

    # 当试图中使用多个序列化器类时，可以使用该方法来区分
    def get_serializer_class(self):
        print('111111111111')
        if self.request.method == 'GET':
            return StudentModelSerializer2
      else:
            return StudentModelSerializer

• get_serializer(self, *args, **kwargs)
  • 返回序列化器对象，主要用来提供给Mixin扩展类使用，如果我们在视图中想要获取序列化器对象，也可以直接调用此方法。
  • 注意，该方法在提供序列化器对象的时候，会向序列化器对象的context属性补充三个数据：request、format、view，这三个数据对象可以在定义序列化器时使用。
  • request 当前视图的请求对象
  • view 当前请求的类视图对象
  • format 当前请求期望返回的数据格式
  • 属性：queryset 指明使用的数据查询集
  • 方法：get_queryset(self) 返回视图使用的查询集，主要用来提供给Mixin扩展类使用，是列表视图与详情视图获取数据的基础，默认返回queryset属性，可以重写，例如：

def get_queryset(self):
    user = self.request.user
    return user.accounts.all()

• get_object(self)
  • 返回详情视图所需的模型类数据对象，主要用来提供给Mixin扩展类使用。在视图中可以调用该方法获取详情信息的模型类对象。若详情访问的模型类对象不存在，会返回404。
    该方法会默认使用APIView提供的check_object_permissions方法检查当前对象是否有权限被访问。

# url(r'^books/(?P<pk>\d+)/$', views.BookDetailView.as_view()),
class BookDetailView(GenericAPIView):
    queryset = BookInfo.objects.all()
    serializer_class = BookInfoSerializer

    def get(self, request, pk):
        book = self.get_object() # get_object()方法根据pk参数查找queryset中的数据对象
        serializer = self.get_serializer(book)
        return Response(serializer.data)

GenericAPIView的使用

新建一个子应用req配置相关文件
settings.py文件

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app01.apps.App01Config',
    'rest_framework',
    'student',
    'ser',
    'mser',
    'req',
]

urls.py文件

from django.contrib import admin
from django.urls import path,re_path,include #  re_path --- django1.11 url
urlpatterns = [
    path('admin/', admin.site.urls),
    path('stu/', include('student.urls')),
    path('ser/', include('ser.urls')),
    path('mser/', include('mser.urls')),
    path('req/', include('req.urls')),
]

req/urls.py

from django.contrib import admin
from django.urls import path,re_path,include 
from req import views
urlpatterns = [
    path('students/', views.StudentsView.as_view()),
    re_path('students/(?P<pk>\d+)/', views.StudentView.as_view()),# pk=3
    path('students2/', views.Students2View.as_view()),
    re_path('students2/(?P<pk>\d+)/', views.Student2View.as_view()), # pk=3

req/serializers.py

from rest_framework import serializers
from ser import models
class StudentModelSerializer(serializers.ModelSerializer):
    # 定义序列化器
    class Meta:
        model = models.Student
        # fields = ['name', 'sex', 'age', 'class_null']
        fields = '__all__'
        extra_kwargs = {
            'id':{'read_only':True},
        }
# 第二个序列化器
class StudentModelSerializer2(serializers.ModelSerializer):
    class Meta:
        model = models.Student
        fields = ['name', 'age']

req/views.py

from rest_framework.generics import GenericAPIView
from django.shortcuts import render
from django.views import View
from rest_framework.views import APIView
# Create your views here.
from ser import models
from req.serializers import StudentModelSerializer, StudentModelSerializer2
from rest_framework.response import Response
from rest_framework import status

class Students2View(GenericAPIView):
	 # 必须写这个参数 ,方法中使用的self.get_queryset()方法自动获取到queryset属性数据
    queryset = models.Student.objects.all() 
    # 非必填属性，self.get_serializer获取到serializer_class制定的序列化器类
    serializer_class = StudentModelSerializer 

    # 当视图中使用多个序列化器类时，可以使用该方法来区分
    def get_serializer_class(self):
        print('111111111111')
        if self.request.method == 'GET':
            return StudentModelSerializer2
        else:
            return StudentModelSerializer
    # 获取所有数据
    def get(self,request):
        # print('get',self.get_serializer())
        print(request.query_params)
        # print(request.GET)
        # print(request.query_params.getlist('b'))
        students = self.get_queryset()
        # 序列化students数据
        serializer_obj = self.get_serializer(instance=students, many=True)
        # return Response(serializer_obj.data,status=400)
        return Response(serializer_obj.data)
    # 添加单条记录
    def post(self,request):
        # print('post',self.get_serializer())
        serializer_obj = self.get_serializer(data=request.data)
        if serializer_obj.is_valid():
            new_obj = models.Student.objects.create(**serializer_obj.validated_data)
            obj = self.get_serializer(instance=new_obj)
            return Response(obj.data, status=status.HTTP_201_CREATED)
        else:
            print(serializer_obj.errors)
            return Response({'error':'校验失败'})
class Student2View(GenericAPIView):
    queryset = models.Student.objects.all()
    serializer_class = StudentModelSerializer
    # 获取单条数据
    def get(self, request, pk):
        # student = models.Student.objects.get(pk=pk)
        # student = self.get_queryset().filter(pk=pk).first()
        student = self.get_object()
        serializer_obj = self.get_serializer(instance=student)
        return Response(serializer_obj.data)
    # 更新单条记录
    def put(self,request,pk):
        student = self.get_object()
        data = request.data
        serializer_obj = self.get_serializer(instance=student,data=data,partial=True)

        if serializer_obj.is_valid():
            instance = serializer_obj.save()
            new_serializer_obj = self.get_serializer(instance=instance)
            return Response(new_serializer_obj.data,status=status.HTTP_202_ACCEPTED)
        else:
            return Response({'error':"检验失败"})
    # 删除单条记录
    def delete(self, request, pk):
        self.get_object().delete()
        # return Response(None,)
        return Response('', status=status.HTTP_204_NO_CONTENT)

基于视图扩展类的五个视图接口

介绍

提供了几种后端视图（对数据资源进行曾删改查）处理流程的实现，如果需要编写的视图属于这五种，则视图可以通过继承相应的扩展类来复用代码，减少自己编写的代码量。

这五个扩展类需要搭配GenericAPIView父类，因为五个扩展类的实现需要调用GenericAPIView提供的序列化器与数据库查询的方法。

换句话说。就是你在视图中的get post put等这些方法中不用写里面的代码了，里面的代码相关的操作已经被封装到对应的Mixin中了。

ListModelMixin获取多条数据的列表视图扩展类

提供list(request, *args, **kwargs)方法快速实现列表视图，返回200状态码。
该Mixin的list方法会对数据进行过滤和分页。
源代码如下

class ListModelMixin(object):
    """
    List a queryset.
    """
    def list(self, request, *args, **kwargs):
        # 过滤
        queryset = self.filter_queryset(self.get_queryset())
        # 分页
        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        # 序列化
        serializer = self.get_serializer(queryset, many=True)
        return Response(serializer.data)

使用：

from rest_framework.generics import GenericAPIView
from rest_framework.mixins import ListModelMixin
class Students3View(GenericAPIView,ListModelMixin):
 	# 必须写这个参数 ,方法中使用的self.get_queryset()方法自动获取到queryset属性数据
    queryset = models.Student.objects.all() 
    # 非必填属性，self.get_serializer获取到serializer_class制定的序列化器类
    serializer_class = StudentModelSerializer  
    # 获取所有数据
    def get(self, request):
        return self.list(request)

CreateModelMixin添加数据的创建视图扩展类

提供create(request, *args, **kwargs)方法快速实现创建资源的视图，成功返回201状态码。
如果序列化器对前端发送的数据验证失败，返回400错误。
源代码

class CreateModelMixin(object):
    """
    Create a model instance.
    """
    def create(self, request, *args, **kwargs):
        # 获取序列化器
        serializer = self.get_serializer(data=request.data)
        # 验证
        serializer.is_valid(raise_exception=True)
        # 保存
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

    def perform_create(self, serializer):
        serializer.save()

    def get_success_headers(self, data):
        try:
            return {'Location': str(data[api_settings.URL_FIELD_NAME])}
        except (TypeError, KeyError):
            return {}

使用：

from rest_framework.generics import GenericAPIView
from rest_framework.mixins import ListModelMixin,CreateModelMixin
class Students3View(GenericAPIView,ListModelMixin,CreateModelMixin):
 	# 必须写这个参数 ,方法中使用的self.get_queryset()方法自动获取到queryset属性数据
    queryset = models.Student.objects.all() 
    # 非必填属性，self.get_serializer获取到serializer_class制定的序列化器类
    serializer_class = StudentModelSerializer  
    # 获取所有数据
    def get(self, request):
        return self.list(request)
    # 添加单条记录
    def post(self, request):
        return self.create(request)

RetrieveModelMixin获取单条数据详情视图扩展类

提供retrieve(request, *args, **kwargs)方法，可以快速实现返回一个存在的数据对象。
如果存在，返回200， 否则返回404。
源码如下

class RetrieveModelMixin(object):
    """
    Retrieve a model instance.
    """
    def retrieve(self, request, *args, **kwargs):
        # 获取对象，会检查对象的权限
        instance = self.get_object()
        # 序列化
        serializer = self.get_serializer(instance)
        return Response(serializer.data)

使用：

from rest_framework.generics import GenericAPIView
from rest_framework.mixins import ListModelMixin,CreateModelMixin,RetrieveModelMixin
class Student3View(GenericAPIView,RetrieveModelMixin):
    queryset = models.Student.objects.all()
    serializer_class = StudentModelSerializer
    # 获取单条数据
    def get(self, request, pk):
        return self.retrieve(request, pk)

UpdateModelMixin更新视图扩展类

提供update(request, *args, **kwargs)方法，可以快速实现更新一个存在的数据对象。
同时也提供partial_update(request, *args, **kwargs)方法，可以实现局部更新。
成功返回200，序列化器校验数据失败时，返回400错误
源码

class UpdateModelMixin(object):
    """
    Update a model instance.
    """
    def update(self, request, *args, **kwargs):
        partial = kwargs.pop('partial', False)
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=request.data, partial=partial)
        serializer.is_valid(raise_exception=True)
        self.perform_update(serializer)
        if getattr(instance, '_prefetched_objects_cache', None):
            # If 'prefetch_related' has been applied to a queryset, we need to
            # forcibly invalidate the prefetch cache on the instance.
            instance._prefetched_objects_cache = {}
        return Response(serializer.data)
    def perform_update(self, serializer):
        serializer.save()
    def partial_update(self, request, *args, **kwargs):
        kwargs['partial'] = True
        return self.update(request, *args, **kwargs)

使用

from rest_framework.generics import GenericAPIView
from rest_framework.mixins import ListModelMixin,CreateModelMixin,RetrieveModelMixin,UpdateModelMixin
class Student3View(GenericAPIView,RetrieveModelMixin, UpdateModelMixin):
    queryset = models.Student.objects.all()
    serializer_class = StudentModelSerializer
    # 获取单条数据
    def get(self, request, pk):
        return self.retrieve(request, pk)
    # 更新单条记录
    '''
    这里不能用put方法进行更新，put方法是更新整条记录，
    提交时要求提交整条数据，因此put方法需要加上partial=True，
    patch则是更新部分记录，不要求提交全部数据，
    源码UpdateModelMixin中的path方法封装了partial_update里面
    有个kwargs['partial'] = True所以不需要自己加，直接使用path
    '''
    def patch(self, request, pk):
        # return self.update(request, pk, partial=True)
        return self.update(request, pk)

DestroyModelMixin删除视图扩展类

提供destroy(request, *args, **kwargs)方法，可以快速实现删除一个存在的数据对象。
成功返回204，不存在返回404。
源码：

class DestroyModelMixin(object):
    """
    Destroy a model instance.
    """
    def destroy(self, request, *args, **kwargs):
        instance = self.get_object()
        self.perform_destroy(instance)
        return Response(status=status.HTTP_204_NO_CONTENT)
    def perform_destroy(self, instance):
        instance.delete()

使用：

from rest_framework.generics import GenericAPIView
from rest_framework.mixins import ListModelMixin,CreateModelMixin,RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin
class Student3View(GenericAPIView,RetrieveModelMixin, UpdateModelMixin,DestroyModelMixin):
    queryset = models.Student.objects.all()
    serializer_class = StudentModelSerializer
    # 获取单条数据
    def get(self, request, pk):
        return self.retrieve(request, pk)
    # 更新单条记录
    def patch(self, request, pk):
        # return self.update(request, pk, partial=True)
        return self.update(request, pk)
    # 删除单条记录
    def delete(self, request, pk):
        return self.destroy(request, pk)

GenericAPIView的视图子类

我们还能上面的代码进行简化。视图子类，也叫通用视图子类。

• CreateAPIView添加数据
  • 提供 post 方法继承自： GenericAPIView、CreateModelMixin
• ListAPIView获取多条数据
  • 提供 get 方法继承自：GenericAPIView、ListModelMixin
• RetrieveAPIView获取单条数据
  • 提供 get 方法继承自: GenericAPIView、RetrieveModelMixin
• DestoryAPIView删除
  • 提供 delete 方法继承自：GenericAPIView、DestoryModelMixin
• UpdateAPIView更新
  • 提供 put 和 patch 方法继承自：GenericAPIView、UpdateModelMixin

用法：

from rest_framework.generics import ListAPIView,CreateAPIView,RetrieveAPIView,UpdateAPIView,DestroyAPIView

class Students4View(ListAPIView,CreateAPIView):
    queryset = models.Student.objects.all()  # 必须写这个参数 ,方法中使用的self.get_queryset()方法自动获取到queryset属性数据
    serializer_class = StudentModelSerializer  # 非必填属性，self.get_serializer获取到serializer_class制定的序列化器类

'''注意：这里的UpdateAPIView实际上调用的事path方法，原因在上面UpdateModelMixin写了'''
class Student4View(RetrieveAPIView,UpdateAPIView,DestroyAPIView):
    queryset = models.Student.objects.all()
    serializer_class = StudentModelSerializer

ViewSet视图集基类

之前我们在写视图类的时候，获取多条数据和提交数据放在了一个类中。获取单条数据，更新单条数据，删除多条数据放到了一个类中

这是因为多条数据操作时不需要指定pk值，而针对单条数据时，需要指定pk值。也就是说需要知道你要操作哪一条数据

这样我们就很矛盾。我们没法将5个方法放到同一个类中。

而下面的ViewSet就可以解决这个问题，将5个方法放到同一个类中

ViewSet属性和方法

• list() 提供一组数据
• retrieve() 提供单个数据
• create() 创建数据
• update() 保存数据
• destory() 删除数据
  ViewSet视图集类不再实现get()、post()等方法，而是实现动作 action 如 list() 、create() 等。

视图集只在使用as_view()方法的时候，才会将action动作与具体请求方式对应上。

ViewSet使用

req/urls.py

from django.contrib import admin
from django.urls import path,re_path,include #  re_path --- django1.11 url
from req import views
urlpatterns = [
    path('students5/', views.Students5View.as_view({'get':'get_all_students','post':'post'})),
    # 发哪个请求就在as_view里传那个方法，写法'请求':'方法名'
    re_path('students5/(?P<pk>\d+)/', views.Students5View.as_view({'get':'get_one_student','patch':'gengxin', 'delete':'shanchu'})),

req/serializers.py

from rest_framework.viewsets import ViewSet
class Students5View(ViewSet):
    # 获取所有数据
    def get_all_students(self,request):
        students = models.Student.objects.all()
        serializer_obj = StudentModelSerializer(instance=students,many=True)
        return Response(serializer_obj.data)
    def get_one_student(self,request,pk):
        student = models.Student.objects.get(pk=pk)
        serializer_obj = StudentModelSerializer(instance=student)
        return Response(serializer_obj.data)
    # 添加单条记录
    def post(self,request):
        serializer_obj = StudentModelSerializer(data=request.data)
        if serializer_obj.is_valid():
            new_obj = models.Student.objects.create(**serializer_obj.validated_data)
            obj = StudentModelSerializer(instance=new_obj)
            return Response(obj.data, status=status.HTTP_201_CREATED)
    # 更新单条记录
    def gengxin(self, request, pk):
        student = models.Student.objects.get(pk=pk)
        data = request.data
        serializer_obj = StudentModelSerializer(instance=student, data=data, partial=True)
        if serializer_obj.is_valid():
            instance = serializer_obj.save()
            new_serializer_obj = StudentModelSerializer(instance=instance)
            return Response(new_serializer_obj.data, status=status.HTTP_202_ACCEPTED)
        else:
            return Response({'error': "检验失败"})
    # 删除单条记录
    def shanchu(self, request, pk):
        models.Student.objects.get(pk=pk).delete()
        # return Response(None,)
        return Response('', status=status.HTTP_204_NO_CONTENT)

基于视图集基类类来写视图接口(ViewSet升级版)

写方法还是太麻烦，怎么办？还有一个更简单的办法，如下
urls.py中将get post put这类请求类型直接与Mixin中内置的list,create,update等动作方法关联起来。

这样它就会自动去执行里面的list,create,update方法。不需要你在视图里定义一个函数名称然后再return self.create()了。
req/urls.py

from django.contrib import admin
from django.urls import path,re_path,include #  re_path --- django1.11 url
from req import views
urlpatterns = [
    path('students6/', views.Students6View.as_view({'get':'list','post':'create'})),
    re_path('students6/(?P<pk>\d+)/', views.Students6View.as_view({'get':'retrieve','patch':'partial_update', 'delete':'destroy'})),
]

req/serializers.py

'''注意这里引入的是Mixin系列的包需要配合GenericAPIView来使用'''
from rest_framework.generics import GenericAPIView
from rest_framework.mixins import ListModelMixin,CreateModelMixin, RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin
from rest_framework.viewsets import ViewSet
class Students6View(ViewSet,GenericAPIView,ListModelMixin,CreateModelMixin, RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin):
    queryset = models.Student.objects.all()  
    serializer_class = StudentModelSerializer  

ModelViewSet（终极版）

继承自GenericViewSet，同时包括了ListModelMixin、RetrieveModelMixin、CreateModelMixin、UpdateModelMixin、DestoryModelMixin。
示例如下：

from rest_framework.viewsets import ModelViewSet
class Students7View(ModelViewSet):
    queryset = models.Student.objects.all()  
    serializer_class = StudentModelSerializer 

视图集中定义附加action动作

在视图集中，除了上述默认的方法动作外，还可以添加自定义动作，进行扩展。举例，比如做一个登录方法login：

from rest_framework.viewsets import ModelViewSet,ReadOnlyModelViewSet
class StudentModelViewSet(ModelViewSet):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer
    def login(self,request):  # 这个就可以称为自定义的action动作
        """学生登录功能"""
        return Response({"message":"登录成功"})

认证组件Authentication

可以在settings.py配置文件中配置全局默认的认证方案

from rest_framework import settings
'''在settings配置文件中，我们可以进行下面的配置来覆盖默认配置'''
REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
      # 哪个写在前面，优先使用哪个认证
      #session认证，admin后台其实就使用的session认证，
      #其实接口开发很少用到session认证，所以我们通过配置
      #可以改为其他认证，比如后面项目里面我们用到jwt，
      #JSON WEB TOKEN认证，或者一些配合redis的认证
        'rest_framework.authentication.SessionAuthentication', 
        # 基本认证，工作当中可能一些测试人员会参与的话，
        #他们会将一些认证数据保存在内存当中，然后验证的，我们基本上用不上 
        'rest_framework.authentication.BasicAuthentication',   
    )
}

也可以在每个视图中通过设置authentication_classes属性来设置，比如说我们很多接口的数据都是可以让别人获取数据的，

但是有可能有些接口是调用给别人网站的，有可能到时候我们就需要一些单独的认证了

from rest_framework.authentication import SessionAuthentication, BasicAuthentication
from rest_framework.views import APIView
class ExampleView(APIView):
    # 类属性
    '''
    也可以写成元组形式的,到时候我们使用我们自己开发的认证组件的时候，
    就需要自己写一个认证组件类，然后写在列表中来使用'''
    authentication_classes = [SessionAuthentication, BasicAuthentication] 

认证失败会有两种可能的返回值：

401 Unauthorized 未认证

403 Permission Denied 权限被禁止

自定义认证组件

from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
class APIAuth(BaseAuthentication):
    def authenticate(self, request):
        print(request) 
        if 1:
            return 'xx','oo'  # request.user = 'xx'  request.auth = 'oo'
        else:
            raise AuthenticationFailed('认证失败')

全局使用，settings配置文件中使用

REST_FRAMEWORK = {
    'DEFAULT_RENDERER_CLASSES': (  # 默认响应渲染类
        'rest_framework.renderers.JSONRenderer',  # json渲染器
        'rest_framework.renderers.BrowsableAPIRenderer',  # 浏览器API渲染器
    ),
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'four.utils.authrenzheng.Auth',# 类的路径
        'rest_framework.authentication.SessionAuthentication',
        'rest_framework.authentication.BasicAuthentication'
	]
}

局部视图中使用

from rest_framework.authentication import SessionAuthentication, BasicAuthentication
from four.utils.auth import APIAuth
class AuthAPIView(APIView):
    authentication_classes = [APIAuth,]
    def get(self,request):
        print('>>>>',request.user)  # AnonymousUser  匿名用户，假用户
        print('>>>>',request.auth)  # AnonymousUser  匿名用户，假用户
        #>>>> root
        return Response({'msg':'hello'})

权限:Permissions

权限控制可以限制用户对于视图的访问和对于具体数据对象的访问。

• 在执行视图的dispatch()方法前，会先进行视图访问权限的判断
• 在通过get_object()获取具体对象时，会进行模型对象访问权限的判断

可以在配置文件中全局设置默认的权限管理类

REST_FRAMEWORK = {
    'DEFAULT_RENDERER_CLASSES': (  # 默认响应渲染类
        'rest_framework.renderers.JSONRenderer',  # json渲染器
        'rest_framework.renderers.BrowsableAPIRenderer',  # 浏览器API渲染器
    ),
    'DEFAULT_PERMISSION_CLASSES': [
    	# VIP用户
        'four.utils.mypermission.VIPpermission',
        # 登录状态下才能访问我们的接口，可以通过退出admin后台之后，
        # 你看一下还能不能访问我们正常的接口就看到效果
        'rest_framework.permissions.IsAuthenticated',
        # 表示任何人都可以进行任何的操作，没做限制
        'rest_framework.permissions.AllowAny',
    ],
}

也可以在具体的视图中通过permission_classes属性来设置

from rest_framework.permissions import IsAuthenticated
from rest_framework.views import APIView
class ExampleView(APIView):
    permission_classes = (IsAuthenticated,)

提供的权限

• AllowAny 允许所有用户
• IsAuthenticated 仅通过认证的用户
• IsAdminUser 仅管理员用户（可以通过admin创建一个用户进行测试）
• IsAuthenticatedOrReadOnly 已经登陆认证的用户可以对数据进行增删改操作，没有登陆认证的只能查看数据。

示例:

from rest_framework.authentication import SessionAuthentication
from rest_framework.permissions import IsAuthenticated
from rest_framework.generics import RetrieveAPIView

class StudentAPIView(RetrieveAPIView):
    queryset = Student.objects.all()
    serializer_class = StudentSerializer
    authentication_classes = [SessionAuthentication]
    permission_classes = [IsAuthenticated]

自定义权限

如需自定义权限，需继承rest_framework.permissions.BasePermission父类，并实现以下两个任何一个方法或全部

• .has_permission(self, request, view)是否可以访问视图， view表示当前视图对象
• .has_object_permission(self, request, view, obj)是否可以访问数据对象， view表示当前视图， obj为数据对象

例如在当前子应用下，创建一个权限文件permissions.py中声明自定义权限类:

from rest_framework.permissions import BasePermission
class IsXiaoMingPermission(BasePermission):
    def has_permission(self, request, view):
        if( request.user.username == "xiaoming" ):
            return True

视图函数

from .permissions import IsXiaoMingPermission
class StudentViewSet(ModelViewSet):
    queryset = Student.objects.all()
    serializer_class = StudentSerializer
    permission_classes = [IsXiaoMingPermission]

限流:Throttling

可以对接口访问的频次进行限制，以减轻服务器压力。
一般用于付费购买次数,投票等场景使用.
可以在配置文件中，使用DEFAULT_THROTTLE_CLASSES 和 DEFAULT_THROTTLE_RATES进行全局配置，

REST_FRAMEWORK = {
    'DEFAULT_THROTTLE_CLASSES': (
        'rest_framework.throttling.AnonRateThrottle', # 匿名用户，未登录的
        'rest_framework.throttling.UserRateThrottle' # 经过登录之后的用户
    ),
    'DEFAULT_THROTTLE_RATES': {
        'anon': '100/day',
        'user': '1000/day'
    }
}

DEFAULT_THROTTLE_RATES 可以使用 second, minute, hour 或day来指明周期
也可以在具体视图中通过throttle_classess属性来配置

from rest_framework.throttling import UserRateThrottle
from rest_framework.views import APIView
class ExampleView(APIView):
    throttle_classes = (UserRateThrottle,)  # 局部配置

可选择的限流类

• AnonRateThrottle
  • 限制所有匿名未认证用户，使用IP区分用户。使用DEFAULT_THROTTLE_RATES['anon']来设置频次
• UserRateThrottle
  • 限制认证用户，使用User id 来区分。使用DEFAULT_THROTTLE_RATES['user'] 来设置频次

示例：
全局配置中设置访问频率

 'DEFAULT_THROTTLE_RATES': {
        'anon': '3/minute',
        'user': '10/minute'
    }

视图

from rest_framework.authentication import SessionAuthentication
from rest_framework.permissions import IsAuthenticated
from rest_framework.generics import RetrieveAPIView
from rest_framework.throttling import UserRateThrottle

class StudentAPIView(RetrieveAPIView):
    queryset = Student.objects.all()
    serializer_class = StudentSerializer
    authentication_classes = [SessionAuthentication]
    permission_classes = [IsAuthenticated]
    throttle_classes = (UserRateThrottle,)

ScopedRateThrottle局部使用示例

# settings.py内容
'DEFAULT_THROTTLE_RATES': {
        'xx': '3/minute',
        'oo': '5/minute',
    },
# views.py内容
from rest_framework.throttling import ScopedRateThrottle
class StudentAPIView(ListAPIView):
    queryset = models.Student.objects.all()
    serializer_class = StudentModelSerializer
    throttle_classes = [ScopedRateThrottle,]
    throttle_scope = 'xx'
class StudentAPI2View(ListAPIView):
    queryset = models.Student.objects.all()
    serializer_class = StudentModelSerializer
    throttle_classes = [ScopedRateThrottle, ]
    throttle_scope = 'oo'
# urls.py内容
    path(r'students/',views.StudentAPIView.as_view()),
    path(r'students2/',views.StudentAPI2View.as_view()),

自定义一个频率组件

from rest_framework.throttling import BaseThrottle,SimpleRateThrottle
import time
from rest_framework import exceptions
visit_record = {}
class VisitThrottle(BaseThrottle):
    # 限制访问时间
    VISIT_TIME = 10
    VISIT_COUNT = 3
    # 定义方法 方法名和参数不能变
    def allow_request(self, request, view):
        # 获取登录主机的id
        id = request.META.get('REMOTE_ADDR')
        self.now = time.time()
        if id not in visit_record:
            visit_record[id] = []
        self.history = visit_record[id]
        # 限制访问时间
        while self.history and self.now - self.history[-1] > self.VISIT_TIME:
            self.history.pop()
        # 此时 history中只保存了最近10秒钟的访问记录
        if len(self.history) >= self.VISIT_COUNT:
            return False
        else:
            self.history.insert(0, self.now)
            return True
    def wait(self):
        return self.history[-1] + self.VISIT_TIME - self.now

过滤:Filtering

对于列表数据可能需要根据字段进行过滤，我们可以通过添加django-fitlter扩展来增强支持。

pip install django-filter 

在配置文件中增加过滤后端的设置：

INSTALLED_APPS = [
    ...
    'django_filters',  # 需要注册应用，
]


REST_FRAMEWORK = {
    'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend',),
    # 'DEFAULT_PAGINATION_CLASS':  'rest_framework.pagination.PageNumberPagination',
    # 'PAGE_SIZE': 5  # 每页最大数据量
    'EXCEPTION_HANDLER': 'req.utils.myexc.custom_exception_handler',
    'DEFAULT_SCHEMA_CLASS': "rest_framework.schemas.AutoSchema",
}

在视图中添加filter_fields属性，指定可以过滤的字段

class StudentListView(ListAPIView):
    queryset = Student.objects.all()
    serializer_class = StudentSerializer
    filter_fields = ('age', 'sex')
# 127.0.0.1:8000/four/students/?sex=1

排序:OrderingFilter

对于列表数据，REST framework提供了OrderingFilter过滤器来帮助我们快速指明数据按照指定字段进行排序。

在类视图中设置filter_backends，使用rest_framework.filters.OrderingFilter过滤器，REST framework会在请求的查询字符串参数中检查是否包含了ordering参数，如果包含了ordering参数，则按照ordering参数指明的排序字段对数据集进行排序。

前端可以传递的ordering参数的可选字段值需要在ordering_fields中指明。

示例：

from rest_framework.filters import OrderingFilter
class Students7View(ModelViewSet):
    queryset = models.Student.objects.all()  # 必须写这个参数 ,方法中使用的self.get_queryset()方法自动获取到queryset属性数据
    serializer_class = StudentModelSerializer  # 非必填属性，self.get_serializer获取到serializer_class制定的序列化器类
    filter_backends = (OrderingFilter,)
    ordering_fields = ('id', 'age')
    # students/?ordering=-id
# 127.0.0.1:8000/books/?ordering=-age 
# 必须是ordering=某个值
# -id 表示针对id字段进行倒序排序
# id  表示针对id字段进行升序排序

如果需要在过滤以后再次进行排序，则需要两者结合!

from rest_framework.generics import ListAPIView
from students.models import Student
from .serializers import StudentModelSerializer
from django_filters.rest_framework import DjangoFilterBackend #需要使用一下它才能结合使用
class Student3ListView(ListAPIView):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer
    filter_fields = ('age', 'sex')
    # 因为filter_backends是局部过滤配置，局部配置会覆盖全局配置,所以需要重新把过滤组件核心类再次声明,
    # 否则过滤功能会失效
    filter_backends = [OrderingFilter,DjangoFilterBackend]
    ordering_fields = ('id', 'age')# 针对的是继承的类中的list方法
# 127.0.0.1:8000/books/?sex=1&ordering=-age 

分页:Pagination

REST framework提供了分页的支持。
我们可以在配置文件中设置全局的分页方式

REST_FRAMEWORK = {
  # 全局分页，一旦设置了全局分页，那么我们drf中的视图扩展类里面的list方法提供的列表页都会产生分页的效果。所以一般不用全局分页
    'DEFAULT_PAGINATION_CLASS':  'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 100  # 每页最大数据量
}

也可通过自定义Pagination类，来为视图添加不同分页行为。在视图中通过pagination_class属性来指明。

class LargeResultsSetPagination(PageNumberPagination):
    page_size = 1000  # 每页显示多少条
    #127.0.0.1:8001/students/?page=5&page_size=10
    page_size_query_param = 'page_size'
    max_page_size = 10000
class BookDetailView(RetrieveAPIView):
    queryset = BookInfo.objects.all()
    serializer_class = BookInfoSerializer
    pagination_class = LargeResultsSetPagination

注意：如果在视图内关闭分页功能，只需在视图内设置

pagination_class = None

可选分页器

PageNumberPagination

前端访问网址形式

GET  http://127.0.0.1:8000/students/?page=4

可以在子类中定义的属性：

• page_size 每页数目
• page_query_param 前端发送的页数关键字名，默认为"page"
• page_size_query_param 前端发送的每页数目关键字名，默认为None
• max_page_size 前端最多能设置的每页数量

# 声明分页的配置类
from rest_framework.pagination import PageNumberPagination
class StandardPageNumberPagination(PageNumberPagination):
    # 默认每一页显示的数据量
    page_size = 2
    # 允许客户端通过get参数来控制每一页的数据量
    page_size_query_param = "size"
    max_page_size = 10
    # 自定义页码的参数名
    page_query_param = "p"
class StudentAPIView(ListAPIView):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer
    pagination_class = StandardPageNumberPagination
# 127.0.0.1/four/students/?p=1&size=5

LimitOffsetPagination(了解)

前端访问网址形式：其实就是通过偏移量来取数据

GET http://127.0.0.1/four/students/?limit=100&offset=400  # 从下标为400的记录开始，取100条记录

可以在子类中定义的属性：

• default_limit 默认限制，每页数据量大小，默认值与PAGE_SIZE设置一致
• limit_query_param limit参数名，默认’limit’ ， 可以通过这个参数来改名字
• offset_query_param offset参数名，默认’offset’ ，可以通过这个参数来改名字
• max_limit 最大limit限制，默认None， 无限制

from rest_framework.pagination import LimitOffsetPagination
class StandardLimitOffsetPagination(LimitOffsetPagination):
    # 默认每一页查询的数据量,类似上面的page_size
    default_limit = 2
    limit_query_param = "size"  # 默认是limit
    offset_query_param = "start"  # 默认是offset
class StudentAPIView(ListAPIView):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer
    # 调用页码分页类
    # pagination_class = StandardPageNumberPagination
    # 调用查询偏移分页类
    pagination_class = StandardLimitOffsetPagination

异常处理:Exception

一个简单的示例

class APIError(Exception):
    pass
class Student2APIView(APIView):
    def get(self,request,pk):
        try:
            instance = Student.objects.get(pk=pk)
        except Student.DoesNotExist:
            raise APIError('自定义API错误')
            return Response({"message":"访问的商品已经下架~"})
        serializer = StudentModelSerializer(instance=instance)
        return Response(serializer.data)

REST framework提供了异常处理，我们可以自定义异常处理函数。

可以创建一个utils文件夹，里面放一个exceptions.py文件，名字随便写，然后写下面的内容

from rest_framework.views import exception_handler
def custom_exception_handler(exc, context): # 自定义的错误处理函数
      '''
      exc错误对象
      context 异常发生时的一些上下文信息
      '''
    # 先调用REST framework默认的异常处理方法获得标准错误响应对象
    '''
	这个函数是drf提供的，它处理了一些错误，但是如果它处理不了的，
	它会返回None，所以，如果是None的话，我们需要自己来处理错误
	'''
    response = exception_handler(exc, context) 
    # 在此处补充自定义的异常处理
    if response is None:
          if isinstance(exc,APIError)
        # 这里就可以记录错误信息了，一般记录到文件中，可以使用日志系统来进行记录
        # return Respose({'msg':'自定义API错误了'})
        response.data['status_code'] = response.status_code
    return response

在配置文件中还要声明自定义的异常处理

REST_FRAMEWORK = {
    'EXCEPTION_HANDLER': 'my_project.my_app.utils.custom_exception_handler'
}

如果未声明，会采用默认的方式，如下

REST_FRAMEWORK = {
    'EXCEPTION_HANDLER': 'rest_framework.views.exception_handler'
}

处理关于数据库的异常

from rest_framework.views import exception_handler as drf_exception_handler
from rest_framework import status
from django.db import DatabaseError
def exception_handler(exc, context):
    response = drf_exception_handler(exc, context)
    if response is None:
        view = context['view'] # 出错的方法或者函数名称
        if isinstance(exc, DatabaseError):
            print('[%s]: %s' % (view, exc))
            response = Response({'detail': '服务器内部错误'}, status=status.HTTP_507_INSUFFICIENT_STORAGE)
    return response

drf定义的异常

• APIException 所有异常的父类
• ParseError 解析错误
• AuthenticationFailed 认证失败
• NotAuthenticated 尚未认证
• PermissionDenied 权限决绝
• NotFound 未找到
• MethodNotAllowed 请求方式不支持
• NotAcceptable 要获取的数据格式不支持
• Throttled 超过限流次数
• ValidationError 校验失败

也就是说，上面列出来的异常不需要我们自行处理了，很多的没有在上面列出来的异常，就需要我们在自定义异常中自己处理了。

自动生成接口文档

REST framework可以自动帮助我们生成接口文档。接口文档以网页的方式呈现。自动接口文档能生成的是继承自APIView及其子类的视图。

安装依赖文件

pip install coreapi

设置接口文档访问路径

在总路由中添加接口文档路径。文档路由对应的视图配置为rest_framework.documentation.include_docs_urls，参数title为接口文档网站的标题。

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

如果报错了下面的错误，说明我们缺少一个依赖，配置一下就行了AutoSchema' object has no attribute 'get_link
配置

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

文档描述说明的定义位置

单一方法的视图，可直接使用类视图的文档字符串，如

class BookListView(generics.ListAPIView):
    """
    get: 返回所有图书信息.
    post: 添加记录
    """
    #注意，这是在类中声明的注释，如果在方法中你声明了其他注释，会覆盖这个注释的

包含多个方法的视图，在类视图的文档字符串中，分开方法定义，如

class BookListCreateView(generics.ListCreateAPIView):
    """
    get:
    返回所有图书信息.
    post:
    新建图书.
    """

对于视图集ViewSet，仍在类视图的文档字符串中封开定义，但是应使用action名称区分，如

class BookInfoViewSet(mixins.ListModelMixin, mixins.RetrieveModelMixin, GenericViewSet):
    """
    list:
    返回图书列表数据
    retrieve:
    返回图书详情数据
    latest:
    返回最新的图书数据
    read:
    修改图书的阅读量
    """

访问接口文档网页

浏览器访问 127.0.0.1:8000/docs/，即可看到自动生成的接口文档。

两点说明：

• 视图集ViewSet中的retrieve名称，在接口文档网站中叫做read
• 参数的Description需要在模型类或序列化器类的字段中以help_text选项定义，如：

class Student(models.Model):
    ...
    age = models.IntegerField(default=0, verbose_name='年龄', help_text='年龄')
    ...

或 注意，如果你多个应用使用同一个序列化器，可能会导致help_text的内容显示有些问题

class StudentSerializer(serializers.ModelSerializer):
    class Meta:
        model = Student
        fields = "__all__"
        extra_kwargs = {
            'age': {
                'required': True,
                'help_text': '年龄'
            }
        }

Xadmin

xadmin是Django的第三方扩展，比使用Django的admin站点更强大也更方便。
GitHub地址：https://github.com/sshwsfc/django-xadmin

安装

通过如下命令安装xadmin的最新版，它文档里面的安装方法好久没有更新了，会导致你安装不成功，所以我们使用下面的网址进行安装

pip install https://codeload.github.com/sshwsfc/xadmin/zip/django2

在配置文件中注册如下应用

INSTALLED_APPS = [
    ...
    'xadmin',
    'crispy_forms',
    'reversion',
    ...
]
# 修改使用中文界面
LANGUAGE_CODE = 'zh-Hans'
# 修改时区
TIME_ZONE = 'Asia/Shanghai'

xadmin有建立自己的数据库模型类，需要进行数据库迁移

python manage.py makemigrations
python manage.py migrate

在总路由中添加xadmin的路由信息

import xadmin
xadmin.autodiscover()
# version模块自动注册需要版本控制的 Model
from xadmin.plugins import xversion
xversion.register_models()
urlpatterns = [
    path(r'xadmin/', xadmin.site.urls),
]

如果之前没有创建超级用户，需要创建，如果有了，则可以直接使用之前的。

python manage.py createsuperuser

使用

• xadmin不再使用Django的admin.py，而是需要编写代码在adminx.py文件中，每一个应用都可以写一创建adminx.py对xadmin站点进行配置。
• xadmin的站点管理类不用继承admin.ModelAdmin，而是直接继承object即可

站点的全局配置

例如：在子应用中创建adminx.py文件。

import xadmin
from xadmin import views
class BaseSetting(object):
    """xadmin的基本配置"""
    enable_themes = True  # 开启主题切换功能
    use_bootswatch = True # 引导控制盘(其实就是我们的左侧菜单栏)
xadmin.site.register(views.BaseAdminView, BaseSetting)
class GlobalSettings(object):
    """xadmin的全局配置"""
    site_title = "xx学城"  # 设置站点标题
    site_footer = "xx学城有限公司"  # 设置站点的页脚
    menu_style = "accordion"  # 设置菜单折叠
xadmin.site.register(views.CommAdminView, GlobalSettings)

站点Model管理

xadmin可以使用的页面样式控制基本与Django原生的admin一样。
可以在models类中定义个__str__方法来定义对象显示成什么内容

from django.db import models
# Create your models here.
class Student(models.Model):  # tb_student
    # 模型字段
    name = models.CharField(max_length=100,verbose_name="姓名", help_text='提示文本：不能为空')
    sex = models.BooleanField(default=1,verbose_name="性别")  #1:男
    age = models.IntegerField(verbose_name="年龄")
    class_null = models.CharField(max_length=5,verbose_name="班级编号")
    description = models.TextField(max_length=1000,verbose_name="个性签名")
    class Meta:
        db_table="tb_student"
        # # 这是给admin后台管理系统配置表名用的
        verbose_name = "学生"
        verbose_name_plural = verbose_name
    def __str__(self):
        return self.name

• list_display 控制列表展示的字段

list_display = ['id', 'btitle', 'bread', 'bcomment']

• search_fields 控制可以通过搜索框搜索的字段名称，xadmin使用的是模糊查询

search_fields = ['id','btitle']

• list_filter 可以进行过滤操作的列，对于分类、性别、状态

list_filter = ['is_delete']

• ordering 默认排序的字段

ordering = ['-age',]  #-倒序

• show_detail_fields 在列表页提供快速显示详情信息

show_detail_fields = ['id',]

• list_editable 在列表页可以快速直接编辑的字段

list_editable = ['name','age',]

• refresh_times 指定列表页的定时刷新

# 设置允许后端管理人员按多长时间(秒)刷新页面,选好之后就能自动刷新了
refresh_times = [5, 10,30,60]  

• list_export 控制列表页导出数据的可选格式

#写元祖或者列表都行   list_export设置为None来禁用数据导出功能
list_export = ('xls', 'json','csv')
#设置允许导出的字段
list_export_fields = ('id', 'btitle', 'bpub_date') 

• show_bookmarks 控制是否显示书签功能

show_bookmarks = True #False就隐藏了这个功能

• data_charts 控制显示图表的样式
  • title 控制图标名称
  • x-field 控制x轴字段
  • y-field 控制y轴字段，可以是多个值
  • order 控制默认排序

data_charts = {
        "order_amount": {  #随便写的名称order_amount
          'title': '图书发布日期表', 
          "x-field": "bpub_date", 
          "y-field": ('btitle',),
          "order": ('id',),
        },
    #    支持生成多个不同的图表
    #    "order_amount2": {
    #      'title': '图书发布日期表', 
    #      "x-field": "bpub_date", 
    #      "y-field": ('btitle',),
    #      "order": ('id',)
    #    },
    }

• model_icon 控制菜单的图标【图标的设置可以参考font-awesome的图标css名称】

model_icon = 'fa fa-gift'

• readonly_fields 在编辑页面的只读字段

readonly_fields = ['name',]

• exclude 在编辑页面隐藏的字段,比如判断这个数据是否删除的delete_status字段，一般就是用来标识一下字段是不是被删除了，但是数据库中不删除

exclude = ['name',]

这并不是所有功能，可以参看它的文档，它提供的一些功能我们可能还需要自定制，调整或者添加一些它没有的功能，后面再说