【Django-rest-framework框架】第03回 序列化类字段与高级用法

目录

• 1. 序列化类常用字段与字段参数
  • 1.1 常用字段类型
  • 1.2 选项参数
  • 1.3 通用参数
• 2. 序列化类高级用法之sourse
  • 2.1 source 可以指定序列化表中得哪个字段
  • 2.2 source 如果是方法，会执行方法
  • 2.3 source 可以跨表查询
• 3. 序列化类高级用法之定制序列化字段的两种方式
  • 3.1 第一种：在【序列化类】中写SerializerMethodField
  • 3.2 第二种：在【表模型】中写方法（又多一些）
• 4. 有关联关系表的反序列化的保存
  • 4.1 使用继承Serializer的序列化类保存需要重写create方法
  • 4.2 缺点
• 5. 反序列化之数据校验
  • 5.1 字段自己的校验规则
  • 5.2 局部钩子
  • 5.3 全局钩子
• 6. 模型类序列化器（ModelSerializer）的使用
  • 6.1 如何使用
• 7. 反序列化数据校验源码分析
• 8. 断言assert

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

1.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	ListField(child=, min_length=None, max_length=None)
DictField	DictField(child=)

1.2 选项参数

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

1.3 通用参数

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

2. 序列化类高级用法之sourse

获取所有图书接口 APIView+Response+序列化类

from rest_framework.views import APIView
from .models import Book
from .serializer import BookSerializer
from rest_framework.response import Response


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

2.1 source 可以指定序列化表中得哪个字段

name字段在前端显示的时候叫book_name

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

2.2 source 如果是方法，会执行方法

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

2.3 source 可以跨表查询

publish = serializers.CharField(max_length=20, min_length=2, source='publish.name')

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

3.1 第一种：在【序列化类】中写SerializerMethodField

# publish要序列化成{name:北京出版社，city:北京，email:2@qq.com}
# 方式一： SerializerMethodField必须配合一个方法(get_字段名，需要接受一个参数)，方法返回什么，这个字段就是什么
publish = serializers.SerializerMethodField()

def get_publish(self, obj):
    # obj 是当前序列化的对象
    return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}

# 练习，用方式一，显示所有的作者对象
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

3.2 第二种：在【表模型】中写方法（又多一些）

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

# 在序列化中取
publish_detail=serializers.DictField()

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

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

# 1 序列化字段和反序列化字段不一样  【序列化类中】
# 反序列化用的
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)

4.1 使用继承Serializer的序列化类保存需要重写create方法

一定要重写create  【序列化类中】
def create(self, validated_data): 
      # validated_data 校验过后的数据  
        {"name":"三国1演义",
          "price":19,
          "publish_date": "2022-09-27",
          "publish":1,
          "authors":[1,2]
          }
      book = 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'),
                                 )
      authors = validated_data.get('authors')
      book.authors.add(*authors)
      return book

4.2 缺点

1.在序列化中每个字段都要写，无论是序列化还是反序列化
2.如果新增或者修改，在序列化类中都需要重写create或update
3.解决这个缺点，使用ModelSerializer来做

5. 反序列化之数据校验

跟forms很像
字段自己的校验规则
局部钩子
全局钩子

5.1 字段自己的校验规则

如果继承的是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': "太短了"}},}

5.2 局部钩子

如果继承的是Serializer，写法一样
如果继承的是ModelSerializer，写法一样
def validate_name(self, name):
  if name.startswith('sb'):
      # 校验不通过，抛异常
      raise ValidationError('不能以sb卡头')
  else:
      return name

5.3 全局钩子

如果继承的是Serializer，写法一样
如果继承的是ModelSerializer，写法一样
def validate(self, attrs):
  if attrs.get('name') == attrs.get('publish_date'):
      raise ValidationError('名字不能等于日期')
  else:
      return attrs

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

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)
	...

6.1 如何使用

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写好了，兼容性更好，任意表都可以直接存

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

# 先校验字段自己的规则(最大，最小)，走局部钩子校验，走全局钩子
# 局部：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

8. 断言assert

# 框架的源码中，大量使用断言
# assert :断言，作用的判断，断定一个变量必须是xx，如果不是就报错

# 土鳖写法
# name = 'zhy1'
# if not name == 'zhy':
#     raise Exception('name不等于zhy')
#
# print('程序执行完了')

# assert的断言写法
name = 'zhy1'
assert name == 'zhy', 'name不等于zhy'
print('程序执行完了')