一 序列化器-Serializer

作用：

1. 序列化,序列化器會把模型物件轉換成字典,經過response以後變成json字串
2. 反序列化,把客戶端傳送過來的資料,經過request以後變成字典,序列化器可以把字典轉成模型
3. 反序列化,完成資料校驗功能

1.1 定義序列化器

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

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

python manage.py startapp sers

我們已有了一個數據庫模型類students/Student

from django.db import models

# Create your models here.
class Student(models.Model):
    # 模型欄位
    name = models.CharField(max_length=100,verbose_name="姓名",help_text="提示文字:賬號不能為空！")
    sex = models.BooleanField(default=True,verbose_name="性別")
    age = models.IntegerField(verbose_name="年齡")
    class_null = models.CharField(max_length=5,verbose_name="班級編號")
    description = models.TextField(verbose_name="個性簽名")

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

我們想為這個模型類提供一個序列化器，可以定義如下：

from rest_framework import serializers

# 宣告序列化器，所有的序列化器都要直接或者間接繼承於 Serializer
# 其中，ModelSerializer是Serializer的子類，ModelSerializer在Serializer的基礎上進行了程式碼簡化
class StudentSerializer(serializers.Serializer):
    """學生資訊序列化器"""
    # 1. 需要進行資料轉換的欄位
    id = serializers.IntegerField()
    name = serializers.CharField()
    age = serializers.IntegerField()
    sex = serializers.BooleanField()
    description = serializers.CharField()

    # 2. 如果序列化器整合的是ModelSerializer，則需要宣告呼叫的模型資訊

    # 3. 驗證程式碼

    # 4. 編寫新增和更新模型的程式碼
 

注意：serializer不是隻能為資料庫模型類定義，也可以為非資料庫模型類的資料定義。serializer是獨立於資料庫之外的存在。

常用欄位型別：

選項引數：

通用引數：

1.2 建立Serializer物件

定義好Serializer類後，就可以建立Serializer物件了。

Serializer的構造方法為：

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

說明：

1）用於序列化時，將模型類物件傳入instance引數

2）用於反序列化時，將要被反序列化的資料傳入data引數

3）除了instance和data引數外，在構造Serializer物件時，還可通過context引數額外新增資料，如

serializer = AccountSerializer(account, context={'request': request})

通過context引數附加的資料，可以通過Serializer物件的context屬性獲取。

1. 使用序列化器的時候一定要注意，序列化器聲明瞭以後，不會自動執行，需要我們在檢視中進行呼叫才可以。
2. 序列化器無法直接接收資料，需要我們在檢視中建立序列化器物件時把使用的資料傳遞過來。
3. 序列化器的欄位宣告類似於我們前面使用過的表單系統。
4. 開發restful api時，序列化器會幫我們把模型資料轉換成字典.
5. drf提供的檢視會幫我們把字典轉換成json,或者把客戶端傳送過來的資料轉換字典.

1.3 序列化器的使用

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

1. 在客戶端請求時，使用序列化器可以完成對資料的反序列化。
2. 在伺服器響應時，使用序列化器可以完成對資料的序列化。

1.3.1 序列化

1.3.1.1 基本使用

1） 先查詢出一個學生物件

from students.models import Student

student = Student.objects.get(id=3)

2） 構造序列化器物件

from .serializers import StudentSerializer

serializer = StudentSerializer(instance=student)

3）獲取序列化資料

通過data屬性可以獲取序列化後的資料

serializer.data
# {'id': 4, 'name': '小張', 'age': 18, 'sex': True, 'description': '猴賽雷'}

完整檢視程式碼：

from django.views import View
from students.models import Student
from .serializers import StudentSerializer
from django.http.response import JsonResponse
class StudentView(View):
    """使用序列化器序列化轉換單個模型資料"""
    def get(self,request,pk):
        # 獲取資料
        student = Student.objects.get(pk=pk)
        # 資料轉換[序列化過程]
        serializer = StudentSerializer(instance=student)
        print(serializer.data)
        # 響應資料
        return JsonResponse(serializer.data)

4）如果要被序列化的是包含多條資料的查詢集QuerySet，可以通過新增many=True引數補充說明

