Django-DRF(1)

時間 2019-11-09

標籤 django drf 欄目 Python 简体版

原文原文鏈接

一. WEB應用模式

　　在開發Web應用中，有兩種應用模式：html

　　1. 先後端不分離

　　2. 先後端分離

二. API接口

　　爲了在團隊內部造成共識、防止我的習慣差別引發的混亂，咱們須要找到一種你們都以爲很好的接口實現規範，並且這種規範可以讓後端寫的接口，用途一目瞭然，減小雙方之間的合做成本。前端

　　目前市面上大部分公司開發人員使用的接口服務架構主要有：restful、rpc。python

　　1. rpc

　　rpc: 翻譯成中文:遠程過程調用[遠程服務調用].mysql

　　http://www.luffy.com/apigit

　　post請求github

　　action=get_all_student&params=301&sex=1web

　　接口多了,對應函數名和參數就多了,前端在請求api接口時,就會比較難找.容易出現重複的接口sql

　　2. restful

　　restful: 翻譯成中文: 資源狀態轉換.數據庫

　　把後端全部的數據/文件都當作資源. django

　　那麼接口請求數據,本質上來講就是對資源的操做了.

　　web項目中操做資源,無非就是增刪查改.因此要求在地址欄中聲明要操做的資源是什麼,而後經過http請求動詞來講明對資源進行哪種操做.

　　POST http://www.luffy.com/api/students/ 添加學生數據

　　GET http://www.luffy.com/api/students/ 獲取全部學生

　　DELETE http://www.luffy.com/api/students/<pk> 刪除1個學生

三. RESTful API規範

　　REST全稱是Representational State Transfer，中文意思是表述（編者注：一般譯爲表徵）性狀態轉移。它首次出如今2000年Roy Fielding的博士論文中。

　　RESTful是一種定義Web API接口的設計風格，尤爲適用於先後端分離的應用模式中。

　　這種風格的理念認爲後端開發任務就是提供數據的，對外提供的是數據資源的訪問接口，因此在定義接口時，客戶端訪問的URL路徑就表示這種要操做的數據資源。而對於數據資源分別使用POST、DELETE、GET、UPDATE等請求動做來表達對數據的增刪查改。

　　事實上，咱們可使用任何一個框架均可以實現符合restful規範的API接口。

　　參考文檔：http://www.runoob.com/w3cnote/restful-architecture.html

四. 序列化

　　api接口開發，最核心最多見的一個過程就是序列化，所謂序列化就是把數據轉換格式。

　　序列化能夠分兩個階段：

　　序列化

　　把咱們識別的數據轉換成指定的格式提供給別人。

　　例如：咱們在django中獲取到的數據默認是模型對象，可是模型對象數據沒法直接提供給前端或別的平臺使用，因此咱們須要把數據進行序列化，變成字符串或者json數據，提供給別人。

　　反序列化

　　把別人提供的數據轉換/還原成咱們須要的格式。

　　例如：前端js提供過來的json數據，對於python而言就是字符串，咱們須要進行反序列化換成模型類對象，這樣咱們才能把數據保存到數據庫中。

五. Django Rest_Framework

　　核心思想: 縮減編寫api接口的代碼

　　Django REST framework是一個創建在Django基礎之上的Web 應用開發框架，能夠快速的開發REST API接口應用。

　　在REST framework中，提供了序列化器Serializer的定義，能夠幫助咱們簡化序列化與反序列化的過程，不只如此，還提供豐富的類視圖、擴展類、視圖集來簡化視圖的編寫工做。

　　REST framework提供了認證、權限、限流、過濾、分頁、接口文檔等功能支持。

　　REST framework提供了一個API 的Web可視化界面來方便查看測試接口。

　　中文文檔：https://q1mi.github.io/Django-REST-framework-documentation/#django-rest-framework

　　github: https://github.com/encode/django-rest-framework/tree/master

　　特色:

