REST framework 序列化組件之ModelSerializer

ModelSerializer

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

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

• 基於模型類自動生成一系列字段
• 包含默認的create()和update()的實現

定義序列化器

比如我們創建一個BookModelSerializer

class BookModelSerializer(serializers.ModelSerializer):
    """圖書數據序列化器"""
    class Meta:
        model = Book
        fields = '__all__'

• model 指明參照哪個模型類(表)
• fields 指明爲模型類的哪些字段生成

指定字段

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

class BookModelSerializer(serializers.ModelSerializer):
    """圖書數據序列化器"""
    class Meta:
        model = Book
        # fields = '__all__'
        fields = ('name', 'price','publish_name')
        # fields採用的是插拔式,即可以指定生成哪些字段

2) 使用exclude可以明確排除掉哪些字段

class BookModelSerializer(serializers.ModelSerializer):
    """圖書數據序列化器"""
    class Meta:
        model = Book
        exclude = ('id', 'is_delete', 'create_time')  # 不展示的字段

4) 指明只讀字段,可以通過read_only_fields指明只讀字段，即僅用於序列化輸出的字段

class BookModelSerializer(serializers.ModelSerializer):
    """圖書數據序列化器"""
    class Meta:
        model = Book
        read_only_fields = ('id', 'is_delete', 'create_time') 

補充:

自動鏈表深度

class BookModelSerializer(serializers.ModelSerializer):
    """圖書數據序列化器"""
    class Meta:
        model = Book
        fields = '__all__'
        depth = 1  # 自動鏈表深度1層

序列化準備

• 配置 settings.py

# 註冊rest_framework框架
INSTALLED_APPS = [
    ...
    'rest_framework'
]
# 配置mysql數據庫
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'db10',
        'USER': 'root',
        'PASSWORD':'root',
    }
}
​
"""
任何__init__.py文件中
import pymysql
pymysql.install_as_MySQLdb()
"""
​
# 國際化
LANGUAGE_CODE = 'zh-hans'
TIME_ZONE = 'Asia/Shanghai'
USE_I18N = True
USE_L10N = True
USE_TZ = False
​
# 配置靜態文件
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

• 配置路由

# 主路由:
from django.conf.urls import url, include
from django.contrib import admin
from django.views.static import serve
from django.conf import settings
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    # 路由分發
    url(r'^api/', include('app01.urls')),
    # 暴露media文件夾
    url(r'^media/(?P<path>.*)', serve, {'document_root': settings.MEDIA_ROOT})
]

# 子路由:
from django.conf.urls import url
from . import views
​
urlpatterns = [
    url(r'^books/$', views.Book.as_view()),
    url(r'^books/(?P<pk>.*)/$', views.Book.as_view()),
]

• 模型層: models.py

多表設計
Book表：name、price、img、authors、publish、is_delete、create_time
Publish表：name、address、is_delete、create_time
Author表：name、age、is_delete、create_time
AuthorDetail表：mobile, author、is_delete、create_time

from django.db import models
​
# 基表
class BaseModel(models.Model):
    is_delete = models.BooleanField(default=False)  # 該字段默認是 0
    create_time = models.DateTimeField(auto_now_add=True)
​
    # 作爲基表的model類不能在數據庫中形參對應的表,所以需要設置 abstract = True
    class Meta:
        abstract = True
​
# 圖書表
class Book(BaseModel):  # 繼承基表,就會繼承基表中的字段
    name = models.CharField(max_length=64)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    img = models.ImageField(upload_to='img', default='img/default.jpg')
    # 關聯出版社外鍵字段
    publish = models.ForeignKey(
        to='Publish',
        db_constraint=False,  # book表與publish表在庫中段關聯,但在邏輯上還是有關係
        related_name='books',  # 反向跨表時按related_name定義的名字即可
        on_delete=models.DO_NOTHING,  # 斷級聯,當出版社刪除時,對應的圖書不錯任何處理
    )
    # 關聯作者外鍵字段
    authors = models.ManyToManyField(
        to='Author',
        db_constraint=False,
        related_name='books',
    )

    # ModelSerializer序列化 自定義序列化字段方式1
    @property
    def publish_name(self):
        return self.publish.name  # 利用跨表查詢返回publish的name
    @property
    def author_list(self):
        return self.authors.values('name', 'detail__mobile')
