經歷了源碼的痛苦，掌握DRF的核心序列化器

• 2022 年 3 月 31 日
• 筆記
• drf, DRF序列化器

DRF的核心–序列化器

上一篇介紹了很多有關視圖類以及DRF中的APIView執行流程、Request對象的源碼分析，源碼都get了🐂；

DRF的核心當然不是知道視圖類執行流程就可以了，DRF框架的核心那就是 序列化器的使用，如何使用序列化器實現 序列化、 反序列化，以及視圖，這篇會介紹到~

序列化器

什麼是序列化和反序列化?

• 序列化：序列化器會把模型對象（QuerySet對象，比如book）轉換成字典，經過response以後變成了json字元串
• 反序列化：將客戶端（前端）發送過來的數據，經過request以後變成字典（data），序列化器可以把字典轉換成模型存到資料庫中
  • 存資料庫需要校驗，反序列化就可以幫我們完成數據的校驗功能
• 通俗理解為：
  • 響應給前端的內容需要序列化（給前端看），存資料庫的數據就反序列化；
  • 序列化：模型對象—-字典—json字元串
  • 反序列化：json數據—字典—-模型對象

導入：from rest_framework.serializers import Serializer

序列化

序列化demo

1. 在app中新建serializer.py，自定義類，繼承DRF框架的Serializer及其子類
2. 在類中寫要序列化的欄位（序列化哪些就寫哪些，不序列化的不寫）
3. 使用序列化類，視圖類中用，得到序列化類對象，對象.data，通過Response返回給前端

serializer.py：序列化類

from rest_framework import serializers


# 繼承Serializer
class BookSerializer(serializers.Serializer):
    '''
    max_length=32
    min_length=3  反序列化保存校驗數據的時候用，序列化不用
    '''
    # 寫要序列化的欄位
    title = serializers.CharField()
    #  models中使用了DecimalField，這個位置使用了CharField會把小數類型轉成字元串,使用CharField或者DecimalField都可以
    # 這裡不需要擔心反序列化存的問題
    price = serializers.CharField()
    authors = serializers.CharField()

views.py：視圖類

from rest_framework.views import APIView
from .models import Book
from .serializer import BookSerializer
from rest_framework.response import Response


# Create your views here.
class BookView(APIView):
    def get(self, request):
        # 從資料庫查數據，做序列化
        book_list = Book.objects.all()
        # 實例化類，傳入初始化的參數，instance和many
        '''
        instance:要序列化的對象  qs，單個對象
        many:如果是qs對象，many=True，如果是單個對象many=False
        '''
        ser = BookSerializer(instance=book_list, many=True)
        # ser.data使用模型類的對象得到序列化後的字典
        return Response(ser.data)

urls.py：路由

path('books/', views.BookView.as_view()),

model.py：模型類

from django.db import models

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

測試

注意

• 視圖類中的參數instance和many的使用，instance是要序列化的對象，一般從資料庫中獲取到的，many=True代表要序列化多個對象，如果是單個對象就等於False
• 序列化器中不要寫max_length等參數，反序列化驗證欄位用
• 在對BookSerializer類實例化傳入的參數不知道傳什麼，由於我們沒有寫構造函數，去父類看需要什麼參數傳什麼就可以了
• 使用瀏覽器測得時候一定要註冊rest_framework

# 源碼
class BaseSerializer(Field):
    """
    The BaseSerializer class provides a minimal class which may be used
    for writing custom serializer implementations.

    Note that we strongly restrict the ordering of operations/properties
    that may be used on the serializer in order to enforce correct usage.

    In particular, if a `data=` argument is passed then:

    .is_valid() - Available.
    .initial_data - Available.
    .validated_data - Only available after calling `is_valid()`
    .errors - Only available after calling `is_valid()`
    .data - Only available after calling `is_valid()`

    If a `data=` argument is not passed then:

    .is_valid() - Not available.
    .initial_data - Not available.
    .validated_data - Not available.
    .errors - Not available.
    .data - Available.
    """
    
BaseSerializer類提供了一個可以使用的最小類
用於編寫自定義序列化器實現。
注意，我們嚴格限制了操作/屬性的順序
可以在序列化器上使用，以強制正確的使用。
特別是，如果傳遞了' data= '參數，則:
.is_valid()——可用。
.initial_data——可用。
.validated_data -僅在調用' is_valid() '後可用
.errors -僅在調用' is_valid() '後可用
.data -僅在調用' is_valid() '後可用
如果沒有傳遞' data= '參數，則:
.is_valid() -不可用。
.initial_data -不可用。
.validated_data -不可用。
.errors -不可用。
. data -可用。

欄位類型

serializer.py文件中常用的欄位

常用的有：

  CharField
  IntegerField
  FloatField
  DecimalField
  DateTimeField
  DateField

注意：

'''
ListField和DictField原來的models是沒有的，主要用來做反序列,處理前端傳入的數據
'''
比如我們從前端接收json格式數據
"hobby":["籃球","足球"] 可以用ListField處理
"wife":{"name":"wh","age":20}  DictField類似使用

