drf入门到精通： 序列化类常用字段和字段参数、序列化高级用法之source、 序列化高级用法之定制字段的两种方式、 多表关联反序列化保存、反序列化字段校验其他、模型类序列化器

目录

• 1 序列化类常用字段和字段参数
  • 1.1 常用字段类
  • 1.2 常用字段参数
• 2 序列化高级用法之source
  • • 代码演示：
  • 2.1 序列化定制字段名字
• 3 序列化高级用法之定制字段的两种方式
  • 3.1 SerializerMethodField定制
  • 3.2 在表模型中定制
• 4 多表关联反序列化保存
  • 4.1 新增图书接口
  • 4.2 修改图书接口
• 5 反序列化字段校验其他
• 6 模型类序列化器

1 序列化类常用字段和字段参数

# 序列化类---》字段类 CharField，除此之外还有哪些其他的

# 序列化类---》字段类，字段类上，传属性的 ，序列化类上，也可以写属性
【models.CharField(max_length=32)】

1.1 常用字段类

重点掌握的

CharField:
    max_length=None, min_length=None, allow_blank=False, trim_whitespace=True

BooleanField：BooleanField()

IntegerField：IntegerField(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)

其他更多

1 BooleanField	      BooleanField()

2 NullBooleanField	  NullBooleanField()

3 CharField	CharField(max_length=None, min_length=None, allow_blank=False, trim_whitespace=True)

4 EmailField	EmailField(max_length=None, min_length=None, allow_blank=False)

5 RegexField	RegexField(regex, max_length=None, min_length=None, allow_blank=False)

6 SlugField	SlugField(max_length=50, min_length=None, allow_blank=False) 正则字段，验证正则模式 [a-zA-Z0-9-]+

7 URLField	URLField(max_length=200, min_length=None, allow_blank=False)

8 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"

9 IPAddressField	IPAddressField(protocol=’both’, unpack_ipv4=False, **options)

10 IntegerField	IntegerField(max_value=None, min_value=None)

11 FloatField	FloatField(max_value=None, min_value=None)

12 DecimalField	DecimalField(max_digits, decimal_places, coerce_to_string=None, max_value=None, min_value=None) max_digits: 最多位数 decimal_palces: 小数点位置

13 DateTimeField	DateTimeField(format=api_settings.DATETIME_FORMAT, input_formats=None)

14 DateField	DateField(format=api_settings.DATE_FORMAT, input_formats=None)

15 TimeField	TimeField(format=api_settings.TIME_FORMAT, input_formats=None)

16 DurationField	DurationField()

17 ChoiceField	ChoiceField(choices) choices与Django的用法相同

18 MultipleChoiceField	MultipleChoiceField(choices)

19 FileField	FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)

20 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=)

1.2 常用字段参数

选项参数：

CharField及其子类的(EmailField) ---》反序列化的校验,字段自己的规则

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

IntegerField:

max_value	最大值
min_value	最小值

所有字段类都有的:

参数名称	作用
required	表明该字段在反序列化时必须输入，默认True
default	反序列化时使用的默认值
allow_null	表明该字段是否允许传入None，默认False
validators	该字段使用的验证码

只需了解的:

error_messages	包含错误编号与错误信息的字典
label	用于HTML展示API页面时显示的字段名称
help_text	用于HTML展示API页面时显示的字段帮助提示信息

重点补充：

• read_only：表明该字段仅用于序列化输出,默认False

• write_only：表明该字段仅用于反序列化输入，默认False

反序列化校验执行流程

-1 先执行字段自己的校验规则----》最大长度，最小长度，是否为空，是否必填，最小数字。。。。
-2 validators=[方法，] ----》单独给这个字段加校验规则
   name=serializers.CharField(validators=[方法,])
-3 局部钩子校验规则
-4 全局钩子校验规则

2 序列化高级用法之source

使用source可以指定序列化表中的哪个字段也可以是方法，且还可以做跨表查询，用于重命名，重命名后在前端显示

代码演示：

创建关联表:models.py

from django.db import models


# 图书跟作者：多对多，需要建立中间表，但是我们可以通过ManyToManyField自动生成，写在哪里都行
# 图书跟出版社：一对多，一个出版社，出版多本书，关联字段写在多的一方，写在Book
class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.CharField(max_length=32)

    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)  # 留住，还有很多
    authors = models.ManyToManyField(to='Author')


