Django-rest-framework --- 總結

[toc]

drf回顧總結

drf基礎

drf全稱：django-rest framework，drf框架是一個用戶構建Web API（API應用程序編程接口）的強大而靈活的工具，drf框架是創建在django框架基礎之上

特色：

1.提供了自定義序列化器Serializer的方法，能夠快速根據Django ORM或者其餘庫自動序列化/反序列化

2.具備豐富的類視圖，Mixin擴展類，簡化視圖的編寫

3.豐富的定製層級：函數視圖，類視圖，視圖集合到自動生成API，知足各類須要

4.多種身份認證和權限認證方式的支持

5.內置了限流系統

6.直觀的API Web界面

7.可擴展性，插件豐富

知識點

"""
一、接口：什麼是接口、restful接口規範
二、CBV生命週期源碼 - 基於restful規範下的CBV接口
三、請求組件、解析組件、響應組件
四、序列化組件(靈魂)
五、三大認證(重中之重)：認證、權限(權限六表)、頻率
六、其餘組件：過濾、篩選、排序、分頁、路由
"""

# 難點：源碼分析

1.drf框架安裝

安裝

>: pip3 install djangorestframework

drf框架規矩的封裝風格

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.request import Request
from rest_framework.serializers import Serializer
from rest_framework.settings import APISettings
from rest_framework.filters import SearchFilter
from rest_framework.pagination import PageNumberPagination
from rest_framework.authentication import TokenAuthentication
from rest_framework.permissions import IsAuthenticated
from rest_framework.throttling import SimpleRateThrottle

class Test(APIView):
    def get(self, request, *args, **kwargs):
        return Response('drf get ok')

drf請求生命週期

"""
1) 請求走的是APIView的as_view函數

2) 在APIView的as_view調用父類(django原生)的as_view，還禁用了 csrf 認證

3) 在父類的as_view中dispatch方法請求走的又是APIView的dispatch

4) 完成任務方法交給視圖類的請求函數處理，獲得請求的響應結果，返回給前臺
"""

2.接口

"""
接口：聯繫兩個物質的媒介，完成信息交互
web程序中：聯繫前臺頁面與後臺數據庫的媒介
web接口組成：
	url：長得像放回數據的url連接
	請求參數：前臺按照指定的key提供數據給後臺
	響應數據：後臺與數據庫交互後將數據反饋給前臺
"""

3.restful接口規範

接口規範：就是爲了採用不一樣的後臺語言，也能使用一樣的接口獲取到一樣的數據

如何寫接口：接口規範是 規範化書寫接口的，寫接口要寫 url、響應數據

​ 注：若是將請求參數也歸入考量範圍，那就是在寫 接口文檔

兩大部分：

• url

1) 用api關鍵字標識接口url
	api.baidu.com | www.baidu.com/api
	
2) 接口數據安全性決定優先選擇https協議

3) 若是一個接口有多版本存在，須要在url中標識體現
	api.baidu.com/v1/... | api.baidu.com/v2/...
	
4) 接口操做的數據源稱之爲 資源，在url中通常採用資源複數形式，一個接口能夠歸納對該資源的多種操做方式
	api.baidu.com/books | api.baidu.com/books/(pk)
	
5) 請求方式有多種，用一個url處理如何保證不混亂 - 經過請求方式標識操做資源的方式
	/books		get			獲取全部
	/books		post		增長一個(多個)
	/books/(pk)	delete		刪除一個
    /books/(pk)	put			總體更新一個
    /books/(pk)	patch		局部更新一個

6) 資源每每涉及數據的各類操做方式 - 篩選、排序、限制
	api.baidu.com/books/?search=西&ordering=-price&limit=3

• 響應數據

1) http請求的響應會有響應狀態碼，接口用來返回操做的資源數據，能夠擁有 操做數據結果的 狀態碼
	status  0(操做資源成功)  1(操做資源失敗)  2(操做資源成功，但沒匹配結果)
	注：資源狀態碼不像http狀態碼，通常都是後臺與前臺或是客戶約定的
	
2) 資源的狀態碼文字提示
	status  ok	'帳號有誤'  '密碼有誤'  '用戶鎖定'
	
3) 資源自己
	results
	注：刪除資源成功不作任何數據返回(返回空字符串)
	
4) 不能直接放回的資源(子資源、圖片、視頻等資源)，返回該資源的url連接

4.基於restful規範的原生Django接口

主路由：url.py

主要是路由分發

from django.conf.urls import url, include
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    # 路由分發
    url(r'^api/', include('api.urls'))
]

api組件的子路由：api/url.py

按照restful規範書寫路由接口

from django.conf.urls import url

from . import views
urlpatterns = [
    url(r'^books/', views.Book.as_view()),
    url(r'^books/(?P<pk>.*)/$', views.Book.as_view()),
]

模型層：model.py

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=64)
    price = models.DecimalField(max_digits=5, decimal_places=2)

    class Meta:
        db_table = 'old_boy_book'
        verbose_name = '書籍'
        verbose_name_plural = verbose_name

    def __str__(self):
        return '《%s》' % self.title

後臺層：admin.py

from django.contrib import admin

from . import models

admin.site.register(models.Book)

數據庫遷移

>: python manage.py makemigrations
>: python manage.py migrrate

>: python manage.py createsuperuser

視圖層：views.py

from django.http import JsonResponse

from django.views import View
from . import models


# 六大基礎接口：獲取一個 獲取全部 增長一個 刪除一個 總體更新一個 局部更新一個
# 十大接口：羣增 羣刪 總體改羣改 局部改羣改
class Book(View):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if not pk:  # 羣查
            # 操做數據庫
            book_obj_list = models.Book.objects.all()
            # 序列化過程
            # 「序列化 (Serialization)將對象的狀態信息轉換爲能夠存儲或傳輸的形式的過程。
            book_list = []
            for obj in book_obj_list:
                dic = {}
                dic['title'] = obj.title
                dic['price'] = obj.price
                book_list.append(dic)
            # 響應數據
            return JsonResponse({
                'status': 0,
                'msg': 'ok',
                'results': book_list
            }, json_dumps_params={'ensure_ascii': False})
        else:  # 單查
            book_dic = models.Book.objects.filter(pk=pk).values('title', 'price').first()
            if book_dic:
                return JsonResponse({
                    'status': 0,
                    'msg': 'ok',
                    'results': book_dic
                }, json_dumps_params={'ensure_ascii': False})
            return JsonResponse({
                'status': 2,
                'msg': '無結果',
            }, json_dumps_params={'ensure_ascii': False})


    # postman能夠完成不一樣方式的請求：get | post | put ...
    # postman發送數據包有三種方式：form-data | urlencoding | json
    # 原生django對urlencoding方式數據兼容最好
    def post(self, request, *args, **kwargs):
        # 前臺經過urlencoding方式提交數據
        try:
            book_obj = models.Book.objects.create(**request.POST.dict())
            if book_obj:
                return JsonResponse({
                    'status': 0,
                    'msg': 'ok',
                    'results': {'title': book_obj.title, 'price': book_obj.price}
                }, json_dumps_params={'ensure_ascii': False})
        except:
            return JsonResponse({
                'status': 1,
                'msg': '參數有誤',
            }, json_dumps_params={'ensure_ascii': False})

        return JsonResponse({
            'status': 2,
            'msg': '新增失敗',
        }, json_dumps_params={'ensure_ascii': False})

JsonResponse與HttpResponse的區別

不一樣的方法仍是有點區別的，咱們後臺給前臺返回數據的時候須要經過json格式的

