DRF序列化

Posted on 2022-11-27 21:35  呱呱呱呱叽里呱啦  阅读(39)  评论(0)    收藏  举报

DRF序列化

目录

序列化组件

# 序列化，序列化器会把模型对象转换成字典，经过response以后变成json字符串
# 反序列化，将客户端发送过来的数据，经过数据校验后变成字典，用序列化器将字典转成模型

序列化

# 注册rest_framework

# 在models.py中定义表模型
class Book(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=6,decimal_places=2)
    author = models.CharField(max_length=32)
    public = models.CharField(max_length=64)

# 在自定义文件中定义序列化器
from rest_framework import serializers


class BooksSerializer(serializers.Serializer):
    name = serializers.CharField()
    price = serializers.DecimalField(max_digits=6,decimal_places=2)
    author = serializers.CharField()
    public = serializers.CharField()

# 在views中定义视图类
class BookView(APIView):
    def get(self,request,id):
        book = Book.objects.filter(id=id).first()
        book_ser = BooksSerializer(book) # 参数就是要序列化的对象
        # book_ser.data就是序列化后的字典
        return Response(book_ser.data) # 也可以用JsonResponse返回，这样不用注册rest_framework，但不能通过判断请求信息区别渲染

# 配置路由信息

序列化类的字段类型

字段 字段构造方式
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(max_length=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页面时，显示的字段帮助提示信息

反序列化

# 注意，序列化器中字段的参数条件应该在表模型字段要求的范围内再做限制

def put(self, request, id):
    response_msg = {'status': 100, 'msg': '成功'}
    book = Book.objects.filter(id=id).first()

    book_ser = BooksSerializer(instance=book, validated_data=request.data)  # put反序列化 第二个参数是修改需要的数据

    if book_ser.is_valid(): # 数据校验
        book_ser.save()
        response_msg['data'] = book_ser.data
    else:
        response_msg['status'] = 101
        response_msg['msg'] = '数据校验失败'
        response_msg['data'] = book_ser.errors
        return Response(response_msg)

put反序列化需要实现序列器类父类的update方法

def update(self, instance, validated_data): # 更新想要反序列化的字段
    # instance是book对象，即要修改的对象
    # validated_data是校验后的数据
    instance.name = validated_data.get('name')
    instance.price = validated_data.get('price')
    instance.author = validated_data.get('author')
    instance.public = validated_data.get('public')
    instance.save()
    return instance

反序列化校验

# 序列化器中定义字段校验
class BooksSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=5)

# 序列化器中定义字段校验2
def check_author(data):
    if 'sb' in data:
        raise ValidationError('含不当词汇')
    else:
        return data

class BooksSerializer(serializers.Serializer):
    author = serializers.CharField(validators=[check_author]) # 此列表传入函数内存地址


# 序列化器中定义局部钩子
class BooksSerializer(serializers.Serializer):
    def validate_price(self, data):
        if float(data) > 10:
            return data
        else:
            raise ValidationError('价格太低，校验不通过')

# 序列化器中定义全局钩子
class BooksSerializer(serializers.Serializer):
    def validate(self, validated_data):
        if float(validated_data.get('price')) > 50 and validated_data.get('public') == '忘记出版社':
            raise ValidationError('忘记出版社是廉价书出版社，你这个不对')
        else:
            return validated_data

read_only和write_only

# 在字段参数中设置read_only=True则该字段只从数据库读出，不从外部获取数据修改
# 在字段参数中设置write_only=True则该字段只用于获取外部数据修改数据库，而不提供数据库查询展示

查询所有

# 将需要过滤参数的请求放在一个视图类，例如查询部分，修改部分，将不需要过滤参数的请求放在另外一个视图类，例如查询所有，新增

# 配置URL
# 新建视图类
class BooksView(APIView):

    def get(self,request):
        response_msg = {'status': 100, 'msg': '成功'}
        books = Book.objects.all()
        books_ser = BooksSerializer(books,many=True) # 序列化多条时需many参数
        response_msg['data'] = books_ser.data
        return Response(response_msg)

新增数据

class BooksView(APIView):
    def post(self, request):
        response_msg = {'status': 100, 'msg': '成功'}
        book_ser = BooksSerializer(data=request.data)
        # 校验字段
        if book_ser.is_valid():
            book_ser.save()
            response_msg['data'] = book_ser.data
        else:
            response_msg['status'] = 102
            response_msg['msg'] = '数据校验失败'
            response_msg['data'] = book_ser.errors
        return Response(response_msg)
# 需要重写create方法
class BooksSerializer(serializers.Serializer):
    def create(self, validated_data):
        book = Book.objects.create(**validated_data)
        return book # 这个对象将序列化后作为data返回给请求端

删除数据

class BookView(APIView):
    def delete(self,request,id):
        response_msg = {'status': 100, 'msg': '成功'}
        book = Book.objects.filter(id=id).delete()
        response_msg['data'] = ''
        return Response(response_msg)

自定义封装Response对象

class MyResponse():
    def __init__(self):
        self.status = '100'
        self.msg = '成功'
    @property
    def get_dict(self):
        return self.__dict__

模型类序列化器

class BookModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book # 指定对应哪个表模型
        fields = '__all__'
        # fields = ('name','price') 指定字段
        # exclude=('name'，) # 排除某个字段，不能同时与fields = '__all__'一起写，注意元组
        # read_only_fields = ('price',)
        # write_only_fields = ('name',) # 弃用
        extra_kwargs = {
            'price': {'write_only':True,'min_value':0}
        }

# 不需要重写update和create方法

源码

# 序列化多条需要传参many=True
def __new__(cls,*args,**kwargs):
    if kwargs.pop('many',False):
        return cls.many_init(*args,**kwargs) # return list_serializer
    return super().__new__(cls,*args,**kwargs)

Serializer高级用法

# 为避免返回数据中key值与数据库字段名完全一致而被恶意攻击，需要在序列化器中将字段名变化，即在序列化器类字段参数中增加参数：'序列化器字段名'=serializers.CharField(source='数据库字段名')

# source支持models类中的方法
# source支持跨表
# '序列化器字段名'=serializers.CharField(source='跨表表名.字段名')

# 外键
# authors = serializers.SerislizerMethodField() #需要一个配套方法，get_字段名
def get_authors(self,instance): # instance即book
    authors=instance.authors.all()
    authors_list = []
    for author in authors:
        authors_list.append('name':author.name,'age':author.age)
    return authors_list