[Python知识库]Django-rest-framework框架之序列化与反序列化方法以及模型类序列化的使用

今日内容学习

• 序列化常用字段类和字段参数
• 序列化类高级用法之source方法
• 序列化类高级用法之定制序列化字段的两种方式
• 反序列化之数据校验
• 模型类序列化器（ModeSerializer）的使用
• 反序列化数据校验源码分析（了解）
• 小知识之断言

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

1.常用字段类

字段类	如何使用
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	{name:‘lqz’,age:19,hobby:[‘篮球’,‘足球’]}
DictField	{name:‘lqz’,age:19,wife:{‘name’:‘刘亦菲’,‘age’:33}}

比较重要的几个字段参数
（1）CharField：CharField 采用定长存储
（2）BooleanField：函数获得一个参数value，判断value是不是 （True，False）
（3）IntegerField：整数字段。默认的form widget是TextInput。
（4）DecimalField：它是使用 Decimal 实例表示固定精度的十进制数的字段。

它有两个必须的参数：

DecimalField.max_digits：数字允许的最大位数

DecimalField.decimal_places：小数的最大位数
例如，要存储的数字最大值是999，而带有两个小数位，你可以使用：
models.DecimalField(..., max_digits=5, decimal_places=2)
要存储大约是十亿级且带有10个小数位的数字，就这样写：
models.DecimalField(..., max_digits=19, decimal_places=10)

2.常用字段参数

• 选项参数

（1）给CharField字段类使用的参数

参数名称	作用
max_length	最大长度
min_length	最小长度
allow_blank	是否允许为空
trim_whitespace	是否截断空白字符

（2）给IntegerField字段类使用的参数

参数名称	作用
max_value	最大值
min_value	最小值

• 通用参数：放在哪个字段类上都可以；

参数名称	作用
required	表明该字段在反序列化时必须输入，默认True
default	反序列化时使用的默认值
allow_null	表明该字段是否允许传入None，默认False
validators	该字段使用的验证器【知道即可】
error_messages	包含错误编号与错误信息的字典
label	用于HTML展示API页面时，显示的字段名称
help_text	用于HTML展示API页面时，显示的字段帮助提示信息

• 重要参数！！！

参数名称	作用
read_only	表明该字段仅用于序列化输出，默认False
write_only	表明该字段仅用于反序列化输入，默认False

序列化类高级用法之source

1.实例引入
序列化类高级用法之source，修改序列化字段名字。

• 获取所有图书接口，用APIView+Response+序列化类；
• 需求展示：name字段在前端显示的时候叫book_name

source作用：
（1）使用source字段参数，可以指定序列化表中的哪个字段；

book_name = serializers.CharField(max_length=8, min_length=3,source='name')

（2）source指定的可以是字段，也可以是方法，用于重命名；

（3）source也可以做跨表查询

2.代码演示

class BookSerializer(serializers.Serializer):
   name_detail = serializers.CharField(max_length=8, >min_length=3,source='name')
   # 或
   publish_name = serializers.CharField(max_length=8, >min_length=3,source='publish.name')   
   # 或
   xx = serializers.CharField(max_length=8, min_length=3,source='xx') >#source的xx表示表模型中的方法

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

1.前端显示形式

{
"name":"西游记"，
“price”：33，
"publish":{name:xx,city:xxx,email:sss
}

2.方式一：SerializerMethodField必须配合一个方法（get_字段名，需要接收一个参数，）方法返回什么，这个字段就是什么。

class BookSerializer(serializers.Serializer):
   name = serializers.CharField(max_length=8,min_length=3)
   price = serializers.IntegerField(min_value=10,max_value=99)
   # publish = serializers.CharField(max_length=8,min_length=3,source='publish.email')



  publish = serializers.SerializerMethodField()
   def get_publish(self,obj):
       # obj是当前序列化的对象，下面obj.publish.name是基于对象的跨表查询
       return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}
   #     {
   #         "name": "西游记",
   #         "price": 99,
   #         "publish": {
   #             "name": "南京出版社",
   #             "city": "南京",
   #             "email": "555@qq.com"
   #         }
   #     },
   

练习之显示所有作者对象：

   authors = serializers.SerializerMethodField()
   def get_authors(self,obj):
       res_list = []
       for author in obj.authors.all():
           res_list.append({'id':author.id,'name':author.name,'age':author.age})
       return res_list
   #         "authors": [
   #             {
   #                 "id": 1,
   #                 "name": "jason",
   #                 "age": 18
   #             },