class Publish(models.Model):
    name = models.CharField(max_length=32)
    addr = models.CharField(max_length=32)
    # 指定在book中现实publish的名字方案一，用的不多
    # def __str__(self):
    #     return self.name

class Author(models.Model):
    name = models.CharField(max_length=32)
    phone = models.CharField(max_length=11)

迁移,录入数据

2.1 序列化定制字段名字

重点：source可以指定序列化字段的名字

views.py:

from rest_framework.views import APIView
from rest_framework.response import Response
from .models import Book,Publish,Author
from .serializer import BookSerializer
class BookView(APIView):
    def get(self,request):
        books = Book.objects.all()
        ser = BookSerializer(instance=books,many=True)
        return Response(ser.data)

serializer.py:

class BookSerializer(serializers.Serializer):
    # 字段参数，通用的，所有字段都可以写  通过source指定哪个字段
    # 自有字段，直接写字段名字 序列化book表中的name字段并重命名成name_real
    name_real = serializers.CharField(max_length=8, source='name')
    # 序列化book表中的price字段并重命名成real_price
    real_price = serializers.CharField(source='price')

    # 关联字段，一对多的关联，直接点 
    #序列化与book表关联的出版社名字重名成publish
    publish = serializers.CharField(source='publish.name')

    #多对多，搞不了,source不能用
    authors=serializers.CharField(source='authors.all')

3 序列化高级用法之定制字段的两种方式

3.1 SerializerMethodField定制

定制关联字段的显示形式:

• 一对多的，显示字典
• 多对多，显示列表套字典

class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8)
    price = serializers.CharField()
# publish_detail要序列化成 {name:出版社名，addr：地址}
    # 方式一：SerializerMethodField必须配合一个方法(get_字段名,需要接受一个参数)，方法返回什么，这个字段就是什么

    publish_detail = serializers.SerializerMethodField()

        # obj 是当前序列化的对象
    def get_publish_detail(self,obj):
        return {'name': obj.publish.name, 'addr':obj.publish.addr}

    author_list = serializers.SerializerMethodField()
    def get_author_list(self, obj):
        l = []
        for author in obj.authors.all():
            l.append({'name':author.name, 'phone':author.phone})
        return l

3.2 在表模型中定制

表模型

class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.CharField(max_length=32)

    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)  # 留住，还有很多
    authors = models.ManyToManyField(to='Author')

    # 写了个方法，可以包装成数据属性，也可以不包
    @property
    def publish_detail(self):
        return {'name': self.publish.name, 'addr': self.publish.addr}
    @property
    def author_list(self):
        l = []
        for author in self.authors.all():
            l.append({'name': author.name, 'phone': author.phone})
        return l

序列化类

class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8)
    price = serializers.CharField()

    # publish_detail = serializers.CharField()
    publish_detail = serializers.DictField()
    author_list = serializers.ListField()

4 多表关联反序列化保存

4.1 新增图书接口

新增图书接口

前端传入的数据格式：
{name:红楼梦,price:19,publish:1,authors:[1,2]}

视图类

class BookView(APIView):
    def post(self, request):
        ser = BookSerializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '新增成功'})
        else:
            return Response({'code': 101, 'msg': ser.errors})

序列化类

class BookSerializer(serializers.Serializer):
    # name和price  既用来序列化，又用来反序列化   即写又读 ,不用加read_only，write_only
    name = serializers.CharField(max_length=8)
    price = serializers.CharField()

   # 1 序列化字段和反序列化字段不一样  【序列化类中】
    # 只用来做序列化   只读  read_only
    publish_detail = serializers.DictField(read_only=True)
    author_list = serializers.ListField(read_only=True)

    # 只用来做反序列化  只写  write_only
    publish = serializers.CharField(write_only=True)
    authors = serializers.ListField(write_only=True)

    # 新增要重写create方法
    # 2 一定要重写create  【序列化类中】
    def create(self, validated_data):
        # validated_data 校验过后的数据，{name:红楼梦,price:19,publish:1,authors:[1,2]}
        # 新增一本图书
        book = Book.objects.create(name=validated_data.get('name'), price=validated_data.get('price'),
                                   publish_id=validated_data.get('publish'))

        # 作者也要关联上
        # book.authors   add remove set clear....
        book.authors.add(*validated_data.get('authors'))
        # book.authors.add(1,2)
        return book

4.2 修改图书接口

新增图书接口

前端传入的数据格式：{name:红楼梦,price:19,publish:1,authors:[1,2]}

视图类

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