- 提供了定義序列化器Serializer的方法，能夠快速根據 Django ORM 或者其它庫自動序列化/反序列化；
- 提供了豐富的類視圖、Mixin擴展類，簡化視圖的編寫；
- 豐富的定製層級：函數視圖、類視圖、視圖集合到自動生成 API，知足各類須要；
- 多種身份認證和權限認證方式的支持；[jwt]
- 內置了限流系統；
- 直觀的 API web 界面；
- 可擴展性，插件豐富

六. 環境安裝與配置

　　DRF須要如下依賴：

Python (2.7, 3.2, 3.3, 3.4, 3.5, 3.6)
Django (1.10, 1.11, 2.0)

　　DRF是以Django擴展應用的方式提供的，因此咱們能夠直接利用已有的Django環境而無需重新建立。（若沒有Django環境，須要先建立環境安裝Django）

　　1. 安裝DRF

　　前提是已經安裝了django，建議安裝在虛擬環境。虛擬環境參考地址

# 注意：切換到對應目錄下執行
# mkvirtualenv drfdemo -p python3
# pip install django

pip install djangorestframework
pip install pymysql

　　2. 建立一個Django項目

django-admin startproject drfdemo

　　使用pycharm打開項目，設置虛擬環境的解釋器。

　　3. 添加rest_framework應用

　　在settings.py的INSTALLED_APPS中添加'rest_framework'。

INSTALLED_APPS = [
    ...
    'rest_framework',
]

　　接下來就可使用DRF提供的功能進行api接口開發了。在項目中若是使用rest_framework框架實現API接口，主要有如下三個步驟：

將請求的數據（如JSON格式）轉換爲模型類對象
操做數據庫
將模型類對象轉換爲響應的數據（如JSON格式）

　　接下來，咱們快速體驗下四天後咱們學習完成drf之後的開發代碼。接下來代碼不須要理解，看步驟。

　　4. 體驗DRF徹底簡寫代碼的過程

　　1. 建立模型類（此時項目尚未app，自行建立）

class Student(models.Model):
    # 模型字段
    name = models.CharField(max_length=100,verbose_name="姓名")
    sex = models.BooleanField(default=1,verbose_name="性別")
    age = models.IntegerField(verbose_name="年齡")
    class_null = models.CharField(max_length=5,verbose_name="班級編號")
    description = models.TextField(max_length=1000,verbose_name="個性簽名")

    class Meta:
        db_table="tb_student"
        verbose_name = "學生"
        verbose_name_plural = verbose_name

　　回憶以前所學的Django使用MySQL數據庫的步驟執行。

　　2. 建立序列化器

　　例如，咱們在django項目中建立學生子應用。

python3 manage.py startapp students

　　在syudents應用目錄中新建serializers.py用於保存該應用的序列化器。

　　建立一個StudentModelSerializer用於序列化與反序列化。

from rest_framework import serializers
from students.models import Student


# 建立序列化器類，回頭會在視圖中被調用
class StudentModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = Student
        fields = "__all__"
        # fields = ("id", "name")  # 也可指定字段

model 指明該序列化器處理的數據字段從模型類Student參考生成
fields 指明該序列化器包含模型類中的哪些字段，'all'指明包含全部字段

　　3. 編寫視圖

　　在students應用的views.py中建立視圖StudentViewSet，這是一個視圖集合。

from rest_framework.viewsets import ModelViewSet
from students.models import Student
from students.serializers import StuentModelSerializer


class StuentAPIView(ModelViewSet):
    queryset = Student.objects.all()
    serializer_class = StuentModelSerializer

queryset 指明該視圖集在查詢數據時使用的查詢集
serializer_class 指明該視圖在進行序列化或反序列化時使用的序列化器

　　4. 定義路由

　　在students應用的urls.py中定義路由信息。

from rest_framework.routers import DefaultRouter
from students import views

urlpatterns = []  # 路由列表

