Django Rest Framework 源码解析--序列化之反序列化
示例代码就只展示了后端编写的代码和序列化过程，示例代码如下：
懒得分文件就全部写再views.py中了
import re
from django.db import models
from rest_framework import serializers
from rest_framework.viewsets import ModelViewSet
class UserProfile(models.Model):
"""
用户表
"""
username = models.CharField(
max_length=20, default="", verbose_name="姓名", help_text="姓名")
email = models.EmailField(
max_length=50, verbose_name="邮箱", help_text="邮箱")
class UserSerializer(serializers.ModelSerializer):
"""
用户序列化
"""
class Meta:
model = UserProfile
fields = "__all__"
class UserViewSet(ModelViewSet):
"""
用户管理：增删改查
"""
queryset = UserProfile.objects.all()
serializer_class = UserSerializer
url.py
from django.contrib import admin
from django.urls import path, include
from study.views import UserViewSet
from rest_framework import routers
router = routers.SimpleRouter()
router.register(r"users", UserViewSet, base_name="users")
urlpatterns = [
path('admin/', admin.site.urls),
path(r"api/", include(router.urls))
一、新增用户Serializer的序列化过程
1、获取序列化对象
class CreateModelMixin:
"""
Create a model instance.
"""
def create(self, request, *args, **kwargs):
# 序列化对象
# 这里面的传参要说明一点data有值就是反序列化，instance有值就是序列化
# 新增数据这里就是反序列化
serializer = self.get_serializer(data=request.data)
# 效验数据
serializer.is_valid(raise_exception=True)
# 执行创建
self.perform_create(serializer)
"""
def perform_create(self, serializer):
serializer.save()
"""
headers = self.get_success_headers(serializer.data)
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
class GenericAPIView(views.APIView):
.......
serializer_class = None
.......
def get_serializer(self, *args, **kwargs):
"""
Return the serializer instance that should be used for validating and
deserializing input, and for serializing output.
"""
# 获取序列化对象
serializer_class = self.get_serializer_class()
kwargs['context'] = self.get_serializer_context()
return serializer_class(*args, **kwargs)
def get_serializer_class(self):
"""
Return the class to use for the serializer.
Defaults to using `self.serializer_class`.
You may want to override this if you need to provide different
serializations depending on the incoming request.
(Eg. admins get full serialization, others get basic serialization)
"""
assert self.serializer_class is not None, (
"'%s' should either include a `serializer_class` attribute, "
"or override the `get_serializer_class()` method."
% self.__class__.__name__
)
# 返回的就是我们再Views定义的serializer_class = UserSerializer
return self.serializer_class
......
通过上一步我们了解到serializer = self.get_serializer(data=request.data) 执行的UserSerializer类的实例化，并传入data参数执行反序列化
2、UserSerializer类的实例化的过程
类实例化之前会执行new方法，用于控制一个类的生成实例的过程生成一个空对象，子类没有的就去找父类的new, new 执行完以后才能执行init构造方法
UserSerializer的父类ModelSerializer没有new方法，ModelSerializer的父类Serializer也没有new方法，在往上找BaseSerlizer中的new方法
class BaseSerializer(Field):
.......
def __init__(self, instance=None, data=empty, **kwargs):
self.instance = instance
# 传入的data参数赋值给了self.initial_data
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 automagically create
# `ListSerializer` classes instead when `many=True` is set.
# many参数默认为False, 所以这次初始化不走下面的many_init
if kwargs.pop('many', False):
return cls.many_init(*args, **kwargs)
# 执行父类Field的new
return super().__new__(cls, *args, **kwargs)
3、UserSerializer类的实例化后执行serializer.is_valid(raise_exception=True)方法验证数据
class BaseSerializer(Field):
......
def is_valid(self, raise_exception=False):
assert not hasattr(self, 'restore_object'), (
'Serializer `%s.%s` has old-style version 2 `.restore_object()` '
'that is no longer compatible with REST framework 3. '
'Use the new-style `.create()` and `.update()` methods instead.' %
(self.__class__.__module__, self.__class__.__name__)
)
assert hasattr(self, 'initial_data'), (
'Cannot call `.is_valid()` as no `data=` keyword argument was '
'passed when instantiating the serializer instance.'
)
if not hasattr(self, '_validated_data'):
try:
# 核心代码 运行验证self.initial_data数据
# 上面也提到了我们传入的data数据经过序列化后赋值给了self.initial_data
self._validated_data = self.run_validation(self.initial_data)
except ValidationError as exc:
self._validated_data = {}
self._errors = exc.detail
else:
self._errors = {}
if self._errors and raise_exception:
raise ValidationError(self.errors)
return not bool(self._errors)
# 重新了父父类Field的run_validation方法
class Serializer(BaseSerializer, metaclass=SerializerMetaclass):
......
def run_validation(self, data=empty):
"""
We override the default `run_validation`, because the validation
performed by validators and the `.validate()` method should
be coerced into an error dictionary with a 'non_fields_error' key.
"""
# 验证空值
(is_empty_value, data) = self.validate_empty_values(data)
# 是空值返回data
if is_empty_value:
return data
# 局部钩子验证 返回OrderedDict()实例化对象
value = self.to_internal_value(data)
try:
# 运行验证器
self.run_validators(value)
# 全局钩子验证
value = self.validate(value)
"""
这里的全局钩子如果我们需要使用的时候，需要重写，重写的时候一定要返回被拿出来验证的属性
def validate(self, attrs):
return attrs
"""
assert value is not None, '.validate() should return the validated data'
except (ValidationError, DjangoValidationError) as exc:
raise ValidationError(detail=as_serializer_error(exc))
return value
# self.validate_empty_values 验证空值
class Field:
......
def get_default(self):
"""
如果没有为该字段提供输入，则返回验证数据时使用的默认值。
如果这个字段还没有设置默认值，那么它只会引发“SkipField”，这表明不应该在这个字段的验证数据中设置任何值。
"""
if self.default is empty or getattr(self.root, 'partial', False):
# No default, or this is a partial update.
raise SkipField()
if callable(self.default):
if hasattr(self.default, 'set_context'):
self.default.set_context(self)
return self.default()
return self.default
def validate_empty_values(self, data):
"""
# 验证空值，或者:
# *Raise “ValidationError”，表示数据无效。
# *Raise “SkipField”，表示该字段应该被忽略。
# * Return (True, data)，表示一个空值，应该在不应用任何进一步验证的情况下返回。
# *Return (False, data)，指示一个非空值，该值应该正常应用验证。
"""
# self.get_default() 获取默认值
# 如果有只读权限
if self.read_only:
return (True, self.get_default())
if data is empty:
# 判断是否是部分更新
if getattr(self.root, 'partial', False):
raise SkipField()
# 判断是否必填
if self.required:
self.fail('required')
return (True, self.get_default())
if data is None:
# 是否允许为null类型
if not self.allow_null:
self.fail('null')
# 当指定的字段为空值时，不应该跳过可空的' source='*' '字段。这是因为' source='*' '意味着字段被传递给整个对象，而对象不是null。
elif self.source == '*':
return (False, None)
return (True, None)
return (False, data)
局部钩子验证self.to_internal_value(data)
# 重新了父父类Field的to_internal_value方法
class Serializer(BaseSerializer, metaclass=SerializerMetaclass):
......
def to_internal_value(self, data):
"""
Dict of native values <- Dict of primitive datatypes.
"""
if not isinstance(data, Mapping):
message = self.error_messages['invalid'].format(
datatype=type(data).__name__
)
raise ValidationError({
api_settings.NON_FIELD_ERRORS_KEY: [message]
}, code='invalid')
ret = OrderedDict()
errors = OrderedDict()
fields = self._writable_fields
for field in fields:
# 如果反射获取方法赋值给validate_method
validate_method = getattr(self, 'validate_' + field.field_name, None)
primitive_value = field.get_value(data)
try:
validated_value = field.run_validation(primitive_value)
# 如果存在局部钩子函数，则验证validated_value
if validate_method is not None:
validated_value = validate_method(validated_value)
except ValidationError as exc:
errors[field.field_name] = exc.detail
except DjangoValidationError as exc:
errors[field.field_name] = get_error_detail(exc)
except SkipField:
pass
else:
set_value(ret, field.source_attrs, validated_value)
if errors:
raise ValidationError(errors)
return ret
4、数据验证之后执行的就是serializer.save()方法
class BaseSerializer(Field):
.......
def save(self, **kwargs):
assert not hasattr(self, 'save_object'), (
'Serializer `%s.%s` has old-style version 2 `.save_object()` '
'that is no longer compatible with REST framework 3. '
'Use the new-style `.create()` and `.update()` methods instead.' %
(self.__class__.__module__, self.__class__.__name__)
)
assert hasattr(self, '_errors'), (
'You must call `.is_valid()` before calling `.save()`.'
)
assert not self.errors, (
'You cannot call `.save()` on a serializer with invalid data.'
)
# Guard against incorrect use of `serializer.save(commit=False)`
assert 'commit' not in kwargs, (
"'commit' is not a valid keyword argument to the 'save()' method. "
"If you need to access data before committing to the database then "
"inspect 'serializer.validated_data' instead. "
"You can also pass additional keyword arguments to 'save()' if you "
"need to set extra attributes on the saved model instance. "
"For example: 'serializer.save(owner=request.user)'.'"
)
assert not hasattr(self, '_data'), (
"You cannot call `.save()` after accessing `serializer.data`."
"If you need to access data before committing to the database then "
"inspect 'serializer.validated_data' instead. "
)
validated_data = dict(
list(self.validated_data.items()) +
list(kwargs.items())
)
# 如果实例不为空执行的是更新，否则执行创建（这里是创建就不看update了)
if self.instance is not None:
self.instance = self.update(self.instance, validated_data)
assert self.instance is not None, (
'`update()` did not return an object instance.'
)
else:
# 调用create方法
self.instance = self.create(validated_data)
assert self.instance is not None, (
'`create()` did not return an object instance.'
)
return self.instance
self.create(validated_data)
# 重写 BaseSerializer 中的create方法
class ModelSerializer(Serializer):
......
# Default `create` and `update` behavior...
def create(self, validated_data):
"""
We have a bit of extra checking around this in order to provide
descriptive messages when something goes wrong, but this method is
essentially just:
return ExampleModel.objects.create(**validated_data)
If there are many to many fields present on the instance then they
cannot be set until the model is instantiated, in which case the
implementation is like so:
example_relationship = validated_data.pop('example_relationship')
instance = ExampleModel.objects.create(**validated_data)
instance.example_relationship = example_relationship
return instance
The default implementation also does not handle nested relationships.
If you want to support writable nested relationships you'll need
to write an explicit `.create()` method.
"""
raise_errors_on_nested_writes('create', self, validated_data)
ModelClass = self.Meta.model
# Remove many-to-many relationships from validated_data.
# They are not valid arguments to the default `.create()` method,
# as they require that the instance has already been saved.
info = model_meta.get_field_info(ModelClass)
many_to_many = {}
for field_name, relation_info in info.relations.items():
if relation_info.to_many and (field_name in validated_data):
many_to_many[field_name] = validated_data.pop(field_name)
try:
instance = ModelClass._default_manager.create(**validated_data)
except TypeError:
tb = traceback.format_exc()
msg = (
'Got a `TypeError` when calling `%s.%s.create()`. '
'This may be because you have a writable field on the '
'serializer class that is not a valid argument to '
'`%s.%s.create()`. You may need to make the field '
'read-only, or override the %s.create() method to handle '
'this correctly.\nOriginal exception was:\n %s' %
(
ModelClass.__name__,
ModelClass._default_manager.name,
ModelClass.__name__,
ModelClass._default_manager.name,
self.__class__.__name__,
tb
)
)
raise TypeError(msg)
# Save many-to-many relationships after the instance is created.
if many_to_many:
for field_name, value in many_to_many.items():
field = getattr(instance, field_name)
field.set(value)
return instance