04 序列化

什么是序列化

序列化是将对象转换为另一种数据格式的行为

为什么需要序列化？

想想django模型，它是一个python类。那么如何在浏览中将python类呈现为JSON呢？

使用django REST 序列化程序；同样将JSON转换为对象，称为反序列化。

可以这样理解：

  • 通过将djagno模型转为JSON，在浏览中显示它们
  • 使用 JSON payload向API发出CRUD请求

功能

  • 对请求数据的验证
  • 对QuerySet序列化

序列化器允许把像查询集QuerySet和模型实例这位的复杂数据转换为可以轻松渲染成JSON/XML或者其他内容类型的原生Python类开。序列化器还提供反序列化，在验证输入的数据之后允许解析数据转换回复杂类型。

REST framework中的serializers与Django的Form和ModelForm类非常像。我们提供了一个Serializer类，它为你提供了强大的通用方法来控制响应的输出，以及一个ModelSerializer类，它为创建用于处理模型实例和查询集的序列化程序提供了有用的快捷实现方式。

传统方式序列化JSON

  1. class RolesView(APIView)：
  2.     def get(self,request，*args，**kwargs)：
  3.         roles=models.Role.objects.all().values('id','title')
  4.         roles=list(roles)
  5.         ret=json.dumps(roles, ensure_ascii=False)    # 使用了json模块
  6.         return HttpResponse(ret)

序列化器方式序列化JSON

  1. from rest_framework import serializers
  3. class RolesSerializer(serializers.Serializer):
  4.     id = serializers.IntegerField()
  5.     title = serializers.CharField()
  8. class RolesView(APIView)：
  9.     """
  10.     将 Roles 对象序列化 json
  11.     """
  12.     def get(self,request,*args,**kwargs):
  13.         # 多个对象
  14.         # 对[obj1, obj2, obj3] 格式化，使用many参数
  15.         roles = modles.Role.objects.all()
  16.         ser = RolesSerializer(instance=roles, many=True)
  17.         ret=json.dumps(ser.data, ensure_ascii=False)
  19.         # 单个对象
  20.         role = modles.Role.objects.all().first()
  21.         ser = RolesSerializer(instance=role, many=False)
  22.         ret=json.dumps(ser.data, ensure_ascii=False)
  24.         return HttpResponse(ret)

自定义序列化字段

