內容概要

• 序列化器介紹
• Serializer的使用
  • 基本使用（序列化）
  • 欄位類型
  • 欄位參數
• 序列化
  • 定製序列化的欄位
• 反序列化
  • 反序列化之新增
  • 反序列化之修改
  • 反序列化之局部和全局鉤子
• ModelSerializer 模型類序列化器
• ModelSerializer 額外添加參數

內容詳細

序列化器介紹

QuerySet 對象 ：queryset_obj = models.Book.objects.all()

單個對象：book = models.Book.objects.all().first()

• 1、序列化：序列化器會將模型對象（QuerySet 對象、單個 book 對象）轉成字典，在經過 response 的時候序列化成 json 格式返回給前端。
• 2、反序列化：前端發送到後端的數據，經過request之變成程字典（request.data），序列化器再把字典轉成模型，存到資料庫中。
• 3、反序列化中，序列化器有進行數據校驗的功能，（前端傳入的數據是否合法，長度夠不夠）

Serializer的使用

1、基本使用（序列化）

首先得在序列化器模塊中書寫序列化類。

然後在視圖函數模塊中書寫 CBV 的get方法（獲取數據）

序列化類的書寫步驟和使用流程：

第一步：寫一個類：必須繼承drf中的Serializer及其子類
第二步：在類中寫要序列化的欄位-->要序列化哪些，就寫哪些，不序列化的不寫
第三步：使用序列化類，視圖類中用
第四步：視圖函數中得到序列化類對象 對象.data,通過Response返回給前端

模型類(models.py)：

class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.DecimalField(decimal_places=2, max_digits=5)
    author = models.CharField(max_length=32)

序列化類(ser.py)：

from rest_framework import serializers
from .models import Book

class BookSerializer(serializers.Serializer):
    # max_length=32,min_length=3  反序列化保存校驗數據的時候用
    name = serializers.CharField(max_length=8, min_length=3)
    price=serializers.CharField() # models中使用了DecimalField，這個位置使用了CharField會把小數類型轉成字元串
    author = serializers.CharField()

視圖層類（views.py）

class BookView(APIView):
    def get(self,request):
        # 查出來的數據做序列化
        book_list=Book.objects.all()
        # instance:要序列化的對象  qs，單個對象
        # many:如果是qs對象，many=True，如果是單個對象many=False
        ser=BookSerializer(instance=book_list,many=True)  # 傳入初始化的參數instance=None, data=empty
        # ser.data使用模型類對象序列化後的字典
        return Response(ser.data) # 字典，列表，字元串都行

路由：

from app01 import views
urlpatterns = [
    path('admin/', admin.site.urls),
    path('books/', views.BookView.as_view()),
]

2、欄位類型

需要記憶：

CharField
IntegerField
FloatField
DecimalField
DateTimeField
DateField

瞭解：

反序列化時，前端發送進來的json數據中，也有值是列表或者字典的時候，那麼這種數據我們需要用什麼欄位來反序列化？

{name:lqz,age:19,hobby:[籃球,足球],wife:{name:lyf,age:38}}

• ListField 反序列化列表值
• DictField 反序列化字典值

3、欄位參數

序列化器中欄位參數是用來在反序列化時做校驗數據的功能作用

如 max_length 是限制數據的字元長度

重點記憶：

• read_only ：該欄位只能序列化，後端發送給前端看
• write_only：該欄位只能反序列化，由前端發送到後端保存

例子：

# 什麼都不寫，表示 name 欄位既序列化，又反序列化
name=serializers.CharField(max_length=32,min_length=3)

# 只反序列化，author 欄位只能由前端把作者信息發到後端保存
author=serializers.CharField(write_only=True)

# 這是錯誤寫法，write_only=True,read_only=True 邏輯矛盾
price=serializers.CharField(write_only=True,read_only=True)

選項參數：

通用參數：

序列化

1、定製序列化的欄位

方式一：在序列化類中寫

使用 serializers的SerializerMethodField()來定製，但必須配合一個方法,方法名get_欄位名，方法返回什麼，欄位就是什麼，obj是當前序列化到的模型類中的單個對象（queryset 或 單個 book）

from rest_framework import serializers
from .models import Book

class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8, min_length=3)
    price=serializers.CharField()
    author = serializers.CharField()
    # 在序列化後返回給前端時，前端就可以多看到一個 price_info 值
    price_info = serializers.SerializerMethodField()
    def get_price_info(self, obj):  # obj是當前序列化到的單個對象
        return "價格是："+str(obj.price)

