序列化元件介紹

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

序列化元件的使用

1、寫一個序列化的類，繼承Serializer
2、在類中寫要序列化的欄位，想序列化哪個欄位，就在類中寫哪個欄位
3、在檢視類中使用，匯入--->例項化得到序列化類的物件，把要序列化的物件傳入
4、序列化類的物件.data  是一個字典
5、把字典返回，如果不使用rest_framework提供的Response，就得使用JsonResponse

1 寫一個序列化的類，繼承Serializer
class BookSerializer(serializers.Serializer):
    # 在這裡寫要序列化的欄位
    # 序列化欄位類(有很多，常用的就幾個，等同於models中的欄位類)
    # 欄位類，有很多欄位引數（）
    name = serializers.CharField()
    price = serializers.IntegerField()
    # publish = serializers.CharField()
2 在類中寫要序列化的欄位
    name = serializers.CharField()
    price 
 
= serializers.IntegerField()
3 在檢視類中使用（例項化）
    book_list = models.Book.objects.all()                   book_ser=BookSerializer(instance=book_list,many=True)
4 得到序列化後的資料,返回
    book_ser.data
    
5 欄位引數，source,指定要序列化表中的哪個欄位

source

1 指定要序列化的欄位（資料表中欄位）
publish = serializers.CharField(source='publish.city
 
')

2 用的最多：只有一個欄位（也可以跨表）

SerializerMethodField

1 用的最多，跨表查（要麼是列表，要麼是字典）
publish=serializers.SerializerMethodField()
def get_publish(self,obj):
        print(obj)
        # return {'name':'sss','city':'sss'}
        return {'name':obj.publish.name,'city':obj.publish.city}

在模型表中寫方法

# 表模型中寫的
def publish_name(self):
   return {'name':self.publish.name,'city':self.publish.city}

@property
def author_list(self):
   return [{'name':author.name,'age':author.age,'id':author.nid} for author in self.authors.all()]

#序列化類中
# publish = serializers.CharField(source='publish_name')
publish_name = serializers.DictField()
author_list=serializers.ListField()

序列化類的欄位型別

有很多 不需要都記住
只需要記住：
    CharField  IntegerField  DateField...

序列化欄位選項

max_length                    最大長度
min_lenght                    最小長度
allow_blank                    是否允許為空
trim_whitespace                是否截斷空白字元
max_value                    最小值
min_value                    最大值

序列化元件修改資料

1、寫一個序列化的類，繼承Serializer
2、在類中寫要反序列化的欄位，想反序列化哪個欄位，就在類中寫哪個欄位，欄位的屬性(max_length...)
3、在檢視類中使用，匯入--->例項化得到序列化類的物件，把要修改的物件傳入，要修改的資料傳入
    book_ser = BookSerializer(book, request.data)
    book_ser = BookSerializer(instance=book, data=request.data)  # 推薦
4、資料校驗
    if book_ser.is_valid():  # 返回True,表示驗證通過
5、如果校驗通過，就儲存
    book_ser.save()  # 注意不是book.save()  而是序列化器提供的
6、如果不通過，邏輯自己寫

7、如果欄位的校驗規則不夠，可以寫鉤子函式(區域性和全域性)
# 區域性鉤子
    def validate_price(self, data):  # validated_欄位名  接收一個引數
        # 如果價格小於10，就校驗不通過
        # print(type(data))  # <class 'str'>
        # print(data)  # 33.66
        if float(data)>10:
            return data
        else:
            # 校驗失敗，拋異常
            raise ValidationError('價格太低')
# 全域性鉤子
    def validate(self,validate_data):
        print(validate_data)
        author = validate_data.get('author')
        publish = validate_data.get('publish')
        if author == publish:
            raise ValidationError('作者名字和出版社一樣')
        else:
            return validate_data
        
8、可以使用欄位的author = serializers.CharField(validators=[check_author])  # validators=[]  列表中寫函式記憶體地址
寫一個自定義函式：
def check_author(data):
    if data.startswith('sb'):
        raise ValidationError('作者名字不能以sb開頭')
    else:
        return data
配置：
    validators=[check_author]

read_only和write_only

read_only    表明該欄位僅用於序列化輸出，預設False，如果設定成True，postman中可以看到該欄位，修改時，不需要傳該欄位
write_only    表明該欄位僅用於反序列化輸入，預設False，如果設定成True，postman中看不到該欄位，修改時需要傳

以下的瞭解：
required          表明該欄位在反序列化時必須輸入，預設True
default              反序列化時使用的預設值
allow_null          表明該欄位是否允許傳入None，預設False
validators          該欄位使用的驗證器
error_messages      包含錯誤編號與錯誤資訊的字典
label              用於HTML展示API頁面時，顯示的欄位名稱
help_text          用於HTML展示API頁面時，顯示的欄位幫助提示資訊

查詢所有

# views.py
# 查詢所有
def get(self, request):
        response_msg = {'status': 100, 'msg': '成功'}
        books = Book.objects.all()
        book_ser = BookSerializer(books, many=True)  # 序列化多條,序列化一條不需要寫many=True
        response_msg['data'] = book_ser.data
        return Response(response_msg)

# urls.py
path('books/', views.BooksView.as_view()),

新增資料

# views.py
class BooksView(APIView):
    # 新增
    def post(self,request):
        response_msg = {'status': 100, 'msg': '成功'}
        # 修改的時候才有instance,新增沒有instance,只有data
        book_ser = BookSerializer(data=request.data)
        # book_ser = BookSerializer(request.data)  # 這個按位置傳request.data會給instance，就報錯了
        # 校驗欄位
        if book_ser.is_valid():
            book_ser.save()
            response_msg['data'] = book_ser.data
        else:
            response_msg['status'] = 102
            response_msg['msg'] = '資料校驗失敗'
            response_msg['data'] = book_ser.errors
        return Response(response_msg)

# ser.py  序列化類重寫create方法
    # 新增需要重寫create()
    def create(self, validated_data):
        instance = Book.objects.create(**validated_data)
        # Book.objects.create(name=validated_data.get('name'))
        return instance
    
# urls.py
path('books/', views.BooksView.as_view()),

刪除一個數據

# views.py:
class BookView(APIView):
    # 刪除
    def delete(self, request, pk):
        ret = Book.objects.filter(pk=pk).delete()
        return Response({'status': 100, 'msg': '刪除成功'})
    
# urls.py:
re_path('books/(?P<pk>\d+)', views.BookView.as_view()),

模型類序列化器

# ser.py
class BookModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book  # 對應上models.py中的模型
        fields = '__all__'
        # fields = ('name','price')  # 只序列化指定的欄位
        # exclude = ('name',)  # 跟fields不能都寫，寫誰，就表示排除誰

        # read_only_fields = ('price',)
        # write_only_fields = ('author',)  # 棄用了，使用extra_kwargs
        extra_kwargs = {  # 類似於這種形式name = serializers.CharField(max_length=16, min_length=3)
            'price': {'write_only': True},
        }
        
# 其他使用一模一樣
# 不需要重寫create和update方法了

原始碼分析

many=True實際用途

# 序列化多條，需要傳many=True
# 
books = Book.objects.all()
book = Book.objects.all().first()
book_ser = BookModelSerializer(books, many=True)  # 序列化多條,序列化一條不需要寫many=True
book_one_ser = BookModelSerializer(book)
print(type(book_ser))
# <class 'rest_framework.serializers.ListSerializer'>
print(type(book_one_ser))
# <class 'app01.ser.BookModelSerializer'>


# 物件的生成 ---> 先呼叫類的__new__方法，生成空物件
# 物件=類名(name=lqz),觸發類的__init__()
# 類的__new__方法控制物件的生成
    def __new__(cls, *args, **kwargs):
        if kwargs.pop('many', False):
            return cls.many_init(*args, **kwargs)
        # 沒有傳many=True,走下面，正常的物件例項化
        return super().__new__(cls, *args, **kwargs)

serializer高階用法

# source的使用
    1、可以改欄位名字
        xxx = serializers.CharField(source='title')
    2、可以.跨表
        publish = serializers.CharField(source='publish.email')  # book.publish.email
    3、可以執行方法
        pub_date = serializers.CharField(source='test')  # test是Book表模型中的方法
# SerializerMethodField()的使用
    1、配套一個方法，方法名叫get_欄位名，返回值就是要顯示的東西
     authors = serializers.SerializerMethodField()
     def get_authors(self, instance):
         # book物件
         authors = instance.authors.all()  # 去除所有作者
         temp = []
         for author in authors:
             temp.append(author.name)
         return temp  # return什麼就是什麼

補充

1 如果有這個錯(把rest_framework在app中註冊)

2 補充自己封裝Response物件

# app01.utils.py:
class MyResponse():
    def __init__(self):
        self.status = 100
        self.msg = '成功'

    @property
    def get_dict(self):
        return self.__dict__

if __name__ == '__main__':
    res = MyResponse()
    res.data = {'name':'lqz'}
    print(res.msg)
    print(res.get_dict)
    
# views.py:
# 匯入自己寫的response類
from app01.utils import MyResponse
class BooksView(APIView):
    # 查詢所有
    def get(self, request):
        response = MyResponse()
        books = Book.objects.all()
        book_ser = BookSerializer(books, many=True)  # 序列化多條,序列化一條不需要寫many=True
        response.data = book_ser.data
        return Response(response.get_dict)

3 你在實際開發中碰到的問題及如何解決的

write_only_fields  不能使用了，使用extra_kwargs

class BookInfoSerializer(serializers.ModelSerializer):
    """圖書資料序列化器"""
    class Meta:
        model = BookInfo
        fields = ('id', 'btitle', 'bpub_date', 'bread', 'bcomment')
        extra_kwargs = {
            'price': {'write_only': True},  # 傳id報錯
        }