Django-DRF(1)

一. WEB應用模式

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

　　1. 前后端不分離

　　2. 前后端分離

二. API接口

　　為了在團隊內部形成共識、防止個人習慣差異引起的混亂，我們需要找到一種大家都覺得很好的接口實現規范，而且這種規范能夠讓后端寫的接口，用途一目了然，減少雙方之間的合作成本。

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

　　1. rpc

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

　　http://www.luffy.com/api

　　post請求

　　action=get_all_student&params=301&sex=1

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

　　2. restful

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

　　把后端所有的數據/文件都看成資源.

　　那么接口請求數據,本質上來說就是對資源的操作了.

　　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屬性獲取。

　　聲明：

1. 使用序列化器的時候一定要注意，序列化器聲明了以后，不會自動執行，需要我們在視圖中進行調用才可以。

2. 序列化器無法直接接收數據，需要我們在視圖中創建序列化器對象時把使用的數據傳遞過來。

3. 序列化器的字段聲明類似於我們前面使用過的表單系統。

4. 開發restful api時，序列化器會幫我們把模型數據轉換成字典.

5. drf提供的視圖會幫我們把字典轉換成json,或者把客戶端發送過來的數據轉換字典.

 　　3. 序列化器的使用

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

1. 在客戶端請求時，使用序列化器可以完成對數據的反序列化。

2. 在服務器響應時，使用序列化器可以完成對數據的序列化。

　　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)