方式二：在模型類中寫

表模型中寫方法，並且把方法包裝成數據屬性，在序列化類中使用的時候把該方法當作普通欄位

class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.DecimalField(decimal_places=2, max_digits=5)
    author = models.CharField(max_length=32)
    @property   # 把方法包裝成數據屬性
    def price_info(self):
       return "價格是：" + str(self.price)

在序列化類中使用：

只能給前端看，前端不能傳送該欄位的值（只序列化）

price_info=serializers.CharField(read_only=True)  # 只用來做序列化

反序列化

1、反序列化之新增

反序列化同時可以進行數據校驗

具體步驟如下：

第一步：把前端傳入的數據，放到Serializer對象中:ser=BookSerializer(data=request.data)
第二步：校驗數據：ser.is_valid():
第三步：保存，ser.save()---》必須重寫create，在序列化類中

# 校驗通過的數據都存放在 validated_data 中
    def create(self, validated_data):
        book=Book.objects.create(**validated_data)
        return book

如果instance為None，調用save本質會調用create，父類create是直接拋異常的，所以我們要重寫

視圖層類：

class BookView(APIView):
    def post(self,request):
        # 反序列化,保存---》使用data參數
        ser=BookSerializer(data=request.data) #
        # 校驗數據
        if ser.is_valid():  # 如果是true表示數據校驗通過，通過，就保存
            ser.save()  # 就會保存,重寫create方法，如果不重寫，我們不知道存到哪個表中
            return Response(ser.data)
        return Response({'code':101,'msg':'數據校驗失敗','err':ser.errors})

序列化類：

註意：重寫 create 方法後 不要忘記返回book對象

from rest_framework import serializers
from .models import Book

# drf提供的類：Serializer
class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8, min_length=3)
    price=serializers.CharField()
    author = serializers.CharField()
    price_info=serializers.CharField(read_only=True)  # 只用來做序列化


    def create(self, validated_data):
        # validated_data校驗過後的數據
        # 手動存到book表中
        book=Book.objects.create(**validated_data)
        # book=Book.objects.create(name=validated_data.get('name'))
        return book  # 不要忘記返回book對象

2、反序列化之修改

視圖層類：

寫 put 方法，與 get 方法很像，但 put 方法序列化器中要有 instance 參數

class BookDetailView(APIView):

    def put(self, request, pk):
        # 修改：用什麼數據，修改哪個對象？
        book = Book.objects.filter(pk=pk).first()
        # 既有instance，又有data，表示修改
        ser = BookSerializer(instance=book, data=request.data)
        if ser.is_valid():
            # 重寫update方法
            ser.save()  # 調用save---》內部根據instance判斷是觸發create還是update
            return Response(ser.data)
        return Response({'code': 102, 'msg': '修改出錯', 'err': ser.errors})

序列化類：

修改，需要重寫 序列化類 中的update 方法，否則和新增一樣也會報錯

from rest_framework import serializers
from .models import Book

class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8, min_length=3)
    price=serializers.CharField()
    author = serializers.CharField()
    
    def update(self, instance, validated_data):
        # validated_data校驗過後的數據,instance 是要修改的對象
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.author = validated_data.get('author')
        instance.save()  # 模型對象自帶的save，保存到資料庫中
        return instance  # 要忘記返回instance對象

3、反序列化之局部和全局鉤子

與 forms 組件類中的校驗局部鉤子全局鉤子書寫方法幾乎一樣。

需要在序列化類中書寫局部和全局鉤子

from rest_framework import serializers
from .models import Book

class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8, min_length=3)
    price=serializers.CharField()
    author = serializers.CharField()
    
        # 局部鉤子
    # 欄位有自己的校驗：max_length .... ,再校驗，就可以寫局部鉤子
    def validate_name(self, attr):
        # attr就是前端傳入的數據
        # 名字不能以sb開頭
        if attr.startswith('sb'):
            raise ValidationError("名字不能以sb開頭")
        else:
            return attr  # 沒有問題，正常返回

    # 先走欄位自己規則，再走局部鉤子，再走全局鉤子
    # 全局鉤子
    def validate(self, attrs):
        # attrs校驗過後的數據
        if attrs.get('name') == attrs.get('author'):
            raise ValidationError('作者名不能等於書名')
        else:
            return attrs

ModelSerializer 模型類序列化器

