drf框架 - 序列化組件 | ModelSerializer (查,增,刪,改)

ModelSerializer

序列化准備:

• 配置 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 = [
    ...
]

 

• 模型層: 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

 

知識補充:

• 基表

# 上述的表中都含有 is_delete、create_time 字段,我們可以創建一個基表類含有這兩個字段,其他的表來繼承這個基表類即可(類似抽象類)
​
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

​

• 斷關聯多表關系(***)

1、外鍵位置：
    一對多 - 外鍵放多的一方
    一對一 - 從邏輯正反向考慮，如作者表與作者詳情表，作者刪除級聯刪除詳情，詳情刪除作者依舊存在，所以建議外鍵在詳情表中
    多對多 - 外鍵在關系表中
2、ORM正向方向連表查找：
    正向：通過外鍵字段 eg: author_detial_obj.author 
    反向：通過related_name的值 eg：author_obj.detail
    注：依賴代碼見下方
3、連表操作關系：
    1）作者刪除，作者詳情級聯 - on_delete=models.CASCADE  # 被關聯表中的數據刪除,主關聯表中的對應數據也刪除 2）作者刪除，作者詳情置空 - null=True, on_delete=models.SET_NULL  # 被關聯表中的數據刪除,主關聯表中的對應的字段為空(null) 3）作者刪除，作者詳情重置 - default=0, on_delete=models.SET_DEFAULT  # 被關聯表中的數據刪除,主關聯表中的對應數據字段可以通過事先定義好的default=0改為0 4）作者刪除，作者詳情不動 - on_delete=models.DO_NOTHING # 被關聯表中的數據刪除,主關聯表中的數據不做任何處理
    注：拿作者與作者詳情表舉例
4、外鍵關聯字段的參數 - 如何實現 斷關聯、目前表間操作關系、方向查詢字段
    - 圖書表中:
    # 關聯出版社外鍵字段
    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',
    )
    - 作者詳情表中
    author = models.OneToOneField(
        to='Author',
        db_constraint=False,
        related_name='detail',
        on_delete=models.CASCADE,  # 級聯
    )
注意: 
    1.ManyToManyField不能設置on_delete，OneToOneField、ForeignKey必須設置on_delete（django1.x系統默認級聯，但是django2.x必須手動明確）
    2.OneToOneField 本質是繼承了 ForeignKey

 

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 序列化 使用:

• 應用下創建 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  # 自動連表深度

 

• 視圖層

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
        })

 

• 路由層

urlpatterns = [
    url(r'^books/$', views.Book.as_view()),
    url(r'^books/(?P<pk>.*)/$', views.Book.as_view()),
]

 

 

ModelSerializer 反序列化 使用:

• 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 方法

 

• 視圖層

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()  # 序列化校驗后的數據操作(保存,修改)

 

• 路由層

urlpatterns = [
    url(r'^books/$', views.Book.as_view()),
    url(r'^books/(?P<pk>.*)/$', views.Book.as_view()),
]

 

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

 

• 視圖層

查 - 單查 | 群查

增 - 單增 | 群增

刪 - 單刪 | 群刪

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': '刪除失敗',
        })

 

• 路由層

from django.conf.urls import url
from . import views
​
urlpatterns = [
    url('^v2/books/$', views.V2Book.as_view()),
    url('^v2/books/(?P<pk>.*)/$', views.V2Book.as_view()),
]

 

改的操作:

單改 - 單整體改 | 單局部改

群改 - 群整體改 | 群局部改

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 校驗規則失效

 

1.單整體改:

# 單整體修改:對 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
        })

 

2.單與群 的 整體/局部修改 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
        ...

 

• 視圖層

# 單局部改：對 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

 

 

Serializer與ModelSerializer區別:

序列化:
Serializer:

- 1. 序列化的字段數量可隨意,單要與表中字段名對應
- 2. 自定義序列化屬性:
gender = serializers.SerializerMethodField()
def get_gender(self, obj): # obj是對應表中的一條記錄(即:對象)
# choice類型的解釋型值 get_字段_display() 來訪問
return obj.get_sex_display()
​
icon = serializers.SerializerMethodField()
def get_icon(self, obj):
# settings.MEDIA_URL: 自己配置的 /media/，給后面高級序列化與視圖類准備的
# obj.icon不能直接作為數據返回，因為內容雖然是字符串，但是類型是ImageFieldFile類型
return '%s%s%s' % (r'http://127.0.0.1:8000', settings.MEDIA_URL, str(obj.icon))

 

ModelSerializer:

- 1. class Meta類中關聯序列化表,字段采用插拔式在fields中注冊
- 2. 自定義序列化字段:
該方式設置的序列化字段，必須在fields中聲明
publish_address = SerializerMethodField()
def get_publish_addr(self, obj):
return obj.publish.address

model類中自定義序列化字段
@property
def publish_name(self):
return self.publish.name # 利用跨表查詢返回publish的name
@property
def author_list(self):
return self.authors.values('name', 'detail__mobile')

 

反序列化:
Serializer:

- 1. 可使用局部鈎子和全局鈎子
- 2. 
類似froms組件的單字段校驗規則,不滿足時采用局部鈎子
name = serializers.CharField(
　　max_length=64,
　　min_length=3,
　　error_messages={
　　　　'max_length': '太長',
　　　　'min_length': '太短'
　　}
　　)
create,update 自定義, 序列化對象.save()時會調用

 

ModelSerializer:

- 1. 可使用局部鈎子和全局鈎子
- 2. 
extra_kwargs 用來完成反序列化字段的 系統校驗規則
　　extra_kwargs = {
　　　　'name': {
　　　　'required': True,
　　　　'min_length':1,
　　　　'error_messages': {'required':'必填項', 'min_length': '太短',}
　　}
　　}
ModelSerializer類已經幫我們實現了 create 與 update 方法,序列化對象.save()時會調用,也可以在序列化類中自定義