​
    class Meta:
        db_table = 'book'
        verbose_name = '書籍'
        verbose_name_plural = verbose_name
​
    def __str__(self):
        return self.name
​
class Publish(BaseModel):
    name = models.CharField(max_length=64)
    address = models.CharField(max_length=64)
​
    class Meta:
        db_table = 'publish'
        verbose_name = '出版社'
        verbose_name_plural = verbose_name
​
    def __str__(self):
        return self.name
​
class Author(BaseModel):
    name = models.CharField(max_length=64)
    age = models.IntegerField()
​
    class Meta:
        db_table = 'author'
        verbose_name = '作者'
        verbose_name_plural = verbose_name
​
    def __str__(self):
        return self.name
​
class AuthorDetail(BaseModel):
    mobile = models.CharField(max_length=11)
    author = models.OneToOneField(
        to='Author',
        db_constraint=False,
        related_name='detail',
        on_delete=models.CASCADE,  # 級聯
    )
​
    class Meta:
        db_table = 'author_detail'
        verbose_name = '作者詳情'
        verbose_name_plural = verbose_name
​
    def __str__(self):
        return '%s的詳情' %self.author.name

ModelSerializer序列化的使用

後端將數據查出返回前端

自定義序列化字段的兩種方式

1) 在模型表中創建自定義字段,在序列化器中的fields中註冊自定義的字段(可註冊也可不註冊)

class Book(BaseModel):  # 繼承基表,就會繼承基表中的字段
    ....
    # ModelSerializer序列化 自定義序列化字段方式1
    @property
    def publish_name(self):
        return self.publish.name  # 利用跨表查詢返回publish的name
    @property
    def author_list(self):
        return self.authors.values('name', 'detail__mobile')

2) 在序列化器中自定義序列化字段,在序列化器中的fields中註冊自定義的字段(必須註冊)

# 創建Book模類的序列化類
class BookModelSerializer(ModelSerializer):
    class Meta:
        # 自定義序列化字段方法2: 該方式設置的序列化字段，必須在fields中聲明
        publish_address = SerializerMethodField()
        def get_publish_addr(self, obj):  obj爲當前Book對象
            return obj.publish.address

使用

• 應用下創建 serializers.py

from rest_framework.serializers import ModelSerializer, SerializerMethodField
from . import models
from rest_framework.exceptions import ValidationError
​
# 創建Book模類的序列化類
class BookModelSerializer(ModelSerializer):
    class Meta:
        # 自定義序列化字段方法2: 該方式設置的序列化字段，必須在fields中聲明
        # publish_address = SerializerMethodField()
        # def get_publish_addr(self, obj):  obj爲當前Book對象
        #     return obj.publish.address
​
        # 1.序列化關聯的model類
        model = models.Book
        # 2.參與序列化的字段(插拔式),可選擇字段展示(model類中有的字段都可以展示,也可以在model類中自定義字段來展示)
        fields = ('name', 'price','publish_name')  # 這裏直接寫外鍵字段,到前端展示的是對應model類一條記錄的外鍵pk值
​
        # 瞭解
        # fields = '__all__'  # 展示所有model類字段,除model中自定義的方法字段
        # exclude = ('id', 'is_delete', 'create_time')  # 不展示的字段
        # depth = 1  # 自動連表深度

• 視圖層 views.py

