[Python知识库]DRF-(3)

内容概览

• 序列化类常用字段类与字段参数
• 序列化类高级用法之source
• 序列化类高级用法之定制序列化字段的两种方式
• 模型类序列化器的使用
• 反序列化的数据校验
• 反序列化数据校验源码分析

序列化类常用字段类与字段参数

常用字段类

需要记住的：CharField、IntegerField、DecimalField、BoolField

常用字段参数

• 选项参数：

  • CharField：

    参数名称	说明
    max_length	最大长度
    min_length	最小长度
    allow_blank	是否可以为空
    trim_whitespace	是否截断空白字符

  • IntegerField：

    参数名称	说明
    max_value	最大值
    min_value	最小值

• 通用参数

  参数名称	说明
  required	反序列化时是否为必填字段，默认为True
  default	反序列化时设置的默认值
  allow_allow_null	表示该字段是否可以传入None，默认为False
  validators	该字段使用的验证器
  error_messages	包含错误编号与错误信息的字典
  label	用于HTML展示API页面时，显示的字段名
  help_text	用于HTML展示API页面时，显示的字段帮助信息
  read_only	表示该字段只用于序列化输出，默认False
  write_only	表示该字段只用于反序列化输入，默认False

序列化类高级用法之source

serializers.py：

class BookSerializer(serializers.Serializer):
    name_detail = serializers.CharField(source='name')
"""使用source可以指定表中的哪个字段序列化,前端显示的则会是name_detail"""

class BookSerializer(serializers.Serializer):
    xx = serializers.CharField(source='limit')
"""也可以指定表模型中的方法,返回值是什么前端就打印什么"""

class BookSerializer(serializers.Serializer):
    publish_city = serializers.CharField(source='publish.city')
"""还可以做跨表查询"""

models.py：

class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    publish_date = models.DateField(null=True)

    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    authors = models.ManyToManyField(to='Author')

    def limit(self):
        return 32

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

方式一：在序列化类中写SerializerMethodField

serializers.py：

class BookSerializer(serializers.Serializer):
    publish_detail= serializers.SerializerMethodField()

    def get_publish_detail(self, obj):  # 方法名是固定的get_字段名;obj是当前序列化的对象
        return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}  # 方法返回什么,前端就显示什么

方式二：在表模型中写

models.py：

class Book(models.Model):
    name = models.CharField(max_length=32)

    def authors_list(self):
        res_list = []
        for author in self.authors.all():  # 因为是多对多,所以需要循环取出
            res_list.append({'name': author.name, 'age': author.age})
        return res_list

serializers.py：

class BookSerializer(serializers.Serializer):
    name_detail = serializers.CharField(source='name')

    authors_list = serializers.ListField()  # 因为返回的是一个列表,使用ListField更合适

有关联关系表的反序列化的保存

1. 序列化字段和反序列化字段不一样
	"""序列化使用的"""
	publish_detail = serializers.DictField(read_only=True)  # 返回的是一个字典
	author_list = serializersListField(read_only=True)  # 返回的是列表
	"""反序列化使用的"""
	publish = serializers.CharField(write_only=True)  # 返回的是publish的id
	authors= serializers.ListField(write_only=True)  # 返回一个列表,存放多个作者的id

2. 需要重写create
	def create(self, validated_data):
    res = models.Book.objects.create(name=validated_data.get('name'),
                                   price=validated_data.get('price'),
                                   publish_date=validated_data.get('publish_date'),
                                   publish_id=validated_data.get('publish'),)
    res.authors.add(*validated_data.get('authors'))
    return res
"""
继承Serializer的序列化类在序列化中的每个字段都要写,无论是序列化还是反序列化
如果新增或者修改,在序列化类中还需要重写create和update
可以继承ModelSerializer来解决这些问题
"""

模型类序列化器的使用

serializers.py：