router = DefaultRouter()  # 能夠處理視圖的路由器

router.register('student', views.StuentAPIView)  # url進行註冊

urlpatterns += router.urls  # 將路由器中的全部路由信息追加到django的路由列表中

　　最後把students子應用中的路由文件加載到總路由文件中.

urlpatterns = [
    path('admin/', admin.site.urls),
    path('drf/', include("students.urls")),
]

　　5. 運行測試

　　運行當前程序（與運行Django同樣）

python3 manage.py runserver

　　在瀏覽器中輸入網址: 127.0.0.1:8000/drf/，能夠看到DRF提供的API Web瀏覽頁面：

　　在瀏覽器中輸入網址: 127.0.0.1:8000/drf/student/ 能夠訪問獲取全部數據的接口，呈現以下頁面：

　　在瀏覽器中輸入網址127.0.0.1:8000/drf/student/2/，能夠訪問獲取單一學生信息的接口（id爲2的學生），呈現以下頁面：

　　在頁面底部表單中填寫學生信息，能夠訪問修改學生的接口：

　　點擊PUT，返回以下頁面信息：

　　點擊DELETE按鈕，能夠訪問刪除學生的接口：

七. 序列化器-Serializer

　　做用：

　　　　1. 序列化,序列化器會把模型對象轉換成字典,通過response之後變成json字符串
　　　　2. 反序列化,把客戶端發送過來的數據,通過request之後變成字典,序列化器能夠把字典轉成模型
　　　　3. 反序列化,完成數據校驗功能

　　1. 定義序列化器

　　Django REST framework中的Serializer使用類來定義，須繼承自rest_framework.serializers.Serializer。

　　接下來，爲了方便演示序列化器的使用，咱們先建立一個新的子應用ser

python manage.py startapp ser

　　咱們仍是繼續使用student下的模型類。

　　下面咱們爲這個模型類提供一個序列化器，能夠定義以下：

from rest_framework import serializers

# 全部的自定義序列化器必須直接或間接繼承於 serializers.Serializer
class StudentSerializer(serializers.Serializer):
    # 聲明序列化器
    # 1. 字段聲明[ 要轉換的字段，固然，若是寫了第二部分代碼，有時候也能夠不用寫字段聲明 ]
    id = serializers.IntegerField()
    name = serializers.CharField()
    sex = serializers.BooleanField()
    age = serializers.IntegerField()
    class_null = serializers.CharField()
    description = serializers.CharField()

    # 2. 可選[ 若是序列化器繼承的是ModelSerializer，則須要聲明對應的模型和字段, ModelSerializer是Serializer的子類 ]

    # 3. 可選[ 用於對客戶端提交的數據進行驗證 ]

    # 4. 可選[ 用於把經過驗證的數據進行數據庫操做，保存到數據庫 ]

　　注意：serializer不是隻能爲數據庫模型類定義，也能夠爲非數據庫模型類的數據定義。serializer是獨立於數據庫以外的存在。

　　經常使用字段類型：

字段	字段構造方式
BooleanField	BooleanField()
NullBooleanField	NullBooleanField()
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(maxlength=50, min_length=None, allow_blank=False) 正則字段，驗證正則模式 [a-zA-Z0-9-]+
URLField	URLField(max_length=200, min_length=None, allow_blank=False)
UUIDField	UUIDField(format='hex_verbose') format: 1)'hex_verbose'如"5ce0e9a5-5ffa-654b-cee0-1238041fb31a" 2）'hex' 如 "5ce0e9a55ffa654bcee01238041fb31a" 3）'int' 如:"123456789012312313134124512351145145114" 4）'urn' 如:"urn:uuid:5ce0e9a5-5ffa-654b-cee0-1238041fb31a"
IPAddressField	IPAddressField(protocol='both', unpack_ipv4=False, **options)
IntegerField	IntegerField(max_value=None, min_value=None)
FloatField	FloatField(max_value=None, min_value=None)
DecimalField	DecimalField(max_digits, decimal_places, coerce_to_string=None, max_value=None, min_value=None) max_digits: 最多位數 decimal_palces: 小數點位置
DateTimeField	DateTimeField(format=api_settings.DATETIME_FORMAT, input_formats=None)
DateField	DateField(format=api_settings.DATE_FORMAT, input_formats=None)
TimeField	TimeField(format=api_settings.TIME_FORMAT, input_formats=None)
DurationField	DurationField()
ChoiceField	ChoiceField(choices) choices與Django的用法相同
MultipleChoiceField	MultipleChoiceField(choices)
FileField	FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
ImageField	ImageField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
ListField	ListField(child=, min_length=None, max_length=None)
DictField	DictField(child=)