"""使用序列化器序列化轉換多個模型資料"""
def get(self,request):
    # 獲取資料
    student_list = Student.objects.all()

    # 轉換資料[序列化過程]
    # 如果轉換多個模型物件資料，則需要加上many=True
    serializer = StudentSerializer(instance=student_list,many=True)
    print( serializer.data ) # 序列化器轉換後的資料

    # 響應資料給客戶端
    # 返回的json資料，如果是列表，則需要宣告safe=False
    return JsonResponse(serializer.data,safe=False)


# 訪問結果：
# [OrderedDict([('id', 1), ('name', 'xiaoming'), ('age', 20), ('sex', True), ('description', '測試')]), OrderedDict([('id', 2), ('name', 'xiaohui'), ('age', 22), ('sex', True), ('description', '後面來的測試')]), OrderedDict([('id', 4), ('name', '小張'), ('age', 18), ('sex', True), ('description', '猴賽雷')])]

1.3.1.2 高階用法

#source和serializers.SerializerMethodField()的用法
# models.py
from django.db import models

class Book(models.Model):
    title=models.CharField(max_length=32)
    price=models.IntegerField()
    pub_date=models.DateField()
    publish=models.ForeignKey("Publish",on_delete=models.CASCADE,null=True)
    authors=models.ManyToManyField("Author")
    def __str__(self):
        return self.title

class Publish(models.Model):
    name=models.CharField(max_length=32)
    email=models.EmailField()
    def __str__(self):
        return self.name

class Author(models.Model):
    name=models.CharField(max_length=32)
    age=models.IntegerField()
    def __str__(self):
        return self.name
# ser.py
from rest_framework import serializers
from app01.models import Book
class BookSerializers(serializers.Serializer):
    id=serializers.CharField(read_only=True)
    title=serializers.CharField(max_length=32)
    price=serializers.IntegerField()
    pub_date=serializers.DateField()
    # publish=serializers.CharField(source="publish.name",read_only=True)
    publish=serializers.CharField(source="publish.name",default='xxx')
    #authors=serializers.CharField(source="authors.all")
    authors=serializers.SerializerMethodField(read_only=True)
    def get_authors(self,obj):
        temp=[]
        for author in obj.authors.all():
            temp.append(author.name)
        return temp

    def create(self, validated_data):
        print(validated_data)
        publish_id=validated_data.get('publish').get('name')
        print(publish_id)
        del validated_data['publish']
        return Book.objects.create(publish_id=publish_id,**validated_data)

    def update(self, instance, validated_data):
        print(validated_data.get('aa'))
        instance.title = validated_data.get('title', instance.title)
        instance.price = validated_data.get('price', instance.price)
        instance.pub_date = validated_data.get('pub_date', instance.pub_date)
        print(validated_data.get('publish', instance.publish))
        instance.publish_id = validated_data.get('publish', instance.publish).get('name')
        instance.save()
        return instance
# views.py
from django.shortcuts import render,HttpResponse
from app01 import models

from django.http import HttpRequest

from rest_framework.views import APIView
from app01.models import Book
from rest_framework.response import Response
from app01.ser import BookSerializers
class BookViewSet(APIView):

    def get(self,request,*args,**kwargs):
        book_list=Book.objects.all()
        # 序列化方式3:
        bs=BookSerializers(book_list,many=True)     #many=True代表有多條資料，如果只有一條資料，many=False
        return Response(bs.data)
    def post(self,request,*args,**kwargs):

        bs=BookSerializers(data=request.data)
        bs.is_valid(raise_exception=True)
        # print(bs.validated_data)
        bs.save()
        return Response(bs.data)

class BookDetailView(APIView):
    def get(self,request,pk):
        book_obj=models.Book.objects.filter(pk=pk).first()
        bs=BookSerializers(book_obj,many=False)
        return Response(bs.data)
    def put(self,request,pk):
        book_obj = models.Book.objects.filter(pk=pk).first()

        bs=BookSerializers(instance=book_obj,data=request.data,partial=True)
        if bs.is_valid():
            bs.save(aa="lqz") # update
            return Response(bs.data)
        else:
            return Response(bs.errors)
    def delete(self,request,pk):
        models.Book.objects.filter(pk=pk).delete()

        return Response("")