序列化类

反序列化的多表关联的保存
class BookSerializer(serializers.Serializer):
    # name和price  既用来序列化，又用来反序列化   即写又读 ,不用加read_only，write_only
    name = serializers.CharField(max_length=8)
    price = serializers.CharField()

    # 只用来做反序列化  只写  write_only
    publish = serializers.CharField(write_only=True)
    authors = serializers.ListField(write_only=True)


    # 修改要重写update
    def update(self, instance, validated_data):
        # validated_data 校验过后的数据，{name:红楼梦,price:19,publish:1,authors:[1,2]}
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.publish_id = validated_data.get('publish')

        # 先清空，再add
        authors = validated_data.get('authors')
        instance.authors.clear()
        instance.authors.add(*authors)

        instance.save()

        return instance

ps：使用继承Serializer的序列化类如果是新增或者修改在序列化类中都需要重写create或update，且序列化中每个字段都要写无论是序列化还是反序列化，我们可以通过ModelSerializer来更简单的做

5 反序列化字段校验其他

反序列化的数据校验与forms的数据校验很像也有字段自己的校验规则、局部钩子与全局钩子

• 继承了Serializer后字段校验写法

name = serializers.CharField(
                max_length=8,
                min_length=3,
                error_messages={'min_length': "太短了"})
# error_messages抛出异常

• 继承了ModelSerializer后字段校验写法

extra_kwargs = {
    'name':{'max_length':8,'min_length':3,'error_messages':{'min_length': "太短了"}}
    'price':{'max_value':100,'min_value':0,'error_messages':{'min_length': "太小了"}}
}

• 局部、全局校验

# 继承了Serializer、ModelSerializer的写法一样
# 局部钩子
def validate_name(self,name):
    if name.startswith('sb'):
        # 校验不通过抛异常
        raise ValidationError('名字不能以sb开头你是不是傻')
    else:
        return name
# 全局钩子 
def validate(self,user):
    if user.get('password') == user.get('re_password'):
        return user
    else:
        raise ValidationError('')

6 模型类序列化器

模型类序列化器就是(ModelSerializer)的使用，ModelSerializer继承了serializers所以用起来更加的方便不需要自己再重写create和update了

ModelSerializer的使用

class BookSerializer(serializers.ModelSerializer):
    # 跟表有关联 不需要再一个个的写字段,直接从表模型中映射过来
    class Meta:
        model = Book  # 跟book表建立了关系     序列化类和表模型类
         fields = '__all__'  # 序列化所有Book中的字段  id name price publish authors
        fields = ['name', 'price', 'publish_detail', 'author_list', 'publish', 'authors']  # 序列化所有Book中的name和price字段字段 给字段添加属性

        # 定制name反序列化时，最长不能超过8   给字段类加属性---方式一
        extra_kwargs = {'name': {'max_length': 8},
                        'publish_detail': {'read_only': True},
                        'author_list': {'read_only': True},
                        'publish': {'write_only': True},
                        'authors': {'write_only': True},
                        }

    # 如果Meta写了__all__ ,就相当于，复制了表模型中的所有字段，放在了这里，做了个映射
    #  name = serializers.CharField(max_length=32)
    #  price = serializers.CharField(max_length=32)

     # 定制name反序列化时，最长不能超过8   给字段类加属性---方式二，重写name字段
     # name = serializers.CharField(max_length=8)

     # 同理，所有的read_only和wirte_only都可以通过重写或使用extra_kwargs传入

    # 终极，把这个序列化类写成跟之前一模一样项目
    #  publish_detail = serializers.SerializerMethodField(read_only=True)
    #  def get_publish_detail(self, obj):
    #      return {'name': obj.publish.name, 'addr': obj.publish.addr}
    # author_list = serializers.SerializerMethodField(read_only=True)
    #  def get_author_list(self, obj):
    #      l = []
    #     for author in obj.authors.all():
    #          l.append({'name': author.name, 'phone': author.phone})
    #      return l

总结:

ModelSerializer使用步骤

        1.写一个类继承ModelSerializer字段从表中映射不需要再写字段

        2.再在类的内部写一个class Meta类

        3.在Meta类中写model指定要序列化的表模型

        4.在Meta类中fields指定序列化的字段：__all__表示表中所有的字段

        5.在Meta类中指定extra_kwargs给字段添加字段参数

ModelSerializer小知识

        在序列化类中可以重写字段会优先使用重写的

        以后不用自己再重写create和update了