django rest framework之序列化的源码流程剖析

当要对数据对象进行序化列实例化的时候

    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): #如果是QuerySet的时候
            return cls.many_init(*args, **kwargs) #会调用ListSerializer
        return super(BaseSerializer, cls).__new__(cls, *args, **kwargs)

当要对数据对象进行序列化的时候会调用到Serializer类中的to_representation方法

    def to_representation(self, instance):
        """
        Object instance -> Dict of primitive datatypes.
        """
        ret = OrderedDict() #生成有序字典
        fields = self._readable_fields  #获取在我们在Serializer中定义的字段（必须和models中的字段名和类型一样）

        for field in fields:
            try:
                attribute = field.get_attribute(instance) #获取字段的对象
            except SkipField:
                continue

            # We skip `to_representation` for `None` values so that fields do
            # not have to explicitly deal with that case.
            #
            # For related fields with `use_pk_only_optimization` we need to
            # resolve the pk value.
            check_for_none = attribute.pk if isinstance(attribute, PKOnlyObject) else attribute
            if check_for_none is None:
                ret[field.field_name] = None
            else:
                ret[field.field_name] = field.to_representation(attribute) #封装字段的值（每个字段类型可能不同）

        return ret

    def get_attribute(self, instance):
        """
        Given the *outgoing* object instance, return the primitive value
        that should be used for this field.
        """
        try:
            return get_attribute(instance, self.source_attrs) #如果在字段的source中定义了如：role.name(外键)会被拆分成[role, name]
        except (KeyError, AttributeError) as exc:
            if self.default is not empty:
                return self.get_default()
            if self.allow_null:
                return None
            if not self.required:
                raise SkipField()
            msg = (
                'Got {exc_type} when attempting to get a value for field '
                '`{field}` on serializer `{serializer}`.
The serializer '
                'field might be named incorrectly and not match '
                'any attribute or key on the `{instance}` instance.
'
                'Original exception text was: {exc}.'.format(
                    exc_type=type(exc).__name__,
                    field=self.field_name,
                    serializer=self.parent.__class__.__name__,
                    instance=instance.__class__.__name__,
                    exc=exc
                )
            )
            raise type(exc)(msg)

def get_attribute(instance, attrs):
    """
    Similar to Python's built in `getattr(instance, attr)`,
    but takes a list of nested attributes, instead of a single attribute.

    Also accepts either attribute lookup on objects or dictionary lookups.
    """
    for attr in attrs:
        try:
            if isinstance(instance, collections.Mapping):
                instance = instance[attr]
            else:
                instance = getattr(instance, attr) #获取对象的属性（如果这个属性还是一个数据实例对象的话就会再次循环调用）
        except ObjectDoesNotExist:
            return None
        if is_simple_callable(instance): #判断是不是一个函数
            try:
                instance = instance()
            except (AttributeError, KeyError) as exc:
                # If we raised an Attribute or KeyError here it'd get treated
                # as an omitted field in `Field.get_attribute()`. Instead we
                # raise a ValueError to ensure the exception is not masked.
                raise ValueError('Exception raised in callable attribute "{0}"; original exception was: {1}'.format(attr, exc))

    return instance