欄位參數

寫在類中的參數

選項參數：

通用參數：

總結：

# 重點記憶：
read_only：表示該欄位僅用於序列化輸出，默認為Fasle，如果read_only = True,這個欄位只用來做序列化（對象---json---前端）

write_only:表明該欄位僅用於反序列化輸入，默認False，如果write_only = True,那麼這個欄位只用來做反序列化（前端---json---存資料庫）
    
# 注意
如果不寫read_only和write_only表示及序列化又反序列化
千萬不要同時寫read_only=True和write_only=True邏輯矛盾了，都要實現直接省略即可

demo

title=serializers.CharField(max_length=32,min_length=3)
price=serializers.CharField(write_only=True,)
author=serializers.CharField(write_only=True)

# 上面title欄位及序列化也反序列化，price，author欄位只反序列化
# 序列化給前端，前端看到的欄位樣子---》只能看到name
# 反序列化，前端需要傳什麼過name,price,author都傳

序列化自訂製返回欄位

如果我們想自訂製序列化返回欄位的樣式，可以使用，有兩種方法

方法一：在序列化類（serializers.py）中寫

'''serializer.py'''
from rest_framework import serializers

# 繼承Serializer
class BookSerializer(serializers.Serializer):
    # 寫要序列化的欄位
    title = serializers.CharField(read_only=True)
    price = serializers.CharField(write_only=True)
    authors = serializers.CharField(write_only=True)

    # 自訂製返回欄位
    author_info = serializers.SerializerMethodField()
    # 搭配方法，方法名必須是get_欄位名，該方法返回什麼欄位，顯示什麼
    def get_author_info(self,obj):
        # obj是當前資料庫book對象
        return obj.authors+'牛掰'
        # 注意字元串拼接的問題

    price = serializers.SerializerMethodField()
    def get_price(self,obj):
        return "價格是："+str(obj.price)

總結：

• 可以自定義返回的key或者value，比如price可以自定義成price_down，通過返回值來控制value
• 在序列化類中寫需要搭配get_欄位的方法，來自訂製欄位

方法二：在表模型（models.py）中寫

'''models.py'''
from django.db import models

# Create your models here.
class Book(models.Model):
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=5,decimal_places=2)
    authors = models.CharField(max_length=32)


    @property
    def price_info(self):
        return '價格是：'+str(self.price)

'''serializer.py'''
from rest_framework import serializers

# 繼承Serializer
class BookSerializer(serializers.Serializer):
    # 寫要序列化的欄位
    title = serializers.CharField(read_only=True)
    price = serializers.CharField(write_only=True)
    authors = serializers.CharField(write_only=True)
    
    # 該欄位是從models的price_info返回值獲取到的，price_info方法返回什麼，這個欄位就是什麼
    price_info = serializers.CharField()

總結:

• 在models中寫和序列化類中寫的區別是，models中處理完返回給序列化類中繼續當成欄位處理了

注意:

如果是返回的是這種格式的數據，需要那麼序列化類中就不能指定CharField類型，這樣會直接返回字元串類型，不方便後期的處理，需要指定成

'''models.py'''
def authors(self):
        return [{"name":"Hammer","age":18},{"name":"Hans","age":28}]
'''serializer.py'''  
authors = serializers.ListField()

反序列化

反序列化demo

• 把前端傳入的數據，放到Serializer對象中:ser=BookSerializer(data=request.data)

• 校驗數據：ser.is_valid()

• 保存，ser.save()，但是必須重寫create，在序列化類中

  反序列化新增

  POST請求處理新增

  '''views.py'''
  from rest_framework.views import APIView
  from .models import Book
  from rest_framework.response import Response
  from app01.serializer import  BookSerializer
  
  class BookView(APIView):
      
      def post(self,request):
          # 反序列化，保存到資料庫使用data參數
          deser = BookSerializer(data=request.data)
          # 校驗數據
          if deser.is_valid():
              # 保存需要重寫create方法,不然不知道存到哪個表
              deser.save()
              return Response(deser.data)
          return Response({'code':101,'msg':'校驗不通過','errors':deser.errors})
  

  重寫create方法

  '''serializer.py'''
      def create(self, validated_data):
          # validated_data是校驗通過的數據，將校驗通過的數據打散存入資料庫
          book = Book.objects.create(**validated_data)
          return book
      
  

反序列化修改

