序列化组件的基本使用

标签：loaded   tar   strong   file   相同   data   区别   校验   rest   

Q：序列化组件有什么用？

A：序列化阶段，能把模型对象转化成字典

? 反序列化阶段，能把客户端发送来的数据经过request变成的字典转化成模型对象，并完成校验

一、创建一个序列化器

1. 在settings中注册rest_framework
2. 在模型里写上序列化器要用的表
3. 在应用下创建一个py文件

from rest_framework import serializers
from rest_framework.exceptions import ValidationError
from app01.models import Student
class StudentSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=10, min_length=5)
    sex = serializers.BooleanField(default=1)
    age = serializers.IntegerField(max_value=100, min_value=18)
    class_null = serializers.CharField(max_length=5)
    description = serializers.CharField(max_length=1000)

一个最基本的序列化器就完成了，接下来就是在视图函数中去使用了

字段类型总结：

二、使用序列化器

提醒：在返回数据的时候，我们可以用Jsonrespone，也可以用drf带的Respone，也可以自己建一个响应信息的方法，jspone和drf自带的区别就是一个是直接返回数据，一个有一个渲染好的页面

1 修改数据

class StudentAPI(APIView):

    def put(self,request,pk):
        back_dic = {‘code‘:200,‘msg‘:‘成功‘}
        obj = models.Student.objects.filter(pk = pk).first()
        ser_obj = ser.StudentSerializer(obj,request.data)
        if ser_obj.is_valid():
            ser_obj.save()
            back_dic[‘data‘] = ser_obj.data
        else:
            back_dic[‘code‘] = 100
            back_dic[‘msg‘] = ‘出错‘
            back_dic[‘error_msg‘] = ser_obj.errors
        return JsonResponse(back_dic)

我们发现在save()调用的时候发生了报错

NotImplementedError: `update()` must be implemented.

提示我们必须重写update方法，在可扩展性高的框架和方法经常会用到这种方式，让我们继承的子类实现多态，python中的多态是鸭子类型，比如你能像鸭子叫，你就能被当成鸭子去使用。

直接在序列化器中重写update方法

 def update(self, instance, validated_data):
        instance.name = validated_data.get(‘name‘)
        instance.age = validated_data.get(‘age‘)
        instance.sex = validated_data.get(‘sex‘)
        instance.class_null = validated_data.get(‘class_null‘)
        instance.description = validated_data.get(‘description‘)
        instance.save()
        return instance

同样的情况出现在提交数据的时候

2 提交数据

class StudentsAPI(APIView):
    def post(self,request):
        # print(request.data)
        back_dic = {‘code‘: 200, ‘msg‘: ‘成功‘}
        obj = ser.StudentSerializer(data = request.data)
        if obj.is_valid():
            obj.save()
            back_dic[‘data‘] = obj.data
        else:
            back_dic[‘code‘] = 100
            back_dic[‘msg‘] = ‘错误‘
            back_dic[‘error_msg‘] = obj.errors

        return (back_dic)

这里的save()在调用的时候也报错，提示我们要重写create方法，按部就班继续写

def create(self, validated_data):
    obj = Student.objects.create(**validated_data)
    return obj

3 校验数据

提交数据和修改数据我们都用了一个方法，is_valid()这个方法的作用和forms组件中基本一样，就是对我们要序列化的数据进行校验

而校验的规则就在我们序列化组件当中

三种校验方式：

1. 在字段后添加校验参数
2. 写全局校验函数和局部校验函数
3. 在类外面写验证器

3.1 字段后添加参数校验

age = serializers.IntegerField(max_value=100, min_value=18)
class_null = serializers.CharField(max_length=5)

选项参数

通用参数

3.2 全局校验与局部校验

这里需要注意一点，我们通常在这里抛出的异常都是drf给我们设定好的错误类型

全局校验传的参数是完成第一步校验的字典

局部校验传的参数是被校验的数据

最后都要把他们返回

from rest_framework.exceptions import ValidationError
def validate(self, attrs):
	name = attrs.get(‘name‘)
	description = attrs.get(‘description‘)
	if name == description:
		raise ValidationError(‘名字和签名不能一致‘)
	return attrs

def validate_name(self, data):
	if data.startswith(‘sb‘):
		raise ValidationError(‘名字不能以sb开头‘)
	return data

3.3 校验器

可以使用字段的author=serializers.CharField(validators=[check_author]) ，来校验
-写一个函数

# 写在类外
def check_author(data):
	if data.startswith(‘sb‘):
		raise ValidationError(‘作者名字不能以sb开头‘)
	else:
		return data
    
author=serializers.CharField(validators=[check_author])

三、模型类序列化器

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},
        }
        
# 其他使用一模一样
#不需要重写create和updata方法了

四、serializers高级用法

1 参数source

放属性名

# 这里的source用法等于是修改前面的名字
# 下面的名字相当于student.name,如果参数中有source会优先使用source定义的名字
# 这里注意，source只是修改了我们查找的对应模型字段名，我们返回数据的字典中，还是name1，在前端发送数据时也应该是name1
name1 = serializers.CharField(max_length=10, min_length=5,source=‘name‘)


# 拓展，如果我们这个字段是一个外键字段，我们甚至可以点到别的表去
# 学生的模型中有一个外键字段课程sourse
sourse = serializers.CharField()
# 这个时候我们在前端展示的是一个object对象，因为这个返回的时候相当于print（）了一下
# 所以我们可以在sourse模型类中去重写__str__方法，
def __str__(self):
    return self.name
# 这样我们在前端看到的sourse的属性就是对应的课程名了
# 由于学生和课程的外键关联，如果我们想要这个字段拿到我们指定的值，比如说得到课程等级
# 我们可以去修改Source的__str__方法，也可以在source参数中通过点跨表查询
sourse = serializers.CharField(source=‘sourse.level‘)
# 相当于 student.sourse.level

放方法名

# source不仅可以放属性，也可以放方法，在模型类中定义的test的返回值，就是msg显示的信息
msg = serializers.CharField(source=‘test‘)

2 SerializerMethodField

 description = serializers.CharField(max_length=1000)
    # 当我们某些数据是需要返回一个列表或字典的，就需要用到SerializerMethodField
    # 它需要一个配套的方法，名字固定叫get_xxx，xxx是前面的名字
    # 这个方法除了self还有一个参数：数据对象本身，这里是student数据对象
    # 这个方法的返回值就是这个名字在前端展示的样子
    msg_list = serializers.SerializerMethodField()
    def get_msg_list(self,data):
        l1 = []
        for i in range(3):
            l1.append(f‘测试{i}‘)
        return l1

这里的应用场景：比如我们的student表有一个多对多老师的外键关联，我们返回一个学生的信息，就可能要返回多个老师，但是普通的序列化器字段只对应一个值，我们可以通过这个方法去把数据拿出来操作，会方便很多。

3 many=True源码

  def __new__(cls, *args, **kwargs):
        # We override this method in order to automagically create
        # `ListSerializer` classes instead when `many=True` is set.
        if kwargs.pop(‘many‘, False):
            return cls.many_init(*args, **kwargs)
        return super().__new__(cls, *args, **kwargs)

在父类中重写了__new__方法，当实例化对象时传进来的参数many=True，则实例化生成ListSerializer对象，如果是False，则生成Serializer对象

序列化组件的基本使用

标签：loaded   tar   strong   file   相同   data   区别   校验   rest   

原文地址：https://www.cnblogs.com/hz2lxt/p/13262651.html