序列化类字段/参数/序列化/source方法/定制字段方法

内容概要

• 序列化类常用 字段/参数
• 序列化高级用法之source
• 序列化定制字段名字(两种方式)
• 多表关联反序列化保存
• 反序列化字段校验
• ModelSerializer基本使用

序列化类常用 字段/参数

'序列化类'
from app01 import models
from rest_framework import serializers
class BookSerializer(serializers.Serializer):
    name = serializers.CharField()
    price = serializers.CharField()

其中CharField就相当于是序列化的字段，序列化类与forms组件很相似
接下来集合一些常见字段

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

#21 ListField	ListField(child=, min_length=None, max_length=None)
#22 DictField	DictField(child=)

常见且重要的:
CharField  IntegerField  DecimalField  DateTimeField BooleanField ListField DictField

字段常见参数：

选项参数：
# CharField及其子类的(EmailField) ---》 反序列化的校验,字段自己的规则
    max_length	最大长度
    min_lenght	最小长度
    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.执行字段参数中的 validator=[方法名] 参数，相当于单独给字段添加校验规则
3.执行局部钩子校验
4.执行全局钩子校验

序列化高级用法之source

首先我们在models.py中创建一些文件和数据
from django.db import models


# Create your models here.


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)
    address = models.CharField(max_length=32)


class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)


class AuthorDetail(models.Model):
    phone = models.CharField(max_length=32)
    home = models.CharField(max_length=32)

1.序列化定制字段名字

# source可以指定序列化字段的名字
from rest_framework import serializers

class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8)
    price = serializers.CharField()
	
在这个我们自定义的序列化类中 我们可以name字段重新命名，只需要在 
name = serializers.CharField(max_length=8,source='name')
加上source='name'即可

注意：source='name' name必须是 book这个类拥有的字段

定制有关联关系字段

我们正常去用get请求访问路由查询所有图书，如果字段都填写上，返回的结果如图所示

前端页面显示

但是这种数据对前端无用，所以我们应该想办法将数据处理成方便前端获取的数据
对于关联字段我们可以使用 source(一对多，一对一)
publish = serializers.CharField(source='publish.name')

但是多对多的字段不能使用 source去帮助我们正常显示

总结：
# 序列化类
class BookSerializer(serializers.Serializer):
    # 字段参数，通用的，所有字段都可以写  通过source指定哪个字段
    # 自有字段，直接写字段名字
    book_name = serializers.CharField(max_length=8, source='name')
    price = serializers.CharField()

    # 关联字段，一对多的关联，直接点
    publish = serializers.CharField(source='publish.name')

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

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

# 定制关联字段的显示形式
	一对多，显示字典
	多对多，显示列表套字典

1.在序列化类中使用SerializerMethodField定制

在序列化类中 使用serializers.SerializerMethodField()
必须跟一个 函数 与serializers.SerializerMethodField()名字相同
    publish_detail = serializers.SerializerMethodField()
	并且在get_publish_detail()中需要携带一个obj，这个obj就是
	Book类产生的对象

    def get_publish_detail(self, obj):
        return {'name': obj.publish.name, 'addr': obj.publish.address}
		
	def get_author_list(self, obj):
		# print(obj.authors.)
		author_list = [{'name': author.name, 'age': author.age} for author in obj.authors.all()]
		return author_list

2.在模型中定制

序列化类
只需要编写 需要序列化的字段
    publish_detail = serializers.DictField()
    author_list = serializers.ListField()
我们在模型类编写函数，对应上序列化字段名字，函数的返回值就会被序列化
模型类
    def publish_detail(self):
        return {'name': self.publish.name, 'addr': self.publish.address}

    def author_list(self):
        return [{'name': author.name, 'age': author.age} for author in self.authors.all()]

我们也可以编写
publish_detail = serializers.CharField()
author_list = serializers.CharField()
但是数据到前端就会被显示成为 字符串！
!

image

多表关联反序列化新增