　　選項參數：

參數名稱	做用
max_length	最大長度
min_lenght	最小長度
allow_blank	是否容許爲空
trim_whitespace	是否截斷空白字符
max_value	最大值
min_value	最小值

　　通用參數：

參數名稱	說明
read_only	代表該字段僅用於序列化輸出，默認False
write_only	代表該字段僅用於反序列化輸入，默認False
required	代表該字段在反序列化時必須輸入，默認True
default	反序列化時使用的默認值
allow_null	代表該字段是否容許傳入None，默認False
validators	該字段使用的驗證器
error_messages	包含錯誤編號與錯誤信息的字典
label	用於HTML展現API頁面時，顯示的字段名稱
help_text	用於HTML展現API頁面時，顯示的字段幫助提示信息

　　2. 建立Serializer對象

　　定義好Serializer類後，就能夠建立Serializer對象了。

　　Serializer的構造方法爲：

Serializer(instance=None, data=empty, **kwarg)

　　說明：

　　　　1）用於序列化時，將模型類對象傳入instance參數

　　　　2）用於反序列化時，將要被反序列化的數據傳入data參數

　　　　3）除了instance和data參數外，在構造Serializer對象時，還可經過context參數額外添加數據，如

serializer = StudentSerializer(student, context={'request': request})

　　　　經過context參數附加的數據，能夠經過Serializer對象的context屬性獲取。

　　聲明：

使用序列化器的時候必定要注意，序列化器聲明瞭之後，不會自動執行，須要咱們在視圖中進行調用才能夠。
序列化器沒法直接接收數據，須要咱們在視圖中建立序列化器對象時把使用的數據傳遞過來。
序列化器的字段聲明相似於咱們前面使用過的表單系統。
開發restful api時，序列化器會幫咱們把模型數據轉換成字典.
drf提供的視圖會幫咱們把字典轉換成json,或者把客戶端發送過來的數據轉換字典.

　　3. 序列化器的使用

　　序列化器的使用分兩個階段：

在客戶端請求時，使用序列化器能夠完成對數據的反序列化。
在服務器響應時，使用序列化器能夠完成對數據的序列化。

　　3.1 序列化

　　　　總路由中的urls.py:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('drf/', include("students.urls")),
    path('ser/', include("ser.urls")),
]

　　　　ser應用下的urls.py文件：

from django.urls import path, re_path
from . import views

urlpatterns = [
    re_path(r"^student/(?P<pk>\d+)/$", views.Student1View.as_view()),
]

　　　　ser應用下的views.py文件：

from django.http import JsonResponse
from django.views import View
from students.models import Student
from .serializers import StudentSerializer


class Student1View(View):
    """使用序列化器進行數據的序列化操做"""
    """序列化器轉換一條數據[模型轉換成字典]"""
    def get(self, request, pk):
        # 接收客戶端傳過來的參數，進行過濾查詢，先查出學生對象
        student = Student.objects.get(pk=pk)
        # 轉換數據類型
        # 1.實例化序列化器類
        """
            StudentSerializer(instance=模型對象或者模型列表，客戶端提交的數據，額外要傳遞到序列化器中使用的數據)
        """
        serializer = StudentSerializer(instance=student)

        # 2.查看序列化器的轉換結果
        print(serializer.data)
        return JsonResponse(serializer.data)

