Django Rest Framework API指南

Django Rest Framework 所有API如下：

• Request 請求
• Response 響應
• View 視圖
• Generic view 通用視圖
• Viewsets 視圖集
• Router 路由
• Parser 解析器
• Renderer 渲染器
• Serializer 序列化器
• Serializer fields 序列化字段
• Serializer relations 序列化字段關系
• Validators 驗證器
• Authentication 認證
• Permissions 權限
• Throttling 節流
• Filtering 過濾器
• Pagination 分頁
• Versioning 版本控制
• Content negotiation 內容協商
• Metadata 元數據
• Schemas 模式
• Format suffixes 格式化后綴
• Returning URLs 返回URL
• Exceptions 異常
• Status codes 狀態碼
• Testing 測試
• Settings 配置

一、請求（Request）
REST_FRAMEWORK 中的 Request 擴展了標准的HttpRequest,為 REST_FRAMEWORK增加了靈活的request解析和request認證。
1、請求
.data: 獲取請求的主體，相當於request.POST和request.FILES，支持解析除POST之外的HTTP方法的內容，即PUT和PATCH方法。
.query_params:   request.GET的重命名，但是比標准的request.GET更准確，任何HTTP方法類型可能包括查詢參數，而不僅僅是GET請求。
.parsers:   APIView類或@api_view裝飾將確保這個屬性將自動設置為一個解析器實例列表，通常不需要使用。
2、內容協商
.accepted_render: 接受渲染一個對象內容協商
.accepted_media_type: 接受的媒體類型
3、身份驗證
.user:  通常返回django.contrib.auth.models.user的對象。雖然行為取決於所使用的身份驗證策略。
如果請求用戶沒有被認證，request.user是一個django.contrib.auth.models.Anoymoser對象。
.auth:  被認證的后才會被使用，返回任何額外身份驗證的信息，未驗證返回None，前端報錯HTTP 401 未經授權
.authenticators:  APIView類或@api_view裝飾將確保這個屬性將自動設置為一個認證實例列表
4、瀏覽器增強方法
django rest framework提供一些附加的表單提交方法:PUT,PATCH,DELETE
.method: 返回一個大寫的HTTP請求方法字符串，包含了PUT,PATCH,DELETE等。
.content_type: 返回一個字符串對象代表HTTP請求的媒體類型的身體,或如果沒有媒體類型提供一個空字符串。通常不需要直接訪問請求的內容類型，
因為通常依賴於REST框架的默認請求解析行為，同樣可以使用：request.META.get(‘HTTP_CONTENT_TYPE’)
.stream: 返回一個請求主體類容的流，通常不需要訪問。
5、 支持其他標准的HttpResquest屬性
.META/.session/等等

二、Response（響應）
使用APIView類或@api_view函數返回response對象的views
1、創建Response
from rest_framework.response import Response
實例化: Response(data, status=None, template_name=None, headers=None, content_type=None)

注意：Response類無法處理諸如Django模型實例之類的復雜數據類型，因此需要在創建Response對象之前將數據序列化為原始數據類型，可以使用REST框架的Serializer類來執行數據序列化。

參數說明：
data: 響應serialized(序列化)后的數據
status: 定義響應狀態碼，默認200
template_name: 如果HTMLRender被選擇，返回一個模板
headers: 是關於HTTP請求頭的一個字典
content_type: 響應內容類型，一般會根據內容自動協商。

2、其他標准的HttpResponse屬性
response = Response()
response[‘Cache-Control’] = ‘no-cache’
.render(): 響應序列化的數據。

三、基本視圖類 (APIView/@api_view)
1、類基礎視圖（APIView）
DRF不同於django常規的view類，有如下幾點優點：
* 提供了更好用的request對象，不同於普通的django HttpRequest更好用。
* 封裝了Response對象，代替了原有的django HttpResponse，視圖將管理內容協商並設置正確的渲染器的響應。
* 任何APIException異常將會被捕捉，並做適當的響應。
* 傳入的請求將身份驗證和適當的權限和節流檢查將之前運行調度請求處理程序的方法。
一個小例子：

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import authentication, permissions
from django.contrib.auth.models import User

class ListUsers(APIView):
    """
    展示系統中所有的用戶
    * 需要令牌認證。
    * 只有admin用戶能夠訪問這一個視圖
    """
    authentication_classes = (authentication.TokenAuthentication,)
    permission_classes = (permissions.IsAdminUser,)

    def get(self, request, format=None):
        """
        返回一個用戶列表
        """
        usernames = [user.username for user in User.objects.all()]
        return Response(usernames)

1） API策略屬性
以下的API策略屬性應用於APIView，控制視圖的策略：
renderer_classes： 渲染器類
parser_classes： 解釋器類
authentication_classes： 權限類
throttle_classes：節流類
permission_classes： 權限類
content_negotiation_class： 內容協商類
2）API 策略方法
以下的策略方法用在API的策略，通常不用重寫它：
get_renderers(self):  獲取渲染器方法
get_parsers(self): 獲取解釋器方法
get_authenticators(self): 獲取認證方法
get_throttles(self): 獲取節流方法
get_permissions(self):  獲取權限方法
get_content_negotiator(self): 獲取內容協商方法
3）API策略實施方法
下列方法之前被稱為調度處理程序方法：
check_permissions(self, request): 檢查權限
check_throttles(self, request): 檢查節流
check_content_negotiation(self, request, force=False): 檢查內容協商
4）調度方法
這些執行任何操作,需要發生之前或之后調用處理程序方法等.
initial(self, request, *args, **kwargs): 執行任何操作,需要發生在處理程序方法之前被調用。這個方法是用來執行權限和節流,並執行內容協商。
handle_exception(self, exc)：拋出的任何異常處理程序方法將被傳遞給這個方法,而返回響應實例,或者re-raises異常。
initialize_request(self, request, *args, **kwargs)：確保請求對象傳遞給處理程序方法是request的一個實例，而不是django的HttpRequest
finalize_response(self, request, response, *args, **kwargs)：確保任何響應處理程序方法返回的對象將被呈現到正確的內容類型
2、函數基礎視圖（@api_view()）
DRF同樣提供了另外一種函數基礎視圖來裝飾django的普通視圖，我們同樣可以使用request來接受請求和response響應。
一個小例子：