前端会传输数据到后端，我们需要对其进行反序列化进行保存操作
我们之前编写的是 判断数据是否合法后就将其保存了
并且在序列化类中，我们需要重写create方法
'路由层'
 path('book/<int:pk>/', views.BookDetailView.as_view())
"视图层"
class BookView(APIView):
    def post(self, request):  # 反序列化 新增一条
        serializer_obj = serializer.BookSerializer(data=request.data)
        if serializer_obj.is_valid():
            serializer_obj.save()
            return Response({"code": 100, 'msg': '新增成功'})
        return Response({"code": 101, 'msg': serializer_obj.errors})
"序列化类"
class BookSerializer(serializers.Serializer):
    book_name = serializers.CharField(max_length=8, source='name')
    price = serializers.CharField()

    publish = serializers.CharField(write_only=True)  # 只进行反序列化
    authors = serializers.ListField(write_only=True)

    publish_detail = serializers.DictField(read_only=True)
    author_list = serializers.ListField(read_only=True)  # 只进行序列化


    def create(self, validated_data):
        book_obj = models.Book.objects.create(
            name=validated_data.get('name'),
            price=validated_data.get('price'),
            publish_id=validated_data.get('publish'),)
        book_obj.authors.add(*validated_data.get('authors'))
        return book_obj
'模型层'
    def publish_detail(self):
        return {'name': self.publish.name, 'addr': self.publish.address}

    def author_list(self):
        return [{'name': author.name, 'age': author.age} for author in self.authors.all()]

多表关联反序列化存储

'路由层'
 path('book/<int:pk>/', views.BookDetailView.as_view())
"序列化类"
存储数据与上述 一致，只需要在序列化类中重写update方法即可
    def update(self, instance, validated_data):
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.publish_id = validated_data.get('publish')
        author_list = validated_data.get('authors')
        instance.authors.clear()
        instance.authors.add(*author_list)
        instance.save()
        return instance
"视图层"
class BookDetailView(APIView):
    def put(self, request, pk):  # 序列化+反序列化 查询数据
        # 先查询到需要修改的数据对象，
        book_obj = models.Book.objects.filter(pk=pk).first()
        print(book_obj.publish_id)
        # 序列化 book_obj 反序列化 请求体里携带的request.data数据
        serializer_obj = serializer.BookSerializer(instance=book_obj, data=request.data)
        # 校验新增数据是否合法
        if serializer_obj.is_valid():
            serializer_obj.save()
            return Response({'code': 1001, 'msg': '修改成功', 'data': serializer_obj.data})
        return Response({'code': 1002, 'msg': serializer_obj.errors})

反序列化字段校验

反序列化校验顺序：
1.序列化类中字段数据进行校验
2.参数 validators=[方法] 进行校验
3.序列化类中局部钩子函数进行校验
4.序列化类中全局钩子函数进行校验

ModelSerializer 基本使用

# ModelSerializer 继承自Serializer，帮咱们完成了很多操作
使用 ModelSerializer 在序列化中进行编写:
class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Book  # 强行绑定Book表
        # fields = '__all__' # 代表序列化所有字段
        # fields = ['']  # 也可以选择需要 序列化/反序列化 的字段加入到这个列表当中
		
        fields = ['name', 'publish_detail', 'price', 'publish', 'author_list', 'authors']
		
        # 给字段类加属性
        extra_kwargs = {'name': {"max_length": 8},
                        'publish': {'write_only': True}, 
                        'authors': {'write_only': True},
                        'author_list': {'read_only': True},
                        'publish_detail': {'read_only': True},
                        }
	# 自定义序列化字段内容
    publish_detail = serializers.SerializerMethodField()
    def get_publish_detail(self, obj):
        return {'name': obj.publish.name, 'addr': obj.publish.address}

    author_list = serializers.SerializerMethodField()

    def get_author_list(self, obj):
        return [{'name': author_obj.name, 'age': author_obj.age,'phone':author_obj.author_detail.phone} for author_obj in obj.authors.all()]

使用ModelSerializer编写序列化类就不需要重新写update和create方法了