# urls.py
from django.contrib import admin
from django.urls import path,re_path
from app01 import views
urlpatterns = [
    path('admin/', admin.site.urls),
    path('books/', views.BookViewSet.as_view()),
    re_path('books/(?P<pk>\d+)/', views.BookDetailView.as_view()),
]

注意：

source 如果是欄位，會顯示欄位，如果是方法，會執行方法，不用加括號（authors=serializers.CharField(source=’authors.all’)）

如在模型中定義一個方法，直接可以在在source指定執行

class UserInfo(models.Model):
    user_type_choices = (
        (1,'普通使用者'),
        (2,'VIP'),
        (3,'SVIP'),
    )
    user_type = models.IntegerField(choices=user_type_choices)

    username = models.CharField(max_length=32,unique=True)
    password = models.CharField(max_length=64)


#檢視
ret=models.UserInfo.objects.filter(pk=1).first()
aa=ret.get_user_type_display()

#serializer
xx=serializers.CharField(source='get_user_type_display')

1.3.2 反序列化

1.3.2.1 資料驗證

使用序列化器進行反序列化時，需要對資料進行驗證後，才能獲取驗證成功的資料或儲存成模型類物件。

在獲取反序列化的資料前，必須呼叫is_valid()方法進行驗證，驗證成功返回True，否則返回False。

驗證失敗，可以通過序列化器物件的errors屬性獲取錯誤資訊，返回字典，包含了欄位和欄位的錯誤。如果是非欄位錯誤，可以通過修改REST framework配置中的NON_FIELD_ERRORS_KEY來控制錯誤字典中的鍵名。

驗證成功，可以通過序列化器物件的validated_data屬性獲取資料。

在定義序列化器時，指明每個欄位的序列化型別和選項引數，本身就是一種驗證行為。

如我們前面定義過的BookInfoSerializer

class BookInfoSerializer(serializers.Serializer):
    """圖書資料序列化器"""
    id = serializers.IntegerField(label='ID', read_only=True)
    btitle = serializers.CharField(label='名稱', max_length=20)
    bpub_date = serializers.DateField(label='釋出日期', required=False)
    bread = serializers.IntegerField(label='閱讀量', required=False)
    bcomment = serializers.IntegerField(label='評論量', required=False)
    image = serializers.ImageField(label='圖片', required=False)

通過構造序列化器物件，並將要反序列化的資料傳遞給data構造引數，進而進行驗證

from booktest.serializers import BookInfoSerializer
data = {'bpub_date': 123}
serializer = BookInfoSerializer(data=data)
serializer.is_valid()  # 返回False
serializer.errors
# {'btitle': [ErrorDetail(string='This field is required.', code='required')], 'bpub_date': [ErrorDetail(string='Date has wrong format. Use one of these formats instead: YYYY[-MM[-DD]].', code='invalid')]}
serializer.validated_data  # {}

data = {'btitle': 'python'}
serializer = BookInfoSerializer(data=data)
serializer.is_valid()  # True
serializer.errors  # {}
serializer.validated_data  #  OrderedDict([('btitle', 'python')])

is_valid()方法還可以在驗證失敗時丟擲異常serializers.ValidationError，可以通過傳遞raise_exception=True引數開啟，REST framework接收到此異常，會向前端返回HTTP 400 Bad Request響應。

# Return a 400 response if the data was invalid.
serializer.is_valid(raise_exception=True)

如果覺得這些還不夠，需要再補充定義驗證行為，可以使用以下三種方法：

1) validate_欄位名

對<field_name>欄位進行驗證，如

class BookInfoSerializer(serializers.Serializer):
    """圖書資料序列化器"""
    ...

    def validate_btitle(self, value):
        if 'django' not in value.lower():
            raise serializers.ValidationError("圖書不是關於Django的")
        return value

測試

from booktest.serializers import BookInfoSerializer
data = {'btitle': 'python'}
serializer = BookInfoSerializer(data=data)
serializer.is_valid()  # False   
serializer.errors
#  {'btitle': [ErrorDetail(string='圖書不是關於Django的', code='invalid')]}

2) validate

在序列化器中需要同時對多個欄位進行比較驗證時，可以定義validate方法來驗證，如

class BookInfoSerializer(serializers.Serializer):
    """圖書資料序列化器"""
    ...

    def validate(self, attrs):
        bread = attrs['bread']
        bcomment = attrs['bcomment']
        if bread < bcomment:
            raise serializers.ValidationError('閱讀量小於評論量')
        return attrs