class BookModelSerializer(serializers.ModelSerializer):
	# 不需要再一个个的写字段,直接从表模型中映射过来
	class Meta:
		model = Book  # 要序列化的表模型
		# fields = '__all__'  # 选择序列化的字段,__all__表示所有字段
		fields = ['name', 'price', 'publish_date', 'publish', 'authors', 'publish_detail']  # 将列表中的字段序列化
		extra_kwargs = {
		'name':{'max_length':8,'min_length':3}
		'price':{'max_value':1000}
		}  # 给字段添加属性

	"""定制序列化字段的方式和Serializer一样,不过要将字段名添加到fields的列表中"""
	publish_detail= serializers.SerializerMethodField()

    def get_publish_detail(self, obj):
        return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}

总结

#  如何使用
	1 定义一个类继承ModelSerializer
    2 类内部写内部内 class Meta:
    3 在内部类中指定model(要序列化的表)
    4 在内部类中指定fields(要序列化的字段，写__all__表示所有，不包含方法，写[一个个字段])
    5 在内部类中指定extra_kwargs，给字段添加字段参数的
    6 在序列化类中，可以重写某个字段，优先使用你重写的
        name = serializers.SerializerMethodField()
    	def get_name(self, obj):
        	return 'sb---' + obj.name
 
    7 以后不需要重写create和update了
    	-ModelSerializer写好了，兼容性更好，任意表都可以直接存

反序列化之数据校验

反序列化的数据校验与forms很相似，可以使用字段自己的校验规则，也有局部钩子与全局钩子

"""字段自己的校验规则"""
	如果继承的是Serializer，写法如下
		name=serializers.CharField(max_length=8,min_length=3,error_messages={'min_length': "太短了"})
	如果继承的是ModelSerializer，写法如下
		extra_kwargs = {
            'name': {'max_length': 8, 'min_length': 3, 'error_messages': {'min_length': "太短了"}},
        }

"""局部钩子"""
Serializer与ModelSerializer写法一样
def validate_name(self, name):  # validate_字段名
	if name.startwith('nb'):
		raise ValidationError('不能以nb开头')  # 校验不通过,抛出异常
	else:
		return name  # 成功就返回

"""全局钩子"""
Serializer与ModelSerializer写法一样
def validate(self, attrs):
	if attrs.get('name') == attrs.get('publish_date'):
		raise ValidationError('名字不能等于日期')
	else:
		return attrs

反序列化数据校验源码分析

# 先校验字段自己的规则(最大，最小)，走局部钩子校验，走全局钩子
# 局部：validate_name，全局叫：validate 为什么？

# 入口：从哪开始看，哪个操作，执行了字段校验ser.is_valid()
	-BaseSerializer内的is_valid()方法
	    def is_valid(self, *, raise_exception=False):
            if not hasattr(self, '_validated_data'):
                try:
                    # 真正的走校验，如果成功，返回校验过后的数据
                    self._validated_data = self.run_validation(self.initial_data)
                except ValidationError as exc:
            return not bool(self._errors)
    
    -内部执行了：self.run_validation(self.initial_data)---》本质执行的Serializer的
    	-如果你按住ctrl键，鼠标点击，会从当前类中找run_validation，找不到会去父类找
    	-这不是代码的执行，代码执行要从头开始找，从自己身上再往上找
    	    def run_validation(self, data=empty):
                #局部钩子的执行
                value = self.to_internal_value(data)
                try:
                    # 全局钩子的执行，从根上开始找着执行，优先执行自己定义的序列化类中得全局钩子
                    value = self.validate(value)
                except (ValidationError, DjangoValidationError) as exc:
                    raise ValidationError(detail=as_serializer_error(exc))

                return value
  -全局钩子看完了，局部钩子---》 self.to_internal_value---》从根上找----》本质执行的Serializer的
     def to_internal_value(self, data):
        for field in fields: # fields：序列化类中所有的字段，for循环每次取一个字段对象
            # 反射：去self：序列化类的对象中，反射 validate_字段名 的方法
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            try:
                # 这句话是字段自己的校验规则（最大最小长度）
                validated_value = field.run_validation(primitive_value)
                # 局部钩子
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail

        return ret
    
 # 你自己写的序列化类---》继承了ModelSerializer---》继承了Serializer---》BaseSerializer---》Field