字符串進行傳輸，由於先後臺都有對json格式字符串進行操做的方式

他們的區別就是HttpResponse須要咱們本身先後臺進行序列化與反序列化

而JasonResponse則把序列化和反序列化封裝了起來，咱們直接傳入可序列化

的字符串，在前臺就能收到對應的數據

drf五大模塊

1.請求模塊：request對象

源碼入口

APIView類的dispatch方法中：request = self.initialize_request(request, *args, **kwargs)

源碼分析

"""
# 二次封裝獲得def的request對象
request = self.initialize_request(request, *args, **kwargs) 點進去

# 在rest_framework.request.Request實例化方法中
self._request = request  將原生request做爲新request的_request屬性

# 在rest_framework.request.Request的__getattr__方法中
try:
	return getattr(self._request, attr)  # 訪問屬性徹底兼容原生request
except AttributeError:
	return self.__getattribute__(attr)
"""

重點總結

# 1) drf 對原生request作了二次封裝，request._request就是原生request
# 2) 原生request對象的屬性和方法均可以被drf的request對象直接訪問(兼容)
# 3) drf請求的全部url拼接參數均被解析到query_params中，全部數據包數據都被解析到data中

class Test(APIView):
    def get(self, request, *args, **kwargs):
        # url拼接的參數
        print(request._request.GET)  # 二次封裝方式
        print(request.GET) # 兼容
        print(request.query_params) # 拓展

        return Response('drf get ok')

    def post(self, request, *args, **kwargs):
        # 全部請求方式攜帶的數據包
        print(request._request.POST)  # 二次封裝方式
        print(request.POST)  # 兼容
        print(request.data)  # 拓展，兼容性最強，三種數據方式均可以

        print(request.query_params)

        return Response('drf post ok')

2.渲染模塊：瀏覽器和Postman請求結果渲染數據的方式不同

源碼入口

APIView類的dispatch方法中：self.response = self.finalize_response(request, response, *args, **kwargs)

源碼分析

"""
# 最後解析reponse對象數據
self.response = self.finalize_response(request, response, *args, **kwargs) 點進去

# 拿到運行的解析類的對象們
neg = self.perform_content_negotiation(request, force=True) 點進去

# 得到解析類對象
renderers = self.get_renderers() 點進去

# 從視圖類中獲得renderer_classes請求類，如何實例化一個個對象形參解析類對象列表
return [renderer() for renderer in self.renderer_classes]


# 重點：self.renderer_classes獲取renderer_classes的順序
#	本身視圖類的類屬性(局部配置) => 
#	APIView類的類屬性設置 => 
#	本身配置文件的DEFAULT_RENDERER_CLASSES(全局配置) => 
#	drf配置文件的DEFAULT_RENDERER_CLASSES
"""

全局配置：全部視圖類統一處理，在項目的settings.py中

REST_FRAMEWORK = {
    # drf提供的渲染類
    'DEFAULT_RENDERER_CLASSES': [
        'rest_framework.renderers.JSONRenderer',
        'rest_framework.renderers.BrowsableAPIRenderer',
    ],
}

局部配置：某一個或一些實體類單獨處理，在views.py視圖類中提供對應的類屬性

class Test(APIView):
    def get(self, request, *args, **kwargs):
        return Response('drf get ok')

    def post(self, request, *args, **kwargs):
        return Response('drf post ok')

# 在setting.py中配置REST_FRAMEWORK，完成的是全局配置，全部接口統一處理
# 若是隻有部分接口特殊化，能夠完成 - 局部配置
from rest_framework.renderers import JSONRenderer
class Test2(APIView):
    # 局部配置
    renderer_classes = [JSONRenderer]
    def get(self, request, *args, **kwargs):
        return Response('drf get ok 2')

    def post(self, request, *args, **kwargs):
        return Response('drf post ok 2')

3.解析模塊

爲何要配置解析模塊

"""
1）drf給咱們經過了多種解析數據包方式的解析類
2）咱們能夠經過配置來控制前臺提交的哪些格式的數據後臺在解析，哪些數據不解析
3）全局配置就是針對每個視圖類，局部配置就是針對指定的視圖來，讓它們能夠按照配置規則選擇性解析數據
"""

源碼入口

# APIView類的dispatch方法中
request = self.initialize_request(request, *args, **kwargs)  # 點進去

# 獲取解析類
parsers=self.get_parsers(),  # 點進去

# 去類屬性(局部配置) 或 配置文件(全局配置) 拿 parser_classes
return [parser() for parser in self.parser_classes]

全局配置：項目settings.py文件

REST_FRAMEWORK = {
    # 全局解析類配置
    'DEFAULT_PARSER_CLASSES': [
        'rest_framework.parsers.JSONParser',  # json數據包
        'rest_framework.parsers.FormParser',  # urlencoding數據包
        'rest_framework.parsers.MultiPartParser'  # form-date數據包
    ],
}

局部配置：應用views.py的具體視圖類

from rest_framework.parsers import JSONParser
class Book(APIView):
    # 局部解析類配置，只要json類型的數據包才能被解析
    parser_classes = [JSONParser]
    pass

4.異常模塊

爲何要自定義異常模塊

"""
1）全部通過drf的APIView視圖類產生的異常，均可以提供異常處理方案
2）drf默認提供了異常處理方案(rest_framework.views.exception_handler)，可是處理範圍有限
3）drf提供的處理方案兩種，處理了返回異常現象，沒處理返回None(後續就是服務器拋異常給前臺)
4）自定義異常的目的就是解決drf沒有處理的異常，讓前臺獲得合理的異常信息返回，後臺記錄異常具體信息
"""

源碼分析

# 異常模塊：APIView類的dispatch方法中
response = self.handle_exception(exc)  # 點進去

# 獲取處理異常的句柄(方法)
# 一層層看源碼，走的是配置文件，拿到的是rest_framework.views的exception_handler
# 自定義：直接寫exception_handler函數，在本身的配置文件配置EXCEPTION_HANDLER指向本身的
exception_handler = self.get_exception_handler()

# 異常處理的結果
# 自定義異常就是提供exception_handler異常處理函數，處理的目的就是讓response必定有值
response = exception_handler(exc, context)

如何使用：自定義exception_handler函數如何書寫實現體

# 修改本身的配置文件setting.py
REST_FRAMEWORK = {
    # 全局配置異常模塊
    'EXCEPTION_HANDLER': 'api.exception.exception_handler',
}

# 1）先將異常處理交給rest_framework.views的exception_handler去處理
# 2）判斷處理的結果(返回值)response，有值表明drf已經處理了，None表明須要本身處理

# 自定義異常處理文件exception，在文件中書寫exception_handler函數
from rest_framework.views import exception_handler as drf_exception_handler
from rest_framework.views import Response
from rest_framework import status
def exception_handler(exc, context):
    # drf的exception_handler作基礎處理
    response = drf_exception_handler(exc, context)
    # 爲空，自定義二次處理
    if response is None:
        # print(exc)
        # print(context)
        print('%s - %s - %s' % (context['view'], context['request'].method, exc))
        return Response({
            'detail': '服務器錯誤'
        }, status=status.HTTP_500_INTERNAL_SERVER_ERROR, exception=True)
    return response

5.響應模塊

響應類構造器：rest_framework.response.Response

