DRF序列化

• DRF序列化
  • 序列化组件
    • 序列化
    • 序列化类的字段类型
    • 序列化类型的选项参数
    • 反序列化
    • put反序列化需要实现序列器类父类的update方法
    • 反序列化校验
    • read_only和write_only
    • 查询所有
    • 新增数据
    • 删除数据
    • 自定义封装Response对象
    • 模型类序列化器
    • 源码
    • Serializer高级用法
    • null

序列化组件

# 序列化，序列化器会把模型对象转换成字典，经过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，但不能通过判断请求信息区别渲染

# 配置路由信息

序列化类的字段类型

序列化类型的选项参数

通用参数：

反序列化

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

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