　　　　若是要被序列化的是包含多條數據的查詢集QuerySet，能夠經過添加many=True參數補充說明。代碼以下：

　　　　ser應用下的urls.py文件：

from django.urls import path, re_path
from . import views

urlpatterns = [
    path("students/", views.Student2View.as_view()),
    re_path(r"^student/(?P<pk>\d+)/$", views.Student1View.as_view()),
]

　　　　ser應用下的views.py文件：

class Student2View(View):
    """序列化器轉換多條數據[模型轉換成字典]"""
    def get(self, request):
        student_list = Student.objects.all()
        # 序列化器轉換多個數據
        # many=True 表示本次序列化器轉換若是有多個模型對象列參數，則必須聲明 Many=True
        serializer = StudentSerializer(instance=student_list, many=True)

        print(serializer.data)
        return JsonResponse(serializer.data)

　　3.2.1 反序列化-數據校驗

　　使用序列化器進行反序列化時，須要對數據進行驗證後，才能獲取驗證成功的數據或保存成模型類對象。

　　在獲取反序列化的數據前，必須調用is_valid()方法進行驗證，驗證成功返回True，不然返回False。

- 驗證失敗，能夠經過序列化器對象的errors屬性獲取錯誤信息，返回字典，包含了字段和字段的錯誤。is_valid()方法還能夠在驗證失敗時拋出異常serializers.ValidationError，能夠經過傳遞raise_exception=True參數開啓。
- 驗證成功，能夠經過序列化器對象的validated_data屬性獲取數據。

　　在定義序列化器時，指明每一個字段的序列化類型和選項參數，自己就是一種驗證行爲。

　　ser應用下的serializers.py文件：

"""
  在drf中，對於客戶端提供的數據，每每須要驗證數據的有效性，這部分代碼是寫在序列化器中的。
  在序列化器中，已經提供三個地方給咱們針對客戶端提交的數據進行驗證。
  1. 內置選項，字段聲明的小圓括號中，以選項存在做爲驗證提交
  2. 自定義方法，在序列化器中做爲對象方法來提供驗證[ 這部分驗證的方法，必須以"validate_<字段>" 或者 "validate" 做爲方法名 ]
  3. 自定義函數，在序列化器外部，提早聲明一個驗證代碼，而後在字段聲明的小圓括號中，經過 "validators=[驗證函數１,驗證函數２...]"
"""

def check_user(data):
    if data == "oldboy":
        raise serializers.ValidationError("用戶名不能爲oldboy！")
    return data

class Student3Serializer(serializers.Serializer):
    # 聲明序列化器
    # 1. 字段聲明[ 要轉換的字段，固然，若是寫了第二部分代碼，有時候也能夠不用寫字段聲明 ]
    name = serializers.CharField(max_length=10, min_length=4, validators=[check_user])
    sex = serializers.BooleanField(required=True)
    age = serializers.IntegerField(max_value=150, min_value=0)

    # 2. 可選[ 若是序列化器繼承的是ModelSerializer，則須要聲明對應的模型和字段, ModelSerializer是Serializer的子類 ]

    # 3. 可選[ 用於對客戶端提交的數據進行驗證 ]
    """驗證單個字段值的合法性"""
    def validate_name(self, data):
        if data == "root":
            raise serializers.ValidationError("用戶名不能爲root！")
        return data

    def validate_age(self, data):
        if data < 18:
            raise serializers.ValidationError("年齡不能小於18")
        return data

    """驗證多個字段值的合法性"""
    def validate(self, attrs):
        name = attrs.get('name')
        age = attrs.get('age')

        if name == "alex" and age == 22:
            raise serializers.ValidationError("alex在22時的故事。。。")

        return attrs

　　ser應用下的urls.py文件：