def __init__(self, data=None, status=None,
                 template_name=None, headers=None,
                 exception=False, content_type=None):
     """
        :param data: 響應數據
        :param status: http響應狀態碼
        :param template_name: drf也能夠渲染頁面，渲染的頁面模板地址（不用瞭解）
        :param headers: 響應頭
        :param exception: 是否異常了
        :param content_type: 響應的數據格式（通常不用處理，響應頭中帶了，且默認是json）
    """
    pass

使用：常規實例化響應對象

# status就是解釋一堆 數字 網絡狀態碼的模塊
from rest_framework import status就是解釋一堆 數字 網絡狀態碼的模塊
# 通常狀況下只須要返回數據，status和headers都有默認值
return Response(data={數據}, status=status.HTTP_200_OK, headers={設置的響應頭})

序列化組件：

知識點：Serializer(偏底層)、ModelSerializer(重點)、ListModelSerializer(輔助羣改)

1.Serializer

序列化準備：

• 模型層：models.py

class User(models.Model):
    SEX_CHOICES = [
        [0, '男'],
        [1, '女'],
    ]
    name = models.CharField(max_length=64)
    pwd = models.CharField(max_length=32)
    phone = models.CharField(max_length=11, null=True, default=None)
    sex = models.IntegerField(choices=SEX_CHOICES, default=0)
    icon = models.ImageField(upload_to='icon', default='icon/default.jpg')

    class Meta:
        db_table = 'old_boy_user'
        verbose_name = '用戶'
        verbose_name_plural = verbose_name

    def __str__(self):
        return '%s' % self.name

• 後臺管理層：admin.py

from django.contrib import admin
from . import models

admin.site.register(models.User)

• 配置層：settings.py

# 註冊rest_framework
INSTALLED_APPS = [
    # ...
    'rest_framework',
]

# 配置數據庫
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'day70',
        'USER': 'root',
        'PASSWORD': '123'
    }
}

# media資源
MEDIA_URL = '/media/'  # 後期高級序列化類與視圖類，會使用該配置
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')  # media資源路徑

# 國際化配置
LANGUAGE_CODE = 'zh-hans'
TIME_ZONE = 'Asia/Shanghai'
USE_I18N = True
USE_L10N = True
USE_TZ = False

• 主路由：項目下urls.py

urlpatterns = [
    # ...
    url(r'^api/', include('api.urls')),

    url(r'^media/(?P<path>.*)', serve, {'document_root': settings.MEDIA_ROOT}),
]

• 子路由：應用下urls.py

urlpatterns = [
    url(r'^users/$', views.User.as_view()),
    url(r'^users/(?P<pk>.*)/$', views.User.as_view()),
]

序列化使用

• 序列化層：api/serializers.py

"""
1）設置須要返回給前臺 那些model類有對應的 字段，不須要返回的就不用設置了
2）設置方法字段，字段名能夠隨意，字段值有 get_字段名 提供，來完成一些須要處理在返回的數據
"""

# 序列化組件 - 爲每個model類經過一套序列化工具類
# 序列化組件的工做方式與django froms組件很是類似
from rest_framework import serializers, exceptions
from django.conf import settings

from . import models

class UserSerializer(serializers.Serializer):
    name = serializers.CharField()
    phone = serializers.CharField()
    # 序列化提供給前臺的字段個數由後臺決定，能夠少提供，
    # 可是提供的數據庫對應的字段，名字必定要與數據庫字段相同
    # sex = serializers.IntegerField()
    # icon = serializers.ImageField()

    # 自定義序列化屬性
    # 屬性名隨意，值由固定的命名規範方法提供:
    #       get_屬性名(self, 參與序列化的model對象)
    #       返回值就是自定義序列化屬性的值
    gender = serializers.SerializerMethodField()
    # 或者在model.py中使用插拔式自定義字段
    # class Car(BaseModel):
	# 	name = models.CharFiled(max_length=64)
	# @property
	# def my_name(self):
		# 自定義字段：能夠連表，能夠完成數據相關的邏輯
		@ return '插拔式字段的值'
    @ def get_gender(self, obj):
        # choice類型的解釋型值 get_字段_display() 來訪問
        return obj.get_sex_display()


    icon = serializers.SerializerMethodField()
    def get_icon(self, obj):
        # settings.MEDIA_URL: 本身配置的 /media/，給後面高級序列化與視圖類準備的
        # obj.icon不能直接做爲數據返回，由於內容雖然是字符串，可是類型是ImageFieldFile類型
        return '%s%s%s' % (r'http://127.0.0.1:8000', settings.MEDIA_URL, str(obj.icon))

• 視圖層

"""
1）從數據庫中將要序列化給前臺的model對象，或是多個model對象查詢出來
	user_obj = models.User.objects.get(pk=pk) 或者
	user_obj_list = models.User.objects.all()
2）將對象交給序列化處理，產生序列化對象，若是序列化的是多個數據，要設置many=True
	user_ser = serializers.UserSerializer(user_obj) 或者
	user_ser = serializers.UserSerializer(user_obj_list, many=True)
3）序列化 對象.data 就是能夠返回給前臺的序列化數據
	return Response({
        'status': 0,
        'msg': 0,
        'results': user_ser.data
    })
"""