from rest_framework.views import APIView
from rest_framework.response import Response
​
from . import models, serializers
​
class Book(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                # 根據pk查詢對應的書籍,注意要指定is_delete=False,因爲被刪除的數據不能給用戶查看
                book_obj = models.Book.objects.get(pk=pk, is_delete=False)
                # model對象不能直接返回給前端,需要序列化,拿到serializers對象字典
                book_data = serializers.BookModelSerializer(book_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '書籍不存在'
                })
        else:
            # 查所有
            book_query = models.Book.objects.filter(is_delete=False).all()
            # 序列化  注意: book_query是列表,序列化是要指定many=True
            book_data = serializers.BookModelSerializer(book_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': book_data
        })

ModelSerializer反序列化的使用

前端提交數據到後端保存或更改,後端需要對這些數據進行校驗

校驗數據的三種方式

1) 系統校驗 extra_kwargs ={}

extra_kwargs = {
            'name': {
                'required': True,
                'min_length':1,
                'error_messages': {'required':'必填項',  'min_length': '太短',}
            }
        }

2) 局部鉤子, 單個字段的額外邏輯校驗 validate_字段名

def validate_name(self, value):  # value是字段的值
        # 書名不能包含 K 字符
        if 'k' in value.lower():
            raise ValidationError('函非法字符')
        return value

3) 全局鉤子, 多個字段的聯合邏輯校驗

def validate(self, attrs):
    ...
    return attrs

使用

• 應用下創建 serializers.py

# 創建Book模型類的反序列化類
class BookModelDeserializer(ModelSerializer):
    class Meta:
        # 序列化關聯的model類
        model = models.Book
        # 1.fields內的變量名(字段)要對應關聯的model類,
        # 2.fields內的字段是前端發來的,字段有默認值的可以不參與反序列化
        fields = ('name', 'price', 'publish', 'authors')
        # extra_kwargs 用來完成反序列化字段的 系統校驗規則
        extra_kwargs = {
            'name': {
                'required': True,
                'min_length':1,
                'error_messages': {'required':'必填項',  'min_length': '太短',}
            }
        }
    # 局部鉤子
    def validate_name(self, value):
        # 書名不能包含 K 字符
        if 'k' in value.lower():
            raise ValidationError('函非法字符')
        return value
    # 全局鉤子
    def validate(self, attrs):  # attrs 是個字典
        print(attrs)
        # OrderedDict([('name', '三國'), ('price', Decimal('2.33')), ('publish', <Publish: 首都出版社>), ('authors', [<Author: hanmm>])])
        publish = attrs.get('publish')
        print(publish, type(publish))
        # 首都出版社 <class 'app01.models.Publish'>
        name = attrs.get('name')
        print(name, type(name))
        # 三國 <class 'str'>
        
        # 同一出版社的書不能重複創建
        if models.Book.objects.filter(name=name, publish=publish):
            raise ValidationError({'book': '該書已存在'})
        return attrs
​
    # ModelSerializer類已經幫我們實現了 create 與 update 方法

• 視圖層 views.py

class Book(APIView):  
    def post(self, request, *args, **kwargs):
        # 拿到數據包中的數據字典
        request_data = request.data
        # 將數據包字典反序列化並校驗,拿到序列化後的對象
        book_ser = serializers.BookModelDeserializer(data=request_data)
        # 當校驗失敗，馬上終止當前視圖方法，拋異常返回給前臺
        book_ser.is_valid(raise_exception=True)  # 指定參數raise_exception=True, 當 book_ser.is_valid爲False時自動向前端拋出錯誤
        book_obj = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.BookModelSerializer(book_obj).data
        })

注意:

ser_obj = CarModelSerializer(數據)  # 產生序列化類對象(可能參與序列化，也可能參與反序列化)
ser_obj.data  # 序列化的數據
ser_obj.is_valid()  # 啓動序列化校驗規則（系統內容=>局部鉤子=>全局鉤子）源碼中run_validation調用一系列的校驗規則
ser_obj.save()  # 序列化校驗後的數據操作(保存,修改)

