Django 学习之Rest Framework 视图集与Routers与扩展功能

一.视图集使用

使用视图集ViewSet，可以将一系列逻辑相关的动作放到一个类中：

list() 提供一组数据

retrieve() 提供单个数据

create() 创建数据

update() 保存数据

destory() 删除数据

ViewSet视图集类不再实现get()、post()等方法，而是实现动作 action 如 list() 、create() 等。

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

在此之前首先创建一个新的app应用名为：collect

python3 manage.py startapp collect

进行相应的注册以及配置url

1.常用的视图集父类

1.ViewSet

继承自APIView 与 ViewSetMixin作用也与APIView基本类似，提供了身份认证、权限校验、流量管理等。

ViewSet主要通过继承ViewSetMixin来实现在调用as_view()时传入字典（如{'get':'list'}）的映射处理工作。

在ViewSet中，没有提供任何动作action方法，需要我们自己实现action方法。

例1：

collect应用中的urls.py的内容为：

from django.urls import path, re_path
from collect import views

urlpatterns = [
    # 不要在同一路由的as_view 中写两个同样的http请求，会产生覆盖！！！
    # ViewSet
    path("student1/", views.Student1ViewSet.as_view({"get": "get_5"})),
    path("student1/get_girl/", views.Student1ViewSet.as_view({"get": "get_5_girl"})),
    re_path(r"^student1/(?P<pk>\d+)/$", views.Student1ViewSet.as_view({"get": "get_one"})),

]

urls.py

colectl应用中的views内容：

from students.models import Student
from rest_framework.response import Response

class Student1ViewSet(ViewSet):
    def get_5(self, request):
        # 获取５条数据
        student_list = Student.objects.all()[:5]
        serializer = StudentModelSerializer(instance=student_list, many=True)  # 多个数时候，需要加many=True
        return Response(serializer.data)

    def get_one(self, request, pk):
        # 获取一条数据
        student_obj = Student.objects.get(pk=pk)
        serializer = StudentModelSerializer(instance=student_obj)
        return Response(serializer.data)

views.py

查询5条数据：

查询id=5的数据：

查找性别女的5条数据：

例2：过渡版

collect应用中的urls.py的添加内容：

# ViewSet 过渡版
path("student2/", views.Student2ViewSet.as_view({"get": "get_5"})),
path("student2/get_girl/", views.Student2ViewSet.as_view({"get": "get_5_girl"})),
re_path(r"^student2/(?P<pk>\d+)/$", views.Student2ViewSet.as_view({"get": "get_one"})),

urls.py

collect应用中的views添加内容：

"""如果希望在视图集中调用GenericAPIView的功能，则可以采用下面方式"""
from rest_framework.generics import GenericAPIView

class Student2ViewSet(ViewSet, GenericAPIView):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer

    def get_5(self, request):
        """获取5条数据"""
        student_list = self.get_queryset()[:5]

        serializer = self.get_serializer(instance=student_list, many=True)

        return Response(serializer.data)

    def get_one(self, request, pk):
        """获取一条数据"""
        student_obj = self.get_object()

        serializer = self.get_serializer(instance=student_obj)

        return Response(serializer.data)

    def get_5_girl(self, request):
        """获取5条女孩数据"""
        student_list = self.get_queryset().filter(sex=False)[:5]

        serializer = self.get_serializer(instance=student_list, many=True)

        return Response(serializer.data)

views.py

测试一个可以查询多条数据，其他就不一一测试。

2.GenericViewSet

使用ViewSet通常并不方便，因为list、retrieve、create、update、destory等方法都需要自己编写，而这些方法与前面讲过的Mixin扩展类提供的方法同名，所以我们可以通过继承Mixin扩展类来复用这些方法而无需自己编写。但是Mixin扩展类依赖与GenericAPIView，所以还需要继承GenericAPIView。

　　GenericViewSet就帮助我们完成了这样的继承工作，继承自GenericAPIView与ViewSetMixin，在实现了调用as_view()时传入字典（如{'get':'list'}）的映射处理工作的同时，还提供了GenericAPIView提供的基础方法，可以直接搭配Mixin扩展类使用。

例1：

collect应用中的urls.py的添加内容：

# GenericViewSet
path("student3/", views.Student3GenericViewSet.as_view({"get": "get_5"})),
path("student3/get_girl/", views.Student3GenericViewSet.as_view({"get": "get_5_girl"})),

urls.py

collect应用中的views.py添加内容：

上面的方式，虽然实现视图集中调用GenericAPIView，但是我们要多了一些类的继承。