urlpatterns = [
    path("students/", views.Student2View.as_view()),
    re_path(r"^student/(?P<pk>\d+)/$", views.Student1View.as_view()),
    # 對數據提交時，進行校驗
    path('student3/', views.Student3View.as_view()),
]

　　ser應用下的views.py文件：

class Student3View(View):

    def post(self, request):
        data = request.body.decode()
        # 反序列化用戶提交的數據
        data_dict = json.loads(data)
        print(data_dict)

        # 調用序列化器進行實例化

        serializer = Student3Serializer(data=data_dict)

        # is_valid在執行的時候，會自動前後調用 字段的內置選項,自定義驗證方法，自定義驗證函數
        # 調用序列化器中寫好的驗證代碼
        # raise_exception=True 拋出驗證錯誤信息，並阻止代碼繼續日後運行
        # 驗證結果
        print(serializer.is_valid(raise_exception=True))

        # 獲取驗證後的錯誤信息
        print(serializer.errors)

        # 獲取驗證後的客戶端提交的數據
        print(serializer.validated_data)

        # return HttpResponse(serializer.validated_data)
        return JsonResponse(serializer.validated_data)

　　3.2.2 反序列化-保存數據

　　前面的驗證數據成功後,咱們可使用序列化器來完成數據反序列化的過程.這個過程能夠把數據轉成模型類對象.

　　能夠經過在序列化器中實現create()和update()兩個方法來實現。

class Student3Serializer(serializers.Serializer):
    # 聲明序列化器
    # 1. 字段聲明[ 要轉換的字段，固然，若是寫了第二部分代碼，有時候也能夠不用寫字段聲明 ]
    name = serializers.CharField(max_length=10, min_length=4, validators=[check_user])
    sex = serializers.BooleanField(required=True)
    age = serializers.IntegerField(max_value=150, min_value=0)

    # 2. 可選[ 若是序列化器繼承的是ModelSerializer，則須要聲明對應的模型和字段, ModelSerializer是Serializer的子類 ]

    # 3. 可選[ 用於對客戶端提交的數據進行驗證 ]
    """驗證單個字段值的合法性"""
    def validate_name(self, data):
        if data == "root":
            raise serializers.ValidationError("用戶名不能爲root！")
        return data

    def validate_age(self, data):
        if data < 18:
            raise serializers.ValidationError("年齡不能小於18")
        return data

    """驗證多個字段值的合法性"""
    def validate(self, attrs):
        name = attrs.get('name')
        age = attrs.get('age')

        if name == "alex" and age == 22:
            raise serializers.ValidationError("alex在22時的故事。。。")

        return attrs


    # 4. 可選[ 用於把經過驗證的數據進行數據庫操做，保存到數據庫 ]
    def create(self, validated_data):
        """接受客戶端提交的新增數據"""
        name = validated_data.get('name')
        age = validated_data.get('age')
        sex = validated_data.get('sex')
        instance = Student.objects.create(name=name, age=age, sex=sex)
        # instance = Student.objects.create(**validated_data)
        print(instance)
        return instance

    def update(self, instance, validated_data):
        """用於在反序列化中對於驗證完成的數據進行保存更新"""
        name = validated_data.get('name')
        age = validated_data.get('age')
        sex = validated_data.get('sex')
        instance.name = name
        instance.age = age
        instance.sex = sex

        instance.save()

        return instance

　　實現了上述兩個方法後，在反序列化數據的時候，就能夠經過save()方法返回一個數據對象實例了

　　ser應用下views.py文件：

