Django REST framework API开发
生活随笔
收集整理的這篇文章主要介紹了
Django REST framework API开发
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
REST
介紹
RESTful API 設計
實現API的兩種方式
FBV 視圖函數
urlpatterns = [url(r'^user/$', views.user),url(r'^user/add/$', views.user_add),url(r'^user/edit/(\d+)/$', views.user_edit),url(r'^user/del/(\d+)/$', views.user_del), ]傳統的視圖函數方式，API接口太多，難以維護。
CBV 視圖類
urlpatterns = [url(r'user/$', views.UserView.as_view()), # GET, POSTurl(r'user/(\d+)$', views.UserView.as_view()), # PUT, DELETE ]根據請求方式的不同，執行視圖類中對應的方法。同樣是實現增刪改查，url少一半。這也是面向資源編程的方式，特點是url中都是名詞。
CBV相關知識參考：http://blog.csdn.net/ayhan_huang/article/details/78036501#t11
協議
大神說：API與用戶的通信協議，總是使用HTTPs協議
域名
- http://api.example.com 盡量使用專用的二級域名
- http://www.example.com/api/ 路由分發。如果確定API很簡單，不會有進一步擴展，可以考慮放在主域名下。
對應前后端分離的項目，可以這樣分配：
前端VUE項目使用域名：http://www.example.com
后端API使用域名：http://api.example.com
版本
應該將API的版本號放入URL。
比如：https://www.example.com/api/v1/ v1是版本信息
路徑
路徑又稱”終點”（endpoint），表示API的具體網址。
在RESTful架構中，每個網址代表一種資源（resource），所以網址中不能有動詞，只能有名詞，而且所用的名詞往往與數據庫的表格名對應。一般來說，數據庫中的表都是同種記錄的”集合”（collection），所以API中的名詞也應該使用復數。
舉例來說，有一個API提供動物園（zoo）的信息，還包括各種動物和雇員的信息，則它的路徑應該設計成下面這樣。
- https://api.example.com/v1/zoos
- https://api.example.com/v1/animals
- https://api.example.com/v1/employees
method
- GET ：從服務器取出資源（一項或多項）
- POST ：在服務器新建一個資源
- PUT ：在服務器更新資源（客戶端提供改變后的完整資源，全部更新）
- PATCH ：在服務器更新資源（客戶端提供改變的屬性，局部更新）
- DELETE ：從服務器刪除資源
- HEAD：和GET一樣，只是只返回響應首部，不返回響應體，用于確認資源的信息
- OPTIONS：查詢支持的方法，復雜請求的預檢會用到。
比如：
- GET /zoos：列出所有動物園
- POST /zoos：新建一個動物園
- GET /zoos/ID：獲取某個指定動物園的信息
- PUT /zoos/ID：更新某個指定動物園的信息（提供該動物園的全部信息）
- PATCH /zoos/ID：更新某個指定動物園的信息（提供該動物園的部分信息）
- DELETE /zoos/ID：刪除某個動物園
- GET /zoos/ID/animals：列出某個指定動物園的所有動物
- DELETE /zoos/ID/animals/ID：刪除某個指定動物園的指定動物
狀態碼
HTTP狀態碼負責表示客戶端HTTP請求的返回結果，標記服務端的處理是否正常，通知出現的錯誤等工作。
狀態碼類別
| 1XX | Informational 信息性狀態碼 | 接收的請求正在處理 |
| 2XX | Success 成功狀態碼 | 請求正常處理完畢 |
| 3XX | Redirection 重定向狀態碼 | 需要進行附加操作以完成請求 |
| 4XX | Client Error 客戶端錯誤狀態碼 | 服務器無法處理請求 |
| 5XX | Server Error 服務器錯誤狀態碼 | 服務器處理請求出錯 |
常用狀態碼一覽
- 200 OK：客戶端發來的請求在服務端被正常處理了。
- 201 CREATED - [POST/PUT/PATCH]：用戶新建或修改數據成功。
- 202 Accepted - [*]：表示一個請求已經進入后臺排隊（異步任務）
- 204 NO CONTENT ：請求已成功處理，但響應中不包含響應體。比如 請求方式為[DELETE]時，表示用戶刪除數據成功。
- 206 Partial Content: 服務器成功執行了客戶端的范圍請求。響應中包含由Content-Range首部字段指定范圍的實體內容
- 301 Moved Permanently: 永久性重定向，請求的資源已被分配了新的URI。應該按Location首部字段提示的URI訪問。
- 302 Found, 303 See Other, 307 Temporary Redirect 都是臨時性重定向，請求的資源已被臨時分配了新的URI，希望用戶本次使用新的URI訪問。標準不太統一，每種瀏覽器可能出現不同的情況，了解即可。
- 304 Not Modified: 這個比較特殊，和重定向沒有關系，表示服務器資源未改變，可直接使用客戶端緩存。
- 400 Bad Request：用戶發出的請求報文中存在語法錯誤，需要修改請求內容后再發送。
- 401 Unauthorized - [*]：表示用戶沒有權限（令牌、用戶名、密碼錯誤）。
- 403 Forbidden - [*] 表示用戶得到授權（與401錯誤相對），但是訪問是被禁止的。
- 404 NOT FOUND - [*]：服務器無法找到請求的資源。或者在服務器拒絕請求且不想說明理由時使用
- 406 Not Acceptable - [GET]：用戶請求的格式不可得（比如用戶請求JSON格式，但是只有XML格式）。
- 410 Gone - [GET]：用戶請求的資源被永久刪除，且不會再得到的。
- 422 Unprocesable entity - [POST/PUT/PATCH] 當創建一個對象時，發生一個驗證錯誤。
- 500 INTERNAL SERVER ERROR - [*]：服務器發生錯誤，可能外web應用存在bug。
- 503 Service Unavailable: 服務器正忙
狀態碼有限，可以再約定code，表示更細的狀態：
def get(self, request, *args, **kwargs):res = {'code': 1001, 'error': None}try:print('do something...')except Exception as e:res['error'] = str(e)return JsonResponse(res, status=500)錯誤處理
如果狀態碼是4xx，就應該向用戶返回出錯信息。一般來說，返回的信息中將error作為鍵名，出錯信息作為鍵值即可。
{error: "Invalid API key" }提供error key，顯示詳細錯誤信息
過濾
如果記錄數量很多，服務器不可能都將它們返回給用戶。API應該提供參數，過濾返回結果
- ?limit=1：指定返回記錄的數量
- ?offset=10：指定返回記錄的開始位置
- ?page=2$per_page=10：指定第幾頁，以及每頁的記錄數
- ?sortby=name$order=asc：指定返回結果按照哪個屬性排序，以及排序順序
- ?id=10：指定篩選條件
返回結果
針對不同操作，服務器向用戶返回的結果應該符合以下規范。
- GET /collection：返回資源對象的列表（數組）
- GET /collection/resource：返回單個資源對象
- POST /collection：返回新生成的資源對象
- PUT /collection/resource：返回完整的資源對象
- PATCH /collection/resource：返回完整的資源對象
- DELETE /collection/resource：返回一個空文檔
Hypermedia
RESTful API最好做到Hypermedia，即返回結果中提供鏈接，連向其他API方法，使得用戶不查文檔，也知道下一步應該做什么。
比如，當用戶向api.example.com的根目錄發出請求，會得到這樣一個文檔。
{"link": {"rel": "collection https://www.example.com/zoos","href": "https://api.example.com/zoos","title": "List of zoos","type": "application/vnd.yourformat+json" }}上面代碼表示，文檔中有一個link屬性，用戶讀取這個屬性就知道下一步該調用什么API了。rel表示這個API與當前網址的關系（collection關系，并給出該collection的網址），href表示API的路徑，title表示API的標題，type表示返回類型。
Hypermedia API的設計被稱為HATEOAS。Github的API就是這種設計，訪問api.github.com會得到一個所有可用API的網址列表：
從上面可以看到，如果想獲取當前用戶的信息，應該去訪問api.github.com/user，然后就得到了下面結果：
{"message": "Requires authentication","documentation_url": "https://developer.github.com/v3" }上面代碼表示，服務器給出了提示信息，以及文檔的網址。
Django REST framework
通過Django本身也可以實現API設計，只是相對要麻煩些。Django REST framework基于Django進行了豐富，能更方便的實現API設計。
基本使用
settings
INSTALLED_APPS = [# ...'rest_framework', ]路由
urlpatterns = [url(r'user/$', views.UserView.as_view()), # GET, POSTurl(r'user/(?P<pk>\d+)/$', views.UserView.as_view()), # PUT, DELETE ]視圖
from rest_framework.views import APIView from django.http import JsonResponseclass UsersView(APIView):def dispatch(self, request, *args, **kwargs):"""請求到來之后，首先執行dispatch方法，dispatch方法根據請求方式的不同，反射執行 get/post/put等方法"""return super().dispatch(request, *args, **kwargs)def get(self, request, *args, **kwargs):res = {'code': '10001','data': [], # 字典元素'error': None}# return HttpResponse(json.dumps(res), status=200, content_type='application/json')# 如果是HttpResponse，需要手動json, 并且指定content_typereturn JsonResponse(res, status=200)def post(self, request, *args, **kwargs):passdef put(self, request, *args, **kwargs):pk = kwargs.get('pk') # 獲取url命名分組傳參passdef delete(self, request, *args, **kwargs):pass生命周期
中間件
路由系統
- .as_view() 方法：return csrf_exempt(view)
CBV視圖類
執行dispatch方法
二次封裝request
def initialize_request(self, request, *args, **kwargs):parser_context = self.get_parser_context(request) # return Request(request,parsers=self.get_parsers(), # 解析器authenticators=self.get_authenticators(), # 認證negotiator=self.get_content_negotiator(), # 選擇器parser_context=parser_context # 字典：view和參數)try:
獲取版本，認證，權限，節流
def initial(self, request, *args, **kwargs):"""Runs anything that needs to occur prior to calling the method handler."""self.format_kwarg = self.get_format_suffix(**kwargs)# Perform content negotiation and store the accepted info on the request# 根據用戶請求選擇neg = self.perform_content_negotiation(request)request.accepted_renderer, request.accepted_media_type = neg# Determine the API version, if versioning is in use.# 獲取版本信息，和處理版本的類的對象version, scheme = self.determine_version(request, *args, **kwargs)request.version, request.versioning_scheme = version, scheme# Ensure that the incoming request is permitted# 認證self.perform_authentication(request)# 權限self.check_permissions(request)# 控制訪問次數（每天訪問10次）self.check_throttles(request)根據請求方法反射執行 GET/POST/DELETE…
except:
- 處理異常
返回響應
版本
查看源碼可知，Django REST framework一共支持5種版本控制方式：
- AcceptHeaderVersioning
- URLPathVersioning
- NamespaceVersioning
- HostNameVersioning
- QueryParameterVersioning
導入及使用方式：
from rest_framework.versioning import URLPathVersioningclass TestView(APIView):versioning_class = URLPathVersioning # 指定版本pass版本控制中通用的settings全局配置：
REST_FRAMEWORK = {# 'DEFAULT_VERSION': 'v1', # 默認版本# 'ALLOWED_VERSIONS': ['v1', 'v2'], # 允許的版本 }下面介紹其中兩種比較常用獲取版本的方式。
基于查詢字符串傳參
settings配置
REST_FRAMEWORK = {'VERSION_PARM': 'version' # 配置從URL中獲取值的key }urls配置
urlpatterns = [url(r'test', views.TestView.as_view(), name='test') ]CBV
from rest_framework.views import APIView from rest_framework.response import Response from rest_framework.versioning import QueryParameterVersioningclass TestView(APIView):versioning_class = QueryParameterVersioning # 指定版本def get(self, request, *args, **kwargs):# 獲取版本print(request.version)# 獲取版本管理的類print(request.versioning_scheme)# 反向生成urlreverse_url = request.versioning_scheme.reverse('test', request=request)print(reverse_url)return Response('get xxxxxx')""" 瀏覽器訪問：http://127.0.0.1:8866/test/?version=v1 打印結果： v1 <rest_framework.versioning.QueryParameterVersioning object at 0x0000024779F1A278> http://127.0.0.1:8866/test?version=v1 """url分組傳參
urls
urlpatterns = [url(r'test/(?P<version>[v1|v2]+)/$', views.TestView.as_view(), name='test') ] # 傳參必須是 v1 或 v2CBV
更換 versioning_class 為 URLPathVersioning 即可
from rest_framework.versioning import URLPathVersioningclass TestView(APIView):versioning_class = URLPathVersioning # 指定版本def get(self, request, *args, **kwargs):pass""" 瀏覽器訪問：http://127.0.0.1:8866/test/v2/ """認證
REST framework自帶了認證方式：
- BasicAuthentication # 基本認證
- SessionAuthentication # 基于django request 對象的用戶session
- TokenAuthentication # 基于rest自帶的Token model，
- RemoteUserAuthentication # 基于request 請求頭中的用戶信息
以及它們的基類 BaseAuthentication，通過派生BaseAuthentication 并實現其中的方法，我們可以自定義認證類，下面我們先簡單體會一下
from rest_framework.views import APIView from django.http import JsonResponse from rest_framework.response import Response # 認證相關 from rest_framework.authentication import BaseAuthentication from rest_framework import exceptionsTOKEN_LIST = [ #定義token，稍后我們會隨機生成它'hello','world' ]class CustomAuthentication(BaseAuthentication):"""自定義認證類"""def authenticate(self, request): # 接口約束token = request._request.GET.get('tk')if token in TOKEN_LIST:return ('lena', None)# return None # 支持匿名用戶raise exceptions.AuthenticationFailed('認證失敗') # 不允許匿名用戶，交給dispatch中的異常處理class TestView(APIView):versioning_class = URLPathVersioning # 指定版本authentication_classes = [CustomAuthentication,] # 指定認證方式；def dispatch(self, request, *args, **kwargs):return super().dispatch(request, *args, **kwargs)def get(self, request, *args, **kwargs):passreturn Response('get xxxxxx')# http://127.0.0.1:8866/test/v2/?tk=hello --> 認證成功 # http://127.0.0.1:8866/test/v2/?tk=hello888 --> 認證失敗 HTTP 403 Forbidden （dispatch中異常處理返回值）正經使用
和model關聯起來，根據用戶名實時生成token，用戶登錄成功后，拿著token訪問需要認證的api
創建model表并遷移
from django.db import modelsclass UserInfo(models.Model):username = models.CharField(max_length=32)password = models.CharField(max_length=64)email = models.EmailField()user_type_choices = [(1, '普通用戶'),(2, '版主'),(3, '管理員'),]user_type = models.IntegerField(choices=user_type_choices, default=1)class Token(models.Model):user = models.OneToOneField(to=UserInfo) # 一對一關系token = models.CharField(max_length=64)說明：
新增登陸路由和登錄認證
urls
urlpatterns = [url(r'api/(?P<version>[v1|v2]+)/auth/$', views.AuthView.as_view(), name='auth') # 登錄認證 ]CBV登錄認證
def generate_token(username):"""根據用戶名和時間，進行MD5值"""import timeimport hashlibmd5 = hashlib.md5(username.encode('utf-8'))md5.update(str(time.time()).encode('utf-8'))return md5.hexdigest()class AuthView(APIView):def post(self, request, *args, **kwargs):res = {'code': 1000, # code: 1000 登錄成功；1001登錄失敗'msg': None, # 錯誤信息'token': None}username = request._request.POST.get('username') pwd = request._request.POST.get('pwd')print('usernaem:',username)print('pwd:',pwd)user_obj = models.UserInfo.objects.filter(username=username, password=pwd).first()if user_obj:# 如果用戶存在，那么生成token并更新token = generate_token(username)models.Token.objects.update_or_create(user=user_obj, defaults={'token': token})res['token'] = tokenelse:res['code'] = 1001res['msg'] = '用戶名或密碼錯誤'return JsonResponse(res)說明：
- 因為是作為api, 只需要post方法即可，登錄頁面由前端處理
- request在dispatch中經過了二測封裝，通過request._request獲取原來的request對象
- 封裝后的request提供了query_params屬性訪問request._request.GET,data屬性訪問request._request.POST
- 更新/創建 token：update_or_create，user=user_obj是篩選條件，存在則用default更新（比如用戶換了登錄設備），不存在則創建；
自定義認證類并給api使用
class CustomAuthentication(BaseAuthentication):def authenticate(self, request):token = request.query_params.get('tk')token_obj = models.Token.objects.filter(token=token).first()if token_obj:# 返回（用戶對象，token對象）return (token_obj.user, token_obj)# return None # 支持匿名用戶raise exceptions.AuthenticationFailed('認證失敗') # 不允許匿名用戶，交給dispatch中的異常處理class TestView(APIView):versioning_class = URLPathVersioning # 指定版本authentication_classes = [CustomAuthentication, ] # 指定認證方式def dispatch(self, request, *args, **kwargs):return super().dispatch(request, *args, **kwargs)def get(self, request, *args, **kwargs):# 認證Ok, 打印用戶信息print(request.user.username)print(request.user.email)return Response('get xxxxxx')""" 認證成功，打印出用戶信息 lena lena@live.com """說明：TestView中之所以能request.user.username，是因為認證類對象執行authenticate方法返回的元組，被賦值給了Request對象：self.user, self.auth = user_auth_tuple
通過requests模塊模擬登錄提交
import requestsapi = 'http://127.0.0.1:8866/api/v1/auth/' response = requests.post(url=api, data={'username': 'lena', 'pwd': '123'}) print(response.text) """ {"code": 1000, "msg": null, "token": "117d16c0b1c9397a0573c28b67dad6f8"} """訪問api，認證成功，收到服務端返回的信息，其中包括token，以后只需要攜帶token就可以訪問需要認證的api
requests模擬訪問api
用之前登錄成功返回的token訪問目標api
api = 'http://127.0.0.1:8866/api/v1/test/' response2 = requests.get(url=api, params={'tk': '117d16c0b1c9397a0573c28b67dad6f8'}) print(response2.text)""" get xxxxxx """認證的幾種配置方式
局部配置
在CBV類中通過authentication_classes = [CustomAuthentication, ]指定，比如上面例子中的做法。
多繼承 – 推薦
并不是所有的api都需要作認證，比如登錄。因此可以通過寫一個基類（指定認證類），讓需要認證的api首先繼承這個基類即可：
# 基類 class Token_auth(APIView):authentication_classes = [CustomAuthentication, ] # 指定認證方式# 需要認證的api 首先繼承基類 class TestView(Token_auth, APIView):versioning_class = URLPathVersioning # 指定版本pass# 不需要認證的api, 不繼承基類 class AuthView(APIView):passsettings全局
在settings中作全局配置，不需要認證的api指定authentication_classes = []為空即可
REST_FRAMEWORK = {'DEFAULT_AUTHENTICATION_CLASSES': [# 自定義認證類路徑'utils.authentication.CustomAuthentication', ] } class AuthView(APIView):authentication_classes = []認證功能源碼剖析
遵循之前的生命周期分析，進入CBV視圖后，流程如下：
dispatch(self, request, *args, **kwargs)
request = self.initialize_request(request, *args, **kwargs) 二次封裝request
return Request(# ...authenticators=self.get_authenticators(), # 為request對象封裝認證類 )def get_authenticators(self):
return [auth() for auth in self.authentication_classes] # 循環認證類列表，并實例化對象self.initial(request, *args, **kwargs) 初始化
self.perform_authentication(request) 執行認證
request.user 調用request對象user方法（@property裝飾）(登錄之后存在request.user 同django默認設計)
self._authenticate()
def _authenticate(self):"""執行每個認證對象的認證方法:一旦異常raise 全部終止，交由dispatch中的異常處理如果返回元組，賦值給request.user, request.auth, 并return 后續不再執行如果既沒有異常，又沒有返回，執行_not_authenticated() 匿名用戶"""for authenticator in self.authenticators:try:user_auth_tuple = authenticator.authenticate(self)except exceptions.APIException:self._not_authenticated()raiseif user_auth_tuple is not None:self._authenticator = authenticatorself.user, self.auth = user_auth_tuplereturnself._not_authenticated()執行自帶認證類或自定義認證類中authenticate方法
class CustomAuthentication(BaseAuthentication):def authenticate(self, request):token = request.query_params.get('tk')token_obj = models.Token.objects.filter(token=token).first()if token_obj:# 返回（用戶對象，token對象）return (token_obj.user, token_obj)# return None # 支持匿名用戶，將執行 self._not_authenticated()raise exceptions.AuthenticationFailed('認證失敗') # 不允許匿名用戶，交給dispatch中的異常處理匿名用戶
def _not_authenticated(self):"""為未認證的請求設置authenticator, user & authtoken默認值分別是 None, AnonymousUser & None，后兩個可以在settings中配置"""self._authenticator = Noneif api_settings.UNAUTHENTICATED_USER: # 默認配置中會使用django內置的AnonymousUser類self.user = api_settings.UNAUTHENTICATED_USER()else:self.user = Noneif api_settings.UNAUTHENTICATED_TOKEN:self.auth = api_settings.UNAUTHENTICATED_TOKEN()else:self.auth = None# 匿名用戶settings相關配置REST_FRAMEWORK = {'UNAUTHENTICATED_USER': None, # 取消匿名用戶'UNAUTHENTICATED_TOKEN': None, }如果認證類的authenticate方法執行了returen None，導致user_auth_tuple為空，進而執行self._not_authenticated()方法時，將默認產生一個匿名用戶。那么request.user非空，而是一個匿名用戶對象。如果希望取消對匿名用戶的支持，就需要在settings中指定'UNAUTHENTICATED_USER': None，來覆蓋默認的匿名用戶配置。
權限
分析了上面的認證后，權限的流程是一摸一樣的，下面我們看一下具體用法
自定義權限類
class CustomPermission(BasePermission):message = '無權限' # 查看源碼可知，可以通過message自定義提示信息def has_permission(self, request, view):"""返回True: 有權限；返回False: 無權限"""method = request._request.methodif request.user.user_type == 1 and isinstance(view, TestView) and method == 'POST': # 限制普通用戶通過post方式訪問TestViewreturn Falsereturn True應用
# 方式一：局部視圖 class TestView(Token_auth, APIView):versioning_class = URLPathVersioning # 指定版本permission_classes = [CustomPermission, ] # 指定權限def dispatch(self, request, *args, **kwargs):return super().dispatch(request, *args, **kwargs)def get(self, request, *args, **kwargs):print(request.user.username)print(request.user.email)return Response('get xxxxxx')def post(self, request, *args, **kwargs):return Response('post xxx')# 方式二：settings全局 REST_FRAMEWORK = {'DEFAULT_PERMISSION_CLASSES': [# path.to.Permissionclass 路徑之間用點分割] }這樣當我們通過get方法訪問TestView時，將得到正常響應，如果是post，那么將得到{"detail":"無權限"}的響應。
請求次數限制
配置
REST_FRAMEWORK = {"DEFAULT_THROTTLE_RATES": {'anon': '5/m'， # scope: rate 匿名用戶: 每分鐘5次'user': '10/m' # 登錄用戶}}自定義訪問控制類
from rest_framework.throttling import SimpleRateThrottle# 根據request.user 判斷匿名不匿名 （在每次進來時認證中賦值了用戶或None）class Custom_anno_control(SimpleRateThrottle):"""匿名用戶控制，用默認get_ident，獲取ip作為標識"""scope = 'anon' # 決定settings中DEFAULT_THROTTLE_RATES 的keydef allow_request(self, request, view):if request.user: # 如果是登錄用戶，不限制return Trueself.key = self.get_cache_key(request, view)print('key=====',self.key)self.history = self.cache.get(self.key, [])self.now = self.timer()while self.history and self.history[-1] <= self.now - self.duration:self.history.pop()if len(self.history) >= self.num_requests:return self.throttle_failure()return self.throttle_success()def get_cache_key(self, request, view):return self.cache_format % {'scope': self.scope,'ident': self.get_ident(request)}class Custom_user_control(SimpleRateThrottle):"""登錄用戶控制，直接用用戶名+CBV視圖類名作為標識"""scope = 'user'def allow_request(self, request, view):if not request.user: # 如果是匿名用戶，不限制return Trueself.key = request.user.username + view.__class__.__name__ # 如果登錄用戶，用用戶名和類名作為標識if self.key is None:return Trueself.history = self.cache.get(self.key, [])self.now = self.timer()while self.history and self.history[-1] <= self.now - self.duration:self.history.pop()if len(self.history) >= self.num_requests:return self.throttle_failure()return self.throttle_success()這里參考源碼稍作修改：
- Custom_anno_control中不限制登錄用戶，Custom_user_control不限制匿名用戶，保證CBV在同時應用二者時，不用關心調用順序。
- Custom_user_control中的key采用用戶名拼接CBV視圖類名，確保訪問次數限制能精確到具體CBV視圖類，而不是所有CBV一共能訪問多少次。
自定義權限
class CustomPermission(BasePermission):message = '無權限' # 查看源碼可知，可以通過message自定義提示信息def has_permission(self, request, view):"""返回True: 有權限；返回False: 無權限"""if not request.user: # 僅允許登錄用戶，限制匿名用戶return Falsereturn TrueCBV中應用
class IndexView(APIView):"""控制登錄用戶訪問頻次：10/m， 匿名用戶訪問頻次5/m"""authentication_classes = [CustomAuthentication, ] # 獲取登錄token和用戶；如果不認證限制，那么無法自動獲取token，都是匿名訪問throttle_classes = [Custom_anno_control, Custom_user_control]# 要同時允許登錄用戶和匿名用戶的訪問并作限制，必須同時指定authentication_classes認證類和throttle_classes訪問控制類：# 如果用戶登錄，那么拿著token，可以訪問配置中指定的次數 'user': '10/m'# 如果用戶未登錄，那么沒有token或者token錯誤，可以訪問配置中指定的數 'anon': '5/m',def get(self, request, *args, **kwargs):return HttpResponse('歡迎訪問首頁')class ShoppingView(APIView):versioning_class = URLPathVersioning # 指定版本authentication_classes = [CustomAuthentication, ] # 認證（認證可能同時允許登錄用戶和匿名用戶）permission_classes = [CustomPermission, ] # 指定權限，這里作二次限制，即便匿名用戶通過了認證，也過不了權限throttle_classes = [Custom_user_control, ] # 限制登錄用戶的訪問次數def dispatch(self, request, *args, **kwargs):return super().dispatch(request, *args, **kwargs)def get(self, request, *args, **kwargs):print(request.user.username)print(request.user.email)return HttpResponse('購物車 訪問')def post(self, request, *args, **kwargs):return HttpResponse('購物車 提交')解析器
根據請求頭中的content-type，對內容進行解析。在執行request.data時觸發。
'DEFAULT_PARSER_CLASSES': ('rest_framework.parsers.JSONParser', # content-type: application/json'rest_framework.parsers.FormParser', # content-type: application/x-www-form-urlencoded'rest_framework.parsers.MultiPartParser' # content-type: multipart/form-data（可以在form中同時上傳數據和文件） ),默認同時支持以上三種解析器（源碼中通過for 循環一一匹配請求頭的content-type），還有一個FileUploadParser （只能上傳文件，雞肋）。如果想配置的話可以在CBV中指定parser_classes=[]，或者在配置中配置，沒啥必要，默認都配置上了，除非你閑的蛋疼。。。
序列化
對于序列化，有兩種方案，一種是將查詢結果通過.value_list('field1', 'field2','xxx')這種方式，返回QuerySet包字典的格式，然后轉化為列表：
queryset = models.UserInfo.objects.all().values_list('id', 'name') res = list(queryset)這種方式有個弊端，無法處理choice，M2M字段的情況。
第二種方案就是這里的序列化類，REST中內置了三種：
- Serializer
- ModelSerializer
- HyperlinkedModelSerializer
作用
- 對數據庫查詢結果進行序列化，返回json數據
- 驗證用戶提交，類似Django中的Form / ModelForm
序列化：
from rest_framework.response import Response # 對于序列化的結果需要用Response對象才能正確返回結果 from rest_framework import serializers from rest_framework.serializers import Serializer from rest_framework.serializers import ModelSerializer from rest_framework.serializers import HyperlinkedModelSerializer# 派生Serializer類 # 兩種方式：Serializer 和 ModelSerializer （相當與Django中的Form和ModelForm） class UserSerializer(Serializer):username = serializers.CharField()password = serializers.CharField()email = serializers.EmailField()user_type = serializers.IntegerField()group = serializers.CharField(source="group.title", required=False) # 通過source指定FK對象的顯示class UserModelSerializer(ModelSerializer):class Meta:model = models.UserInfofields = '__all__'depth = 2# depth = 0 或 1, 只顯示FK的PK, 如果=2，可以顯示FK對象的字段，比如下面的group外鍵;# [{"id":1,"username":"Lena",..."group":{"id":1,"title":"A組"}},# 如果外鍵嵌套很多，depth深度過深可能會影響性能。。# 返回json數據 class SerializerView(APIView):def get(self, request, *args, **kwargs):user_list = models.UserInfo.objects.all()user_obj = models.UserInfo.objects.all().first()ser = UserSerializer(instance=user_list, many=True) # 返回queryset序列化對象時，many=True# ser = UserModelSerializer(instance=user_list, many=True)# ser = UserSerializer(instance=user_obj, many=False) # 返回單個序列化對象時，many=Falsereturn Response(ser.data)定制序列化結果
對于choice字段，外鍵或者多對多等跨表字段，需要自定制
from rest_framework import serializers# 假設CourseDetail 和 Course 表是一對一關系 class CourseDetailSerializer(serializers.ModelSerializer):"""課程詳情"""course_name = serializers.CharField(source='course.name') # O2O跨表recommend_courses = serializers.SerializerMethodField() # 寫一個函數 def get_field(self, obj)，返回的結果就是該字段的結果price_policy = serializers.SerializerMethodField()class Meta:model = models.CourseDetailfields = ['id', 'course_name', 'recommend_courses']def get_recommend_courses(self, obj): # obj指當前表CourseDetail中的一條記錄"""獲取M2M字段的結果"""ret = []recommend_courses_list = obj.recommend_courses.all()for item in recommend_courses_list:ret.append({'id': item.id, 'name': item.name})return retdef get_price_policy(self, obj):"""獲取choice字段的結果"""ret = []price_policy = obj.course.price_policy.all()for item in price_policy:ret.append({'valid_period': item.get_valid_period_display(), 'price': item.price})return ret# 也可以繼承派生字段類型，只需要重寫get_attribute 和 to_representation 方法即可 class MtoMField(serializers.CharField):def get_attribute(self, instance):return instance.objects.values('name','title')def to_representation(self,value):return list(value)class MyField(serializers.CharField):def get_attribute(self, instance):#instance 是數據庫對應的每行數據，即model 實例對象data_list = instance.recommend_courses.all()return data_listdef to_representation(self, value):ret = []for row in value:ret.append({'id': row.id, 'name': row.name})return rethypermedia相關
如果希望序列化的結果包括相關的鏈接關系，那么需要在序列化對象時提供當前的request，這里只需要提供一個上下文參數context即可實現。注意路由需要傳id
urlpatterns = [url(r'test/(?P<pk>\d+)/', views.TestView.as_view(), name='test'), ] class ModelUserSerializer(serializers.ModelSerializer):ut = serializers.HyperlinkedIdentityField(view_name='test')class Meta:model = models.UserInfofields = "__all__"class TestView(APIView):def get(self, request, *args, **kwargs):data_list = models.UserInfo.objects.all()ser = ModelUserSerializer(instance=data_list, many=True, context={'request': request})return Response(ser.data) from rest_framework import serializers from rest_framework.response import Responseclass UserSerialize(serializers.HyperlinkedModelSerializer):class Meta:model = models.UserInfofields = ['user','pwd','id','url']class SerializeView(APIView):def get(self, request, *args, **kwargs):user_list = models.UserInfo.objects.all()ser = UserSerialize(instance=user_list,many=True,context={'request': request})return Response(ser.data)def post(self, request, *args, **kwargs):ser = UserSerialize(data=request.data)if ser.is_valid():print(ser.validated_data)print(request.data)return Response(ser.validated_data)else:return Response(ser.errors)驗證用戶提交
# 自定義驗證類， 在__call__中寫驗證邏輯 class PasswordValidator:def __init__(self):passdef __call__(self, value):if value != '123':raise serializers.ValidationError('密碼必須是123')def set_context(self, serializer_field):pass# 派生Serializer，同樣有兩種方式 # 兩種方式：Serializer 和 ModelSerializer （相當與Django中的Form和ModelForm） class UserSerializer(Serializer):username = serializers.CharField(min_length=6)password = serializers.CharField(validators=[PasswordValidator(),])email = serializers.EmailField()user_type = serializers.IntegerField()group = serializers.CharField(source="group.title", required=False) # 通過source指定FK對象的顯示class UserModelSerializer(ModelSerializer):# username = serializers.CharField(min_length=6) 相當于下面的extra_kwargs# password = serializers.CharField(validators=[PasswordValidator(), ])class Meta:model = models.UserInfofields = '__all__'extra_kwargs = {'username': {'min_length': 6},'password': {'validators: [PasswordValidator(),]'}}class SerializerView(APIView):def post(self, request, *args, **kwargs):ser = UserSerializer(data=request.data)if ser.is_valid():print(ser.validated_data)else:print(ser.errors)return Response('got post .....')post提交數據
api = 'http://127.0.0.1:8899/api/v1/ser/' response = requests.post(url=api, data={'username':'sebastian', 'password':123, 'email':'asb'})通過requests模塊模擬post提交，CBV中打印結果如下：
{'email': ['Enter a valid email address.'], 'user_type': ['This field is required.']}分頁器
PageNumberPagination 頁碼分頁
分頁器類不能直接使用，需要繼承它并指定參數
urlpatterns = [ url(r'api/page/$', views.PageTestView.as_view())] from rest_framework.pagination import PageNumberPagination from rest_framework import serializersclass CustomPagination(PageNumberPagination):# http://api.example.org/accounts/?page=4&page_size=100# 指定客戶端query_param參數：每頁數據大小 和 頁碼page_size_query_param = 'page_size'page_query_param = 'page'# 定制每頁顯示多少條數據(默認為None, 最終取決于請求中的查詢參數) 以及最大值page_size = 10max_page_size = 20class UserSerializer(serializers.ModelSerializer):class Meta:model = models.UserInfofields = "__all__"class PageTestView(APIView):def get(self, request, *args, **kwargs):user_list = models.UserInfo.objects.all()# 實例化分頁對象，并根據請求參數，獲取分頁數據paginator = CustomPagination()page_user_list = paginator.paginate_queryset(user_list, request, view=self)# 序列化分頁數據ser = UserSerializer(instance=page_user_list, many=True)# 獲取分頁響應(可額外生成上一頁/下一頁鏈接)response = paginator.get_paginated_response(ser.data)return response可能會報如下警告，對于無序的數據，分頁器生成的分頁數據可能不一致：
UnorderedObjectListWarning: Pagination may yield inconsistent results with an unordered object_list因此在獲取數據庫數據時，可以做一下排序，這樣就不會報警告了：
user_list = models.UserInfo.objects.all().order_by('id')通過requests模塊對該api發起請求，將得到如下結果：
{"count":2,"next":"http://127.0.0.1:8899/api/page/?page=2&page_size=1","previous":null,"results":[{"id":1,"username":"Lena","password":"123","email":"lena@live.com","user_type":1,"group":1}]}LimitOffsetPagination 位置分頁
class CustomPagination(LimitOffsetPagination):# http://api.example.org/accounts/?offset=400&limit=100limit_query_param = 'limit'offset_query_param = 'offset'max_limit = Nonedefault_limit = 10CursorPagination 游標分頁
對于以上兩種分頁方式，都存在性能問題，頁碼往后翻的越多，速度越慢。即便是offset，每次也要從頭掃描，因此如果每次都能從上一次索引位置繼續的話，就可以解決性能下降的問題。看下面的幾種情況：
select * from tb where dept = 'it' select * from tb where dept = 'it' limit 1 # 性能高加入limit，找到1條就不找了，否則找完整個表，速度自然慢。
select * from tb offset 0 limit 5 select * from tb offset 100 limit 5 select * from tb offset 1000 limit 5 ... select * from tb where id>1000 offset 0 limit 5 # 性能高通過id篩選，跳過前面的，這樣就不用從頭掃描。這就是cursor游標分頁的原理。cursor分頁每一次從上一次索引位置繼續，因此只能上一頁，下一頁，不能直接跳轉頁碼。
class CustomPagination(CursorPagination):# URL傳入的游標參數cursor_query_param = 'cursor'# 默認每頁顯示的數據條數page_size = 1# URL傳入的每頁顯示條數的參數page_size_query_param = 'page_size'# 每頁顯示數據最大條數max_page_size = 1000# 根據ID從大到小排列ordering = "id"通過requests模塊訪問，結果如下
api = 'http://127.0.0.1:8899/api/page/?page_size=1' response = requests.get(url=api) print(response.text) """ {"next":"http://127.0.0.1:8899/api/page/?cursor=cD0x&page_size=1","previous":null,"results":[{"id":1,"username":"Lena","password":"123","email":"lena@live.com","user_type":1,"group":1}]} """可以看到cursor=cD0x是加密，看不到第幾頁，只能一頁頁翻，沒辦法通過指定cursor的值直接翻頁。
路由和視圖
如果要支持url帶后綴，比如.json，那么可以在路由規則后面加\.(?P<format>\w+)$（具體見后面的渲染器部分）。下面通過實現增刪改查視圖，來看看幾種不同路由方式的區別。
增刪改查分別對應幾種不同請求方法：
- GET: 查詢列表
- POST: 增加
- GET: 查詢單條數據（id）
- PUT: 更新（id）
- DELETE: 刪除（id）
手動路由
需要寫兩套路由，以分別支持無id和有id傳參的情況，每套路由還要支持無url后綴和有url后綴的情況，共計4條路由。推薦手動路由，可定制性強。
urlpatterns = [# http: //127.0.0.1:8000/api/router 無id# GET: 查詢（列表）# POST: 增加url(r'api/router/$', views.RouterView.as_view()),url(r'api/router\.(?P<format>\w+)$', views.RouterView.as_view()), # 支持后綴# http: //127.0.0.1:8000/api/router/1 有id# GET: 查詢（單條記錄）# PUT: 更新# DELETE: 刪除url(r'api/router/(?P<pk>\d+)/$', views.RouterView.as_view()),url(r'api/router/(?P<pk>\d+)\.(?P<format>\w+)$', views.RouterView.as_view()), # 支持后綴 ]視圖中手動實現這幾種請求方式：
from rest_framework.serializers import ModelSerializer from rest_framework.views import APIViewclass RouterSerializer(ModelSerializer):class Meta:model = models.UserInfofields = '__all__'class RouterView(APIView):def get(self, request, *args, **kwargs):pk = kwargs.get('pk')if pk:obj = models.UserInfo.objects.filter(pk=pk).first()ser = RouterSerializer(instance=obj, many=False)else:user_list = models.UserInfo.objects.all()ser = RouterSerializer(instance=user_list, many=True)return Response(ser.data)def post(self, request, *args, **kwargs):passdef put(self, request, *args, **kwargs):pk = kwargs.get('pk')passdef delete(self, request, *args, **kwargs):pk = kwargs.get('pk')pass半自動路由
視圖繼承中繼承ModelViewSet，其中提供了增刪改查方法，不過需要在路由中指定。（視圖部分存疑先）
urlpatterns = [url(r'api/router/$', views.RouterView.as_view({'get': 'list', 'post': 'create'})),url(r'api/router/(?P<pk>\d+)/$', views.RouterView.as_view({'get': 'retrieve', 'put': 'update', 'delete': 'destroy'})), ] from rest_framework.serializers import ModelSerializer from rest_framework.viewsets import ModelViewSetclass RouterSerializer(ModelSerializer):class Meta:model = models.UserInfofields = '__all__'class RouterView(ModelViewSet):queryset = models.UserInfo.objects.all()serializer_class = RouterSerializer全自動路由
from django.conf.urls import url,include from app01 import views from rest_framework.routers import DefaultRouter # 自動路由router = DefaultRouter() # 實例化router對象 router.register(r'/XXX/', views.TargetView1) # 將目標視圖注冊到router對象上 router.register(r'/XXY/', views.TargetView2) # 可以注冊多個urlpatterns = [url(r'^', include(router.urls)), # 自動實現增刪改路由 ] from rest_framework.viewsets import ModelViewSet from rest_framework import serializersclass RouteSerializer(serializers.ModelSerializer):class Meta:model = models.UserInfofields = "__all__"class RouteView(ModelViewSet):queryset = models.UserInfo.objects.all()serializer_class = RouteSerializer渲染器
根據 用戶請求URL 或 用戶可接受的類型，篩選出合適的 渲染組件。注意，如果要支持url后綴，路由正則后面必須加\.(?P<format>\w+)。如果同時多個存在時，自動根據URL后綴來選擇渲染器。
urlpatterns = [url(r'test/$', views.RenderTestView.as_view()),url(r'test\.(?P<format>\w+)$', views.RenderTestView.as_view()), # 支持后綴 ]json
用戶請求url
- http://127.0.0.1:8000/test/?format=json
- http://127.0.0.1:8000/test.json
- http://127.0.0.1:8000/test
CBV
from rest_framework.views import APIView from rest_framework.response import Response from rest_framework.pagination import PageNumberPagination from rest_framework import serializers from rest_framework.renderers import JSONRendererclass CustomPagination(PageNumberPagination):passclass RenderTestSerializer(serializers.ModelSerializer):passclass RenderTestView(APIView):renderer_classes = [JSONRenderer, ]def get(self, request, *args, **kwargs):pass表格
以table表友好地呈現 ，好看，沒多大用。
用戶訪問url
- http://127.0.0.1:8000/test/?format=admin
- http://127.0.0.1:8000/test.admin
- http://127.0.0.1:8000/test/
CBV
from rest_framework.renderers import HTMLFormRendererclass RenderTestView(APIView):renderer_classes = [HTMLFormRenderer, ]def get(self, request, *args, **kwargs):passForm表單
form表單，只能返回單個序列化對象，否則報錯，沒暖用。
用戶訪問url
- http://127.0.0.1:8000/test/?format=admin
- http://127.0.0.1:8000/test.admin
- http://127.0.0.1:8000/test/
CBV
from rest_framework.renderers import HTMLFormRendererclass RenderTestView(APIView):renderer_classes = [HTMLFormRenderer, ]def get(self, request, *args, **kwargs):pass瀏覽器格式API+JSON
這種是最常用的
用戶訪問url
- http://127.0.0.1:8000/test/?format=api
- http://127.0.0.1:8000/test.json
- http://127.0.0.1:8000/test/
CBV
from rest_framework.renderers import JSONRenderer from rest_framework.renderers import BrowsableAPIRendererclass RenderTestView(APIView):renderer_classes = [JSONRenderer, BrowsableAPIRenderer, ]def get(self, request, *args, **kwargs):pass總結
以上是生活随笔為你收集整理的Django REST framework API开发的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 性能调优某大型银行的一个系统过程跟踪和记
- 下一篇： Git入门到删库