ModelSerializer 序列化反序列化整合

1) fields中設置所有序列化與反序列化字段(插拔式)
2) extra_kwargs劃分只序列化或只反序列化字段
    write_only：只反序列化 (要寫入數據庫的字段)
    read_only：只序列化 (要展示給前端的字段)
    自定義字段默認只序列化(read_only)
3) 設置反序列化所需的 系統、局部鉤子、全局鉤子 等校驗規則

• serializers.py文件中:

class V2BookModelSerializer(ModelSerializer):
    class Meta:
        model = models.Book
        # 設置所有字段
        fields = ('name', 'price', 'img', 'author_list', 'publish_name', 'publish', 'authors')
        # extra_kwargs劃分只序列化或只反序列化字段
        extra_kwargs = {
            'name': {
                'required': True,
                'min_length': 1,
                'error_messages': {'required': '必填項', 'min_length': '太短', },
            },
            'publish': { 'write_only': True },  # 外鍵字段序列化到前端就是一個數字,所有沒不要參與序列化,但有必要參與反序列化
            'authors': {'write_only': True },
            'img': {'read_only': True},
            'author_list': {'read_only': True},
            'publish_name': { 'read_only': True}
        }
​
    # 局部鉤子
    def validate_name(self, value):
        # 書名不能包含 K 字符
        if 'k' in value.lower():
            raise ValidationError('函非法字符')
        return value
​
    # 全局鉤子
    def validate(self, attrs):  # attrs 是個字典
        print(attrs)
        # OrderedDict([('name', '三國'), ('price', Decimal('2.33')), ('publish', <Publish: 首都出版社>), ('authors', [<Author: hanmm>])])
        publish = attrs.get('publish')
        print(publish, type(publish))
        # 首都出版社 <class 'app01.models.Publish'>
        name = attrs.get('name')
        print(name, type(name))
        # 三國 <class 'str'>
        if models.Book.objects.filter(name=name, publish=publish):
            raise ValidationError({'book': '該書已存在'})
        return attrs

• 視圖層 views.py

查 - 單查 | 羣查

增 - 單增 | 羣增

刪 - 單刪 | 羣刪

class V2Book(APIView):
    # 單查 有pk(有指定的查)
    # 羣查 無pk
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                book_obj = models.Book.objects.get(pk=pk, is_delete=False)
                book_data = serializers.V2BookModelSerializer(book_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '書籍不存在'
                })
        else:
            book_query = models.Book.objects.filter(is_delete=False).all()
            book_data = serializers.V2BookModelSerializer(book_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': book_data
        })
​
    # 單增 : 傳輸的數據包是一個與model類對應的字典, 需要邏輯判斷
    # 羣層 : 傳輸的數據包是一個裝了多個與model類對應的列表, 需要邏輯判斷
    def post(self, request, *args, **kwargs):
        request_data = request.data
        # 單增與羣增的代碼一樣,區別在與反序列化時是否指定many=True
        if isinstance(request_data, dict):  # 判斷request_data是否是dict的對象
            # 是單增 many=False
            many = False
        elif isinstance(request_data, list): # 判斷request_data是否是dict的對象
            # 是羣增 many=True
            many = True
        else:
            # 都沒通過數據有誤
            return Response({
                'status': 1,
                'msg': '數據有誤',
            })
        # 反序列化
        book_ser = serializers.V2BookModelSerializer(data=request_data, many=many)
        # 校驗字段是否都符合
        book_ser.is_valid(raise_exception=True)
        book_obj_list = book_ser.save()
        print(book_obj_list, type(book_obj_list))  # [<Book: 東遊>, <Book: 水滸>] <class 'list'>
        return Response({
            'status': 0,
            'msg': 'ok',
            'results':serializers.V2BookModelSerializer(book_obj_list, many=many).data
        })