所以我们可以直接继承 GenericViewSet

from rest_framework.viewsets import GenericViewSet

class Student3GenericViewSet(GenericViewSet):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer

    def get_5(self, request):
        # 获取５条数据
        student_list = self.get_queryset()[:5]
        serializer = self.get_serializer(instance=student_list, many=True)
        return Response(serializer.data)

    def get_5_girl(self, request):
        # 获取５条女孩数据
        student_list = self.get_queryset().filter(sex=False)[:5]
        serializer = self.get_serializer(instance=student_list, many=True)
        return Response(serializer.data)

views.py

进程测试一个查询5条女孩数据的：

例2：

在使用GenericViewSet时，虽然已经提供了基本调用数据集（queryset）和序列化器属性，但是我们要编写一些基本的

API时，还是需要调用DRF提供的模型扩展类 [Mixins]

collect应用中的urls.py的添加内容：

# GenericViewSet，可以和模型类进行组合快速生成基本的API接口
path('student4/', views.Student4GenericViewSetAndMixin.as_view({"get": "list", "post": "create"})),

urls.py

collect应用中的views.py添加内容：

# 这样不要试图写方法，只要urls中写对应请求方式即可。

from rest_framework.mixins import ListModelMixin, CreateModelMixin

class Student4GenericViewSetAndMixin(GenericViewSet, ListModelMixin, CreateModelMixin):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer

views.py

测试返回所有数据：

3.ModelViewSet

继承自GenericViewSet，同时包括了ListModelMixin、RetrieveModelMixin、CreateModelMixin、UpdateModelMixin、DestoryModelMixin。

不用再写方法，直接在路由处进行配置写方法即可。

例：

collect应用中的urls.py的添加内容：

   # ModelViewSet 默认提供了5个API接口
    path('student5/', views.Student5ModelViewSet.as_view({"get": "list", "post": "create"})),
    re_path(r"^student5/(?P<pk>\d+)/$",
            views.Student5ModelViewSet.as_view({"get": "retrieve", "put": "update", "delete": "destroy"})),

urls.py

collect应用中的views.py添加内容：

from rest_framework.viewsets import ModelViewSet

class Student5ModelViewSet(ModelViewSet):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer

views.py

测试删除id=15的数据：

从数据库看出数据被删除：

4.ReadOnlyModelViewSet

继承自GenericViewSet，同时包括了ListModelMixin、RetrieveModelMixin。

例：

collect应用中的urls.py的添加内容：

# ReadOnlyModelViewSet
    path('student6/', views.Student6ReadOnlyModelViewSet.as_view({'get': 'list'})),
re_path(r"^student6/(?P<pk>\d+)/$", views.Student6ReadOnlyModelViewSet.as_view({"get": "retrieve"})),

urls.py

collect应用中的views.py添加内容：

from rest_framework.viewsets import ReadOnlyModelViewSet

class Student6ReadOnlyModelViewSet(ReadOnlyModelViewSet):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer

urls.py

5.视图集中多个自定义序列化器

在视图集中，除了上述默认的方法动作外，那么有时候会出现一个类中需要调用多个序列化器,那么可以进行添加自定义动作。

首先是对serializer.py新增新的序列化器类代码如下：

class StudentMyModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = Student
        fields = ["id", "name"]

serializers.py

(1)一个视图类调用多个序列化器类

urls.py内添加：

  # 一个视图类调用多个序列化器类
    path("student8/", views.Student8GenericAPIView.as_view()),

views.py添加内容为：

from .serializers import StudentMyModelSerializer

class Student8GenericAPIView(GenericAPIView):
    """原来的视图类中基本上一个视图类只会调用一个序列化器，当然也有可能要调用多个序列化器"""

    class Student8GenericAPIView(GenericAPIView):
        queryset = Student.objects.all()

        # GenericAPI内部调用序列化器的方法，我们可以重写这个方法来实现根据不同的需求来调用不同的序列化器
        def get_serializer_class(self):
            if self.request.method == "GET":
                return StudentMyModelSerializer  # 如果是GET 返回的是新的序列化器类
            return StudentModelSerializer

        def get(self, request):
            """获取所有数据的id和name"""
            student_list = self.get_queryset()

            serializer = self.get_serializer(instance=student_list, many=True)

            return Response(serializer.data)

        def post(self, request):
            """添加数据"""
            data = request.data
            serializer = self.get_serializer(data=data)
            serializer.is_valid(raise_exception=True)
            serializer.save()
            return Response(serializer.data)

views.py

(2)在一个视图集中调用多个序列化器

urls.py内添加：

