序列化组件的使用

Posted surpass123

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了序列化组件的使用相关的知识,希望对你有一定的参考价值。

序列化组件的使用

序列化器的作用:

序列化:序列化器会将模型对象转换成字典,经过response变成json格式字符串
反序列化:把客户端发来的数据,经由response对象变成字典,序列化器可以将字典转换成模型对象
反序列化,可以完成数据的校验功能

1.1 定义序列化器

Django REST framework 中的序列化器,需要 继承于rest_framework.serializer.Serializer

序列化流程如下:

1写一个继承于Serializer类的序列化类;
2在类中写要序列化的字段,想要序列化的字段,就在类中写哪个字段
3在视图类中使用,导入实例化得到序列化器
4序列化器.data 是一个字典
5把字典返回,使用rest_framework中的Response

serializer.py

class BookSerializer(serializers.Serializer):
    id = serializers.CharField(read_only=True)
    book_name = serializers.CharField(source=‘name‘)
    book_price = serializers.DecimalField(max_digits=5, decimal_places=2, source=‘price‘)
    publish = serializers.CharField()
    author = serializers.CharField()

vierws.py

class Book1Detail(APIView):
    def get(self,request,pk):
        book_obj = BookModel.objects.filter(pk=pk).first()
        if book_obj:
            book_ser = BookSerializer(book_obj) # 调用类的__init__
            # book_ser.data 序列化对象.data就是序列化后的字典
            return Response(book_ser.data)
        else:
            return Response({‘status‘:101,‘msg‘:‘无效的pk‘})

class Book1View(APIView):
    def get(self,request):
        book = BookModel.objects.all()
        book_ser = BookSerializer(book,many=True)
        return Response(book_ser.data)

urls.py

path(‘books/<int:pk>/‘, views.Book1View.as_view()), # GET/PUT/DELETE 一条数据
path(‘books/‘,views.Book1Detail.as_view()), # GET/POST  或者所有的数据,或者新增加一条数据

反序列化流程如下:

使用序列化器进行反序列化的时,需要对客户端传过来的数据进行校验工作,数据校验通过后,才会操作保存模型对象,其通过book_ser.is_valid()来校验,若成功,返回True,可通过序列化器的validated_data属性来获取验证通过的数据;如果失败,则返回False,可通过序列化器的errors属性来获取错误的字段。

# 关于字段的校验:
(1)每个字段的序列化类型(Charfield)和选项参数(max_length,min_length,max_digits...)是第一道关卡
(2)钩子函数是第二道关卡,主要分为局部钩子函数,和全局钩子函数
def validated_price(self,price):
    if float(price)<10:
        raise ValidationError(‘价格不能低于10元‘)
    return price

def validated(self,validated_data):
    password = validated_data.get(‘password‘)
    re_password = validated_data.get(‘re_password‘)
    if not re_password == password:
        raise ValidationError(‘两次密码输入不一致‘)
    else:
        return Validated_data  

# 此外,在第一道关卡中,还有validator参数,可以使用外部函数做当前字段的校验方式
def check_author(name):
    if name.startswith(‘sb‘) or name.endswith(‘sb‘):
        raise ValidationError(‘作者姓名中含有敏感词‘)
    else:
        return name
    
# 配置
author = serializers.CharField(validators=[check_author])

serializer.py

def check_name(name):
    if name.startswith(‘sb‘) or name.endswith(‘sb‘):
        raise ValidationError(‘书籍名称中含有敏感词‘)
    else:
        return name

class BookSerializer(serializers.Serializer):
    id = serializer.CharField(read_only=True)
    book_name = serializer.CharField(source=‘name‘,validators=[check_name,])
    book_price = serializers.DecimalField(source=‘price‘,max_digits=5,decimal_place=2)
    publish = serializers.SerializerMethodField()
    author = serializers.CharField(source=‘author.name‘)
    
    def get_publish(self, instance):
        # instance 就是book对象
        publish_dict = {}
        attr_list = [‘name‘, ‘addr‘, ‘email‘, ‘phone‘]
        publish = instance.publish
        for attr in attr_list:
            if hasattr(publish, attr):
                publish_dict[attr] = getattr(publish, attr)
                return publish_dict
   
	def create(self, validated_data):  # 增加一条数据
        instance = BookModel.objects.create(**validated_data)
        return instance

    def update(self, instance, validated_data):  # 新增一条数据
        for attr, value in validated_data.items():
            if hasattr(instance, attr):
                setattr(instance, attr, value)
        instance.save()
        return instance

models.py

from django.db import models

# Create your models here.
from django.db.models import CASCADE

GENDER_CHOICE = (
    (0, ‘male‘),
    (1, ‘female‘),
    (2, ‘secret‘),
)


class BookModel(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32, verbose_name=‘书名‘)
    price = models.DecimalField(max_digits=5, decimal_places=2, verbose_name=‘价格‘)
    publish = models.ForeignKey(to=‘Publish‘, on_delete=CASCADE)
    authors = models.ManyToManyField(to=‘Author‘)

    def __str__(self):
        return self.name

    class Meta:
        verbose_name_plural = ‘书名表‘

views.py