class User(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                # 用戶對象不能直接做爲數據返回給前臺
                user_obj = models.User.objects.get(pk=pk)
                # 序列化一下用戶對象
                user_ser = serializers.UserSerializer(user_obj)
                # print(user_ser, type(user_ser))
                return Response({
                    'status': 0,
                    'msg': 0,
                    'results': user_ser.data
                })
            except:
                return Response({
                    'status': 2,
                    'msg': '用戶不存在',
                })
        else:
            # 用戶對象列表(queryset)不能直接做爲數據返回給前臺
            user_obj_list = models.User.objects.all()
            # 序列化一下用戶對象
            user_ser_data = serializers.UserSerializer(user_obj_list, many=True).data
            return Response({
                'status': 0,
                'msg': 0,
                'results': user_ser_data
            })

反序列化使用

• 反序列層：api/serializers.py

"""
1）設置必填與選填序列化字段，設置校驗規則
2）爲須要額外校驗的字段提供局部鉤子函數，若是該字段不入庫，且不參與全局鉤子校驗，能夠將值取出校驗
3）爲有聯合關係的字段們提供全局鉤子函數，若是某些字段不入庫，能夠將值取出校驗
4）重寫create方法，完成校驗經過的數據入庫工做，獲得新增的對象
"""

class UserDeserializer(serializers.Serializer):
    # 1) 哪些自動必須反序列化
    # 2) 字段都有哪些安全校驗
    # 3) 哪些字段須要額外提供校驗
    # 4) 哪些字段間存在聯合校驗
    # 注：反序列化字段都是用來入庫的，不會出現自定義方法屬性，會出現能夠設置校驗規則的自定義屬性(re_pwd)
    name = serializers.CharField(
        max_length=64,
        min_length=3,
        error_messages={
            'max_length': '太長',
            'min_length': '過短'
        }
    )
    pwd = serializers.CharField()
    phone = serializers.CharField(required=False)
    sex = serializers.IntegerField(required=False)

    # 自定義有校驗規則的反序列化字段
    re_pwd = serializers.CharField(required=True)

    # 小結：
    # name，pwd，re_pwd爲必填字段
    # phone，sex爲選填字段
    # 五個字段都必須提供完成的校驗規則


    # 局部鉤子：validate_要校驗的字段名(self, 當前要校驗字段的值)
    # 校驗規則：校驗經過返回原值，校驗失敗，拋出異常
    def validate_name(self, value):
        if 'g' in value.lower():  # 名字中不能出現g
            raise exceptions.ValidationError('名字非法，是個雞賊！')
        return value

    # 全局鉤子：validate(self, 系統與局部鉤子校驗經過的全部數據)
    # 校驗規則：校驗經過返回原值，校驗失敗，拋出異常
    def validate(self, attrs):
        pwd = attrs.get('pwd')
        re_pwd = attrs.pop('re_pwd')
        if pwd != re_pwd:
            raise exceptions.ValidationError({'pwd&re_pwd': '兩次密碼不一致'})
        return attrs

    # 要完成新增，須要本身重寫 create 方法
    def create(self, validated_data):
        # 儘可能在全部校驗規則完畢以後，數據能夠直接入庫
        return models.User.objects.create(**validated_data)

• 視圖層

"""
1）book_ser = serializers.UserDeserializer(data=request_data)  # 數據必須賦值data
2）book_ser.is_valid()  # 結果爲 經過 | 不經過
3）不經過返回 book_ser.errors 給前臺，經過 book_ser.save() 獲得新增的對象，再正常返回
"""

class User(APIView):
    # 只考慮單增
    def post(self, request, *args, **kwargs):
        # 請求數據
        request_data = request.data
        # 數據是否合法（增長對象須要一個字典數據）
        if not isinstance(request_data, dict) or request_data == {}:
            return Response({
                'status': 1,
                'msg': '數據有誤',
            })
        # 數據類型合法，但數據內容不必定合法，須要校驗數據，校驗(參與反序列化)的數據須要賦值給data
        book_ser = serializers.UserDeserializer(data=request_data)

        # 序列化對象調用is_valid()完成校驗，校驗失敗的失敗信息都會被存儲在 序列化對象.errors
        if book_ser.is_valid():
            # 校驗經過，完成新增
            book_obj = book_ser.save()
            return Response({
                'status': 0,
                'msg': 'ok',
                'results': serializers.UserSerializer(book_obj).data
            })
        else:
            # 校驗失敗
            return Response({
                'status': 1,
                'msg': book_ser.errors,
            })

2.序列化與反序列化整合（重點）

序列化層：api/serializers.py

"""
1) fields中設置全部序列化與反序列化字段
2) extra_kwargs劃分只序列化或只反序列化字段
    write_only：只反序列化
    read_only：只序列化
    自定義字段默認只序列化(read_only)
3) 設置反序列化所需的 系統、局部鉤子、全局鉤子 等校驗規則
"""
class V2BookModelSerializer(ModelSerializer):
    class Meta:
        model = models.Book
        fields = ('name', 'price', 'img', 'author_list', 'publish_name', 'publish', 'authors')
        extra_kwargs = {
            'name': {
                'required': True,
                'min_length': 1,
                'error_messages': {
                    'required': '必填項',
                    'min_length': '過短',
                }
            },
            'publish': {
                'write_only': True
            },
            'authors': {
                'write_only': True
            },
            'img': {
                'read_only': True,
            },
            'author_list': {
                'read_only': True,
            },
            'publish_name': {
                'read_only': True,
            }
        }

    def validate_name(self, value):
        # 書名不能包含 g 字符
        if 'g' in value.lower():
            raise ValidationError('該g書不能出版')
        return value

    def validate(self, attrs):
        publish = attrs.get('publish')
        name = attrs.get('name')
        if models.Book.objects.filter(name=name, publish=publish):
            raise ValidationError({'book': '該書已存在'})
        return attrs

視圖層：api/views.py

class V2Book(APIView):
    # 單查：有pk
    # 羣查：無pk
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                book_obj = models.Book.objects.get(pk=pk, is_delete=False)
                book_data = serializers.V2BookModelSerializer(book_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '書籍不存在'
                })
        else:
            book_query = models.Book.objects.filter(is_delete=False).all()
            book_data = serializers.V2BookModelSerializer(book_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': book_data
        })

    # 單增：傳的數據是與model對應的字典
    # 羣增：傳的數據是 裝多個 model對應字典 的列表
    def post(self, request, *args, **kwargs):
        request_data = request.data
        if isinstance(request_data, dict):
            many = False
        elif isinstance(request_data, list):
            many = True
        else:
            return Response({
                'status': 1,
                'msg': '數據有誤',
            })
        book_ser = serializers.V2BookModelSerializer(data=request_data, many=many)
        # 當校驗失敗，立刻終止當前視圖方法，拋異常返回給前臺
        book_ser.is_valid(raise_exception=True)
        book_result = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer(book_result, many=many).data
        })

    # 單刪：有pk
    # 羣刪：有pks   |  {"pks": [1, 2, 3]}
    def delete(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            pks = [pk]
        else:
            pks = request.data.get('pks')
        if models.Book.objects.filter(pk__in=pks, is_delete=False).update(is_delete=True):
            return Response({
                'status': 0,
                'msg': '刪除成功',
            })
        return Response({
            'status': 1,
            'msg': '刪除失敗',
        })

路由層：api/urls.py

urlpatterns = [
    url(r'^v2/books/$', views.V2Book.as_view()),
    url(r'^v2/books/(?P<pk>.*)/$', views.V2Book.as_view()),
]

3.總體單改

路由層、模型層、序列化層不須要作修改，只須要處理視圖層：views.py

"""
1) 單總體改，說明前臺要提供修改的數據，那麼數據就須要校驗，校驗的數據應該在實例化「序列化類對象」時，賦值給data
2）修改，就必須明確被修改的模型類對象，並在實例化「序列化類對象」時，賦值給instance
3）總體修改，全部校驗規則有required=True的字段，都必須提供，由於在實例化「序列化類對象」時，參數partial默認爲False


注：若是partial值設置爲True，就是能夠局部改
1）單總體修改，通常用put請求：
V2BookModelSerializer(
    instance=要被更新的對象, 
    data=用來更新的數據,
    partial=默認False，必須的字段所有參與校驗
)
2）單局部修改，通常用patch請求：
V2BookModelSerializer(
    instance=要被更新的對象, 
    data=用來更新的數據,
    partial=設置True，必須的字段都變爲選填字段
)
    注：partial設置True的本質就是使字段 required=True 校驗規則失效
"""

class V2Book(APIView):
    # 單總體改: 對 v2/books/(pk)/ 傳的數據是與model對應的字典{name|price|publish|authors}
    def put(self, request, *args, **kwargs):
        request_data = request.data
        pk = kwargs.get('pk')
        old_book_obj = models.Book.objects.filter(pk=pk).first()
        # 目的：將衆多數據的校驗交給序列化類來處理 - 讓序列化類扮演反序列化角色，校驗成功後，序列化類來幫你入庫
        book_ser = serializers.V2BookModelSerializer(instance=old_book_obj, data=request_data, partial=False)
        book_ser.is_valid(raise_exception=True)
        # 校驗經過，完成數據的更新：要更新的目標，用來更新的新數據
        book_obj = book_ser.save()

        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer(book_obj).data
        })

4.單與總體局部修改

序列化層：serializers.py

# 重點：ListSerializer與ModelSerializer創建關聯的是：
# ModelSerializer的Meta類的 - list_serializer_class
class V2BookListSerializer(ListSerializer):
    def update(self, instance, validated_data):
        # print(instance)  # 要更新的對象們
        # print(validated_data)  # 更新的對象對應的數據們
        # print(self.child)  # 服務的模型序列化類 - V2BookModelSerializer
        for index, obj in enumerate(instance):
            self.child.update(obj, validated_data[index])
        return instance
    