​
    # 單刪 有pk 指定一個pk
    # 羣刪 有pks 指定多個pk {"pks": [1, 2, 3]}
    def delete(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            pks = [pk]
        else:
            pks =request.data.get('pks')
        # 返回修改幾條記錄的數量
        num = models.Book.objects.filter(pk__in=pks, is_delete=False).update(is_delete=True)
        if num:
            return Response({
                'status': 0,
                'msg': '刪除成功',
            })
        return Response({
            'status': 1,
            'msg': '刪除失敗',
        })

改的操作:
單改 - 單整體改 | 單局部改

羣改 - 羣整體改 | 羣局部改

1) 單整體改，說明前臺要提供修改的數據，那麼數據就需要校驗，校驗的數據應該在實例化“序列化類對象”時，賦值給data
2）修改，就必須明確被修改的模型類對象，並在實例化“序列化類對象”時，賦值給instance
3）整體修改，所有校驗規則有required=True的字段，都必須提供，因爲在實例化“序列化類對象”時，參數partial默認爲False

1.單整體修改，一般用put請求：# 如果partial值設置爲True，就是可以局部改
book_ser = serializers.V2BookModelSerializer(
    instance=book_obj,  # instance是要被修改的對象,有這個參數就是修改,沒有就是增加
    data=request_data,  # 參與反序列化校驗的數據信息
    partial=False,  # partial默認就是False,意思是每個必須字段都要有,也就是整體改,反之是局部改
        )
2.單局部修改，一般用patch請求：
V2BookModelSerializer(
    instance=要被更新的對象, 
    data=用來更新的數據,
    partial=設置True，必須的字段都變爲選填字段
)
注：partial設置True的本質就是使字段 required=True 校驗規則失效

單整體改:

# 單整體修改:對 v2/books/(pk)/ 傳的數據是與model對應的字典{name|price|publish|authors}
    def put(self, request, *args, **kwargs):
        # 數據
        request_data = request.data
        # 被修改model類對象的pk
        pk = kwargs.get('pk')
        # 先拿到被修改的model類對象,再利用反序列化校驗request_data數據
        book_obj = models.Book.objects.filter(pk=pk).first()
        if book_obj is None:
            return Response({
                'status': 1,
                'msg': '參數錯誤',
            })
        # 目的：將衆多數據的校驗交給序列化類來處理 - 讓序列化類扮演反序列化角色，校驗成功後，序列化類來幫你入庫
        book_ser = serializers.V2BookModelSerializer(
            instance=book_obj,  # instance是要被修改的對象,有這個參數就是修改,沒有就是增加
            data=request_data,  # 參與反序列化校驗的數據信息
            partial=False,  # partial默認就是False,意思是每個必須字段都要有,也就是整體改,反之是局部改
        )
        # 校驗
        book_ser.is_valid(raise_exception=True)
        # 校驗通過後利用save()方法,調用ModelSerializer中的update方法自動完成單個整體修改
        book_ser.save()
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer(instance=book_obj).data  # instance=book_obj 也可以只寫book_obj,默認就是傳給instance
        })

單與羣 的 整體/局部修改 ListSerializer

• serializers.py文件中

from rest_framework.serializers import ListSerializer
# 重點：ListSerializer與ModelSerializer建立關聯的是：ModelSerializer的Meta類的 - list_serializer_class

class V2BookListSerializer(ListSerializer):
    def update(self, instance, validated_data):
        print(instance)  # 要更新的model類對象們,如Book表的一條條記錄
        print(validated_data)  # 更新的model對象對應的數據們(前端傳來的)
        print(self.child)  # 服務的模型序列化類 (這裏是:V2BookModelSerializer)
        for index, obj in enumerate(instance):
            # drf框架沒有羣改實現體,調用的是ModelSerializer的update
            self.child.update(obj, validated_data[index])
        return instance
    
# 原模型序列化類變化
class V2BookModelSerializer(ModelSerializer):
    class Meta:
        # 羣改，需要設置 自定義ListSerializer，重寫羣改的 update 方法
        list_serializer_class = V2BookListSerializer
        ...