from rest_framework.decorators import api_view @api_view def hello_world(request): return Response({“message”:”Hello world!”})

1）api_view()使用方法
這個視圖將使用默認渲染器、解析器、身份驗證設置中指定的類等。通常默認只有GET方法，其他請求方法會報405錯誤，我們可以手動添加方法為這
裝飾器指定request方法。像這樣：

@api_view([‘GET’, ‘POST’])
def hello_world(request): 　　if request.method == ‘POST’: 　　　　return Response({“message”:”Got some data”, “data”: request.data}) 　　return Response({“messsage”:”Hello world!”})

2）API策略裝飾器
DRF提供了很多附加的裝飾器，我們可以添加到@api_view()后面，例如要加入一個節流的裝飾器來確保特定用戶每天只能一次通過這個視圖，我
我們就要用到@throttle_classes裝飾器：

from rest_framework.decorators import api_view, throttle_classes from rest_framework.throttling import UserRateThrottle class OncePerDayUserThrottle(UserRateThrottle): 　　rate = “1/day” @api_view([‘GET’]) @throttle_classes([OncePerDayUserThrottle]) def view(request): 　　return Response({“message”:”Hello for to day! see you tomorrow!”})

其他可用API的裝飾器：
@renderer_classes(…)
@parser_classes(…)
@authentication_classes(…)
@throttle_classes(…)
@permission_classes(…)

四、 通用視圖（Generic views）
基於類視圖的主要好處之一是他們允許您編寫可重用的行為.
REST框架提供的通用視圖允許您快速構建API觀點緊密地映射到您的數據庫模型.
如果通用視圖不適合你的需要API,您可以使用常規APIView類,或重用mixin和基類使用的通用視圖來組成自己的組可重用通用視圖。
1、通用視圖
同樣我們可以設置一些類屬性在通用視圖內，也可以根據特殊需要重寫它的內部視圖方法。一個小例子：

from django.contrib.auth.models import User from myapp.serializers import UserSerializer from rest_framework import generics from rest_framework.permissions import IsAdminUser class UserList(generics.ListCreateAPIView): 　　queryset = User.objects.all() 　　serializer_class = UserSerializer 　　permission_classes = (IsAdminUser,) 　　def list(self, request): 　　　　# Note the use of get_queryset() instead of self.queryset 　　　　queryset = self.get_queryset() 　　　　serializer = UserSerializer(queryset, many=True) 　　　　return Response(serializer.data)

在urls配置中，我們可以使用.as_views()來轉換成視圖函數，當然也可以配置一些屬性

url(r’^/users/’, ListCreateAPIView.as_view(queryset=User.objects.all(), serializer_class=UserSerializer), name=’user-list’)

2、GenericAPIView通用視圖API參考：
GenericAPIView繼承了DRF的APIView類，為list和detail視圖增加了一些一般需求行為方法（提供queryset）。
1）屬性
基本屬性：
queryset: 用於返回查詢對象集合，也可以使用get_queryset()方法。
serializer_class: 序列化器類,應該用於輸入進行驗證和反序列化,並用於序列化輸出。通常情況下,你必須設置這個屬性,或重寫get_serializer_class()方法。
lookup_field: 用於對單個模型實例的對象查找的字段，默認為'pk'。請注意，使用超鏈接API時，如果需要使用自定義值，則需要確保API視圖和序列化器類都設置該查找字段。
lookup_url_kwarg:對象查找的URL關鍵字參數。URL conf應包含與該值相對應的關鍵字參數。 如果取消設置，則默認使用與lookup_field相同的值。

分頁屬性：
pagination_class: 用於返回一個分頁列表視圖的分頁類，默認與settings中設置的DEFAULT_PAGINATION_CLASS 值相同，
可以通過’rest_framework.pagination.PageNumberPagination’設置分頁數
過濾器屬性：
filter_backends: 過濾queryset的類列表，和在settings中設置DEFAULT_FILTER_BACKENDS 一樣
2）方法
基本方法：
get_queryset(): 返回queryset。（詳情見官網http://www.django-rest-framework.org/api-guide/generic-views/）
get_object():獲取某一個具體的model實例對象。
保存與刪除掛鈎方法：
以下方法是mixins類提供，提供簡單的對象保存和刪除的行為重寫：
perform_create(self, serializer): CreateModelMixin 當要保存對象時候會被調用
perform_update(self, serializer):UpdateModelMixin 當要更新對象時候會被調用
perform_destroy(self, instance): DestoryModelMixin 當葯刪除對象時候會被調用
其他方法：
通常不需要覆蓋以下方法，但可能會調用。
get_serializer_context(self)：返回序列化程序的上下文的字典。
get_serializer(self, instance=None, data=None, many=False, partial=False)：返回一個序列化實例
get_paginated_response(self, data)：返回一個分頁樣式的response對象
paginate_queryset(self, queryset)：分頁查詢
filter_queryset(self, queryset)：不理解

3、Mixins
mixin類提供用於提供基礎視圖的操作行為。注意,mixin類提供操作方法而不是定義處理程序方法,比如. get()和. post(),直接。這允許更靈活的組合的行為。
通過rest_framework.mixins引用。
ListModelMixin：提供list方法，列出queryset
CreateModelMixin： 提供create方法，創建和保存一個Model對象
RetrieveModelMixin：提供retrieve方法，檢索一個存在的model對象
UpdateModelMixin： 提供Update方法，更改一個模型對象
DestroyModelMixin：提供destroy方法，刪除一個模型對象
4）Generic view
Generic通用視圖類提供具體操作的通用視圖類，可以理解為Generic.GenericAPIView和mixin類的合體，通過rest_framework.generic.調用
.CreateAPIView：創建一個模型實例，提供post方法的處理器，繼承於：GenericAPIView，CreateModelMixin
.ListAPIView：模型實例的集合，提供get方法處理器，繼承於：GenericAPIView，ListModelMixin
.RetrieveAPIView：一個模型實例，提供get方法處理器，繼承於：GenericAPIView，RetrieveModelMixin
.DestoryAPIView：刪除一個模型實例，提供delete方法處理器，繼承於：GenericAPIView，DestroyModelMixin
.UpdateAPIView：修改模型實例，提供put和patch方法處理器，繼承於：GenericAPIView，UpdateModelMixi
.ListCreateAPIView：創建和展示一個模型實例集合，提供get和post處理器，繼承於：GenericAPIView，ListModelMixin，CreateModelMixin
.RetrieveUpdateAPIView：讀和改一個模型實例，提供get,put,patch處理器，繼承於：GenericAPIView，RetrieveModelMixin，UpdateModelMixin
.RetrieveDestoryAPIView：讀和刪除一個模型實例，提供get和delete處理器，繼承於：GenericAPIView，RetrieveModelMixin，DestroyModelMixin
.RetrieveUpdateDestroyAPIView：讀、改和刪一個模型實例，get, put, patch,delete處理器，繼承於：GenericAPIView，RetrieveModelMixin，UpdateModelMixin，DestroyModelMixin