3.方式二：在【表模型】中写方法（又多一些）

表模型中：

   # 方式二：再表模型中写方法
   publish_detail = serializers.DictField()
   # 练习使用方式二显示所有作者
   author_list = serializers.ListField()
   #     {
   #         "name": "西游记",
   #         "price": 99,
   #         "publish_detail": {
   #             "name": "南京出版社",
#             "city": "南京",
   #             "email": "555@qq.com"
   #         },
   #         "author_list": [
   #             {
#                 "id": 1,
   #                 "name": "jason",
   #                 "age": 18
   #             }
   #         ]
   #     },

序列化类中

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

   publish = models.ForeignKey(to='Publish',on_delete=models.CASCADE)
   authors=models.ManyToManyField(to='Author')
   def __str__(self):
       return self.name

# 写个方法，可以包装成数据属性，也可以不包（第二种方法）
def publish_detail(self):
       return {'name':self.publish.name,'city':self.publish.city,'email':self.publish.email}
      
       
练习，使用方式二实现，显示所有作者
   def author_list(self):
       res_list = []
       for author in self.authors.all():
           res_list.append({'id':author.id,'name':author.name,'age':author.age})
return res_list

在模型类中写逻辑代码。称之为ddd，领域驱动模型。

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

• 序列化字段和反序列化字段不一样 【序列化类中】

# 反序列化用的
   publish = serializers.CharField(write_only=True)
   authors = serializers.ListField(write_only=True)

#序列化用的
   publish_detail = serializers.DictField(read_only=True)
   author_list = serializers.ListField(read_only=True)

• 一定要重写create 【序列化类中】

   def create(self, validated_data):
       # validated_data校验过后的数据
       book = Book.objects.create(name=validated_data.get('name'),
                           price=validated_data.get('price'),
                           publish_date=validated_data.get('publish_data'),
                           publish_id=validated_data.get('publish'),
                           )
       authors = validated_data.get('authors')
       book.authors.add(*authors)
      return book

• 使用继承Serializer的序列化类保存需要重写create方法:
  （1）在序列化中每个字段都要写，无论是序列化还是反序列化
  （2）如果新增或者修改，在序列化类中都需要重写create或update

解决这个缺点，使用ModelSerializer来做

模型类序列化器（ModelSerializer）的使用

1.代码展示

class BookModelSerializer(serializers.ModelSerializer): #ModelSerializer继承Serializer
   # 不需要写字段了，字段从表模型映射过来
   class Meta:
       model = Book  # 要序列化的表模型
       # fields='__all__' # 所有字段都序列化
       fields = ['name', 'price', 'publish_date', 'publish', 'authors', 'publish_detail',
                 'author_list']  # 列表中有什么，就是序列化哪个字段
       # 给authors和publish加write_only属性
       # name加max_len属性
       extra_kwargs = {
           'name': {'max_length': 8},
           'publish': {'write_only': True},
           'authors': {'write_only': True},
       }  
  publish_detail = serializers.SerializerMethodField(read_only=True)
	 ...
  author_list = serializers.SerializerMethodField(read_only=True)
	...

2.总结代码
如何使用：

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

反序列化之数据校验（与forms很像）

1.字段自己的校验规则
说明：如果继承的是Serializer，写法如下：

name=serializers.CharField(max_length=8,min_length=3,error_messages={'min_length': "太短了"})

如果继承的是ModelSerializer，写法如下：

在内部类中指定extra_kwargs中：
extra_kwargs = {
           'name': {'max_length': 8, 'min_length': 3, 'error_messages': {'min_length': "太短了"}},
       }

2.局部钩子

• 继承Serializer与ModelSerializer写法一样：

	def validate_name(self, name):
       if name.startswith('sb'):
           # 校验不通过，抛异常
           raise ValidationError('不能以sb卡头')
       else:
           return name

3.全局钩子

• 继承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

断言写法

土鳖写法

name = 'lqz1'
if not name == 'lqz':
   raise Exception('name不等于lqz')

print('程序执行完了')

断言写法

name = 'lqz1'
assert name == 'lqz', 'name不等于lqz'
print('程序执行完了')