測試

from booktest.serializers import BookInfoSerializer
data = {'btitle': 'about django', 'bread': 10, 'bcomment': 20}
s = BookInfoSerializer(data=data)
s.is_valid()  # False
s.errors
#  {'non_field_errors': [ErrorDetail(string='閱讀量小於評論量', code='invalid')]}

3) validators

在欄位中新增validators選項引數，也可以補充驗證行為，如

def about_django(value):
    if 'django' not in value.lower():
        raise serializers.ValidationError("圖書不是關於Django的")

class BookInfoSerializer(serializers.Serializer):
    """圖書資料序列化器"""
    id = serializers.IntegerField(label='ID', read_only=True)
    btitle = serializers.CharField(label='名稱', max_length=20, validators=[about_django])
    bpub_date = serializers.DateField(label='釋出日期', required=False)
    bread = serializers.IntegerField(label='閱讀量', required=False)
    bcomment = serializers.IntegerField(label='評論量', required=False)
    image = serializers.ImageField(label='圖片', required=False)

測試：

from booktest.serializers import BookInfoSerializer
data = {'btitle': 'python'}
serializer = BookInfoSerializer(data=data)
serializer.is_valid()  # False   
serializer.errors
#  {'btitle': [ErrorDetail(string='圖書不是關於Django的', code='invalid')]}

1.3.2.2 反序列化-儲存資料

前面的驗證資料成功後,我們可以使用序列化器來完成資料反序列化的過程.這個過程可以把資料轉成模型類物件.

可以通過實現create()和update()兩個方法來實現。

class BookInfoSerializer(serializers.Serializer):
    """圖書資料序列化器"""
    ...

    def create(self, validated_data):
        """新建"""
        return BookInfo(**validated_data)

    def update(self, instance, validated_data):
        """更新，instance為要更新的物件例項"""
        instance.btitle = validated_data.get('btitle', instance.btitle)
        instance.bpub_date = validated_data.get('bpub_date', instance.bpub_date)
        instance.bread = validated_data.get('bread', instance.bread)
        instance.bcomment = validated_data.get('bcomment', instance.bcomment)
        return instance

如果需要在返回資料物件的時候，也將資料儲存到資料庫中，則可以進行如下修改

class BookInfoSerializer(serializers.Serializer):
    """圖書資料序列化器"""
    ...

    def create(self, validated_data):
        """新建"""
        return BookInfo.objects.create(**validated_data)

    def update(self, instance, validated_data):
        """更新，instance為要更新的物件例項"""
        instance.btitle = validated_data.get('btitle', instance.btitle)
        instance.bpub_date = validated_data.get('bpub_date', instance.bpub_date)
        instance.bread = validated_data.get('bread', instance.bread)
        instance.bcomment = validated_data.get('bcomment', instance.bcomment)
        instance.save()
        return instance

實現了上述兩個方法後，在反序列化資料的時候，就可以通過save()方法返回一個數據物件例項了

book = serializer.save()

如果建立序列化器物件的時候，沒有傳遞instance例項，則呼叫save()方法的時候，create()被呼叫，相反，如果傳遞了instance例項，則呼叫save()方法的時候，update()被呼叫。

from db.serializers import BookInfoSerializer
data = {'btitle': '封神演義'}
serializer = BookInfoSerializer(data=data)
serializer.is_valid()  # True
serializer.save()  # <BookInfo: 封神演義>

from db.models import BookInfo
book = BookInfo.objects.get(id=2)
data = {'btitle': '倚天劍'}
serializer = BookInfoSerializer(book, data=data)
serializer.is_valid()  # True
serializer.save()  # <BookInfo: 倚天劍>
book.btitle  # '倚天劍'

1.3.2.3 附加說明

1） 在對序列化器進行save()儲存時，可以額外傳遞資料，這些資料可以在create()和update()中的validated_data引數獲取到

# request.user 是django中記錄當前登入使用者的模型物件
serializer.save(owner=request.user)

2）預設序列化器必須傳遞所有required的欄位，否則會丟擲驗證異常。但是我們可以使用partial引數來允許部分欄位更新

# Update `comment` with partial data
serializer = CommentSerializer(comment, data={'content': u'foo bar'}, partial=True)