class Student3View(View):

    def post(self, request):
        data = request.body.decode()
        # 反序列化用戶提交的數據
        data_dict = json.loads(data)
        print(data_dict)

        # 調用序列化器進行實例化

        serializer = Student3Serializer(data=data_dict)

        # is_valid在執行的時候，會自動前後調用 字段的內置選項,自定義驗證方法，自定義驗證函數
        # 調用序列化器中寫好的驗證代碼
        # raise_exception=True 拋出驗證錯誤信息，並阻止代碼繼續日後運行
        # 驗證結果
        print(serializer.is_valid(raise_exception=True))

        # 獲取驗證後的錯誤信息
        print(serializer.errors)

        # 獲取驗證後的客戶端提交的數據
        print(serializer.validated_data)

        # save 表示讓序列化器開始執行反序列化代碼。create和update的代碼
        serializer.save()
        # return HttpResponse(serializer.validated_data)
        return JsonResponse(serializer.validated_data)

　　若是建立序列化器對象的時候，沒有傳遞instance實例，則調用save()方法的時候，create()被調用，相反，若是傳遞了instance實例，則調用save()方法的時候，update()被調用。

class Student4View(View):
    def put(self, request, pk):
        data = request.body.decode()
        import json
        data_dict = json.loads(data)

        student_obj = Student.objects.get(pk=pk)
        # 有instance參數，調用save方法，就會調用update方法。
        serializer = Student3Serializer(instance=student_obj, data=data_dict)

        serializer.is_valid(raise_exception=True)

        serializer.save()  # 觸發序列器中的update方法

        return JsonResponse(serializer.validated_data)

　　ser應用下的urls.py文件：

urlpatterns = [
    path("students/", views.Student2View.as_view()),
    re_path(r"^student/(?P<pk>\d+)/$", views.Student1View.as_view()),
    # 對數據提交時，進行校驗
    path('student3/', views.Student3View.as_view()),
    # 反序列化階段
    re_path(r'^student4/(?P<pk>\d+)/$', views.Student4View.as_view()),
]

　　3.3 序列化與反序列化合並使用

"""
開發中每每一個資源的序列化和反序列化階段都是寫在一個序列化器中的
因此咱們能夠把上面的兩個階段合併起來，之後咱們再次寫序列化器，則直接按照如下風格編寫便可。
"""


class Student5Serializer(serializers.Serializer):
    id = serializers.IntegerField(read_only=True)
    name = serializers.CharField(max_length=10, min_length=4, validators=[check_user])
    sex = serializers.BooleanField(required=True)
    age = serializers.IntegerField(max_value=150, min_value=0)
    class_null = serializers.CharField(read_only=True)
    description = serializers.CharField(read_only=True)

    # 2. 可選[ 若是序列化器繼承的是ModelSerializer，則須要聲明對應的模型和字段, ModelSerializer是Serializer的子類 ]

    # 3. 可選[ 用於對客戶端提交的數據進行驗證 ]
    """驗證單個字段值的合法性"""
    def validate_name(self, data):
        if data == "root":
            raise serializers.ValidationError("用戶名不能爲root！")
        return data

    def validate_age(self, data):
        if data < 18:
            raise serializers.ValidationError("年齡不能小於18")
        return data

    """驗證多個字段值的合法性"""
    def validate(self, attrs):
        name = attrs.get('name')
        age = attrs.get('age')

        if name == "alex" and age == 22:
            raise serializers.ValidationError("alex在22時的故事。。。")

        return attrs

    # 4. 可選[ 用於把經過驗證的數據進行數據庫操做，保存到數據庫 ]
    def create(self, validated_data):
        """接受客戶端提交的新增數據"""
        name = validated_data.get('name')
        age = validated_data.get('age')
        sex = validated_data.get('sex')
        instance = Student.objects.create(name=name, age=age, sex=sex)
        # instance = Student.objects.create(**validated_data)
        print(instance)
        return instance

    def update(self, instance, validated_data):
        """用於在反序列化中對於驗證完成的數據進行保存更新"""
        name = validated_data.get('name')
        age = validated_data.get('age')
        sex = validated_data.get('sex')
        instance.name = name
        instance.age = age
        instance.sex = sex

        instance.save()

        return instance

　　在ser應用下urls.py文件：

