• DRF序列化组件

    一 序列化器-Serializer

    作用：

    1. 序列化,序列化器会把模型对象转换成字典,经过response以后变成json字符串
2. 反序列化,把客户端发送过来的数据,经过request以后变成字典,序列化器可以把字典转成模型
3. 反序列化,完成数据校验功能

    1.1 定义序列化器

    Django REST framework中的Serializer使用类来定义，须继承自rest_framework.serializers.Serializer。

    接下来，为了方便演示序列化器的使用，我们先创建一个新的子应用sers

    1
    		 
    python manage.py startapp sers

    我们已有了一个数据库模型类students/Student

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    		 
    from django.db import models

    # Create your models here.
    class Student(models.Model):
        # 模型字段
        name = models.CharField(max_length=100,verbose_name="姓名",help_text="提示文本:账号不能为空！")
        sex = models.BooleanField(default=True,verbose_name="性别")
        age = models.IntegerField(verbose_name="年龄")
        class_null = models.CharField(max_length=5,verbose_name="班级编号")
        description = models.TextField(verbose_name="个性签名")

        class Meta:
            db_table="tb_student"
            verbose_name = "学生"
            verbose_name_plural = verbose_name

    我们想为这个模型类提供一个序列化器，可以定义如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    		 
    from rest_framework import serializers

    # 声明序列化器，所有的序列化器都要直接或者间接继承于 Serializer
    # 其中，ModelSerializer是Serializer的子类，ModelSerializer在Serializer的基础上进行了代码简化
    classStudentSerializer(serializers.Serializer):
    """学生信息序列化器"""
    # 1. 需要进行数据转换的字段
        id = serializers.IntegerField()
        name = serializers.CharField()
        age = serializers.IntegerField()
        sex = serializers.BooleanField()
        description = serializers.CharField()

    # 2. 如果序列化器集成的是ModelSerializer，则需要声明调用的模型信息

    # 3. 验证代码

    # 4. 编写添加和更新模型的代码

    注意：serializer不是只能为数据库模型类定义，也可以为非数据库模型类的数据定义。serializer是独立于数据库之外的存在。

    常用字段类型：

    字段字段构造方式
    BooleanField BooleanField()
    NullBooleanField NullBooleanField()
    CharField CharField(max_length=None, min_length=None, allow_blank=False, trim_whitespace=True)
    EmailField EmailField(max_length=None, min_length=None, allow_blank=False)
    RegexField RegexField(regex, max_length=None, min_length=None, allow_blank=False)
    SlugField SlugField(maxlength=50, min_length=None, allow_blank=False) 正则字段，验证正则模式 [a-zA-Z0-9-]+
    URLField URLField(max_length=200, min_length=None, allow_blank=False)
    UUIDField UUIDField(format=’hex_verbose’) format: 1) 'hex_verbose' 如"5ce0e9a5-5ffa-654b-cee0-1238041fb31a" 2） 'hex' 如 "5ce0e9a55ffa654bcee01238041fb31a" 3）'int' - 如: "123456789012312313134124512351145145114" 4）'urn' 如: "urn:uuid:5ce0e9a5-5ffa-654b-cee0-1238041fb31a"
    IPAddressField IPAddressField(protocol=’both’, unpack_ipv4=False, **options)
    IntegerField IntegerField(max_value=None, min_value=None)
    FloatField FloatField(max_value=None, min_value=None)
    DecimalField DecimalField(max_digits, decimal_places, coerce_to_string=None, max_value=None, min_value=None) max_digits: 最多位数 decimal_palces: 小数点位置
    DateTimeField DateTimeField(format=api_settings.DATETIME_FORMAT, input_formats=None)
    DateField DateField(format=api_settings.DATE_FORMAT, input_formats=None)
    TimeField TimeField(format=api_settings.TIME_FORMAT, input_formats=None)
    DurationField DurationField()
    ChoiceField ChoiceField(choices) choices与Django的用法相同
    MultipleChoiceField MultipleChoiceField(choices)
    FileField FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
    ImageField ImageField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
    ListField ListField(child=, min_length=None, max_length=None)
    DictField DictField(child=)

    选项参数：

    参数名称作用
    max_length 最大长度
    min_lenght 最小长度
    allow_blank 是否允许为空
    trim_whitespace 是否截断空白字符
    max_value 最小值
    min_value 最大值

    通用参数：

    参数名称说明
    read_only 表明该字段仅用于序列化输出，默认False
    write_only 表明该字段仅用于反序列化输入，默认False
    required 表明该字段在反序列化时必须输入，默认True
    default 反序列化时使用的默认值
    allow_null 表明该字段是否允许传入None，默认False
    validators 该字段使用的验证器
    error_messages 包含错误编号与错误信息的字典
    label 用于HTML展示API页面时，显示的字段名称
    help_text 用于HTML展示API页面时，显示的字段帮助提示信息

    1.2 创建Serializer对象

    定义好Serializer类后，就可以创建Serializer对象了。

    Serializer的构造方法为：

    1
    		 
    Serializer(instance=None, data=empty, **kwarg)

    说明：

    1）用于序列化时，将模型类对象传入instance参数

    2）用于反序列化时，将要被反序列化的数据传入data参数

    3）除了instance和data参数外，在构造Serializer对象时，还可通过context参数额外添加数据，如

    1
    		 
    serializer = AccountSerializer(account, context={'request': request})

    通过context参数附加的数据，可以通过Serializer对象的context属性获取。

    1. 使用序列化器的时候一定要注意，序列化器声明了以后，不会自动执行，需要我们在视图中进行调用才可以。
    2. 序列化器无法直接接收数据，需要我们在视图中创建序列化器对象时把使用的数据传递过来。
    3. 序列化器的字段声明类似于我们前面使用过的表单系统。
    4. 开发restful api时，序列化器会帮我们把模型数据转换成字典.
    5. drf提供的视图会帮我们把字典转换成json,或者把客户端发送过来的数据转换字典.

    1.3 序列化器的使用

    序列化器的使用分两个阶段：

    1. 在客户端请求时，使用序列化器可以完成对数据的反序列化。
    2. 在服务器响应时，使用序列化器可以完成对数据的序列化。

    1.3.1 序列化

    1.3.1.1 基本使用

    1） 先查询出一个学生对象

    1
    2
    3
    		 
    from students.models import Student

    student = Student.objects.get(id=3)

    2） 构造序列化器对象

    1
    2
    3
    		 
    from .serializers import StudentSerializer

    serializer = StudentSerializer(instance=student)

    3）获取序列化数据

    通过data属性可以获取序列化后的数据

    1
    2
    		 
    serializer.data
    # {'id': 4, 'name': '小张', 'age': 18, 'sex': True, 'description': '猴赛雷'}

    完整视图代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    		 
    from django.views import View
    from students.models import Student
    from .serializers import StudentSerializer
    from django.http.response import JsonResponse
    class StudentView(View):
        """使用序列化器序列化转换单个模型数据"""
        defget(self,request,pk):
            # 获取数据
            student = Student.objects.get(pk=pk)
    # 数据转换[序列化过程]
            serializer = StudentSerializer(instance=student)
            print(serializer.data)
    # 响应数据
    return JsonResponse(serializer.data)

    4）如果要被序列化的是包含多条数据的查询集QuerySet，可以通过添加many=True参数补充说明

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    		 
    """使用序列化器序列化转换多个模型数据"""
    defget(self,request):
        # 获取数据
        student_list = Student.objects.all()

    # 转换数据[序列化过程]
    # 如果转换多个模型对象数据，则需要加上many=True
        serializer = StudentSerializer(instance=student_list,many=True)
        print( serializer.data ) # 序列化器转换后的数据

    # 响应数据给客户端
    # 返回的json数据，如果是列表，则需要声明safe=False
    return JsonResponse(serializer.data,safe=False)


    # 访问结果：
    # [OrderedDict([('id', 1), ('name', 'xiaoming'), ('age', 20), ('sex', True), ('description', '测试')]), OrderedDict([('id', 2), ('name', 'xiaohui'), ('age', 22), ('sex', True), ('description', '后面来的测试')]), OrderedDict([('id', 4), ('name', '小张'), ('age', 18), ('sex', True), ('description', '猴赛雷')])]

    1.3.1.2 高级用法

    1
    		 
    #source和serializers.SerializerMethodField()的用法
    		 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    		 
    # models.py
    from django.db import models

    classBook(models.Model):
        title=models.CharField(max_length=32)
        price=models.IntegerField()
        pub_date=models.DateField()
        publish=models.ForeignKey("Publish",on_delete=models.CASCADE,null=True)
        authors=models.ManyToManyField("Author")
    def__str__(self):
    return self.title

    classPublish(models.Model):
        name=models.CharField(max_length=32)
        email=models.EmailField()
    def__str__(self):
    return self.name

    classAuthor(models.Model):
        name=models.CharField(max_length=32)
        age=models.IntegerField()
    def__str__(self):
    return self.name
    		 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    		 
    # ser.py
    from rest_framework import serializers
    from app01.models import Book
    classBookSerializers(serializers.Serializer):
        id=serializers.CharField(read_only=True)
        title=serializers.CharField(max_length=32)
        price=serializers.IntegerField()
        pub_date=serializers.DateField()
    # publish=serializers.CharField(source="publish.name",read_only=True)
        publish=serializers.CharField(source="publish.name",default='xxx')
    #authors=serializers.CharField(source="authors.all")
        authors=serializers.SerializerMethodField(read_only=True)
    defget_authors(self,obj):
            temp=[]
    for author in obj.authors.all():
                temp.append(author.name)
    return temp

    defcreate(self, validated_data):
            print(validated_data)
            publish_id=validated_data.get('publish').get('name')
            print(publish_id)
    del validated_data['publish']
    return Book.objects.create(publish_id=publish_id,**validated_data)

    defupdate(self, instance, validated_data):
            print(validated_data.get('aa'))
            instance.title = validated_data.get('title', instance.title)
            instance.price = validated_data.get('price', instance.price)
            instance.pub_date = validated_data.get('pub_date', instance.pub_date)
            print(validated_data.get('publish', instance.publish))
            instance.publish_id = validated_data.get('publish', instance.publish).get('name')
            instance.save()
    return instance
    		 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    		 
    # views.py
    from django.shortcuts import render,HttpResponse
    from app01 import models

    from django.http import HttpRequest

    from rest_framework.views import APIView
    from app01.models import Book
    from rest_framework.response import Response
    from app01.ser import BookSerializers
    classBookViewSet(APIView):

    defget(self,request,*args,**kwargs):
            book_list=Book.objects.all()
    # 序列化方式3:
            bs=BookSerializers(book_list,many=True)     #many=True代表有多条数据，如果只有一条数据，many=False
    return Response(bs.data)
    defpost(self,request,*args,**kwargs):

            bs=BookSerializers(data=request.data)
            bs.is_valid(raise_exception=True)
    # print(bs.validated_data)
            bs.save()
    return Response(bs.data)

    classBookDetailView(APIView):
    defget(self,request,pk):
            book_obj=models.Book.objects.filter(pk=pk).first()
            bs=BookSerializers(book_obj,many=False)
    return Response(bs.data)
    defput(self,request,pk):
            book_obj = models.Book.objects.filter(pk=pk).first()

            bs=BookSerializers(instance=book_obj,data=request.data,partial=True)
    if bs.is_valid():
                bs.save(aa="lqz") # update
    return Response(bs.data)
    else:
    return Response(bs.errors)
    defdelete(self,request,pk):
            models.Book.objects.filter(pk=pk).delete()

    return Response("")
    		 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    		 
    # urls.py
    from django.contrib import admin
    from django.urls import path,re_path
    from app01 import views
    urlpatterns = [
        path('admin/', admin.site.urls),
        path('books/', views.BookViewSet.as_view()),
        re_path('books/(?P<pk>d+)/', views.BookDetailView.as_view()),
    ]

    注意：

    source 如果是字段，会显示字段，如果是方法，会执行方法，不用加括号（authors=serializers.CharField(source=’authors.all’)）

    如在模型中定义一个方法，直接可以在在source指定执行

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    		 
    classUserInfo(models.Model):
        user_type_choices = (
            (1,'普通用户'),
            (2,'VIP'),
            (3,'SVIP'),
        )
        user_type = models.IntegerField(choices=user_type_choices)

        username = models.CharField(max_length=32,unique=True)
        password = models.CharField(max_length=64)


    #视图
    ret=models.UserInfo.objects.filter(pk=1).first()
    aa=ret.get_user_type_display()

    #serializer
    xx=serializers.CharField(source='get_user_type_display')

    1.3.2 反序列化

    1.3.2.1 数据验证

    使用序列化器进行反序列化时，需要对数据进行验证后，才能获取验证成功的数据或保存成模型类对象。

    在获取反序列化的数据前，必须调用is_valid()方法进行验证，验证成功返回True，否则返回False。

    验证失败，可以通过序列化器对象的errors属性获取错误信息，返回字典，包含了字段和字段的错误。如果是非字段错误，可以通过修改REST framework配置中的NON_FIELD_ERRORS_KEY来控制错误字典中的键名。

    验证成功，可以通过序列化器对象的validated_data属性获取数据。

    在定义序列化器时，指明每个字段的序列化类型和选项参数，本身就是一种验证行为。

    如我们前面定义过的BookInfoSerializer

    1
    2
    3
    4
    5
    6
    7
    8
    		 
    classBookInfoSerializer(serializers.Serializer):
        """图书数据序列化器"""
        id = serializers.IntegerField(label='ID', read_only=True)
        btitle = serializers.CharField(label='名称', max_length=20)
        bpub_date = serializers.DateField(label='发布日期', required=False)
        bread = serializers.IntegerField(label='阅读量', required=False)
        bcomment = serializers.IntegerField(label='评论量', required=False)
        image = serializers.ImageField(label='图片', required=False)

    通过构造序列化器对象，并将要反序列化的数据传递给data构造参数，进而进行验证

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    		 
    from booktest.serializers import BookInfoSerializer
    data = {'bpub_date': 123}
    serializer = BookInfoSerializer(data=data)
    serializer.is_valid()  # 返回False
    serializer.errors
    # {'btitle': [ErrorDetail(string='This field is required.', code='required')], 'bpub_date': [ErrorDetail(string='Date has wrong format. Use one of these formats instead: YYYY[-MM[-DD]].', code='invalid')]}
    serializer.validated_data  # {}

    data = {'btitle': 'python'}
    serializer = BookInfoSerializer(data=data)
    serializer.is_valid()  # True
    serializer.errors  # {}
    serializer.validated_data  #  OrderedDict([('btitle', 'python')])

    is_valid()方法还可以在验证失败时抛出异常serializers.ValidationError，可以通过传递raise_exception=True参数开启，REST framework接收到此异常，会向前端返回HTTP 400 Bad Request响应。

    1
    2
    		 
    # Return a 400 response if the data was invalid.
    serializer.is_valid(raise_exception=True)

    如果觉得这些还不够，需要再补充定义验证行为，可以使用以下三种方法：

    1) validate_字段名

    对<field_name>字段进行验证，如

    1
    2
    3
    4
    5
    6
    7
    8
    		 
    classBookInfoSerializer(serializers.Serializer):
        """图书数据序列化器"""
        ...

        defvalidate_btitle(self, value):
            if 'django' not in value.lower():
                raise serializers.ValidationError("图书不是关于Django的")
            return value

    测试

    1
    2
    3
    4
    5
    6
    		 
    from booktest.serializers import BookInfoSerializer
    data = {'btitle': 'python'}
    serializer = BookInfoSerializer(data=data)
    serializer.is_valid()  # False   
    serializer.errors
    #  {'btitle': [ErrorDetail(string='图书不是关于Django的', code='invalid')]}
    2) validate

    在序列化器中需要同时对多个字段进行比较验证时，可以定义validate方法来验证，如

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    		 
    classBookInfoSerializer(serializers.Serializer):
        """图书数据序列化器"""
        ...

        defvalidate(self, attrs):
            bread = attrs['bread']
            bcomment = attrs['bcomment']
            if bread < bcomment:
                raise serializers.ValidationError('阅读量小于评论量')
            return attrs

    测试

    1
    2
    3
    4
    5
    6
    		 
    from booktest.serializers import BookInfoSerializer
    data = {'btitle': 'about django', 'bread': 10, 'bcomment': 20}
    s = BookInfoSerializer(data=data)
    s.is_valid()  # False
    s.errors
    #  {'non_field_errors': [ErrorDetail(string='阅读量小于评论量', code='invalid')]}
    3) validators

    在字段中添加validators选项参数，也可以补充验证行为，如

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    		 
    defabout_django(value):
        if 'django' not in value.lower():
            raise serializers.ValidationError("图书不是关于Django的")

    classBookInfoSerializer(serializers.Serializer):
        """图书数据序列化器"""
        id = serializers.IntegerField(label='ID', read_only=True)
        btitle = serializers.CharField(label='名称', max_length=20, validators=[about_django])
        bpub_date = serializers.DateField(label='发布日期', required=False)
        bread = serializers.IntegerField(label='阅读量', required=False)
        bcomment = serializers.IntegerField(label='评论量', required=False)
        image = serializers.ImageField(label='图片', required=False)

    测试：

    1
    2
    3
    4
    5
    6
    		 
    from booktest.serializers import BookInfoSerializer
    data = {'btitle': 'python'}
    serializer = BookInfoSerializer(data=data)
    serializer.is_valid()  # False   
    serializer.errors
    #  {'btitle': [ErrorDetail(string='图书不是关于Django的', code='invalid')]}

    1.3.2.2 反序列化-保存数据

    前面的验证数据成功后,我们可以使用序列化器来完成数据反序列化的过程.这个过程可以把数据转成模型类对象.

    可以通过实现create()和update()两个方法来实现。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    		 
    classBookInfoSerializer(serializers.Serializer):
        """图书数据序列化器"""
        ...

        defcreate(self, validated_data):
            """新建"""
            return BookInfo(**validated_data)

        defupdate(self, instance, validated_data):
            """更新，instance为要更新的对象实例"""
            instance.btitle = validated_data.get('btitle', instance.btitle)
            instance.bpub_date = validated_data.get('bpub_date', instance.bpub_date)
            instance.bread = validated_data.get('bread', instance.bread)
            instance.bcomment = validated_data.get('bcomment', instance.bcomment)
            return instance

    如果需要在返回数据对象的时候，也将数据保存到数据库中，则可以进行如下修改

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    		 
    classBookInfoSerializer(serializers.Serializer):
        """图书数据序列化器"""
        ...

        defcreate(self, validated_data):
            """新建"""
            return BookInfo.objects.create(**validated_data)

        defupdate(self, instance, validated_data):
            """更新，instance为要更新的对象实例"""
            instance.btitle = validated_data.get('btitle', instance.btitle)
            instance.bpub_date = validated_data.get('bpub_date', instance.bpub_date)
            instance.bread = validated_data.get('bread', instance.bread)
            instance.bcomment = validated_data.get('bcomment', instance.bcomment)
            instance.save()
            return instance

    实现了上述两个方法后，在反序列化数据的时候，就可以通过save()方法返回一个数据对象实例了

    1
    		 
    book = serializer.save()

    如果创建序列化器对象的时候，没有传递instance实例，则调用save()方法的时候，create()被调用，相反，如果传递了instance实例，则调用save()方法的时候，update()被调用。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    		 
    from db.serializers import BookInfoSerializer
    data = {'btitle': '封神演义'}
    serializer = BookInfoSerializer(data=data)
    serializer.is_valid()  # True
    serializer.save()  # <BookInfo: 封神演义>

    from db.models import BookInfo
    book = BookInfo.objects.get(id=2)
    data = {'btitle': '倚天剑'}
    serializer = BookInfoSerializer(book, data=data)
    serializer.is_valid()  # True
    serializer.save()  # <BookInfo: 倚天剑>
    book.btitle  # '倚天剑'

    1.3.2.3 附加说明

    1） 在对序列化器进行save()保存时，可以额外传递数据，这些数据可以在create()和update()中的validated_data参数获取到

    1
    2
    		 
    # request.user 是django中记录当前登录用户的模型对象
    serializer.save(owner=request.user)

    2）默认序列化器必须传递所有required的字段，否则会抛出验证异常。但是我们可以使用partial参数来允许部分字段更新

    1
    2
    		 
    # Update `comment` with partial data
    serializer = CommentSerializer(comment, data={'content': u'foo bar'}, partial=True)

    1.3.3 模型类序列化器

    如果我们想要使用序列化器对应的是Django的模型类，DRF为我们提供了ModelSerializer模型类序列化器来帮助我们快速创建一个Serializer类。

    ModelSerializer与常规的Serializer相同，但提供了：

    • 基于模型类自动生成一系列字段
    • 基于模型类自动为Serializer生成validators，比如unique_together
    • 包含默认的create()和update()的实现

    1.3.3.1 定义

    比如我们创建一个BookInfoSerializer

    1
    2
    3
    4
    5
    		 
    classBookInfoSerializer(serializers.ModelSerializer):
        """图书数据序列化器"""
        classMeta:
            model = BookInfo
            fields = '__all__'
    • model 指明参照哪个模型类
    • fields 指明为模型类的哪些字段生成

    我们可以在python manage.py shell中查看自动生成的BookInfoSerializer的具体实现

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    		 
    >>> from booktest.serializers import BookInfoSerializer
    >>> serializer = BookInfoSerializer()
    >>> serializer
    BookInfoSerializer():
        id = IntegerField(label='ID', read_only=True)
        btitle = CharField(label='名称', max_length=20)
        bpub_date = DateField(allow_null=True, label='发布日期', required=False)
        bread = IntegerField(label='阅读量', max_value=2147483647, min_value=-2147483648, required=False)
        bcomment = IntegerField(label='评论量', max_value=2147483647, min_value=-2147483648, required=False)
        image = ImageField(allow_null=True, label='图片', max_length=100, required=False)

    1.3.3.2 指定字段

    1) 使用fields来明确字段，__all__表名包含所有字段，也可以写明具体哪些字段，如

    1
    2
    3
    4
    5
    		 
    classBookInfoSerializer(serializers.ModelSerializer):
        """图书数据序列化器"""
        classMeta:
            model = BookInfo
            fields = ('id', 'btitle', 'bpub_date')

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

    1
    2
    3
    4
    5
    		 
    classBookInfoSerializer(serializers.ModelSerializer):
        """图书数据序列化器"""
        classMeta:
            model = BookInfo
            exclude = ('image',)

    3) 显示指明字段，如：

    1
    2
    3
    4
    5
    6
    		 
    classHeroInfoSerializer(serializers.ModelSerializer):
        hbook = BookInfoSerializer()

        classMeta:
            model = HeroInfo
            fields = ('id', 'hname', 'hgender', 'hcomment', 'hbook')

    4) 指明只读字段

    可以通过read_only_fields指明只读字段，即仅用于序列化输出的字段

    1
    2
    3
    4
    5
    6
    		 
    classBookInfoSerializer(serializers.ModelSerializer):
        """图书数据序列化器"""
        classMeta:
            model = BookInfo
            fields = ('id', 'btitle', 'bpub_date'， 'bread', 'bcomment')
            read_only_fields = ('id', 'bread', 'bcomment')

    1.3.3.3 添加额外参数选项

    我们可以使用extra_kwargs参数为ModelSerializer添加或修改原有的选项参数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    		 
    classBookInfoSerializer(serializers.ModelSerializer):
        """图书数据序列化器"""
        classMeta:
            model = BookInfo
            fields = ('id', 'btitle', 'bpub_date', 'bread', 'bcomment')
            extra_kwargs = {
                'bread': {'min_value': 0, 'required': True},
                'bcomment': {'min_value': 0, 'required': True},
            }

    # BookInfoSerializer():
    #    id = IntegerField(label='ID', read_only=True)
    #    btitle = CharField(label='名称', max_length=20)
    #    bpub_date = DateField(allow_null=True, label='发布日期', required=False)
    #    bread = IntegerField(label='阅读量', max_value=2147483647, min_value=0, required=True)
    #    bcomment = IntegerField(label='评论量', max_value=2147483647, min_value=0, required=True)

    1.4 局部全局校验源码分析

    1
    		 
    #is_valid---->self.run_validation-(执行Serializer的run_validation)-->self.to_internal_value(data)---（执行Serializer的run_validation：485行）

    image-20200706212122698

    image-20200706212239321

    1.5 序列化组件源码分析

    1
    2
    3
    4
    5
    		 
    序列化组件，先调用__new__方法，如果many=True，生成ListSerializer对象，如果为False，生成Serializer对象
    序列化对象.data方法--调用父类data方法---调用对象自己的to_representation（自定义的序列化类无此方法，去父类找）
    Aerializer类里有to_representation方法，for循环执行attribute = field.get_attribute(instance)
    再去Field类里去找get_attribute方法，self.source_attrs就是被切分的source，然后执行get_attribute方法，source_attrs
    当参数传过去，判断是方法就加括号执行，是属性就把值取出来
  • 相关阅读:
    apache的用户认证
    Apache的配置文件
    AH00052: child pid 25043 exit signal Segmentation fault (11)
    Apache的工作模式
    apache的目录别名
    RAID的几种级别
    网络服务--NFS服务
    MySQL 5.7元数据库
    [ERROR] COLLATION 'latin1_swedish_ci' is not valid for CHARACTER SET 'utf8'
    .Net MVC断点进不去
  • 原文地址：https://www.cnblogs.com/plyc/p/14055559.html
Copyright © 2020-2023  润新知