class Book1View(APIView):
    def post(self,request):
        # 新增没有instance,更新才有instance
        book_ser = BookSerializer(data=request.data)
        if book_ser.is_valid():
            book_ser.save()
            return Resposne(book_ser.data)
        else:
            return Response({‘status‘:101,‘msg‘:‘数据检验未通过‘})

class Book1Detail(APIView):
    def put(self, request, pk):
        # 修改需要instance
        instance = BookModel.objects.filter(pk=pk).first()
        book_ser = BookSerializer(instance=instance, data=request.data)
        if book_ser.is_valid():
            book_ser.save()
            return Response(book_ser.data)
        else:
            return Response({‘status‘: 101, ‘smg‘: ‘数据校验未通过‘})

    def delete(self, request, pk):
        book = BookModel.objects.filter(pk=pk)
        if book:
            book.delete()
            return Response({‘status‘: 200, ‘msg‘: ‘删除成功‘})
        else:
            return Response({‘status‘: 101, ‘msg‘: ‘无效的pk‘})

1.2 序列化的字段类型

字段 字段构造方式
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页面时,显示的字段帮助提示信息
read_only	表明该字段仅用于序列化输出,默认False,如果设置成True,postman中可以看到该字段,修改时,不需要传该字段
write_only	表明该字段仅用于反序列化输入,默认False,如果设置成True,postman中看不到该字段,修改时,该字段需要传

# 以下的了解
required	表明该字段在反序列化时必须输入,默认True
default	反序列化时使用的默认值
allow_null	表明该字段是否允许传入None,默认False
validators	该字段使用的验证器
error_messages	包含错误编号与错误信息的字典

1.3 模型类序列化器ModelSerializer

class BookModelSerializer(serializers.ModelSerializer):
    class Meta:
        model=Book  # 对应上models.py中的模型
        fields=‘__all__‘
        # fields=(‘name‘,‘price‘,‘id‘,‘author‘) # 只序列化指定的字段
        # exclude=(‘name‘,) #跟fields不能都写,写谁,就表示排除谁
        # read_only_fields=(‘price‘,)
        # write_only_fields=(‘id‘,) # 弃用了,使用extra_kwargs
        extra_kwargs = {  # 类似于这种形式name=serializers.CharField(max_length=16,min_length=4)
            ‘price‘: {‘write_only‘: True},
        }
        
# 其他使用和Serializer的使用方法一模一样
# 不需要重写create和updata方法了
# 注意:write_only_fields弃用了,使用extra_kwargs
# id此时默认是read_only的,不能给id使用write_only

1.4 序列化器的高级用法

#1 source的作用及其使用
	1 可以改字段名字  book_name=serializers.CharField(source=‘name‘)
    2 可以.跨表publish=serializers.CharField(source=‘publish.email‘)[基于对象的跨表查询,子查询]
    3 可以执行方法pub_date=serializers.CharField(source=‘test‘) test是在Book表模型中定义的方法
    

#2 SerializerMethodField()的使用
	1 它需要有个配套方法,方法名叫get_字段名,返回值就是要显示的东西
    authors=serializers.SerializerMethodField() 
    
    def get_authors(self,instance):
        # book对象
        authors=instance.authors.all()  # 取出所有作者
        ll=[]
        for author in authors:
            ll.append({‘name‘:author.name,‘age‘:author.age})
        return ll
    
# 注意:
	- 如果在模型类序列化器中使用source和SerializerMethodField, 需要重写字段,把class Meta中的fields覆盖掉
    class BookModelSerializer(ModelSerializer):
        class Meta:
            model = models.Book
            # exclude = (‘authors‘, )
            fields = ‘__all__‘
            extra_kwargs = {
                ‘pub_date‘: {‘read_only‘: True},
                # ‘publish‘: {‘source‘: ‘publish.email‘},
            }
        publish = serializers.CharField(source=‘publish.name‘)
        authors = serializers.SerializerMethodField()
        def get_authors(self, instance):
            authors = instance.authors.all()  # 取出所有作者
            ll = []
            for author in authors:
                ll.append({‘name‘: author.name, ‘age‘: author.age})
            return ll

1.5 源码分析many=True的实际用途

# 序列化多条,需要传many=True
# 
book_ser=BookModelSerializer(books,many=True)
book_one_ser=BookModelSerializer(book)
print(type(book_ser))
#<class ‘rest_framework.serializers.ListSerializer‘>
print(type(book_one_ser))
#<class ‘app01.ser.BookModelSerializer‘>

# 对象的生成--》先调用类的__new__方法,生成空对象
# 对象=类名(name=lqz),触发类的__init__()
# 类的__new__方法控制对象的生成


def __new__(cls, *args, **kwargs):
    if kwargs.pop(‘many‘, False):
        return cls.many_init(*args, **kwargs)
    # 没有传many=True,走下面,正常的对象实例化
    return super().__new__(cls, *args, **kwargs)

以上是关于序列化组件的使用的主要内容,如果未能解决你的问题,请参考以下文章

RestFramework

rest_framework

Unity自定义组件之序列帧播放组件

VsCode 代码片段-提升研发效率

微信小程序代码片段

vue中的组件