# 原模型序列化類變化
class V2BookModelSerializer(ModelSerializer):
    class Meta:
        # ...
        # 羣改，須要設置 自定義ListSerializer，重寫羣改的 update 方法
        list_serializer_class = V2BookListSerializer
    # ...

視圖層：views.py

class V2Book(APIView):
    # 單局部改：對 v2/books/(pk)/ 傳的數據，數據字段key都是選填
    # 羣局部改：對 v2/books/ 
    # 請求數據 - [{pk:1, name:123}, {pk:3, price:7}, {pk:7, publish:2}]
    def patch(self, request, *args, **kwargs):
        request_data = request.data
        pk = kwargs.get('pk')

        # 將單改，羣改的數據都格式化成 pks=[要須要的對象主鍵標識] | request_data=[每一個要修改的對象對應的修改數據]
        if pk and isinstance(request_data, dict):  # 單改
            pks = [pk, ]
            request_data = [request_data, ]
        elif not pk and isinstance(request_data, list): # 羣改
            pks = []
            for dic in request_data:  # 遍歷前臺數據[{pk:1, name:123}, {pk:3, price:7}, {pk:7, publish:2}]，拿一個個字典
                pk = dic.pop('pk', None)
                if pk:
                    pks.append(pk)
                else:
                    return Response({
                        'status': 1,
                        'msg': '數據有誤',
                    })
        else:
            return Response({
                'status': 1,
                'msg': '數據有誤',
            })

        # pks與request_data數據篩選，
        # 1）將pks中的沒有對應數據的pk與數據已刪除的pk移除，request_data對應索引位上的數據也移除
        # 2）將合理的pks轉換爲 objs
        objs = []
        new_request_data = []
        for index, pk in enumerate(pks):
            try:
                # pk對應的數據合理，將合理的對象存儲
                obj = models.Book.objects.get(pk=pk)
                objs.append(obj)
                # 對應索引的數據就須要保存下來
                new_request_data.append(request_data[index])
            except:
                # 重點：反面教程 - pk對應的數據有誤，將對應索引的data中request_data中移除
                # index = pks.index(pk)
                # request_data.pop(index)
                continue

        book_ser = serializers.V2BookModelSerializer(instance=objs, data=new_request_data, partial=True, many=True)
        book_ser.is_valid(raise_exception=True)
        book_objs = book_ser.save()

        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer(book_objs, many=True).data
        })

視圖類

視圖類傳遞參數給序列化類

# 1）在視圖類中實例化序列化對象時，能夠設置context內容
# 2）在序列化類中的局部鉤子、全局鉤子、create、update方法中，均可以用self.context訪問視圖類傳遞過來的內容


# 需求：
# 1) 在視圖類中，能夠經過request獲得登錄用戶request.user
# 2) 在序列化類中，要完成數據庫數據的校驗與入庫操做，可能會須要知道當前的登錄用戶，但序列化類沒法訪問request
# 3) 在視圖類中實例化序列化對象時，將request對象傳遞進去

視圖層：views.py

class Book(APIView):
    def post(self, request, *args, **kwargs):
        book_ser = serializers.BookModelSerializer(data=request_data,context={'request':request})
        book_ser.is_valid(raise_exception=True)
        book_result = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.BookModelSerializer(book_result).data
        })

序列化層：serializers.py

class BookModelSerializer(ModelSerializer):
    class Meta:
        model = models.Book
        fields = ('name', 'price')
    def validate_name(self, value):
        print(self.context.get('request').method)
        return value

二次封裝Response類

"""
Response({
    'status': 0,
    'msg': 'ok',
    'results': [],
    'token': ''  # 有這樣的額外的key-value數據結果
},status=http_status,headers=headers,exception=True|False)

APIResponse() => Response({'status': 0,'msg': 'ok'})
"""

from rest_framework.response import Response

class APIResponse(Response):
    def __init__(self, data_status=0, data_msg='ok', results=None, http_status=None, headers=None, exception=False, **kwargs):
        # data的初始狀態：狀態碼與狀態信息
        data = {
            'status': data_status,
            'msg': data_msg,
        }
        # data的響應數據體
        # results多是False、0等數據，這些數據某些狀況下也會做爲合法數據返回
        if results is not None:
            data['results'] = results
        # data響應的其餘內容
        # if kwargs is not None:
        #     for k, v in kwargs.items():
        #         setattr(data, k, v)
        data.update(kwargs)

        super().__init__(data=data, status=http_status, headers=headers, exception=exception)

視圖家族

"""
views：視圖
generics：工具視圖
mixins：視圖工具集
viewsets：視圖集
"""
"""
學習曲線
APIView => GenericAPIView => mixins的五大工具類 => generics中的工具視圖 => viewsets中的視圖集
"""

GenericAPIView基類

# GenericAPIView是繼承APIView的，使用徹底兼容APIView
# 重點：GenericAPIView在APIView基礎上完成了哪些事
# 1）get_queryset()：從類屬性queryset中得到model的queryset數據
# 2）get_object()：從類屬性queryset中得到model的queryset數據，再經過有名分組pk肯定惟一操做對象
# 3）get_serializer()：從類屬性serializer_class中得到serializer的序列化類

urlpatterns = [
    url(r'^v2/books/$', views.BookGenericAPIView.as_view()),
    url(r'^v2/books/(?P<pk>.*)/$', views.BookGenericAPIView.as_view()),
]

from rest_framework.generics import GenericAPIView
class BookGenericAPIView(GenericAPIView):
    queryset = models.Book.objects.filter(is_delete=False)
    serializer_class = serializers.BookModelSerializer
    # 自定義主鍵的 有名分組 名
    lookup_field = 'pk'
    # 羣取
    # def get(self, request, *args, **kwargs):
    #     book_query = self.get_queryset()
    #     book_ser = self.get_serializer(book_query, many=True)
    #     book_data = book_ser.data
    #     return APIResponse(results=book_data)

    # 單取
    def get(self, request, *args, **kwargs):
        book_query = self.get_object()
        book_ser = self.get_serializer(book_query)
        book_data = book_ser.data
        return APIResponse(results=book_data)

mixins視圖工具集 - 輔助GenericAPIView

# 1）mixins有五個工具類文件，一共提供了五個工具類，六個工具方法：單查、羣查、單增、單刪、單總體改、單局部改
# 2）繼承工具類能夠簡化請求函數的實現體，可是必須繼承GenericAPIView，須要GenericAPIView類提供的幾個類屬性和方法(見上方GenericAPIView基類知識點)
# 3）工具類的工具方法返回值都是Response類型對象，若是要格式化數據格式再返回給前臺，能夠經過 response.data 拿到工具方法返回的Response類型對象的響應數據

urlpatterns = [
   	url(r'^v3/books/$', views.BookMixinGenericAPIView.as_view()),
    url(r'^v3/books/(?P<pk>.*)/$', views.BookMixinGenericAPIView.as_view()),
]

from rest_framework.mixins import ListModelMixin, CreateModelMixin, RetrieveModelMixin, UpdateModelMixin
class BookMixinGenericAPIView(ListModelMixin, CreateModelMixin, RetrieveModelMixin, UpdateModelMixin, GenericAPIView):
    queryset = models.Book.objects.filter(is_delete=False)
    serializer_class = serializers.BookModelSerializer

    def get(self, request, *args, **kwargs):
        if 'pk' in kwargs:
            response = self.retrieve(request, *args, **kwargs)
        else:
            # mixins提供的list方法的響應對象是Response，想將該對象格式化爲APIResponse
            response = self.list(request, *args, **kwargs)
        # response的數據都存放在response.data中
        return APIResponse(results=response.data)

    def post(self, request, *args, **kwargs):
        response = self.create(request, *args, **kwargs)
        return APIResponse(results=response.data)

    def put(self, request, *args, **kwargs):
        response = self.update(request, *args, **kwargs)
        return APIResponse(results=response.data)

    def patch(self, request, *args, **kwargs):
        response = self.partial_update(request, *args, **kwargs)
        return APIResponse(results=response.data)

