[Python知识库]rest framework框架--序列化源码分析

使用序列化的代码

1. 编写自定义Serializers类

## 模型类
class Media(models.Model):
    TYPE_CHOICES = (
        (1, "pic"),
        (2, "video")
    )
    type = models.IntegerField(verbose_name='类型', choices=TYPE_CHOICES, default=1)
    url = models.CharField(verbose_name='图片', max_length=64)
## 序列化类
class MediaSerializers(serializers.ModelSerializer):
    class Meta:
        model = Media
        fields = '__all__'

2. 数据库拿到的数据序列化

queryset = Media.objects.all()
ser_obj = MediaSerializers(page_data, many=True)
ser_obj.data  # 序列化后的数据

分析

入口

1.我们先进行了实例化自定义的MediaSerializers类，生成一个对象。
看源码存在类实例化对象，重点关注该类和其父类中的__new__方法，其返回的是什么类的对象，就会调用该对象的__init__进行初始化对象。

在BaseSerializer类中找到__init__和__new__，python中一个类实例化对象，会先执行该类的__new__方法。

class BaseSerializer(Field):
    def __init__(self, instance=None, data=empty, **kwargs):
        self.instance = instance
        if data is not empty:
            self.initial_data = data
        self.partial = kwargs.pop('partial', False)
        self._context = kwargs.pop('context', {})
        kwargs.pop('many', None)
        super().__init__(**kwargs)

    def __new__(cls, *args, **kwargs):
        # We override this method in order to automatically create
        # `ListSerializer` classes instead when `many=True` is set.
        # 1. 判断many参数的值，当实例化多个对象是many=True,实例化单个对象时，many=False
        if kwargs.pop('many', False):
        	# 2.实例化多个对象时，返回ListSerializer类实例化对象
            return cls.many_init(*args, **kwargs)
        # 3.实例化一个对象时，返回的BaseSerializer类实例化对象
        return super().__new__(cls, *args, **kwargs)

2.分析单个对象的序列化，序列化的入口是ser_obj.data

class BaseSerializer(Field):
    @property
    def data(self):
		...
        if not hasattr(self, '_data'):
            if self.instance is not None and not getattr(self, '_errors', None):
            	# 1.从最开始的子类一层一层往父类找，找到to_representation
                self._data = self.to_representation(self.instance)
            elif hasattr(self, '_validated_data') and not getattr(self, '_errors', None):
                self._data = self.to_representation(self.validated_data)
            else:
                self._data = self.get_initial()
        return self._data

class Serializer(BaseSerializer, metaclass=SerializerMetaclass):
    def to_representation(self, instance):
        """
        Object instance -> Dict of primitive datatypes.
        """
        ret = OrderedDict()
        fields = self._readable_fields
		# 2.遍历MediaSerializers中的字段，有id,type,url
        for field in fields:
            try:
            	# 3.调用MediaSerializers字段的get_attribute方法，如，url的字段类型是serializers.CharField，就调用CharField.get_attribute(instance)，instance 是一个模型类对象
            	# 拿到字段对应的模型类对象的值
                attribute = field.get_attribute(instance)
            except SkipField:
                continue

            check_for_none = attribute.pk if isinstance(attribute, PKOnlyObject) else attribute
            if check_for_none is None:
                ret[field.field_name] = None
            else:
            	# 4.对拿到的值根据其对应的field类型，做数据转换，如时间类型的格式化时间输出，数据写入有序字典
                ret[field.field_name] = field.to_representation(attribute)
		# 5. 返回有序字典。
        return ret  
        
class Field:
	# 3.1
    def get_attribute(self, instance):
        try:
        	# 3.2 从instance模型类对象中，拿到字段属性为url的值
        	# 3.3 self.source_attrs = self.source.split('.')，对自定义字段时的source参数进行切分，如果是一对多，就可以指定source='type.id'
            return get_attribute(instance, self.source_attrs)

# fields.py文件中的普通函数
def get_attribute(instance, attrs):
    for attr in attrs:
        try:
           	# 获取模型类对象的attr属性
            if isinstance(instance, Mapping):
                instance = instance[attr]
            else:
                instance = getattr(instance, attr)
        except ObjectDoesNotExist:
            return None
        # 如果是可调用的，调用其拿到值，如，Choice字段，source='get_type_dispaly'
        if is_simple_callable(instance):
            try:
                instance = instance()
            except (AttributeError, KeyError) as exc:
                raise ValueError('Exception raised in callable attribute "{}"; original exception was: {}'.format(attr, exc))
	
    return instance