urlpatterns = [
    path("students/", views.Student2View.as_view()),
    re_path(r"^student/(?P<pk>\d+)/$", views.Student1View.as_view()),
    # 對數據提交時，進行校驗
    path('student3/', views.Student3View.as_view()),
    # 反序列化階段
    re_path(r'^student4/(?P<pk>\d+)/$', views.Student4View.as_view()),
    # 一個序列化器同時實現序列化和反序列化
    path('student5/', views.Student5View.as_view()),
]

　　在ser應用下views.py文件：

class Student5View(View):
    def get(self, request):
        # 獲取全部數據
        student_list = Student.objects.all()
        serializer = Student5Serializer(instance=student_list, many=True)

        return JsonResponse(serializer.data, safe=False)

    def post(self, request):
        data = request.body.decode()
        data_dict = json.loads(data)

        serializer = Student5Serializer(data=data_dict)

        serializer.is_valid(raise_exception=True)

        instance = serializer.save()

        return JsonResponse(serializer.data)

　　3.4 模型類序列化器

　　若是咱們想要使用序列化器對應的是Django的模型類，DRF爲咱們提供了ModelSerializer模型類序列化器來幫助咱們快速建立一個Serializer類。

　　在ser應用下serializers.py文件定義模型類序列化器：

"""
咱們可使用ModelSerializer來完成模型類序列化器的聲明
這種基於ModelSerializer聲明序列化器的方式有三個優點：
1. 能夠直接經過聲明當前序列化器中指定的模型中把字段聲明引用過來
2. ModelSerializer是繼承了Serializer的全部功能和方法，同時還編寫update和create
3. 模型中同一個字段中關於驗證的選項，也會被引用到序列化器中一併做爲選項參與驗證
"""


class StudentModelSerializer(serializers.ModelSerializer):

    class Meta:
        model = Student
        # fields = "__all__"  # 表示引用全部字段
        fields = ["id", "name", "age", "class_null", "is_18"]  # is_18 爲自定製字段，須要在models裏自定義方法。
        # exclude = ["age"]  # 使用exclude能夠明確排除掉哪些字段, 注意不能和fields同時使用。
        # 傳遞額外的參數，爲ModelSerializer添加或修改原有的選項參數
        extra_kwargs = {
            "name": {"max_length": 10, "min_length": 4, "validators": [check_user]},
            "age": {"max_value": 150, "min_value": 0},
        }

    def validate_name(self, data):
        if data == "root":
            raise serializers.ValidationError("用戶名不能爲root！")
        return data

    def validate(self, attrs):
        name = attrs.get('name')
        age = attrs.get('age')

        if name == "alex" and age == 22:
            raise serializers.ValidationError("alex在22時的故事。。。")

        return attrs

　　在ser應用下的urls.py文件：

urlpatterns = [
    path("students/", views.Student2View.as_view()),
    re_path(r"^student/(?P<pk>\d+)/$", views.Student1View.as_view()),
    # 對數據提交時，進行校驗
    path('student3/', views.Student3View.as_view()),
    # 反序列化階段
    re_path(r'^student4/(?P<pk>\d+)/$', views.Student4View.as_view()),
    # 一個序列化器同時實現序列化和反序列化
    path('student5/', views.Student5View.as_view()),
    # 使用模型類序列化器
    path('student6/', views.Student6View.as_view()),
]

　　在ser應用下views.py文件：

class Student6View(View):
    def get(self, request):
        # 獲取全部數據
        student_list = Student.objects.all()

        serializer = StudentModelSerializer(instance=student_list, many=True)

        return JsonResponse(serializer.data, safe=False)

    def post(self, request):
        data = request.body.decode()
        data_dict = json.loads(data)

        serializer = StudentModelSerializer(data=data_dict)

        serializer.is_valid(raise_exception=True)

        serializer.save()

        return JsonResponse(serializer.data)

更多相關文章...

相關標籤/搜索

Python

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。