# 處理修改再寫一個視圖類，防止get衝突
class BookDetailView(APIView):
    # 獲取一條的
    def get(self,request,pk):
        book = Book.objects.filter(pk=pk).first()
        ser = BookSerializer(instance=book)  # 這裡設置了主鍵值，單條記錄many不需要寫
        return Response(ser.data)
    # 刪除一條的
    def delete(self,request,pk):
        res = Book.objects.filter(pk=pk).delete()
        print(res) # (1, {'app01.Book': 1})
        # res是影響的行數
        if res[0]>0:
            return Response({'code': 100, 'msg': '刪除成功'})
        else:
            return  Response({'code': 103, 'msg': '要刪除的數據不存在'})

    # 反序列化修改
    def put(self,request,pk):
        # 修改處理單條數據用過pk確定求改哪條數據
        book = Book.objects.filter(pk=pk).first()
        # 序列化器類實例化需要傳入instance，data才表示修改
        ser = BookSerializer(instance=book,data=request.data)
        if ser.is_valid():
            # 重寫update方法才能存入
            ser.save()
            return Response(ser.data)
        return Response({'code':101,'msg':'校驗未通過','error':ser.errors})

重寫update方法

'''serializer.py'''   
    def update(self, instance, validated_data):
        '''
        :param instance: 表示要修改的對象
        :param validated_data: 校驗通過的數據
        :return: instance
        '''
        # 如果只修改一個的情況，從校驗通過的數據中get到其他數據是none，做一層校驗
        instance.title = validated_data.get('title')
        instance.price = validated_data.get('price')
        instance.authors = validated_data.get('authors')
        instance.save()  # 保存到資料庫中
        return instance  # 返回instance對象

路由

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

為什麼不重寫就會拋異常？

# 源碼
def save(self, **kwargs):
        assert hasattr(self, '_errors'), (
            'You must call `.is_valid()` before calling `.save()`.'
        )
        
      def update(self, instance, validated_data):
        raise NotImplementedError('`update()` must be implemented.')

    def create(self, validated_data):
        raise NotImplementedError('`create()` must be implemented.')

    def save(self, **kwargs):
        assert hasattr(self, '_errors'), (
            'You must call `.is_valid()` before calling `.save()`.'
 ·····
        if self.instance is not None:
            self.instance = self.update(self.instance, validated_data)
            assert self.instance is not None, (
                '`update()` did not return an object instance.'
            )
        else:
            self.instance = self.create(validated_data)
            assert self.instance is not None, (
                '`create()` did not return an object instance.'
            )

        return self.instance
'''
發現如果我們傳了instance不是空的，那麼就是修改(update)，不傳就是新增(create)，調用save，父類不然就拋異常
'''

總結

• 不管是序列化使用get方法或者反序列化使用post方法都需要序列化類實例化，如果有instance參數代表是序列化，如果有data參數代表是新增，如果都有就是修改

注意

• 如果保存不重寫create方法，報錯

  NotImplementedError at /books/
  `create()` must be implemented.
  

• 如果修改不重寫update方法，報錯

  NotImplementedError at /books/1
  `update()` must be implemented.
  

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

 '''serializer.py'''
    
    # 局部鉤子
    def validate_title(self,attr):
        # attr就是前端傳入的數據
        # 局部校驗書名
        if attr.startswith('sb'):
            from django.core.exceptions import ValidationError
            raise ValidationError("名字不能以sb開頭")
        else:
            return attr  # 沒有問題，正常返回


    '''
    校驗順序:先走欄位自己規則，再走局部鉤子，再走全局鉤子
    '''
    # 全局鉤子
    def validate(self,attrs):
        # attrs校驗過後的數據,通過了前面校驗的規則
        if attrs.get('title') == attrs.get('authors'):
            from django.core.exceptions import ValidationError
            raise ValidationError('作者名不能等於書名')
        else:
            return attrs

ModelSerializer模型類序列化器

# ModelSerializer和表模型有綁定關係
class BookSerializer1(serializers.ModelSerializer):
    class Meta:
        model = Book  # 指定和哪個表有關係
        # 所有欄位
        # fields = '__all__'
        # 這裡注意id欄位是從表模型映射過來的，auto自增的，不傳也可以
        # 自訂製的欄位不傳必須註冊，在列表中
        fields = ['id', 'title', 'price', 'price_info']  # 指定欄位
        extra_kwargs = {
            'title': {'write_only': True, 'max_length': 8, 'min_length': 3}
        }
    # 指定序列化的欄位：兩種寫法：在序列化類中寫；models中寫
    price_info = serializers.SerializerMethodField()
    def get_price_info(self, obj):
        return "價格是：" + str(obj.price)
    '''
    注意：自訂製欄位如果和表模型獲取到的欄位是同名，那麼自訂製返回給前端的欄位值就被自訂製覆蓋了，比如：
    title = serializers.SerializerMethodField()
    def get_title(self, obj):
        return "書名是：" + str(obj.title)
    '''

    #  局部和全局鉤子，跟之前一樣，但是要注意寫在Meta外

ps：視圖類，路由處理方式和Serializer是一樣的

欄位參數

ModelSerializer中的欄位傳參不需要在去括弧內指定了，通過extra_kwargs傳

extra_kwargs = {
            'title': {'write_only': True, 'max_length': 8, 'min_length': 3}
        }

總結

• ModelSerializer類序列化器不需要重寫create方法和update方法了，因為明確指定了操作哪個表
• 固定寫法，ModelSerializer類內寫Meta類，用來指定一些欄位和表模型