Django restframework(二) 视图及其视图集-用法详解

以你之姓@ 2023-03-01 10:49 24阅读 0赞

# 一、Request 与 Response #

## 1.1 Request ##

REST framework 传入视图的request对象不再是Django默认的HttpRequest对象，而是REST framework提供的扩展了HttpRequest类的**Request**类的对象。

REST framework **提供了Parser解析器**，在接收到请求后会自动根据Content-Type指明的请求数据类型（如JSON、表单等）将请求数据进行parse解析，解析为类字典对象保存到Request对象中。

Request对象的数据是自动根据前端发送数据的格式进行解析之后的结果。

无论前端发送的哪种格式的数据，我们都可以以统一的方式读取数据。

### 1.1.1 常用属性 ###

*  **.data**

`request.data` 返回解析之后的请求体数据。类似于Django中标准的`request.POST`和 `request.FILES`属性，但提供如下特性：

1.  包含了解析之后的文件和非文件数据
2.  包含了对POST、PUT、PATCH请求方式解析后的数据
3.  利用了REST framework的parsers解析器，不仅支持表单类型数据，也支持JSON数据

*  **.query\_params**

request.query\_params与Django标准的request.GET相同，只是更换了更正确的名称而已。

## 1.2 Response ##

`rest_framework.response.Response`  
REST framework提供了一个响应类Response，使用该类构造响应对象时，响应的具体数据内容会被转换（render渲染）成符合前端需求的类型。

### 1.2.1 构造方式 ###

`Response(data, status=None, template_name=None, headers=None, content_type=None)`

`data`数据不要是`render`处理之后的数据，只需传递python的内建类型数据即可，REST framework会使用`renderer`渲染器处理`data`。

`data`不能是复杂结构的数据，如Django的模型类对象，对于这样的数据我们可以使用`Serializer`序列化器序列化处理后（转为了Python字典类型）再传递给data参数。

**参数说明:**

*  data: 为响应准备的序列化处理后的数据；
 *  status: 状态码，默认200；
 *  template\_name: 模板名称，如果使用HTMLRenderer 时需指明；
 *  headers: 用于存放响应头信息的字典；
 *  content\_type: 响应数据的Content-Type，通常此参数无需传递，REST framework会根据前端所需类型数据来设置该参数。

### 1.2.2 状态码 ###

为了方便设置状态码，REST framewrok在rest\_framework.status模块中提供了常用状态码常量。

1.  信息告知 - 1xx

HTTP_100_CONTINUE
    HTTP_101_SWITCHING_PROTOCOLS

1.  成功 - 2xx

HTTP_200_OK
    HTTP_201_CREATED
    HTTP_202_ACCEPTED
    HTTP_203_NON_AUTHORITATIVE_INFORMATION
    HTTP_204_NO_CONTENT
    HTTP_205_RESET_CONTENT
    HTTP_206_PARTIAL_CONTENT
    HTTP_207_MULTI_STATUS

1.  重定向 - 3xx

HTTP_300_MULTIPLE_CHOICES
    HTTP_301_MOVED_PERMANENTLY
    HTTP_302_FOUND
    HTTP_303_SEE_OTHER
    HTTP_304_NOT_MODIFIED
    HTTP_305_USE_PROXY
    HTTP_306_RESERVED
    HTTP_307_TEMPORARY_REDIRECT

1.  客户端错误 - 4xx

HTTP_400_BAD_REQUEST
    HTTP_401_UNAUTHORIZED
    HTTP_402_PAYMENT_REQUIRED
    HTTP_403_FORBIDDEN
    HTTP_404_NOT_FOUND
    HTTP_405_METHOD_NOT_ALLOWED
    HTTP_406_NOT_ACCEPTABLE
    HTTP_407_PROXY_AUTHENTICATION_REQUIRED
    HTTP_408_REQUEST_TIMEOUT
    HTTP_409_CONFLICT
    HTTP_410_GONE
    HTTP_411_LENGTH_REQUIRED
    HTTP_412_PRECONDITION_FAILED
    HTTP_413_REQUEST_ENTITY_TOO_LARGE
    HTTP_414_REQUEST_URI_TOO_LONG
    HTTP_415_UNSUPPORTED_MEDIA_TYPE
    HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE
    HTTP_417_EXPECTATION_FAILED
    HTTP_422_UNPROCESSABLE_ENTITY
    HTTP_423_LOCKED
    HTTP_424_FAILED_DEPENDENCY
    HTTP_428_PRECONDITION_REQUIRED
    HTTP_429_TOO_MANY_REQUESTS
    HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE
    HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS

1.  服务器错误 - 5xx

HTTP_500_INTERNAL_SERVER_ERROR
    HTTP_501_NOT_IMPLEMENTED
    HTTP_502_BAD_GATEWAY
    HTTP_503_SERVICE_UNAVAILABLE
    HTTP_504_GATEWAY_TIMEOUT
    HTTP_505_HTTP_VERSION_NOT_SUPPORTED
    HTTP_507_INSUFFICIENT_STORAGE
    HTTP_511_NETWORK_AUTHENTICATION_REQUIRED

# 二、 视图继承关系 #

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q0Pgr6Nm-1595569215289)(http://blog.julywhj.cn/%E9%80%9A%E7%94%A8%E8%A7%86%E5%9B%BE%E7%9A%84%E7%BB%A7%E6%89%BF%E5%85%B3%E7%B3%BB.png?e=1595133617&attname=&token=2mXC2bkkH46J1P3XvnecyBPAX1y\_K11Je5BYz2t4:\_-6LH2sOnmLxZGwWqgQ6MAfa1Rk=)\]

# 三、 视图说明 #

## 3.1 两个基类 ##

### 3.1.1 APIView ###

`rest_framework.views.APIView`

`APIView` 是REST framework提供的**所**有视图的基类，继承自Django的`View`父类。

**APIView** 与**View**：的不同之处在于:

- 传入到视图方法中的是REST framework的Request对象，而不是Django的HttpRequeset对象；
    - 视图方法可以返回REST framework的Response对象，视图会为响应数据设置（render）符合前端要求的格式；
    - 任何APIException异常都会被捕获到，并且处理成合适的响应信息；
    - 在进行dispatch()分发前，会对请求进行身份认证、权限检查、流量控制。

**支持定义的属性：**

*  **authentication\_classes** 列表或元祖，身份认证类
 *  **permissoin\_classes** 列表或元祖，权限检查类
 *  **throttle\_classes** 列表或元祖，流量控制类

在APIView中仍以常规的类视图定义方法来实现get() 、post() 或者其他请求方式的方法。

from rest_framework.views import APIView
    from rest_framework.response import Response
    
    # url(r'^books/$', views.BookListView.as_view()),
    class BookListView(APIView):
        def get(self, request):
            books = BookInfo.objects.all()
            serializer = BookInfoSerializer(books, many=True)
            return Response(serializer.data)

### 3.1.2 GenericAPIView ###

`rest_framework.generics.GenericAPIView`

继承自`APIVIew`，增加了对于列表视图和详情视图可能用到的通用支持方法。通常使用时，可搭配一个或多个Mixin扩展类。

**支持定义的属性：**

*  列表视图与详情视图通用：
    
     *  **queryset** 列表视图的查询集
     *  **serializer\_class** 视图使用的序列化器
 *  列表视图使用：
    
     *  **pagination\_class** 分页控制类
     *  **filter\_backends** 过滤控制后端
 *  详情页视图使用：
    
     *  **lookup\_field** 查询单一数据库对象时使用的条件字段，默认为’pk’
     *  **lookup\_url\_kwarg** 查询单一数据时URL中的参数关键字名称，默认与look\_field相同

**提供的方法：**

*  列表视图与详情视图通用：
    
     *  get\_queryset(self):
        
        返回视图使用的查询集，是列表视图与详情视图获取数据的基础，默认返回`queryset`属性，可以重写，例如：
        
            def get_queryset(self):
                user = self.request.user
                return user.accounts.all()
     *  get\_serializer\_class(self):
        
        返回序列化器类，默认返回serializer\_class，可以重写，例如：
        
            def get_serializer_class(self):
                if self.request.user.is_staff:
                    return FullAccountSerializer
                return BasicAccountSerializer
     *  get\_serializer(self, args, \*kwargs):
        
        返回序列化器对象，被其他视图或扩展类使用，如果我们在视图中想要获取序列化器对象，可以直接调用此方法。
        
        **注意，在提供序列化器对象的时候，REST framework会向对象的context属性补充三个数据：request、format、view，这三个数据对象可以在定义序列化器时使用。**
 *  详情视图使用：
    
     *  get\_object(self):
        
        返回详情视图所需的模型类数据对象，默认使用lookup\_field参数来过滤queryset。 在试图中可以调用该方法获取详情信息的模型类对象。
        
        **若详情访问的模型类对象不存在，会返回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()
                    serializer = self.get_serializer(book)
                    return Response(serializer.data)

## 3.2 五个扩展类 ##

### 3.2.1 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.mixins import ListModelMixin
    
    class BookListView(ListModelMixin, GenericAPIView):
        queryset = BookInfo.objects.all()
        serializer_class = BookInfoSerializer
    
        def get(self, request):
            return self.list(request)

### 3.2.2 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 {}

### 3.2.3 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)

举例：

class BookDetailView(RetrieveModelMixin, GenericAPIView):
        queryset = BookInfo.objects.all()
        serializer_class = BookInfoSerializer
    
        def get(self, request, pk):
            return self.retrieve(request)

### 3.2.4 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)

### 3.2.5 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()

## 3.3 几个可用子类视图 ##

<table> 
 <thead> 
  <tr> 
   <th>API方法</th> 
   <th>提供实现</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>CreateAPIView</td> 
   <td>提供 post 方法 继承自： GenericAPIView、CreateModelMixin</td> 
  </tr> 
  <tr> 
   <td>ListAPIView</td> 
   <td>提供 get 方法 继承自：GenericAPIView、ListModelMixin</td> 
  </tr> 
  <tr> 
   <td>RetireveAPIView</td> 
   <td>提供 get 方法 继承自: GenericAPIView、RetrieveModelMixin</td> 
  </tr> 
  <tr> 
   <td>DestoryAPIView</td> 
   <td>提供 delete 方法 继承自：GenericAPIView、DestoryModelMixin</td> 
  </tr> 
  <tr> 
   <td>UpdateAPIView</td> 
   <td>提供 put 和 patch 方法 继承自：GenericAPIView、UpdateModelMixin</td> 
  </tr> 
  <tr> 
   <td>RetrieveUpdateAPIView</td> 
   <td>提供 get、put、patch方法 继承自：GenericAPIView、RetrieveModelMixin、UpdateModelMixin</td> 
  </tr> 
  <tr> 
   <td>RetrieveUpdateDestoryAPIView</td> 
   <td>提供 get、put、patch、delete方法 继承自：GenericAPIView、RetrieveModelMixin、UpdateModelMixin、DestoryModelMixin</td> 
  </tr> 
 </tbody> 
</table>

# 四、视图集ViewSet #

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

*  list() 提供一组数据
 *  retrieve() 提供单个数据
 *  create() 创建数据
 *  update() 保存数据
 *  destory() 删除数据

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

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

class BookInfoViewSet(viewsets.ViewSet):
    
        def list(self, request):
            ...
    
        def retrieve(self, request, pk=None):
            ...

在设置路由时，我们可以如下操作

urlpatterns = [
        url(r'^books/$', BookInfoViewSet.as_view({'get':'list'}),
        url(r'^books/(?P<pk>\d+)/$', BookInfoViewSet.as_view({'get': 'retrieve'})
    ]

## 4.1 action属性 ##

在视图集中，我们可以通过action对象属性来获取当前请求视图集时的action动作是哪个。

def get_serializer_class(self):
        if self.action == 'create':
            return OrderCommitSerializer
        else:
            return OrderDataSerializer

## 4.2 常用视图集父类 ##

<table> 
 <thead> 
  <tr> 
   <th>视图集</th> 
   <th>父类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ViewSet</td> 
   <td>继承自APIView，作用也与APIView基本类似，提供了身份认证、权限校验、流量管理等。在ViewSet中，没有提供任何动作action方法，需要我们自己实现action方法。</td> 
  </tr> 
  <tr> 
   <td>GenericViewSet</td> 
   <td>继承自GenericAPIView，作用也与GenericAPIVIew类似，提供了get_object、get_queryset等方法便于列表视图与详情信息视图的开发。</td> 
  </tr> 
  <tr> 
   <td>ModelViewSet</td> 
   <td>继承自GenericAPIVIew，同时包括了ListModelMixin、RetrieveModelMixin、CreateModelMixin、UpdateModelMixin、DestoryModelMixin。</td> 
  </tr> 
  <tr> 
   <td>ReadOnlyModelViewSet</td> 
   <td>继承自GenericAPIVIew，同时包括了ListModelMixin、RetrieveModelMixin。</td> 
  </tr> 
 </tbody> 
</table>

## 4.3 视图集中定义附加action动作 ##

在视图集中，除了上述默认的方法动作外，还可以添加自定义动作。

添加自定义动作需要使用`rest_framework.decorators.action`装饰器。

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

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

*  methods: 该action支持的请求方式，列表传递
 *  detail: 表示是action中要处理的是否是视图资源的对象（即是否通过url路径获取主键）
    
     *  True 表示使用通过URL获取的主键对应的数据对象
     *  False 表示不使用URL获取主键

from rest_framework import mixins
    from rest_framework.viewsets import GenericViewSet
    from rest_framework.decorators import action
    
    class BookInfoViewSet(mixins.ListModelMixin, mixins.RetrieveModelMixin, GenericViewSet):
        queryset = BookInfo.objects.all()
        serializer_class = BookInfoSerializer
    
        # detail为False 表示不需要处理具体的BookInfo对象
        @action(methods=['get'], detail=False)
        def latest(self, request):
            """
            返回最新的图书信息
            """
            book = BookInfo.objects.latest('id')
            serializer = self.get_serializer(book)
            return Response(serializer.data)
    
        # detail为True，表示要处理具体与pk主键对应的BookInfo对象
        @action(methods=['put'], detail=True)
        def read(self, request, pk):
            """
            修改图书的阅读量数据
            """
            book = self.get_object()
            book.bread = request.data.get('read')
            book.save()
            serializer = self.get_serializer(book)
            return Response(serializer.data)

url的定义

urlpatterns = [
        url(r'^books/$', views.BookInfoViewSet.as_view({'get': 'list'})),
        url(r'^books/latest/$', views.BookInfoViewSet.as_view({'get': 'latest'})),
        url(r'^books/(?P<pk>\d+)/$', views.BookInfoViewSet.as_view({'get': 'retrieve'})),
        url(r'^books/(?P<pk>\d+)/read/$', views.BookInfoViewSet.as_view({'put': 'read'})),
    ]

# 五、路由Routers #

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

REST framework提供了两个router

*  SimpleRouter
 *  DefaultRouter

## 5.1 使用方法 ##

创建router对象，并注册视图集，例如

from rest_framework import routers
    
    router = routers.SimpleRouter()
    router.register(r'books', BookInfoViewSet, base_name='book')

*  prefix 该视图集的路由前缀
 *  viewset 视图集
 *  base\_name 路由名称的前缀  
    如上述代码会形成的路由如下：

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

**添加路由数据**  
可以有两种方式：

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

## 5.2 视图集中包含附加action的 ##

class BookInfoViewSet(mixins.ListModelMixin, mixins.RetrieveModelMixin, GenericViewSet):
        queryset = BookInfo.objects.all()
        serializer_class = BookInfoSerializer
    
        @action(methods=['get'], detail=False)
        def latest(self, request):
            ...
    
        @action(methods=['put'], detail=True)
        def read(self, request, pk):
            ...

此视图集会形成的路由：

^books/latest/$    name: book-latest
    ^books/{pk}/read/$  name: book-read

# 六、扩展功能 #

## 6.1 认证Authentication ##

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

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

也可以在每个视图中通过设置authentication\_classess属性来设置

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 权限被禁止

## 6.2 权限Permissions ##

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

*  在执行视图的dispatch()方法前，会先进行视图访问权限的判断
 *  在通过get\_object()获取具体对象时，会进行对象访问权限的判断

**使用**  
可以在配置文件中设置默认的权限管理类，如

REST_FRAMEWORK = {
        'DEFAULT_PERMISSION_CLASSES': (
            'rest_framework.permissions.IsAuthenticated',
        )
    }

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

'DEFAULT_PERMISSION_CLASSES': (
       '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 仅管理员用户
 *  IsAuthenticatedOrReadOnly 认证的用户可以完全操作，否则只能get读取

from rest_framework.authentication import SessionAuthentication
    from rest_framework.permissions import IsAuthenticated
    from rest_framework.generics import RetrieveAPIView
    
    class BookDetailView(RetrieveAPIView):
        queryset = BookInfo.objects.all()
        serializer_class = BookInfoSerializer
        authentication_classes = [SessionAuthentication]
        permission_classes = [IsAuthenticated]

## 6.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': '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']` 来设置频次

*  ScopedRateThrottle

限制用户对于每个视图的访问频次，使用ip或user id。

class ContactListView(APIView):
        throttle_scope = 'contacts'
        ...
    
    class ContactDetailView(APIView):
        throttle_scope = 'contacts'
        ...
    
    class UploadView(APIView):
        throttle_scope = 'uploads'
        ...

REST_FRAMEWORK = {
        'DEFAULT_THROTTLE_CLASSES': (
            'rest_framework.throttling.ScopedRateThrottle',
        ),
        'DEFAULT_THROTTLE_RATES': {
            'contacts': '1000/day',
            'uploads': '20/day'
        }
    }

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 BookDetailView(RetrieveAPIView):
        queryset = BookInfo.objects.all()
        serializer_class = BookInfoSerializer
        authentication_classes = [SessionAuthentication]
        permission_classes = [IsAuthenticated]
        throttle_classes = (UserRateThrottle,)

# 6.4 过滤Filtering #

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

`pip insall django-filter`

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

INSTALLED_APPS = [
        ...
        'django_filters',  # 需要注册应用，
    ]
    
    REST_FRAMEWORK = {
        'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend',)
    }

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

class BookListView(ListAPIView):
        queryset = BookInfo.objects.all()
        serializer_class = BookInfoSerializer
        filter_fields = ('btitle', 'bread')
    
    # 127.0.0.1:8000/books/?btitle=西游记

## 6.5 排序 ##

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

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

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

class BookListView(ListAPIView):
        queryset = BookInfo.objects.all()
        serializer_class = BookInfoSerializer
        filter_backends = [OrderingFilter]
        ordering_fields = ('id', 'bread', 'bpub_date')
    
    # 127.0.0.1:8000/books/?ordering=-bread

## 6.6 分页Pagination ##

REST framework提供了分页的支持。

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

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

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

class LargeResultsSetPagination(PageNumberPagination):
        page_size = 1000
        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://api.example.org/books/?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_query_param = 'page_size'
        max_page_size = 10
    
    class BookListView(ListAPIView):
        queryset = BookInfo.objects.all().order_by('id')
        serializer_class = BookInfoSerializer
        pagination_class = StandardPageNumberPagination
    
    # 127.0.0.1/books/?page=1&page_size=2

*  LimitOffsetPagination

前端访问网址形式：

`GET http://api.example.org/books/?limit=100&offset=400`

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

*  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 BookListView(ListAPIView):
        queryset = BookInfo.objects.all().order_by('id')
        serializer_class = BookInfoSerializer
        pagination_class = LimitOffsetPagination
    
    # 127.0.0.1:8000/books/?offset=3&limit=2

## 5.7 异常处理 Exceptions ##

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

from rest_framework.views import exception_handler
    
    def custom_exception_handler(exc, context):
        # 先调用REST framework默认的异常处理方法获得标准错误响应对象
        response = exception_handler(exc, context)
    
        # 在此处补充自定义的异常处理
        if response is not None:
            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

**REST framework定义的异常**

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

更多内容请查看 [Julywhj的博客][Julywhj]期待您的光顾。

[Julywhj]: https://bs.julywhj.cn/#/