工具視圖

# 1）工具視圖都是GenericAPIView的子類，且不一樣的子類繼承了不一樣的工具類，重寫了請求方法
# 2）工具視圖的功能若是直接能夠知足需求，只須要繼承工具視圖，提供queryset與serializer_class便可

urlpatterns = [
   	url(r'^v4/books/$', views.BookListCreatePIView.as_view()),
    url(r'^v4/books/(?P<pk>.*)/$', views.BookListCreatePIView.as_view()),
]

from rest_framework.generics import ListCreateAPIView, UpdateAPIView
class BookListCreatePIView(ListCreateAPIView, UpdateAPIView):
    queryset = models.Book.objects.filter(is_delete=False)
    serializer_class = serializers.BookModelSerializer

視圖集

# 1）視圖集都是優先繼承ViewSetMixin類，再繼承一個視圖類（GenericAPIView或APIView）
#       GenericViewSet、ViewSet
# 2）ViewSetMixin提供了重寫的as_view()方法，繼承視圖集的視圖類，配置路由時調用as_view()必須傳入 請求名-函數名 映射關係字典
#       eg: url(r'^v5/books/$', views.BookGenericViewSet.as_view({'get': 'my_get_list'})),
#       表示get請求會交給my_get_list視圖函數處理

urlpatterns = [
   	# View的as_view()：將get請求映射到視圖類的get方法
    # ViewSet的as_view({'get': 'my_get_list'})：將get請求映射到視圖類的my_get_list方法
    url(r'^v5/books/$', views.BookGenericViewSet.as_view({'get': 'my_get_list'})),
    url(r'^v5/books/(?P<pk>.*)/$', views.BookGenericViewSet.as_view({'get': 'my_get_obj'})),
]

from rest_framework.viewsets import GenericViewSet
from rest_framework import mixins
class BookGenericViewSet(mixins.RetrieveModelMixin, mixins.ListModelMixin, GenericViewSet):
    queryset = models.Book.objects.filter(is_delete=False)
    serializer_class = serializers.BookModelSerializer

    def my_get_list(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)

    def my_get_obj(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)

GenericAPIView 與 APIView 最爲兩大繼承視圖的區別

# 1）GenericViewSet和ViewSet都繼承了ViewSetMixin，as_view均可以配置 請求-函數 映射
# 2）GenericViewSet繼承的是GenericAPIView視圖類，用來完成標準的 model 類操做接口
# 3）ViewSet繼承的是APIView視圖類，用來完成不須要 model 類參與，或是非標準的 model 類操做接口
#       post請求在標準的 model 類操做下就是新增接口，登錄的post不知足
#       post請求驗證碼的接口，不須要 model 類的參與
# 案例：登錄的post請求，並非完成數據的新增，只是用post提交數據，獲得的結果也不是登錄的用戶信息，而是登錄的認證信息

工具視圖集

urlpatterns = [
   	url(r'^v6/books/$', views.BookModelViewSet.as_view({'get': 'list', 'post': 'create'})),
    url(r'^v6/books/(?P<pk>.*)/$', views.BookModelViewSet.as_view({'get': 'retrieve', 'put': 'update', 'patch': 'partial_update', 'delete': 'destroy'})),
]

from rest_framework.viewsets import ModelViewSet
class BookModelViewSet(ModelViewSet):
    queryset = models.Book.objects.filter(is_delete=False)
    serializer_class = serializers.BookModelSerializer

    # 刪不是數據庫，而是該記錄中的刪除字段
    def destroy(self, request, *args, **kwargs):
        instance = self.get_object()  # type: models.Book
        if not instance:
            return APIResponse(1, '刪除失敗')  # 實際操做，在此以前就作了判斷
        instance.is_delete = True
        instance.save()
        return APIResponse(0, '刪除成功')

路由組件（瞭解）

from django.conf.urls import include
from rest_framework.routers import SimpleRouter
router = SimpleRouter()
# 全部路由與ViewSet視圖類的均可以註冊，會產生 '^v6/books/$' 和 '^v6/books/(?P<pk>[^/.]+)/$'
router.register('v6/books', views.BookModelViewSet)

urlpatterns = [
    # 第一種添加子列表方式
    url(r'^', include(router.urls)),
]
# 第二種添加子列表方式
# urlpatterns.extend(router.urls)

認證規則演變圖

數據庫session認證：低效

緩存認證：高效

jwt認證：高效

緩存認證：不易併發

jwt認證：易併發

JWT

工做原理

"""
1) jwt = base64(頭部).base(載荷).hash256(base64(頭部).base(載荷).密鑰)
2) base64是可逆的算法、hash256是不可逆的算法
3) 密鑰是固定的字符串，保存在服務器
"""

優勢

"""
1) 服務器不要存儲token，token交給每個客戶端本身存儲，服務器壓力小
2）服務器存儲的是 簽發和校驗token 兩段算法，簽發認證的效率高
3）算法完成各集羣服務器同步成本低，路由項目完成集羣部署（適應高併發）
"""

格式

"""
1) jwt token採用三段式：頭部.載荷.簽名
2）每一部分都是一個json字典加密形參的字符串
3）頭部和載荷採用的是base64可逆加密（前臺後臺均可以解密）
4）簽名採用hash256不可逆加密（後臺校驗採用碰撞校驗）
5）各部分字典的內容：
	頭部：基礎信息 - 公司信息、項目組信息、可逆加密採用的算法
	載荷：有用但非私密的信息 - 用戶可公開信息、過時時間
	簽名：頭部+載荷+祕鑰 不可逆加密後的結果
	注：服務器jwt簽名加密祕鑰必定不能泄露
	
簽發token：固定的頭部信息加密.當前的登錄用戶與過時時間加密.頭部+載荷+祕鑰生成不可逆加密
校驗token：頭部可校驗也能夠不校驗，載荷校驗出用戶與過時時間，頭部+載荷+祕鑰完成碰撞檢測校驗token是否被篡改
"""

drf-jwt

官網

http://getblimp.github.io/django-rest-framework-jwt/

安裝：虛擬環境

pip install djangorestframework-jwt

使用：user/urls.py

from django.urls import path
from rest_framework_jwt.views import obtain_jwt_token
urlpatterns = [
    path('login/', obtain_jwt_token),
]

測試接口：post請求

"""
postman發生post請求

接口：http://api.luffy.cn:8000/user/login/

數據：
{
	"username":"admin",
	"password":"admin"
}
"""

drf-jwt開發

配置信息：JWT_AUTH到dev.py中

import datetime
JWT_AUTH = {
    # 過時時間
    'JWT_EXPIRATION_DELTA': datetime.timedelta(days=1),
    # 自定義認證結果：見下方序列化user和自定義response
    'JWT_RESPONSE_PAYLOAD_HANDLER': 'user.utils.jwt_response_payload_handler',  
}

序列化user：user/serializers.py(本身建立)

from rest_framework import serializers
from . import models
class UserModelSerializers(serializers.ModelSerializer):
    class Meta:
        model = models.User
        fields = ['username']

