Django Rest Framework API指南

 

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 配置

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

2、Response（響應）
使用APIView類或@api_view函數返回response對象的views
一、建立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: 響應內容類型，通常會根據內容自動協商。

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

3、基本視圖類 (APIView/@api_view)
一、類基礎視圖（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)：確保任何響應處理程序方法返回的對象將被呈現到正確的內容類型
二、函數基礎視圖（@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(…)

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

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’)

二、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)：不理解

三、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

5、視圖集合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修飾符。
裝飾器在其URL模式中包含pk，用於單個實例（有pk）的方法，
@detail_route@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

 

6、路由(routers)
一、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這個屬性。

二、使用路由routers

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

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

7、解釋器(parse)
一、設置解釋器
設置成全局：

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,))

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

8、渲染器(renders)
一、設置渲染器
設置成全局：

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,))

 

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

serializer = CommentSerializer(comment)
serializer.data
# {’email’: ‘leila@example.com’, ‘content’: ‘foo bar’, ‘created’: ‘2016-01-27T15:17:10.375877′}  json = JSONRenderer().render(serializer.data) # 渲染成json格式 # b'{「email」:」leila@example.com」,」content」:」foo bar」,」created」:」2016-01-27T15:17:10.375877″}’

二、反序列化

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

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

10、序列化字段serializer fields
一、核心參數
*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: 字典的鍵-值對,能夠用來控制渲染器應該如何呈現。
二、字段類型
*布爾字段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：

11、字段關係serializer relations
多對一：ForeignKey
多對多: ManyToManyField
一對一：OneToOneField
一、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’)  # 超連接身份關係
二、嵌套關係
序列化類中能夠直接引用其餘序列化化類

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

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

 

十3、認證Authentication
一、設置認證方案
*能夠在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,))

 

十4、權限
一、設置權限方案
*能夠在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, ))

二、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)

 

十5、節流Trottling
限制請求量
一、設置節流方案
*能夠在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])

 

十6、過濾器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

一、generic filter過濾
*經過settings文件中配置過濾

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

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

二、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',)

三、自定義過濾類，再用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

 

十7、分頁Pagination
一、設置自帶的分頁
*能夠在settings使用DEFAULT_PAGINATION_CLASS和PAGE_SIZE設置鍵全局默認分頁樣式。

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

二、修改分頁樣式，若是要修改分頁樣式的特定方面，則須要覆蓋其中一個分頁類，並設置要更改的屬性。

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

 

三、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'
}

 

十8、 版本控制（Versioning）

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

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

二、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。
三、當使用超連接序列化樣式和基於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})

四、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

五、其餘配置

• DEFAULT_VERSION
  
• ALLOWED_VERSIONS
• VERSION_PARAM

六、API參考

• AcceptHeaderVersioning
• URLPathVersioning
• HostNameVersioning
• QueryParameterVersioning

七、自定義版本控制模式

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

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

 

十9、 內容協商（Content negotiation）

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

二10、 元數據（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'
}

 

二11、 架構（Schemas）

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

一、內部模式表示
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.'
        )
    }
)

二、模式輸出格式

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

三、添加模式

安裝：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 ：

 

二12、 格式化後綴（Format suffixes）

二十3、 Returning URLs

一般狀況下，最好從Web API返回絕對URI，例如http://example.com/foobar，而不是返回相對的URI，如/ foobar。
這樣作的好處是：
     它更明確
     它爲您的API客戶端減小了工做。
     當在不具備本機URI類型的表示形式（如JSON）中找到字符串的含義時，這種含義不會有歧義。
     它使得超連接進行標記HTML表示等操做變得容易。
REST框架提供了兩個實用功能，能夠更簡單地從Web API返回絕對URI。
一、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)

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

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

 

二十4、 異常（Exceptions）

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

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

二、自定義異常處理
自定義異常處理函數必須使用一對參數，第一個是要處理的異常，第二個是包含任何額外的上下文的字典，例如當前正在處理的視圖。異常處理函數應該返回一個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響應。

三、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)

 

二十5、 狀態碼（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

 

二十6、 測試（Testing）

二十7、 配置（settings）

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

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

二、通用視圖配置

如下設置控制基於類的通用視圖的行爲。

• DEFAULT_FILTER_BACKENDS
• PAGE_SIZE
• SEARCH_PARAM
• ORDERING_PARAM

三、版本控制配置

• DEFAULT_VERSION
• ALLOWED_VERSIONS
• VERSION_PARAM

四、認證配置

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

• UNAUTHENTICATED_USER
• UNAUTHENTICATED_TOKEN

五、測試配置

如下設置控制APIRequestFactory和APIClient的行爲

• TEST_REQUEST_DEFAULT_FORMAT
• TEST_REQUEST_RENDERER_CLASSES

六、模式生成配置

• SCHEMA_COERCE_PATH_PK
• SCHEMA_COERCE_METHOD_NAMES

七、Content type配置

• URL_FORMAT_OVERRIDE
• FORMAT_SUFFIX_KWARG

八、日期和時間格式配置

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

九、編碼配置

• UNICODE_JSON
• COMPACT_JSON
• COERCE_DECIMAL_TO_STRING