# 一个视图集调用多个序列化器类
    path("student9/", views.Student9GenericAPIView.as_view({"get": "list"})),
re_path(r"^student9/(?P<pk>\d+)/$", views.Student9GenericAPIView.as_view({"get": "retrieve"})),

views.py添加内容为：

class Student9GenericAPIView(ModelViewSet):
    queryset = Student.objects.all()
    """要求:
            列表数据list，返回２个字段，
            详情数据retrieve，返回所有字段，
    """

    def get_serializer_class(self):
        # print(self.action)  # 当前请求要执行的方法名称
        if self.action == "list":
            return StudentMyModelSerializer
        return StudentModelSerializer

views.py

测试获取全部只有两个字段:

查询单个显示多个字段：

二．路由Routers

对于视图集ViewSet，我们除了可以自己手动指明请求方式与动作action之间的对应关系外，还可以使用Routers来帮助我们快速实现路由信息。

REST framework提供了两个router

SimpleRouter

DefaultRouter

1. 使用方法

(1)创建router对象，并注册视图集

例如:

from rest_framework import routers
router = routers.DefaultRouter()
router.register(r'router_stu', StudentModelViewSet, base_name='student')

register(prefix, viewset, base_name)

prefix 该视图集的路由前缀

viewset 视图集

base_name 路由别名的前缀

如上述代码会形成的路由如下：

^books/$    name: book-list

^books/{pk}/$   name: book-detail

(2)添加路由数据

可以有两种方式：

urlpatterns = [
    ...
]
urlpatterns += router.urls

或

urlpatterns = [
    ...
    url(r'^', include(router.urls))
]

例：urls.py代码为：

"""
有了视图集以后，视图文件中多个视图类可以合并成一个，但是，路由的代码就变得复杂了，
需要我们经常在as_view方法 ,编写http请求和视图方法的对应关系，
事实上，在路由中，DRF也提供了一个路由类给我们对路由的代码进行简写。
当然，这个路由类仅针对于 视图集 才可以使用。
"""
from rest_framework.routers import DefaultRouter, SimpleRouter

# 实例化router对象
router = DefaultRouter()  # 会生成api-root
# router = SimpleRouter()

# router.register("访问地址前缀"，"视图集类","访问别买[可选]")
# 注册视图视图集类

router.register("student7", views.Student7RouterModelViewSet)  # url后缀不要加/

# print(router.urls)
# 把路由列表注册到django项目中
urlpatterns += router.urls

urls.py

上面的代码就成功生成了路由地址[增/删/改/查一条/查多条的功能]，但是不会自动我们在视图集自定义方法的路由。

所以我们如果也要给自定义方法生成路由，则需要进行action动作的声明。

2.视图集中附加action的声明

在视图集中，如果想要让Router自动帮助我们为自定义的动作生成路由信息，需要使用rest_framework.decorators.action装饰器。

self.action # 获取本次请求的视图方法名

以action装饰器装饰的方法名会作为action动作名，与list、retrieve等同。

action装饰器可以接收两个参数：

methods: 声明该action对应的请求方式，列表传递

detail

声明该action的路径是否与单一资源对应，及是否是

xxx/<pk>/action方法名/

True 表示路径格式是`xxx/<pk>/action方法名/`