自定義response：user/utils.py

from .serializers import UserModelSerializers
def jwt_response_payload_handler(token, user=None, request=None):
    return {
        'status': 0,
        'msg': 'ok',
        'data': {
            'token': token,
            'user': UserModelSerializers(user).data
        }
    }

基於drf-jwt的全局認證：user/authentications.py(本身建立)

import jwt
from rest_framework.exceptions import AuthenticationFailed
from rest_framework_jwt.authentication import jwt_decode_handler
from rest_framework_jwt.authentication import get_authorization_header
from rest_framework_jwt.authentication import BaseJSONWebTokenAuthentication

class JSONWebTokenAuthentication(BaseJSONWebTokenAuthentication):
    def authenticate(self, request):
        jwt_value = get_authorization_header(request)

        if not jwt_value:
            raise AuthenticationFailed('Authorization 字段是必須的')
        try:
            payload = jwt_decode_handler(jwt_value)
        except jwt.ExpiredSignature:
            raise AuthenticationFailed('簽名過時')
        except jwt.InvalidTokenError:
            raise AuthenticationFailed('非法用戶')
        user = self.authenticate_credentials(payload)

        return user, jwt_value

全局啓用：settings/dev.py

REST_FRAMEWORK = {
    # 認證模塊
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'user.authentications.JSONWebTokenAuthentication',
    ),
}

局部啓用禁用：任何一個cbv類首行

# 局部禁用
authentication_classes = []

# 局部啓用
from user.authentications import JSONWebTokenAuthentication
authentication_classes = [JSONWebTokenAuthentication]

多方式登陸：user/utils.py

import re
from .models import User
from django.contrib.auth.backends import ModelBackend
class JWTModelBackend(ModelBackend):
    def authenticate(self, request, username=None, password=None, **kwargs):
        try:
            if re.match(r'^1[3-9]\d{9}$', username):
                user = User.objects.get(mobile=username)
            else:
                user = User.objects.get(username=username)
        except User.DoesNotExist:
            return None
        if user.check_password(password) and self.user_can_authenticate(user):
            return user

配置多方式登陸：settings/dev.py

AUTHENTICATION_BACKENDS = ['user.utils.JWTModelBackend']

手動簽發JWT：瞭解 - 能夠擁有原生登陸基於Model類user對象簽發JWT

from rest_framework_jwt.settings import api_settings

jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER

payload = jwt_payload_handler(user)
token = jwt_encode_handler(payload)

針對token操做

登陸 - 簽發token：api/urls.py

# ObtainJSONWebToken視圖類就是經過username和password獲得user對象而後簽發token
from rest_framework_jwt.views import ObtainJSONWebToken, obtain_jwt_token
urlpatterns = [
    # url(r'^jogin/$', ObtainJSONWebToken.as_view()),
    url(r'^jogin/$', obtain_jwt_token),
]

認證 - 校驗token：全局或局部配置drf-jwt的認證類 JSONWebTokenAuthentication

from rest_framework.views import APIView
from utils.response import APIResponse
# 必須登陸後才能訪問 - 經過了認證權限組件
from rest_framework.permissions import IsAuthenticated
from rest_framework_jwt.authentication import JSONWebTokenAuthentication
class UserDetail(APIView):
    authentication_classes = [JSONWebTokenAuthentication]  # jwt-token校驗request.user
    permission_classes = [IsAuthenticated]  # 結合權限組件篩選掉遊客
    def get(self, request, *args, **kwargs):
        return APIResponse(results={'username': request.user.username})

路由與接口測試

# 路由
url(r'^user/detail/$', views.UserDetail.as_view()),

# 接口：/api/user/detail/
# 認證信息：必須在請求頭的 Authorization 中攜帶 "jwt 後臺簽發的token" 格式的認證字符串

三大認證

源碼分析

"""
1）APIView的dispath(self, request, *args, **kwargs)
2）dispath方法內 self.initial(request, *args, **kwargs) 進入三大認證
	# 認證組件：校驗用戶 - 遊客、合法用戶、非法用戶
    # 遊客：表明校驗經過，直接進入下一步校驗（權限校驗）
    # 合法用戶：表明校驗經過，將用戶存儲在request.user中，再進入下一步校驗（權限校驗）
    # 非法用戶：表明校驗失敗，拋出異常，返回403權限異常結果
    self.perform_authentication(request)
    
    # 權限組件：校驗用戶權限 - 必須登陸、全部用戶、登陸讀寫遊客只讀、自定義用戶角色
    # 認證經過：能夠進入下一步校驗（頻率認證）
    # 認證失敗：拋出異常，返回403權限異常結果
    self.check_permissions(request)
    
    # 頻率組件：限制視圖接口被訪問的頻率次數 - 限制的條件(IP、id、惟一鍵)、頻率週期時間(s、m、h)、頻率的次數（3/s）
    # 沒有達到限次：正常訪問接口
    # 達到限次：限制時間內不能訪問，限制時間達到後，能夠從新訪問
    self.check_throttles(request)
    
    
3) 認證組件
	Request類的 方法屬性 user 的get方法 => self._authenticate() 完成認證
	
	認證的細則：
	# 作認證
    def _authenticate(self):
        # 遍歷拿到一個個認證器，進行認證
        # self.authenticators配置的一堆認證類產生的認證類對象組成的 list
        for authenticator in self.authenticators:
            try:
                # 認證器(對象)調用認證方法authenticate(認證類對象self, request請求對象)
                # 返回值：登錄的用戶與認證的信息組成的 tuple
                # 該方法被try包裹，表明該方法會拋異常，拋異常就表明認證失敗
                user_auth_tuple = authenticator.authenticate(self)
            except exceptions.APIException:
                self._not_authenticated()
                raise

            # 返回值的處理
            if user_auth_tuple is not None:
                self._authenticator = authenticator
                # 如何有返回值，就將 登錄用戶 與 登錄認證 分別保存到 request.user、request.auth
                self.user, self.auth = user_auth_tuple
                return
        # 若是返回值user_auth_tuple爲空，表明認證經過，可是沒有 登錄用戶 與 登錄認證信息，表明遊客
        self._not_authenticated()

4) 權限組件
	self.check_permissions(request)
	認證細則：
    def check_permissions(self, request):
        # 遍歷權限對象列表獲得一個個權限對象(權限器)，進行權限認證
        for permission in self.get_permissions():
            # 權限類必定有一個has_permission權限方法，用來作權限認證的
            # 參數：權限對象self、請求對象request、視圖類對象
            # 返回值：有權限返回True，無權限返回False
            if not permission.has_permission(request, self):
                self.permission_denied(
                    request, message=getattr(permission, 'message', None)
                )
"""

認證組件

自定義認證類

"""
1) 建立繼承BaseAuthentication的認證類
2) 實現authenticate方法
3) 實現體根據認證規則 肯定遊客、非法用戶、合法用戶
4) 進行全局或局部配置

認證規則
i.沒有認證信息返回None(遊客)
ii.有認證信息認證失敗拋異常(非法用戶)
iii.有認證信息認證成功返回用戶與認證信息元組(合法用戶)
"""

utils/authentications.py

# 自定義認證類