五、視圖集合ViewSets
Django REST框架允許將一組相關的邏輯視圖在一個類ViewSets中，將重復的邏輯組合成一個類。
一個小例子：

from django.contrib.auth.models import User
from django.shortcuts import get_object_or_404
from myapps.serializers import UserSerializer
from rest_framework import viewsets
from rest_framework.response import Response

class UserViewSet(viewsets.ViewSet):
    """
    A simple ViewSet for listing or retrieving users.
    """
    def list(self, request):
        queryset = User.objects.all()
        serializer = UserSerializer(queryset, many=True)
        return Response(serializer.data)

    def retrieve(self, request, pk=None):
        queryset = User.objects.all()
        user = get_object_or_404(queryset, pk=pk)
        serializer = UserSerializer(user)
        return Response(serializer.data)

1）關於ViewSets
如果我們需要，我們需要為兩個GET請求分開綁定視圖：
user_list = UserViewSet.as_view({“GET”:’list’})
user_detail = UserViewSet.as_view({‘GET’:’retrieve’})

但是通常我們不會這樣做，而是通過注冊路由來配置url：

from myapp.views import UserViewSet from rest_framework.routers import DefaultRouter router = DefaultRouter() router.register(r’users’, UserViewSet) urlpatterns = router.urls

或許你會經常用到自己模型數據，而不是手動寫視圖集合，這樣就要用到模型視圖集合ModelViewSet:

class UserViewSet(viewsets.ModelViewSet):
    """
    A viewset for viewing and editing user instances.
    """
    serializer_class = UserSerializer
    queryset = User.objects.all()

REST框架附帶的默認路由器將為標准的create / retrieve / update / destroy樣式操作提供路由：

class UserViewSet(viewsets.ViewSet):
    """
    Example empty viewset demonstrating the standard
    actions that will be handled by a router class.

    If you're using format suffixes, make sure to also include
    the `format=None` keyword argument for each action.
    """

    def list(self, request):
        pass

    def create(self, request):
        pass

    def retrieve(self, request, pk=None):
        pass

    def update(self, request, pk=None):
        pass

    def partial_update(self, request, pk=None):
        pass

    def destroy(self, request, pk=None):
        pass

如果有需要被路由到的其他方法,可以將它們標記為需要路由使用@detail_route或@list_route修飾符。
@detail_route裝飾器在其URL模式中包含pk，用於單個實例（有pk）的方法，
@list_route裝飾器適用於在對象列表上操作的方法

from django.contrib.auth.models import User
from rest_framework import status
from rest_framework import viewsets
from rest_framework.decorators import detail_route, list_route
from rest_framework.response import Response
from myapp.serializers import UserSerializer, PasswordSerializer

class UserViewSet(viewsets.ModelViewSet):
    """
    A viewset that provides the standard actions
    """
    queryset = User.objects.all()
    serializer_class = UserSerializer

    @detail_route(methods=['post'])
    def set_password(self, request, pk=None):
        user = self.get_object()
        serializer = PasswordSerializer(data=request.data)
        if serializer.is_valid():
            user.set_password(serializer.data['password'])
            user.save()
            return Response({'status': 'password set'})
        else:
            return Response(serializer.errors,
                            status=status.HTTP_400_BAD_REQUEST)

    @list_route()
    def recent_users(self, request):
        recent_users = User.objects.all().order('-last_login')

        page = self.paginate_queryset(recent_users)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.get_serializer(recent_users, many=True)
        return Response(serializer.data)

2）ViewSets的API參考
.ViewSet：繼承自APIView，可以使用任何標准的屬性例如permission_class,authentication_classes來控制視圖上的API策略。ViewSet同樣不提供具體
行為方法的實現，你可以重寫和定義一些請求處理方法。而代替了原來APIVIew的POST，GET等方法，取而代之的是list，create等方法。
.GenericViewSet：繼承自GenericAPIView，提供了默認的get_queryset()和get_object()等方法來獲取model數據，但不提供任何請求處理方法，為了使用需要混合mixin類，或明確定義操作實現。
.ModelViewSet：繼承了GenericAPIView，並通過混入各種mixin類的行為來包含各種操作的實現，請求處理方法有list()、retrieve()、create()、update()、partial_update()和destroy()。通常需要至少提供queryset和serializer_class屬性，也可以使用get_queryset()方法動態確定查詢集，但也注意從ViewSet中刪除queryset屬性后，任何關聯的路由器將無法自動導出模型的base_name，因此必須制定base_name作為路由器注冊。
例子：

class AccountViewSet(viewsets.ModelViewSet):
    """
    A simple ViewSet for viewing and editing the accounts
    associated with the user.
    """
    serializer_class = AccountSerializer
    permission_classes = [IsAccountAdminOrReadOnly]

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

 

.ReadOnlyModelViewSet：繼承了GenericAPIView，只提供了只讀的請求處理方法list()和retrieve()
自定義View類：只需要繼承GenericAPIView, 增加mixins的相關處理方法。如：

from rest_framework import mixins

class CreateListRetrieveViewSet(mixins.CreateModelMixin,
                                mixins.ListModelMixin,
                                mixins.RetrieveModelMixin,
                                viewsets.GenericViewSet):
    """
    A viewset that provides `retrieve`, `create`, and `list` actions.

    To use it, override the class and set the `.queryset` and
    `.serializer_class` attributes.
    """
    pass

 