False 表示路径格式是`xxx/action方法名/

例：配合添加路由例子中的代码结合

视图views.py代码：

from rest_framework.decorators import action

class Student7RouterModelViewSet(ModelViewSet):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer

    # methods 指定允许哪些http请求访问当前视图方法
    # detail  指定生成的路由地址中是否要夹带pk值，True为需要
    # @action(methods=['get', "post"], detail=False)
    # def get_6(self, request):

    # < URLPattern
    # '^student7/get_6/$'[name = 'student-get-6'] >,
    # < URLPattern
    # '^student7/get_6\.(?P<format>[a-z0-9]+)/?$'[name = 'student-get-6'] >,

    # @action(methods=['get', "post"], detail=True)  #　可以添加多个方法实现一种功能，不过一般不这样加
    @action(methods=['get'], detail=True)
    def get_6(self, request, pk):
        # < URLPattern
        # '^student7/(?P<pk>[^/.]+)/get_6/$'[name = 'student-get-6'] >,
        # < URLPattern
        # '^student7/(?P<pk>[^/.]+)/get_6\.(?P<format>[a-z0-9]+)/?$'[name = 'student-get-6'] >,
        student_obj = self.get_queryset().get(pk=pk)
        serializer = self.get_serializer(instance=student_obj)
        return Response(serializer.data)

views.py

经过测试可以进行查询一条数据，其他就不多做测试：

3.路由router形成URL的方式

(1)SimpleRouter

(2)DefaultRouter

DefaultRouter与SimpleRouter的区别是，DefaultRouter会多附带一个默认的API根视图，返回一个包含所有列表视图的超链接响应数据。

三.扩展功能

为了方便接下来的学习，我们创建一个新的子应用 opt

python3 manage.py startapp opt

配置路由并注册（此步骤就不多做详细介绍，需要请移步：）

因为接下来的功能中需要使用到登录功能，所以我们使用django内置admin站点并创建一个管理员.

创建管理员以后，访问admin站点，先修改站点的语言配置，在settings里修改

创建管理员命令：

python manage.py createsuperuser

运行项目：http://127.0.0.1:8000/admin/

然后就进入到这样的页面：

1.认证Authentication

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

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework.authentication.SessionAuthentication',  # session认证
        'rest_framework.authentication.BasicAuthentication',   # 基本认证
    )
}

也可以在每个视图中通过设置局部authentication_classess属性来设置

opt下的urls.py：

urlpatterns = [
    path('auth1/', views.Demo1APIView.as_view()),
    path('auth2/', views.Demo2APIView.as_view()),
]

opt下的views.py:

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated, IsAdminUser

"""用户的认证和权限识别"""

class Demo1APIView(APIView):
    """只允许登录后的用户访问"""
    permission_classes = [IsAuthenticated]

    def get(self, request):
        """个人中心"""
        return Response("个人中心")

class Demo2APIView(APIView):
    """只允许管理员访问"""
    permission_classes = [IsAdminUser]

    def get(self, request):
        """个人中心2"""
        return Response("个人中心2")

views.py

在登录用户浏览器访问：

在未登录的浏览器访问：

auth2的验证过程是，先用admin页面里面新增一个aaqqq用户，将其用户设置为超级用户，然后让aaqqq在另外一个浏览器进行登录操作，登录后，将aaqqq用户设置为普通用户，这时这个用户就是普通用户且登录的状态，所有显示：

登录后修改的权限状态

而超级用户访问auth2是：

2. 权限Permissions

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

在执行视图的dispatch()方法前，会先进行视图访问权限的判断

在通过get_object()获取具体对象时，会进行模型对象访问权限的判断

内置提供的权限：

AllowAny 允许所有用户

IsAuthenticated 仅通过认证的用户

IsAdminUser 仅管理员用户

IsAuthenticatedOrReadOnly 已经登陆认证的用户可以对数据进行增删改操作，没有登陆认证的只能查看数据。

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

REST_FRAMEWORK = {
    ....

    'DEFAULT_PERMISSION_CLASSES': (
        'rest_framework.permissions.IsAuthenticated',
    )
}

如果未指明，则采用如下默认配置

'DEFAULT_PERMISSION_CLASSES': (

'rest_framework.permissions.AllowAny',

)

也可以在具体的视图中通过局部permission_classes属性来（在每个类中）设置。

opt下的urls.py新加内容为：

# 自定义权限
path('auth3/', views.Demo3APIView.as_view()),

opt下的views.py:

# 以下内容需要新建一个用户为xiaoming的用户，在admin管理里面进行新建即可。
# 自定义权限
from rest_framework.permissions import BasePermission

class MyPermission(BasePermission):
    def has_permission(self, request, view):
        """
        针对访问视图进行权限判断
        :param request: 本次操作的http请求对象
        :param view:  本次访问路由对应的视图对象
        :return:
        """
        if request.user.username == "xiaoming":
            return True
        return False

class Demo3APIView(APIView):
    permission_classes = [MyPermission]

    def get(self, request):
        """个人中心3"""
        return Response("个人中心3")

views.py

只有xiaoming才能访问到auth3

设置了权限就连root都访问不了：

3.限流Throttling

可以对接口访问的频次进行限制，以减轻服务器压力。

一般用于付费购买次数,投票等场景使用.

可以在配置文件中，使用DEFAULT_THROTTLE_CLASSES 和 DEFAULT_THROTTLE_RATES进行全局配置。

REST_FRAMEWORK = {
    # 限流
    'DEFAULT_THROTTLE_CLASSES': (  # 对全局进行设置
        'rest_framework.throttling.AnonRateThrottle',
        'rest_framework.throttling.UserRateThrottle'
    ),
    'DEFAULT_THROTTLE_RATES': {
        'anon': '3/hour',
        'user': '3/minute',
    }
}

DEFAULT_THROTTLE_RATES 可以使用 second, minute, hour 或day来指明周期。

　　也可以在具体视图中通过throttle_classess属性来配置

opt下的urls.py新加内容为：

 # 限流
path('auth4/', views.Demo4APIView.as_view()),

opt下的views.py:

# 限流
from rest_framework.throttling import UserRateThrottle, AnonRateThrottle

class Demo4APIView(APIView):
    throttle_classes = [UserRateThrottle, AnonRateThrottle]  # 全局配置后，这里就不用指定

    def get(self, request):
        """投票页面"""
        return Response("投票页面")

views.py

setting.py文件下新加内容：

REST_FRAMEWORK = {
    # 限流
    # 'DEFAULT_THROTTLE_CLASSES': (  # 对全局进行设置
    #     'rest_framework.throttling.AnonRateThrottle',
    #     'rest_framework.throttling.UserRateThrottle'
    # ),
    'DEFAULT_THROTTLE_RATES': {
        'anon': '3/hour',
        'user': '3/minute',
    }
}

运行测试：

未登录用户投票三次后(访问三次后)只能过一小时才能继续投票：

登录的用户：只需要等待1分钟

这些都是通过setting里面设置的。

4. 过滤Filtering

对于列表数据可能需要根据字段进行过滤，我们可以通过添加django-fitlter扩展来增强支持。过滤需要采用之前的序列化器内容：

pip3 install django-filter

在配置文件里进行注册：

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

# 这个也是全局配置
REST_FRAMEWORK = {
    ...
    'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend',)
}

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

opt下的urls.py新加内容为：

# 过滤
path('data5/', views.Demo5APIView.as_view()),

opt下的views.py新增:

在没有过滤的情况下：

# 过滤
from rest_framework.generics import GenericAPIView, ListAPIView
from students.models import Student
from .serializers import StudentModelSerializer
from django_filters.rest_framework import DjangoFilterBackend

class Demo5APIView(ListAPIView):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer
    filter_backends = [DjangoFilterBackend]  # 全局配置后，这里就不用指定了。
    filter_fields = ['age', "id"]  # 声明过滤字段

在过滤age=27的情况下：

http://127.0.0.1:8000/opt/data5/?age=27

5. 排序Ordering

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

　　使用方法：

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

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

opt下的urls.py新加内容为：

   # 排序
path('data6/', views.Demo6APIView.as_view()),

opt下的views.py新增:

# 排序
from rest_framework.filters import OrderingFilter

class Demo6APIView(ListAPIView):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer
    filter_backends = [DjangoFilterBackend, OrderingFilter]  # 局部配置会覆盖全局配置
    filter_fields = ['id', "age", "sex"]
ordering_fields = ['id', "age"]

views.py

首先用过滤age=24出来两条

然后进行排序id倒序：

http://127.0.0.1:8000/opt/data6/?age=24&ordering=-id

6. 分页Pagination

REST framework提供了分页的支持。

我们可以在配置文件中设置全局的分页方式，如：

REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS':  'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 100  # 每页数目
}

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

opt下的urls.py新加内容为：

 # 分页
    path('data7/', views.Demo7APIView.as_view()),

opt下的views.py新增:

# 分页
from rest_framework.pagination import PageNumberPagination, LimitOffsetPagination

"""1. 自定义分页器，定制分页的相关配置"""
"""
# 页码分页  PageNumberPagination
前端访问形式：GET  http://127.0.0.1:8000/opt/data7/?page=4

page=1   limit 0,10
page=2   limit 10,20

# 偏移量分页  LimitOffsetPagination
前端访问形式：GET  http://127.0.0.1:8000/opt/data7/?start=4&size=3

start=0  limit 0,10
start=10 limit 10,10
start=20 limit 20,10
"""

class StandardPageNumberPagination(PageNumberPagination):
    """分页相关配置"""
    page_query_param = "page"  # 设置分页页码关键字名
    page_size = 3  # 设置每页显示数据条数
    page_size_query_param = "size"  # 设置指定每页大小的关键字名
    max_page_size = 5  # 设置每页显示最大值

class StandardLimitOffsetPagination(LimitOffsetPagination):
    default_limit = 2  # 默认限制，默认值与PAGE_SIZE设置一致
    limit_query_param = "size"  # limit参数名
    offset_query_param = "start"  # offset参数名
    max_limit = 5  # 最大limit限制

class Demo7APIView(ListAPIView):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer
    # 分页
    # 页码分页类
    pagination_class = StandardPageNumberPagination
    # 偏移量分页类
# pagination_class = StandardLimitOffsetPagination

views.py

测试(只做了页码分页的测试)：