断言assert

框架的源码中,大量使用了断言
断言assert:断定一个变量必须是什么,如果不是就报错

不使用断言:
name = 'al'
if not name == 'al':
	raise Exception('name不等于al')
print('执行完毕')

使用断言:
name = 'al'
assert name == 'al', 'name不等于al'  # 断言name等于al,否则报错,错误信息是后边的值
print('执行完毕')

练习

写出带关联关系的book表的5个接口

name最大8，最小3，名字中不能带sb
price最小9，最大199，不能为66

• Serializer

"""serializers.py"""
from rest_framework import serializers
from app01 import models
from rest_framework.exceptions import ValidationError


class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8, min_length=3)
    price = serializers.IntegerField(max_value=199, min_value=9)
    publish_date = serializers.DateField()

    publish = serializers.CharField(write_only=True)
    authors = serializers.ListField(write_only=True)

    publish_detail = serializers.SerializerMethodField(read_only=True)
    authors_list = serializers.ListField(read_only=True)

    def get_publish_detail(self, obj):
        return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}

    def validate_name(self, name):
        if 'sb' in name:
            raise ValidationError('名字中包含敏感字')
        else:
            return name

    def validate_price(self, price):
        if price == 66:
            raise ValidationError('价格不能为66')
        else:
            return price

    def create(self, validated_data):
        res = models.Book.objects.create(name=validated_data.get('name'),
                                         price=validated_data.get('price'),
                                         publish_date=validated_data.get('publish_date'),
                                         publish_id=validated_data.get('publish'), )
        res.authors.add(*validated_data.get('authors'))
        return res

    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')
        instance.publish_date = validated_data.get('publish_date')
        instance.authors.set(validated_data.get('authors'))
        instance.save()
        return instance


"""views.py"""
from app01 import models
from rest_framework.views import APIView
from rest_framework.response import Response
from app01.serializers import BookSerializer

class BookView(APIView):
    def get(self, request):
        book = models.Book.objects.all()
        bs = BookSerializer(instance=book, many=True)
        return Response(bs.data)

    def post(self, request):
        bs = BookSerializer(data=request.data)
        if bs.is_valid(): 
            bs.save()  
            return Response(bs.data)  
        else:
            return Response(bs.errors)  


class BookDetailView(APIView):
    def get(self, request, pk):
        book = models.Book.objects.filter(pk=pk).first()
        bs = BookSerializer(instance=book)
        return Response(bs.data)

    def put(self, request, pk):
        book = models.Book.objects.filter(pk=pk).first()
        bs = BookSerializer(instance=book, data=request.data)
        if bs.is_valid():
            bs.save()
            return Response(bs.data)
        else:
            return Response(bs.errors)

    def delete(self, request, pk):
        models.Book.objects.filter(pk=pk).delete()
        return Response()

• ModelSerializer

"""serializers.py"""
class BookModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Book
        fields = ['name', 'price', 'publish_date', 'publish', 'authors', 'publish_dict', 'authors_list']
        extra_kwargs = {
            'publish': {'write_only': True},
            'authors': {'write_only': True},
            'publish_dict': {'read_only': True},
            'authors_dict': {'read_only': True},
            'name': {'max_length': 8, 'min_length': 3},
            'price': {'max_value': 199, 'min_value': 9},
        }

    def validate_name(self, name):
        if 'sb' in name:
            raise ValidationError('名字中包含敏感字')
        else:
            return name

    def validate_price(self, price):
        if price == 66:
            raise ValidationError('价格不能为66')
        else:
            return price
"""views.py"""
将BookSerializer改为BookModelSerializer即可