支持两种方式：

  1. 序列器定义时，字段使用参数source或者使用SerializerMethodField字段
  2. 定义序列器时，继承自 serializers.ModelSerializer
  1. from rest_framework import serializers
  3. class UserInfoSerializer(serializers.Serializer):
  4.     id = serializers.IntegerField()
  5.     useranme = serializers.CharField(source="get_user_type_display") # row.get_user_type_display
  6.     password = serializers.CharField()
  7.     gp = serializers.CharField(source="group.title")
  8.     rls = serializers.SerializerMethodField() # 自定义显示
  10.     det get_rls(self, now):
  11.         role_obj_list = row.roles.all()
  12.         ret = []
  13.         for item in role_obj_list:
  14.             ret.append({'id:item.id, 'title': item.title})
  15.         return ret
  18. class UserInfoView(APIView)：
  19.     """
  20.     将 UserInfo 对象序列化 json
  21.     """
  22.     def get(self,request,*args,**kwargs):
  23.         # 多个对象
  24.         # 对[obj1, obj2, obj3] 格式化，使用many参数
  25.         roles = modles.UserInfo.objects.all()
  26.         ser = UserInfoSerializer(instance=roles, many=True)
  27.         ret=json.dumps(ser.data, ensure_ascii=False)
  29.         return HttpResponse(ret)

自定义序列化类，基于继承

  1. from rest_framework import serializers
  3. class UserInfoSerializer(serializers.ModelSerializer):
  4.         class Meta:
  5.             model = models.UserInfo
  6.             # fields = "__all__"
  7.             fields = ['id', 'useranme', 'password', 'rls', 'group']
  8.             # depth = 1  # depth = n

验证

验证器可以用于在不同类型的字段之间重新使用验证逻辑。 —django文档

大多数情况下，您在REST框架中处理验证时，只需依赖缺省字段验证，或者在序列化程序或字段类上编写显式验证方法。

但是，有时您会希望将验证逻辑放置到可重用组件中，以便在整个代码库中轻松地重用它。这可以通过使用验证器函数和验证器类来实现。

DRF验证

REST框架验证完全在序列化程序类上执行。

  1. 它引入了一个适当的问题分离，使用您的代码行为更加明显
  2. 使用快捷ModelSerializer类和使用显示Serializer类很容易切换。任何正在使用验证行为ModelSerializer都很容易复制。
  3. 打印repr一个序列化器实例将显示它到底应用了哪些验证规则。在在模型实例上没有额外的隐藏验证行为。

DRF常用验证器

UniqueValidator

用来强制 unique=True模型字段的约束。一个必需参数和一个可选的message参数

  • queryset 必需，查询集对字段做唯一性检查
  • message 验证失败时应该使用的错误消息
  1. from rest_framework.validators import UniqueValidator
  3. slug = SlugField(
  4.     max_length=100,
  5.     validators=[UniqueValidator(queryset=BlogPost.objects.all())]
  6. )

UniqueTogeherValicator

用来强制unique_together对模型实例进行约束。有两个必需的参数和一个可选的message参数：

  • queryset 必需，查询集对字段做唯一性检查
  • fieldes 必需，应该创建唯一集体的字段的字段名称列表或者元组。必须作为序列化类中的字段已经存在。
  • message 验证失败时错误提示消息
  1. from rest_framework.validators import UniqueTogetherValidator
  3. class ExampleSerializer(serializers.Serializer):
  4.     # ...
  5.     class Meta:
  6.         # ToDo items belong to a parent list, and have an ordering defined
  7.         # by the 'position' field. No two items in a given list may share
  8.         # the same position.
  9.         validators = [
  10.             UniqueTogetherValidator(
  11.                 queryset=ToDoItem.objects.all(),
  12.                 fields=('list', 'position')
  13.             )
  14.         ]
验证器 作用
UniqueForDateValidator
UniqueForMonthValidator
UniqueForYearValidator

参数：

  • queryset 必需，唯一性检查
  • field 必需 在给定日期范围内唯一
  • date_field required 确定唯一性约束的日期范围的字段名称
  • message 错误提示消息
  1. from rest_framework.validators import UniqueForYearValidator
  3. class ExampleSerializer(serializers.Serializer):
  4.     # ...
  5.     class Meta:
  6.         # Blog posts should have a slug that is unique for the current year.
  7.         validators = [
  8.             UniqueForYearValidator(
  9.                 queryset=BlogPostItem.objects.all(),
  10.                 field='slug',
  11.                 date_field='published'
  12.             )
  13.         ]

日期字段可读写时设置方法

  1. # 可写字段
  2. published = serializers.DateTimeField(required=True)
  4. # 只读字段，用户不可写
  5. published = serializers.DateTimeField(read_only=True, default=timezone.now)
  7. # 隐藏日期字段
  8. published = serializers.HiddenField(default=timezone.now)

为不同的请求方法使用相应的序列化类

DRF提供了一种非常方便的方式来开发RESTful应用程序。比如generics通用模块，它包含许多基于请求方法的有用的APIView。

但是，对于具有这些generics通用模块视图的序列化程序类，有以下麻烦。

  1. # models.py
  2. import uuid
  4. from django.db import models
  7. class Organization(models.Model):
  8.     org_uuid = models.UUIDField(
  9.         primary_key=True, default=uuid.uuid4, editable=False)
  10.     name = models.CharField(max_length=40)
  13. class User(AbstractBaseUser):
  14.     user_uuid = models.UUIDField(
  15.         primary_key=True, default=uuid.uuid4, editable=False)
  16.     # Omit username and all the rest of fields for simplicity.
  17.     org = models.ForeignKey('Organization', on_delete=models.CASCADE,)

在定义的模型中常使用到的外键情况。当我们创建一个User或者需要更新User的org属性时，我们只想要向视图提供一个 org_uuid。但是当我们获取或者列出User用户实例的信息时，我们又更愿意看到更多信息而不仅仅是org_uuid。

因此，创建或者更新具有带有列表或者视图方法的不同序列化程序。我们通常为像 User这样的模型类定义以下至少两个序列化器类。

  1. # serializers.py
  2. from rest_framework import serializers
  4. from myapp import models
  6. class OrganizationListViewSerializer(serializers.ModelSerializer):
  7.     """组织列视图序列器"""
  8.     class Meta:
  9.         model = models.Organization
  10.         fields = '__all__'
  13. class UserListViewSerializer(serializers.ModelSerializer):
  14.     """用户列视图序列器"""
  15.     org = OrganizationListViewSerializer()
  17.     class Meta:
  18.         model = models.User
  19.         fields = '__all__'
  22. class UserCreateUpdateSerializer(serializers.ModelSerializer):
  23.     """用户创建视图序列器"""
  24.     org = serializers.PrimaryKeyRelatedField(
  25.         queryset=models.Organization.objects.all())
  27.     class Meta:
  28.         model = models.User
  29.         fields = '__all__

如上，它可以列出或者查看用户信息或者使用嵌套的序列化程序来扩展用户的组织信息。另一方面，org_uuid足以创建或者更新User实例

回到generics通用模块。基于REST的原则，也许是 generics.ListCreateAPIView和generics.RetrieveUpdateAPIView 是最常用的观点，这是基于请求方法设计。DRF在view中做得很好，但是在Serializer中它没有更进一步。

  1. # views.py
  2. from rest_framework import exceptions
  3. from rest_framework import generics
  5. from myapp import models
  6. from myapp import serializers as ser
  9. class MethodSerializerView(object):
  10.     '''
  11.     通过请求方法获得不同的通用类
  12.     For example:
  13.     method_serializer_classes = {
  14.         ('GET', ): MyModelListViewSerializer,
  15.         ('PUT', 'PATCH'): MyModelCreateUpdateSerializer
  16.     }
  17.     '''
  18.     method_serializer_classes = None
  20.     def get_serializer_class(self):
  21.         assert self.method_serializer_classes is not None, (
  22.             'Expected view %s should contain method_serializer_classes '
  23.             'to get right serializer class.' %
  24.             (self.__class__.__name__, )
  25.         )
  26.         for methods, serializer_cls in self.method_serializer_classes.items():
  27.             if self.request.method in methods:
  28.                 return serializer_cls
  30.         raise exceptions.MethodNotAllowed(self.request.method)
  33. class UsersListCreateView(MethodSerializerView, generics.ListCreateAPIView):
  34.     '''
  35.     API: /users
  36.     Method: GET/POST
  37.     '''
  38.     queryset = models.User.objects.all()
  39.     method_serializer_classes = {
  40.         ('GET', ): ser.UserListViewSerializer,
  41.         ('POST'): ser.UserCreateUpdateSerializer
  42.     }
  45. class UsersDetailView(MethodSerializerView, generics.RetrieveUpdateAPIView):
  46.     '''
  47.     API: /user/:user_uuid
  48.     Method: GET/PUT/PATCH
  49.     '''
  50.     queryset = models.User.objects.all()
  51.     method_serializer_classes = {
  52.         ('GET', ): ser.UserListViewSerializer,
  53.         ('PUT', 'PATCH'): ser.UserCreateUpdateSerializer
  54.     }

注意：MethodSerializerView应放在generics通用模块视图之前，因此它可以覆盖get_serializer_class方法。

最后，在处理generics通用模块视图时，我们有多个串行器选择，所有这些都基于请求方法😀。