# 1）繼承BaseAuthentication類
# 2）從新authenticate(self, request)方法，自定義認證規則
# 3）認證規則基於的條件：
#       沒有認證信息返回None(遊客)
#       有認證信息認證失敗拋異常(非法用戶)
#       有認證信息認證成功返回用戶與認證信息元組(合法用戶)
# 4）徹底視圖類的全局(settings文件中)或局部(確切的視圖類)配置
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
from . import models
class MyAuthentication(BaseAuthentication):
    """
    同前臺請求頭拿認證信息auth（獲取認證的字段要與前臺約定）
    沒有auth是遊客，返回None
    有auth進行校驗
    	失敗是非法用戶，拋出異常
    	成功是合法用戶，返回 (用戶, 認證信息)
    """
    def authenticate(self, request):
        # 前臺在請求頭攜帶認證信息，
        #       且默認規範用 Authorization 字段攜帶認證信息，
        #       後臺固定在請求對象的META字段中 HTTP_AUTHORIZATION 獲取
        auth = request.META.get('HTTP_AUTHORIZATION', None)

        # 處理遊客
        if auth is None:
            return None

        # 設置一下認證字段小規則(兩段式)："auth 認證字符串"
        auth_list = auth.split()

        # 校驗合法仍是非法用戶
        if not (len(auth_list) == 2 and auth_list[0].lower() == 'auth'):
            raise AuthenticationFailed('認證信息有誤，非法用戶')

        # 合法的用戶還須要從auth_list[1]中解析出來
        # 注：假設一種狀況，信息爲abc.123.xyz，就能夠解析出admin用戶；實際開發，該邏輯必定是校驗用戶的正常邏輯
        if auth_list[1] != 'abc.123.xyz':  # 校驗失敗
            raise AuthenticationFailed('用戶校驗失敗，非法用戶')

        user = models.User.objects.filter(username='admin').first()

        if not user:
            raise AuthenticationFailed('用戶數據有誤，非法用戶')
        return (user, None)

權限組件

系統權限類源碼

"""
1）AllowAny：
	認證規則所有返還True：return True
		遊客與登錄用戶都有全部權限

2) IsAuthenticated：
	認證規則必須有登錄的合法用戶：return bool(request.user and request.user.is_authenticated)
		遊客沒有任何權限，登錄用戶纔有權限
	
3) IsAdminUser：
	認證規則必須是後臺管理用戶：return bool(request.user and request.user.is_staff)
		遊客沒有任何權限，登錄用戶纔有權限

4) IsAuthenticatedOrReadOnly
	認證規則必須是隻讀請求或是合法用戶：
		return bool(
            request.method in SAFE_METHODS or
            request.user and
            request.user.is_authenticated
        )
        遊客只讀，合法用戶無限制
"""

# api/views.py
from rest_framework.permissions import IsAuthenticated
class TestAuthenticatedAPIView(APIView):
    permission_classes = [IsAuthenticated]
    def get(self, request, *args, **kwargs):
        return APIResponse(0, 'test 登陸才能訪問的接口 ok')
    
    
# 由於默認全局配置的權限類是AllowAny
# settings.py
REST_FRAMEWORK = {
    # 權限類配置
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.AllowAny',
    ],
}

自定義權限類

"""
1) 建立繼承BasePermission的權限類
2) 實現has_permission方法
3) 實現體根據權限規則 肯定有無權限
4) 進行全局或局部配置

認證規則
i.知足設置的用戶條件，表明有權限，返回True
ii.不知足設置的用戶條件，表明有權限，返回False
"""

# utils/permissions.py
from rest_framework.permissions import BasePermission
from django.contrib.auth.models import Group
class MyPermission(BasePermission):
    def has_permission(self, request, view):
        # 只讀接口判斷
        r1 = request.method in ('GET', 'HEAD', 'OPTIONS')
        # group爲有權限的分組
        group = Group.objects.filter(name='管理員').first()
        # groups爲當前用戶所屬的全部分組
        groups = request.user.groups.all()
        r2 = group and groups
        r3 = group in groups
        # 讀接口你們都有權限，寫接口必須爲指定分組下的登錄用戶
        return r1 or (r2 and r3)
    
    
# 遊客只讀，登陸用戶只讀，只有登陸用戶屬於 管理員 分組，才能夠增刪改
from utils.permissions import MyPermission
class TestAdminOrReadOnlyAPIView(APIView):
    permission_classes = [MyPermission]
	# 全部用戶均可以訪問
    def get(self, request, *args, **kwargs):
        return APIResponse(0, '自定義讀 OK')
	# 必須是 自定義「管理員」分組 下的用戶
    def post(self, request, *args, **kwargs):
        return APIResponse(0, '自定義寫 OK')

頻率組件

頻率類源碼

入口

# 1）APIView的dispath方法中的 self.initial(request, *args, **kwargs) 點進去
# 2）self.check_throttles(request) 進行頻率認證

# 頻率組件核心源碼分析
def check_throttles(self, request):
    throttle_durations = []
    # 1）遍歷配置的頻率認證類，初始化獲得一個個頻率認證類對象（會調用頻率認證類的 __init__() 方法）
    # 2）頻率認證類對象調用 allow_request 方法，判斷是否限次（沒有限次可訪問，限次不可訪問）
    # 3）頻率認證類對象在限次後，調用 wait 方法，獲取還需等待多長時間能夠進行下一次訪問
    # 注：頻率認證類都是繼承 SimpleRateThrottle 類
    for throttle in self.get_throttles():
        if not throttle.allow_request(request, self):
            # 只要頻率限制了，allow_request 返回False了，纔會調用wait
            throttle_durations.append(throttle.wait())

            if throttle_durations:
                # Filter out `None` values which may happen in case of config / rate
                # changes, see #1438
                durations = [
                    duration for duration in throttle_durations
                    if duration is not None
                ]

                duration = max(durations, default=None)
                self.throttled(request, duration)

自定義頻率類

# 1) 自定義一個繼承 SimpleRateThrottle 類 的頻率類
# 2) 設置一個 scope 類屬性，屬性值爲任意見名知意的字符串
# 3) 在settings配置文件中，配置drf的DEFAULT_THROTTLE_RATES，格式爲 {scope字符串: '次數/時間'}
# 4) 在自定義頻率類中重寫 get_cache_key 方法
	# 限制的對象返回 與限制信息有關的字符串
    # 不限制的對象返回 None (只能放回None，不能是False或是''等)

短信接口 1/min 頻率限制

頻率：api/throttles.py

from rest_framework.throttling import SimpleRateThrottle

class SMSRateThrottle(SimpleRateThrottle):
    scope = 'sms'

    # 只對提交手機號的get方法進行限制
    def get_cache_key(self, request, view):
        mobile = request.query_params.get('mobile')
        # 沒有手機號，就不作頻率限制
        if not mobile:
            return None
        # 返回能夠根據手機號動態變化，且不易重複的字符串，做爲操做緩存的key
        return 'throttle_%(scope)s_%(ident)s' % {'scope': self.scope, 'ident': mobile}

配置：settings.py

# drf配置
REST_FRAMEWORK = {
    # 頻率限制條件配置
    'DEFAULT_THROTTLE_RATES': {
        'sms': '1/min'
    },
}

視圖：views.py

# drf配置
REST_FRAMEWORK = {
    # 頻率限制條件配置
    'DEFAULT_THROTTLE_RATES': {
        'sms': '1/min'
    },
}

路由：api/url.py

url(r'^sms/$', views.TestSMSAPIView.as_view()),

限制的接口

# 只會對 /api/sms/?mobile=具體手機號 接口才會有頻率限制
# 1）對 /api/sms/ 或其餘接口發送無限制
# 2）對數據包提交mobile的/api/sms/接口無限制
# 3）對不是mobile（如phone）字段提交的電話接口無限制