1.3.3 模型類序列化器

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

ModelSerializer與常規的Serializer相同，但提供了：

• 基於模型類自動生成一系列欄位
• 基於模型類自動為Serializer生成validators，比如unique_together
• 包含預設的create()和update()的實現

1.3.3.1 定義

比如我們建立一個BookInfoSerializer

class BookInfoSerializer(serializers.ModelSerializer):
    """圖書資料序列化器"""
    class Meta:
        model = BookInfo
        fields = '__all__'

• model 指明參照哪個模型類
• fields 指明為模型類的哪些欄位生成

我們可以在python manage.py shell中檢視自動生成的BookInfoSerializer的具體實現

>>> from booktest.serializers import BookInfoSerializer
>>> serializer = BookInfoSerializer()
>>> serializer
BookInfoSerializer():
    id = IntegerField(label='ID', read_only=True)
    btitle = CharField(label='名稱', max_length=20)
    bpub_date = DateField(allow_null=True, label='釋出日期', required=False)
    bread = IntegerField(label='閱讀量', max_value=2147483647, min_value=-2147483648, required=False)
    bcomment = IntegerField(label='評論量', max_value=2147483647, min_value=-2147483648, required=False)
    image = ImageField(allow_null=True, label='圖片', max_length=100, required=False)

1.3.3.2 指定欄位

1. 使用fields來明確欄位，__all__表名包含所有欄位，也可以寫明具體哪些欄位，如

class BookInfoSerializer(serializers.ModelSerializer):
    """圖書資料序列化器"""
    class Meta:
        model = BookInfo
        fields = ('id', 'btitle', 'bpub_date')

2. 使用exclude可以明確排除掉哪些欄位

class BookInfoSerializer(serializers.ModelSerializer):
    """圖書資料序列化器"""
    class Meta:
        model = BookInfo
        exclude = ('image',)

3. 顯示指明欄位，如：

class HeroInfoSerializer(serializers.ModelSerializer):
    hbook = BookInfoSerializer()

    class Meta:
        model = HeroInfo
        fields = ('id', 'hname', 'hgender', 'hcomment', 'hbook')

4. 指明只讀欄位

可以通過read_only_fields指明只讀欄位，即僅用於序列化輸出的欄位

class BookInfoSerializer(serializers.ModelSerializer):
    """圖書資料序列化器"""
    class Meta:
        model = BookInfo
        fields = ('id', 'btitle', 'bpub_date'， 'bread', 'bcomment')
        read_only_fields = ('id', 'bread', 'bcomment')

1.3.3.3 新增額外引數選項

我們可以使用extra_kwargs引數為ModelSerializer新增或修改原有的選項引數

class BookInfoSerializer(serializers.ModelSerializer):
    """圖書資料序列化器"""
    class Meta:
        model = BookInfo
        fields = ('id', 'btitle', 'bpub_date', 'bread', 'bcomment')
        extra_kwargs = {
            'bread': {'min_value': 0, 'required': True},
            'bcomment': {'min_value': 0, 'required': True},
        }

# BookInfoSerializer():
#    id = IntegerField(label='ID', read_only=True)
#    btitle = CharField(label='名稱', max_length=20)
#    bpub_date = DateField(allow_null=True, label='釋出日期', required=False)
#    bread = IntegerField(label='閱讀量', max_value=2147483647, min_value=0, required=True)
#    bcomment = IntegerField(label='評論量', max_value=2147483647, min_value=0, required=True)

1.4 區域性全域性校驗原始碼分析

#is_valid---->self.run_validation-(執行Serializer的run_validation)-->self.to_internal_value(data)---（執行Serializer的run_validation：485行）

1.5 序列化元件原始碼分析

序列化元件，先呼叫__new__方法，如果many=True，生成ListSerializer物件，如果為False，生成Serializer物件
序列化物件.data方法--呼叫父類data方法---呼叫物件自己的to_representation（自定義的序列化類無此方法，去父類找）
Aerializer類裡有to_representation方法，for迴圈執行attribute = field.get_attribute(instance)
再去Field類裡去找get_attribute方法，self.source_attrs就是被切分的source，然後執行get_attribute方法，source_attrs
當引數傳過去，判斷是方法就加括號執行，是屬性就把值取出來