六、路由(routers)
1、REST框架還支持自動Django URL路由,並為您提供了一個簡單的、快速的和一致的方式連接視圖邏輯的URL。
如果設置basename將自動生成基於queryset viewset的屬性,如果它有一個。注意,如果viewset不包括queryset屬性然后注冊時必須設置base_name viewset。

 

from rest_framework import routers

router = routers.SimpleRouter()
router.register(r'users', UserViewSet)
router.register(r'accounts', AccountViewSet)
urlpatterns = router.urls

注意：router.register有三個參數屬性： *prefix：這是url匹配正則表達式。 *viewset: 指定視圖集合 *base_name: 基於基礎的url名字設置。這個特別要注意，如果不加這個參數，那么視圖集合必須要包含queryset這個屬性。

2、使用路由routers

router = routers.SimpleRouter()
router.register(r’users’, UserViewSet)
urlpatterns = [ url(r’^api/’, include(router.urls, namespace=’api’)), ] 或者：urlpatterns +=router.urls

3、@detail_route / @list_route指定路由
@detail_route(methods=[‘post’], permission_classes=[IsAdminOrIsSelf])
->指定post方法，權限為IsAdminOrIsSelf

七、解釋器(parse)
1、設置解釋器
設置成全局：

REST_FRAMEWORK ={
‘DEFAULT_PARSER_CLASSES’: (‘rest_framework.parsers.JSONParser’,）
}

也可以在視圖APIView中設置：

from rest_framework.parsers import JSONParser parser_class = (JSONParser,)

如果是@api_view裝飾的視圖：
@api_view([‘POST’])
@parser_classes((JSONParser,))

2、API 參考
JSONParse: application/json
FormParse: application/x-www-form-urlencoded
MultiPartParser:  multipart/form-data
FileUploadParser: */*
–>file_obj = request.data[‘file’]

八、渲染器(renders)
1、設置渲染器
設置成全局：

REST_FRAMEWORK ={
‘rest_framework.renderers.JSONRenderer’,
‘rest_framework.renderers.BrowsableAPIRenderer’,
}

也可以在視圖APIView中設置：

from rest_framework.renderers import JSONRenderer renderer_classes = (JSONRenderer, ) 如果是@api_view裝飾的視圖： @api_view([‘GET’]) @renderer_classes((JSONRenderer,))

 

九、序列化器serializers
序列化器可以將python的復雜數據格式渲染成json，xml等格式，同時也提供了反序列化器，可以將渲染成的數據解釋成python的數據模型對象。它和django中
的from表單用法很相似。
1、渲染序列化對象：
可以將對象序列化成json,xml格式等

serializer = CommentSerializer(comment)
serializer.data
# {’email’: ‘[e-mail]’, ‘content’: ‘foo bar’, ‘created’: ‘2016-01-27T15:17:10.375877′}  json = JSONRenderer().render(serializer.data) # 渲染成json格式 # b'{“email”:”[e-mail]”,”content”:”foo bar”,”created”:”2016-01-27T15:17:10.375877″}’

2、反序列化

from django.utils.six import BytesIO from rest_framework.parsers import JSONParser stream = BytesIO(json) data = JSONParser().parse(stream) # 解析json格式  serializer.is_valid() # True serializer.validated_data

3、保存實例
可以利用.create()和.update()方法
調用.save()方法會執行上面兩個方法，自動保存或者更新實例對象
有時候，需要保存其他的信息，可以在參數中添加，如：
serializer.save(owner=request.user)
4、驗證validation
當需要保存反序列化的數據時，我們往往需要在之前用is_valid()驗證數據的合法性，如果不合法可以用
serializer.errors得到該錯誤信息。這個錯誤信息可以根據error_message來進行自定義
5、模型序列化ModelSerializer
模型序列化與字段序列化用法類似，只需在類的屬性Meta中指定相應的模型，就會根據模型自動生成相應的字段
class AccountSerializer(serializers.ModelSerializer):
　　class Meta:
　　　　model = Account
　　　　fields = (‘id’, ‘account_name’, ‘users’, ‘created’)
6、超鏈接模型序列化HyperlinkedModelSerializer
與模型序列化類似，只不過給了一個可鏈接的形式。

十、序列化字段serializer fields
1、核心參數
*read_only: 只讀形式，只能序列化到api輸出，不能被反序列化數據更新修改操作。默認False
*wirte_only: 只寫形式，只能被反序列化數據更新和創建，不能序列化表示。默認False
*required: 必須字段，通常出現在反序列化的過程中，該字段必須有值。默認True
*allow_null：是否允許為空，默認False
*default: 默認值，
*source：字段來源，為字段指定一個字段來源，如(source=’user.email’).
*validators: 合法性函數列表，支持django的ValidationError包。
*error_message: 一個錯誤信息的字典，包含null, blank, invalid, invalid_choice, unique等鍵值。
*label:一篇簡短的文本字符串,可以用作在HTML表單字段的名稱或其他描述性的元素
*help_text: 一個文本字符串,可以用作描述字段的HTML表單字段或其他描述性的元素。
*initial: 用於預先填充HTML表單字段的值。
*style: 字典的鍵-值對,可以用來控制渲染器應該如何呈現。
2、字段類型
*布爾字段BooleanField: BoolenField(defalut=True)
*字符字段CharField: CharField(max_length=None, min_length=None, allow_blank=False, trim_whitespace=True)
*郵箱字段EmailField: EmailField(max_length=None, min_length=None, allow_blank=False)
*正則字段RegexField: RegexField(regex, max_length=None, min_length=None, allow_blank=False)
*新聞標題字段SlugField：SlugField(max_length=50, min_length=None, allow_blank=False)
*URL地址字段 UrlField: URLField(max_length=200, min_length=None, allow_blank=False)
*UUID字段 UUIDField: UUIDField(format=’hex_verbose’)   —“de305d54-75b4-431b-adb2-eb6b9e546013″
*文件路徑字段FilePathField：FilePathField(path, match=None, recursive=False, allow_files=True, allow_folders=False, required=None, **kwargs)
*IP地址字段IPAddressField：IPAddressField(protocol=’both’, unpack_ipv4=False, **options)
*數字型字段：IntegerField、FloatField、DecimalField
*時間和日期字段：DateTimeField：DateTimeField(format=None, input_formats=None)
DateField：
TimeField：
DurationField：
*選擇字段：ChoiceField
*文件字段：FileField：FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
*圖片字段：ImageField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
*模型字段：ModelField：ModelField(model_field=<Django ModelField instance>)
*只讀字段：ReadOnlyField：

十一、字段關系serializer relations
多對一：ForeignKey
多對多: ManyToManyField
一對一：OneToOneField
1、api參考
tracks = serializers.StringRelatedField(many=True)  # 字符串形式關系字段
tracks = serializers.PrimaryKeyRelatedField(many=True, read_only=True)# 主鍵形式關系字段
tracks = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name=’track-detail’) # 超鏈接形式關系字段
tracks = serializers.SlugRelatedField(many=True, read_only=True, slug_field=’title’)  # 以小標題形式關系
track_listing = serializers.HyperlinkedIdentityField(view_name=’track-list’)  # 超鏈接身份關系
2、嵌套關系
序列化類中可以直接引用其他序列化化類

十二、合法性驗證(Validation)
1、數據的唯一性UniqueValidator
在模型中，只需設置字段的unique=True就會在該字段自動生成改唯一性判斷
例:slug = SlugField(max_length=100, validators=[UniqueValidator(queryset=BlogPost.objects.all(), messsage=”)])
*queryset：模型數據對象集合
*message: 異常提示信息
2、數據字段的不重復性UniqueTogetherValidator

class Meta: validators = [ UniqueTogetherValidator( queryset=ToDoItem.objects.all(), fields=(‘list’, ‘position’) ) ] *queryset：模型數據對象集合 *fields: 字段的集合元祖 *message: 異常提示信息

 

十三、認證Authentication
1、設置認證方案
*可以在settings文件中配置DEFAULT_AUTHENTICATION_CLASSES：

REST_FRAMEWORK = {
‘DEFAULT_AUTHENTICATION_CLASSES’: (
‘rest_framework.authentication.BasicAuthentication’,
‘rest_framework.authentication.SessionAuthentication’,
)
}

*也可以在視圖中設置
(APIView)：

authentication_classes = (SessionAuthentication, BasicAuthentication)
permission_classes = (IsAuthenticated,) (@api_view) @authentication_classes((SessionAuthentication, BasicAuthentication)) @permission_classes((IsAuthenticated,))

 

十四、權限
1、設置權限方案
*可以在settings文件中配置DEFAULT_PERMISSION_CLASSES

 

REST_FRAMEWORK = {
‘DEFAULT_PERMISSION_CLASSES’: (
‘rest_framework.permissions.IsAuthenticated’,
# ‘rest_framework.permissions.AllowAny’, ) }

*視圖中設置：
（APIView）

permission_classes = (IsAuthenticated,)
（@api_view）
@permission_classes((IsAuthenticated, ))

2、API引用
*AllowAny：允許任何
*IsAuthenticated：是否被認證
*IsAdminUser：是管理用戶
*IsAuthenticatedOrReadOnly：是被認證或者只讀
*DjangoModelPermissions：標准的django模型設置權限
*DjangoModelPermissionsOrAnonReadOnly：標准的django模型處理或者只讀權限
*DjangoObjectPermissions：相比模型權限，只提供queryset和get_queryset方法。
*自定義權限：
繼承BasePermission;
重寫：.has_permission(self, request, view)
.has_object_permission(self, request, view, obj)

 

十五、節流Trottling
限制請求量
1、設置節流方案
*可以在settings文件中配置DEFAULT_THROTTLE_CLASSES 和 DEFAULT_THROTTLE_RATES

‘DEFAULT_THROTTLE_CLASSES’: (
‘rest_framework.throttling.AnonRateThrottle’,
‘rest_framework.throttling.UserRateThrottle’
),
‘DEFAULT_THROTTLE_RATES’: {
‘anon’: ‘100/day’, ‘user’: ‘1000/day’ }

*可以在視圖中設置：
（APIView）

throttle_classes = (UserRateThrottle,)
（@api_view）
@throttle_classes([UserRateThrottle])

 

十六、過濾器Filtering
通常drf的默認的通用list視圖類要處理的是全部模型的查詢集合集，如果我們要指定結果集，
這就必須用到過濾器了。通常的方法是重寫get_queryset(self)方法。
例如：

class PurchaseList(generics.ListAPIView): 　　serializer_class = PurchaseSerializer
 　　# 根據用戶過濾 　　def get_queryset(self): 　　　　user = self.request.user 　　　　return Purchase.objects.filter(purchase = user)
 　　# 根據url請求過濾 　　#def get_queryset(self): 　　#　　username = self.kwargs[‘username’] 　　#　　return Purchase.objects.filter(purchaser__username=username)
 　　# 根據請求參數過濾同上 　　#def get_queryset(self): 　　#　　queryset = Purchase.objects.all() 　　#　　username = self.request.query_params.get(‘username’, None) 　　#　　if username is not None: 　　#　　　　queryset = queryset.filter(purchaser__username=username) 　　#　　return queryset

1、generic filter過濾
*通過settings文件中配置過濾

REST_FRAMEWORK = {
‘DEFAULT_FILTER_BACKENDS’: (‘rest_framework.filters.DjangoFilterBackend’,)
}

*也可通過視圖中過濾
filter_backends = (filters.DjangoFilterBackend,)

2、API向導

• DjangoFilterBackend

django-filter庫包括一個DjangoFilterBackend類，它支持REST框架的高度可定制的字段過濾。
首先安裝django-filter， 然后將django_filters添加到Django的INSTALLED_APPS。
pip install django-filter
在settings.py加上如下配置：

REST_FRAMEWORK = {
    'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend',)
}

或者將過濾器加到單個View或ViewSet中：

from django_filters.rest_framework import DjangoFilterBackend

class UserListView(generics.ListAPIView):
    ...
    filter_backends = (DjangoFilterBackend,)

如果要允許對某些字段進行過濾，可以使用filter_fields屬性。

class ProductList(generics.ListAPIView):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer
    filter_backends = (DjangoFilterBackend,)
    filter_fields = ('category', 'in_stock')

對應的列表過濾請求：http://example.com/api/products?category=clothing&in_stock=True

• 　SearchFilter

如果要明確指定可以對哪些字段進行搜索，可以使用search_fields屬性，默認為可以對serializer_class屬性指定的串行器上的任何可讀字段進行搜索：

class UserListView(generics.ListAPIView):
    queryset = User.objects.all()
    serializer_class = UserSerializer
    filter_backends = (filters.SearchFilter,)
    search_fields = ('username', 'email')

對應的列表搜索請求：http://example.com/api/users?search=russell
也可以使用雙下划線在Foreign Key或ManyToManyField上執行相關查找：

search_fields = ('username', 'email', 'profile__profession')

默認情況下，搜索將使用不區分大小寫的部分匹配。 搜索參數可以包含多個搜索項，它們應該是空格和/或逗號分隔。 如果使用多個搜索項，則僅當所有提供的條款匹配時，才會在列表中返回對象。默認情況下，搜索參數被命名為“search”，但這可能會被SEARCH_PARAM設置覆蓋。
The search behavior may be restricted by prepending various characters to the search_fields.
可以通過在search_fields中加入一些字符來限制搜索行為，如下：

• '^'  ：以xx字符串開始搜索
  
• '='  ：完全匹配
• '@' ：全文搜索（目前只支持Django的MySQL后端）
• '$'  ：正則表達式搜索

例如：

search_fields = ('=username', '=email')

• 　　OrderingFilter

OrderingFilter類支持簡單的查詢參數控制結果排序。
默認情況下，查詢參數被命名為“ordering”，但這可能會被ORDERING_PARAM設置覆蓋。
可以使用ordering_fields屬性明確指定可以對哪些字段執行排序，這有助於防止意外的數據泄露，例如允許用戶對密碼散列字段或其他敏感數據進行排序。
如果不指定ordering_fields屬性，則默認為可以對serializer_class屬性指定的串行器上的任何可讀字段進行過濾，同：ordering_fields = '__all__'

class UserListView(generics.ListAPIView):
    queryset = User.objects.all()
    serializer_class = UserSerializer
    filter_backends = (filters.OrderingFilter,)
    ordering_fields = ('username', 'email')

使用ordering屬性設置默認排序：

class UserListView(generics.ListAPIView):
    queryset = User.objects.all()
    serializer_class = UserSerializer
    filter_backends = (filters.OrderingFilter,)
    ordering_fields = ('username', 'email')
    ordering = ('username',)

3、自定義過濾類，再用filter_class指定過濾集合類

import django_filters from myapp.models import Product from myapp.serializers impoert ProductSerializer from rest_framework import filters from rest_framework import generics class ProductFilter(filters.FilterSet): 　　min_price = django_filters.NumberFilter(name=’price’, lookup_type=”gte”) 　　max_price = django_filters.NumberFilter(name=’price’, lookup_type=”lte”) 　　class Meta: 　　　　model = Product 　　　　fields = [‘category’, ‘in_stock’, ‘min_price’, ‘max_price’] class ProductList(generics.ListAPIView): 　　queryset = Product.object.all() 　　serializer_class = ProductSerializer 　　filter_backends = (filter.DjangoFilterBackend,) 　　filter_class = ProductFilter

請求示例： http://example.com/api/products?category=clothing&max_price=10.00

 

十七、分頁Pagination
1、設置自帶的分頁
*可以在settings使用DEFAULT_PAGINATION_CLASS和PAGE_SIZE設置鍵全局默認分頁樣式。

REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination',
    'PAGE_SIZE': 100
}

2、修改分頁樣式，如果要修改分頁樣式的特定方面，則需要覆蓋其中一個分頁類，並設置要更改的屬性。

class LargeResultsSetPagination(PageNumberPagination): 　　page_size = 1000 　　page_size_query_param = ‘page_size’ 　　max_page_size = 10000 class StandardResultsSetPagination(PageNumberPagination): 　　page_size = 100 　　page_size_query_param = ‘page_size’ 　　max_page_size = 1000

應用到視圖中

class BillingRecordsView(generics.ListAPIView): 　　queryset = Billing.objects.all() 　　serializer = BillingRecordsSerializer 　　pagination_class = LargeResultsSetPagination

或者設置為全局分頁樣式：

class BillingRecordsView(generics.ListAPIView):
    queryset = Billing.objects.all()
    serializer_class = BillingRecordsSerializer
    pagination_class = LargeResultsSetPagination

 

3、API參考

PageNumberPagination：此分頁樣式在請求查詢參數中接受單個編號頁碼。

　　請求示例：GET https://api.example.org/accounts/?page=4

　　全局設置：

REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 100
}

　　PageNumberPagination類包括可以覆蓋以修改分頁樣式的許多屬性，要設置這些屬性，應覆蓋PageNumberPagination類，然后如上所示啟用自定義分頁類。

• django_paginator_class：使用的Django Paginator類，默認是django.core.paginator.Paginator，對大部分用例是適用的。

• page_size：數值，頁面大小，默認是全局PAGE_SIZE的值。
• page_query_param：字符串，查詢參數的名稱，默認是'page'
• page_size_query_param：字符串，請求設置頁面大小的參數名稱，默認是None，表示客戶端可能無法控制請求的頁面大小。
• max_page_size：字符串，最大允許請求的頁面大小， 此屬性僅在page_size_query_param也被設置時有效。
• last_page_strings：字符串列表或者元組，默認是('last',)
• template：分頁控件使用的模板的名稱，可以覆蓋或設置為None，默認為"rest_framework/pagination/numbers.html"

LimitOffsetPagination：查找多個數據庫記錄時使用的語法，客戶端包括“limit”和“offset”查詢參數，limit指示要返回的最大項目數，並且相當於其他樣式中的page_size，offset表示查詢起始位置。

　　請求示例：GET https://api.example.org/accounts/?limit=100&offset=400

　　全局設置：

REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination'
}

 

十八、 版本控制（Versioning）

啟用API版本控制時，request.version屬性將包含與傳入客戶端請求中請求的版本相對應的字符串。
默認情況下，版本控制未啟用，request.version將始終返回None。
1、基於版本的不同，改變API的行為，常見的一種用法是在較新版本中切換到其他序列化樣式。 例如：

def get_serializer_class(self):
    if self.request.version == 'v1':
        return AccountSerializerVersion1
    return AccountSerializer

2、REST框架包含的reverse（反向）功能與版本控制方案有關，參數加上request：

from rest_framework.reverse import reverse

reverse('bookings-list', request=request)

上述功能用於請求版本的任何URL轉換，如果使用的是NamespacedVersioning，API版本是“v1”，則使用的URL查找將是“v1：bookings-list”，這可能會解析為http://example.org/v1/bookings/這樣的URL，如果使用QueryParameterVersioning，API版本為1.0，則返回的URL類似於http://example.org/bookings/?version=1.0。
3、當使用超鏈接序列化樣式和基於URL的版本控制方案時，請確保將request作為context包含在序列化實例化中，這樣做將允許返回的URL都包含適當的版本。

def get(self, request):
    queryset = Booking.objects.all()
    serializer = BookingsSerializer(queryset, many=True, context={'request': request})
    return Response({'all_bookings': serializer.data})

4、settings配置

REST_FRAMEWORK = {
    'DEFAULT_VERSIONING_CLASS': 'rest_framework.versioning.NamespaceVersioning'
}

除非明確設置，DEFAULT_VERSIONING_CLASS的值將為“None”。 在這種情況下，request.version屬性將始終返回None。
也可以在單個視圖中設置版本控制方案， 但通常不需要這樣做，因為在全局范圍內使用單個版本控制方案更有意義， 如果確實需要這樣做，請使用versioning_class屬性。

class ProfileList(APIView):
    versioning_class = versioning.QueryParameterVersioning

5、其他配置

• DEFAULT_VERSION
  
• ALLOWED_VERSIONS
• VERSION_PARAM

6、API參考

• AcceptHeaderVersioning
• URLPathVersioning
• HostNameVersioning
• QueryParameterVersioning

7、自定義版本控制模式

要實現一個自定義版本控制方案，子類繼承BaseVersioning並覆蓋.determine_version方法。

class XAPIVersionScheme(versioning.BaseVersioning):
    def determine_version(self, request, *args, **kwargs):
        return request.META.get('HTTP_X_API_VERSION', None)

 

十九、 內容協商（Content negotiation）

Content negotiation是根據客戶端或服務器的首選項 從多個可能的表示選擇一個 返回給客戶端的過程。

二十、 元數據（Metadata）

REST框架包括一個可配置的機制，用於確定API應如何響應OPTIONS請求，允許返回API模式或其他資源信息。
目前還沒有任何廣泛采用的慣例來確定HTTP OPTIONS請求應該返回什么樣的響應，因此我們提供一種特殊的樣式，返回一些有用的信息。
這是一個示例響應，演示了默認情況下返回的信息。

HTTP 200 OK
Allow: GET, POST, HEAD, OPTIONS
Content-Type: application/json

{
    "name": "To Do List",
    "description": "List existing 'To Do' items, or create a new item.",
    "renders": [
        "application/json",
        "text/html"
    ],
    "parses": [
        "application/json",
        "application/x-www-form-urlencoded",
        "multipart/form-data"
    ],
    "actions": {
        "POST": {
            "note": {
                "type": "string",
                "required": false,
                "read_only": false,
                "label": "title",
                "max_length": 100
            }
        }
    }
}

全局配置：

REST_FRAMEWORK = {
    'DEFAULT_METADATA_CLASS': 'rest_framework.metadata.SimpleMetadata'
}

 

二十一、 架構（Schemas）

API模式是一個非常有用的工具，它允許一系列用例，包括生成參考文檔，或者驅動與API進行交互的動態客戶端庫。

1、內部模式表示
REST框架使用Core API用於以格式無關的表示來模擬模式信息。 該信息可以呈現為各種不同的模式格式，或用於生成API文檔。
當使用Core API時，模式為文檔，有關API的信息的頂級容器對象。 可用的API交互通過鏈接對象來表示，每個鏈接都包含一個URL，HTTP方法，並且可以包括一個Field實例的列表，它描述API端點可以接受的任何參數。 鏈接和字段實例還可以包括允許將API模式呈現為用戶文檔的描述。
示例：

coreapi.Document(
    title='Flight Search API',
    url='https://api.example.org/',
    content={
        'search': coreapi.Link(
            url='/search/',
            action='get',
            fields=[
                coreapi.Field(
                    name='from',
                    required=True,
                    location='query',
                    description='City name or airport code.'
                ),
                coreapi.Field(
                    name='to',
                    required=True,
                    location='query',
                    description='City name or airport code.'
                ),
                coreapi.Field(
                    name='date',
                    required=True,
                    location='query',
                    description='Flight date in "YYYY-MM-DD" format.'
                )
            ],
            description='Return flight availability and prices.'
        )
    }
)

2、模式輸出格式

為了在HTTP響應中呈現，內部表示必須是呈現為響應中使用的實際字節。
Core JSON被設計為與Core API一起使用的規范格式。 REST框架包括一個用於處理這種媒體類型的渲染器類，即renderers.CoreJSONRenderer。
其他模式格式，如Open API（“Swagger”）、JSON HyperSchema或API Blueprint，也可以通過實現自定義渲染器類來支持。

3、添加模式

安裝：pip install coreapi
REST框架包括自動生成模式的功能，也允許明確指定一個模式，有多個方法用於在API來添加一個模式
get_schema_view()：最簡單的方法

from rest_framework.schemas import get_schema_view

schema_url_patterns = [
    url(r'^api/', include('myproject.api.urls')),
]

schema_view = get_schema_view(
    title='Server Monitoring API',
    url='https://www.example.org/api/',
    urlconf='myproject.urls',
    renderer_classes=[CoreJSONRenderer, APIBlueprintRenderer],
    patterns=schema_url_patterns,
)

urlpatterns = [ url('^$', schema_view), ... ]

 

參數說明：

• title：模式的描述性標題
• url：模式的URL地址
• urlconf ：URL配置文件路徑，默認為Django的 ROOT_URLCONF
• renderer_classes ：渲染器類
• patterns ：
• generator_class ：

 

二十二、 格式化后綴（Format suffixes）

二十三、 Returning URLs

通常情況下，最好從Web API返回絕對URI，例如http://example.com/foobar，而不是返回相對的URI，如/ foobar。
這樣做的好處是：
     它更明確
     它為您的API客戶端減少了工作。
     當在不具有本機URI類型的表示形式（如JSON）中找到字符串的含義時，這種含義不會有歧義。
     它使得超鏈接進行標記HTML表示等操作變得容易。
REST框架提供了兩個實用功能，可以更簡單地從Web API返回絕對URI。
1、reverse(viewname, *args, **kwargs)
同django.urls.reverse，返回完全限定的URL，使用request確定主機和端口。
需將request作為關鍵字參數包含在函數中：

from rest_framework.reverse import reverse
from rest_framework.views import APIView
from django.utils.timezone import now

class APIRootView(APIView):
    def get(self, request):
        year = now().year
        data = {
            ...
            'year-summary-url': reverse('year-summary', args=[year], request=request)
        }
        return Response(data)

2、reverse_lazy(viewname, *args, **kwargs)

同django.urls.reverse_lazy，返回一個完全限定的URL，使用request確定主機和端口。用法同reverse

 

二十四、 異常（Exceptions）

1、REST框架視圖處理各種異常，並處理返回適當的錯誤響應。
處理的異常有：

•  REST框架內引發的APIException子類
•  Django的Http404異常
•  Django的PermissionDenied異常

2、自定義異常處理
自定義異常處理函數必須使用一對參數，第一個是要處理的異常，第二個是包含任何額外的上下文的字典，例如當前正在處理的視圖。異常處理函數應該返回一個Response對象，如果異常不能被處理，返回None。 如果處理程序返回None，則異常將被重新引發，Django將返回標准的HTTP 500'服務器錯誤'響應。
例如：

from rest_framework.views import exception_handler

def custom_exception_handler(exc, context):
    # Call REST framework's default exception handler first,
    # to get the standard error response.
    response = exception_handler(exc, context)

    # Now add the HTTP status code to the response.
    if response is not None:
        response.data['status_code'] = response.status_code

    return response

必須在settings配置EXCEPTION_HANDLER：

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

如果未指定，則默認為REST框架提供的標准異常處理程序：

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

請注意，異常處理程序將只會由引發異常生成的響應進行調用。 它不會用於視圖直接返回的任何響應，例如當序列化器驗證失敗時通用視圖返回的HTTP_400_BAD_REQUEST響應。

3、API參考

• APIException()
• ParseError(detail=None, code=None)
• AuthenticationFailed(detail=None, code=None)
• NotAuthenticated(detail=None, code=None)
• PermissionDenied(detail=None, code=None)
• NotFound(detail=None, code=None)
• MethodNotAllowed(method, detail=None, code=None)
• NotAcceptable(detail=None, code=None)
• UnsupportedMediaType(media_type, detail=None, code=None)
• Throttled(wait=None, detail=None, code=None)
• ValidationError(detail, code=None)

 

二十五、 狀態碼（Status Code）

不建議在響應中使用裸狀態代碼，REST框架包括一組命名常量，可用於使更多的代碼更加明顯和可讀。

例如：

from rest_framework import status
from rest_framework.response import Response

def empty_view(self):
    content = {'please move along': 'nothing to see here'}
    return Response(content, status=status.HTTP_404_NOT_FOUND)

所有狀態碼分類如下：

信息--1XX

此類狀態碼表示臨時響應。 默認情況下，REST框架中沒有使用1xx狀態代碼。

HTTP_100_CONTINUE
HTTP_101_SWITCHING_PROTOCOLS

成功--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

重定向--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

客戶端錯誤--4XX

4xx類的狀態碼適用於客戶端似乎有錯誤的情況。 除了響應HEAD請求之外，服務器應該包含一個包含錯誤情況說明的實體，以及它是一個臨時的還是永久的。

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

服務器錯誤--5XX

以數字“5”開頭的響應狀態代碼表示服務器知道它已經發生錯誤或不能執行請求的情況。 除了響應HEAD請求之外，服務器應該包含一個包含錯誤情況說明的實體，以及它是一個臨時的還是永久的。

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

以下幫助函數可用於識別響應代碼的類別。

is_informational()  # 1xx
is_success()        # 2xx
is_redirect()       # 3xx
is_client_error()   # 4xx
is_server_error()   # 5xx

 

二十六、 測試（Testing）

二十七、 配置（settings）

REST框架的配置在Django settings中命名為REST_FRAMEWORK。
可以做的配置如下：
1、API策略配置
以下設置控制基本API策略，並應用於基於APIView類的每個視圖或基於@api_view功能的視圖。

• DEFAULT_RENDERER_CLASSES
• DEFAULT_PARSER_CLASSES
• DEFAULT_AUTHENTICATION_CLASSES
• DEFAULT_PERMISSION_CLASSES
• DEFAULT_THROTTLE_CLASSES
• DEFAULT_CONTENT_NEGOTIATION_CLASS

2、通用視圖配置

以下設置控制基於類的通用視圖的行為。

• DEFAULT_FILTER_BACKENDS
• PAGE_SIZE
• SEARCH_PARAM
• ORDERING_PARAM

3、版本控制配置

• DEFAULT_VERSION
• ALLOWED_VERSIONS
• VERSION_PARAM

4、認證配置

以下設置控制未經身份驗證的請求的行為。

• UNAUTHENTICATED_USER
• UNAUTHENTICATED_TOKEN

5、測試配置

以下設置控制APIRequestFactory和APIClient的行為

• TEST_REQUEST_DEFAULT_FORMAT
• TEST_REQUEST_RENDERER_CLASSES

6、模式生成配置

• SCHEMA_COERCE_PATH_PK
• SCHEMA_COERCE_METHOD_NAMES

7、Content type配置

• URL_FORMAT_OVERRIDE
• FORMAT_SUFFIX_KWARG

8、日期和時間格式配置

• DATETIME_FORMAT
• DATETIME_INPUT_FORMATS
• DATE_FORMAT
• DATE_INPUT_FORMATS
• TIME_FORMAT
• TIME_INPUT_FORMATS

9、編碼配置

• UNICODE_JSON
• COMPACT_JSON
• COERCE_DECIMAL_TO_STRING