• 視圖層 views.py

# 單局部改：對 v2/books/(pk)/ 傳的數據，數據字段key都是選填
# 羣局部改：對 v2/books/ 
# 請求數據 - [{pk:1, name:123}, {pk:3, price:7}, {pk:7, publish:2}]
    def patch(self, request, *args, **kwargs):
        request_data = request.data
        pk = kwargs.get('pk')
​
        # 將單改，羣改的數據都格式化成 pks=[需要的對象主鍵標識] | request_data=[每個要修改的對象對應的修改數據]
        if pk and isinstance(request_data, dict):  # 單局部改
            pks = [pk,]
            request_data = [request_data,]
        elif not pk and isinstance(request_data, list):  #羣局部改
            # 拿到pk
            pks = []
            for dic in request_data:  # 遍歷前臺數據[{pk:1, name:123}, {pk:3, price:7}, {pk:7, publish:2}]，拿一個個字典
                pk = dic.pop('pk', None)  # 若前臺沒有傳pk,要指定None
                if pk:
                    pks.append(pk)
                else:
                    return Response({
                        'status': 1,
                        'msg': '數據有誤',
                    })
        else:
            return Response({
                'status': 1,
                'msg': '數據有誤',
            })
​
        # pks與request_data數據篩選，
        # 1）將pks中的沒有對應數據的pk與數據已刪除的pk移除，request_data對應索引位上的數據也移除
        # 2）將合理的pks轉換爲 objs
        objs = []
        new_request_data = []
        for index, pk in enumerate(pks):
            try:
                # 拿到pk對應的合理model對象,並存儲
                obj = models.Book.objects.get('pk')
                objs.append(obj)
                # 對應索引的數據就需要保存下來
                new_request_data.append(request_data[index])
            except:
                continue
        book_ser = serializers.V2BookModelSerializer(
            instance=objs,
            data=new_request_data,
            partial=True,  # 字段任意 羣局部改和羣整體改都可以
            many=True,
        )
        book_ser.is_valid(raise_exception=True)
        book_objs = book_ser.save()  # update與create 都會返回對應的model對象
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer(book_objs, many=True).data
        })

總結

1、整體修改與局部修改
    # 序列化
    ser_obj = ModelSerializer(model_obj)  
    # 反序列化，save() => create()
    ser_obj = ModelSerializer(data=model_data)  
    # save() => update()
    ser_obj = ModelSerializer(instance=model_obj,data=model_data)  
    # partial=True => 匹配字段required=True校驗條件
    ser_obj = ModelSerializer(instance=model_obj,data=model_data,partial=True)
    

2、羣改ListSerializer
    ser_obj = ModelSerializer(instance=model_obj,data=model_data,partial=True,many=True)
    
    # 一旦設置了many=True，反序列化情況下的create、update就不再調用ModelSerializer的
    # 而是調用 ModelSerializer.Meta.list_serializer_class 指向的 ListSerializer 類的create、update
    # ListSerializer默認只實現了羣增的create，要實現羣改，必須重寫update
    
    class MyListSerializer(ListSerializer):
        def update(self, instance, validated_data):
            # print(instance)  # 要更新的對象們: [obj1, obj2, ...]
            # print(validated_data)  # 更新的對象對應的數據們: [{}, {}, ...]
            # print(self.child)  # 服務的模型序列化類 - V2BookModelSerializer
            for index, obj in enumerate(instance):
                self.child.update(obj, validated_data[index])
            return instance
            
     class MyModelSerializer(ModelSerializer):
         class Meta:
             # ...
             list_serializer_class = MyListSerializer
     
     將兩者類建立關聯，在MyListSerializer中就可以用self.child拿到MyModelSerializer，進而使用MyModelSerializer中封裝好的方法
     cls.Meta.list_serializer_class.child = cls