以後我們在實際開發中會使用ModelSerializer跟表模型做綁定比較多，不需要重寫update和create方法了

序列化類：

class BookSerializer2(serializers.ModelSerializer):
    class Meta:
        model = Book  # 跟哪個表有關係
        fields='__all__' # 所有欄位
        # id是從表模型中映射過來的，auto，它會不要求你傳
        # price_info：它不是資料庫中欄位
        # 即便擴寫的欄位，也要在fields中註冊
        # fields = ['id', 'name', 'price', 'author', 'price_info']
  
  # 重寫欄位
  # 局部和全局鉤子跟之前一樣

ModelSerializer 額外添加參數

class BookSerializer2(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['id', 'name', 'price', 'author', 'price_info']
        
        # 原來的欄位參數，通過extra_kwargs傳進去
        extra_kwargs = {
            'name': {'write_only': True, 'max_length': 8, 'min_length': 3}
        }

序列化多表操作

• 實現跨表查詢，添加定製序列化欄位
• 在 models 模型表類中添加定製序列化欄位

模型類：

圖書表：跨表查詢出版社表和作者表

定製序列化欄位：

• 書本的出版社名稱和出版地址（多條信息）
• 書本的作者詳情（多條信息）

註意：在 sqlite 這中資料庫中如果存時間欄位，查詢時會報錯

class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    authors = models.ManyToManyField(to='Author')

    def __str__(self):
        return self.name

    @property
    def publish_detail(self):  # 定製序列化欄位，想查詢什麼就返回什麼結果
        return {'name': self.publish.name, 'addr': self.publish.city}

    @property
    def author_list(self):
        l = []
        print(self.authors.all())   # 查詢改圖書對應的作者對象
        for author in self.authors.all():
            print(author.author_detail)
            l.append({'name': author.name,'age':author.age,'addr':author.author_detail.addr})
        return l

作者表、作者詳情表、出版社表：

class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    author_detail = models.OneToOneField(to='AuthorDatail', on_delete=models.CASCADE)
    # OneToOneField 就是ForeignKey+unique=True


class AuthorDatail(models.Model):
    telephone = models.BigIntegerField()
    # birthday = models.DateField()
    addr = models.CharField(max_length=64)


class Publish(models.Model):
    name = models.CharField(max_length=32)
    city = models.CharField(max_length=32)
    email = models.EmailField()

序列化類

圖書表的序列化類：

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['id', 'name', 'price', 'authors', 'publish', 'publish_detail', 'author_list']
        # depth=1  # 儘量不要用，關聯表一層全部取出來
        extra_kwargs = {
            'publish': {'write_only': True},  # 這兩個欄位數據只能反序列化
            'authors': {'write_only': True},
        }

class AuthorSerialzier(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = '__all__'


class AuthorDetailSerialzier(serializers.ModelSerializer):
    class Meta:
        model = AuthorDatail
        fields = '__all__'


class PublishSerialzier(serializers.ModelSerializer):
    class Meta:
        model = Publish
        fields = '__all__'

視圖層類：

不需要傳入參數 pk 的操作：獲取所有資源（get 請求）、新增一個資源（post）請求

class BookView(APIView):
    def get(self, request):
        book_list = Book.objects.all()
        ser = BookSerializer(instance=book_list, many=True)
        return Response(ser.data)

    def post(self, request):
        ser = BookSerializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({"code": 100, 'msg': '新增成功', 'data': ser.data})
        return Response({"code": 101, 'msg': '新增出錯', 'err': ser.errors})

需要傳入 pk 參數，並且只操作單個資源對象的操作：獲取單個資源（get請求）、修改資源（put請求）、刪除資源（delete請求）

class BookDetailView(APIView):
    def get(self, request, pk):
        book = Book.objects.all().filter(pk=pk).first()
        ser = BookSerializer(instance=book)
        return Response(ser.data)

    def put(self, request, pk):
        book = Book.objects.all().filter(pk=pk).first()
        ser = BookSerializer(instance=book, data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({"code": 100, 'msg': '修改成功', 'data': ser.data})
        return Response({"code": 101, 'msg': '修改出錯', 'err': ser.errors})

    def delete(self, request, pk):
        Book.objects.filter(pk=pk).delete()
        return Response({"code": 100, 'msg': '刪除成功'})

路由層：

urlpatterns = [
    path('admin/', admin.site.urls),
    path('books/', views.BookView.as_view()),
    path('books/<int:pk>', views.BookDetailView.as_view()),
]

新增測試：