数据校验&序列化放到同一个类。
    前面示例均属于单一功能（要么校验，要么序列化），其实当我们编写一个序列化类既可以做数据校验，也可以做序列化。

    • read_only 只用于序列化，不用于校验。
    • wrire_only 只用于校验，不用于序列化。

    image.png
    序列化
    image.png
    数据校验
    image.png

    1. # models.py
    3. from django.db import models
    6. class Role(models.Model):
    7.     """ 角色表 """
    8.     title = models.CharField(verbose_name="名称", max_length=32)
    11. class Department(models.Model):
    12.     """ 部门表 """
    13.     title = models.CharField(verbose_name="名称", max_length=32)
    16. class UserInfo(models.Model):
    17.     """ 用户表 """
    18.     level_choices = ((1, "普通会员"), (2, "VIP"), (3, "SVIP"),)
    19.     level = models.IntegerField(verbose_name="级别", choices=level_choices, default=1)
    21.     username = models.CharField(verbose_name="用户名", max_length=32)
    22.     password = models.CharField(verbose_name="密码", max_length=64)
    23.     age = models.IntegerField(verbose_name="年龄", default=0)
    24.     email = models.CharField(verbose_name="邮箱", max_length=64, null=True, blank=True)
    25.     token = models.CharField(verbose_name="TOKEN", max_length=64, null=True, blank=True)
    27.     depart = models.ForeignKey(verbose_name="部门", to="Department", on_delete=models.CASCADE, null=True, blank=True)
    28.     roles = models.ManyToManyField(verbose_name="角色", to="Role")
    1. # urls.py
    3. from django.urls import path, re_path, include
    4. from app01 import views
    6. urlpatterns = [
    7.     path('api/users/', views.UserView.as_view()),
    8. ]
    1. # views.py
    3. from django.core.validators import EmailValidator
    4. from rest_framework.views import APIView
    5. from rest_framework.response import Response
    6. from rest_framework import serializers
    8. from app01 import models
    11. class DepartModelSerializer(serializers.ModelSerializer):
    12.     class Meta:
    13.         model = models.Department
    14.         fields = ['id', "title"]
    15.         extra_kwargs = {
    16.             "id": {"read_only": False},  # 数据验证
    17.             "title": {"read_only": True}  # 序列化
    18.         }
    21. class RoleModelSerializer(serializers.ModelSerializer):
    22.     class Meta:
    23.         model = models.Role
    24.         fields = ['id', "title"]
    25.         extra_kwargs = {
    26.             "id": {"read_only": False},  # 数据验证
    27.             "title": {"read_only": True}  # 序列化
    28.         }
    31. class UserModelSerializer(serializers.ModelSerializer):
    32.     level_text = serializers.CharField(source="get_level_display", read_only=True)
    34.     # Serializer嵌套，不是read_only，一定要自定义create和update，自定义新增和更新的逻辑。
    35.     depart = DepartModelSerializer(many=False)
    36.     roles = RoleModelSerializer(many=True)
    38.     extra = serializers.SerializerMethodField(read_only=True)
    39.     email2 = serializers.EmailField(write_only=True)
    41.     # 数据校验：username、email、email2、部门、角色信息
    42.     class Meta:
    43.         model = models.UserInfo
    44.         fields = [
    45.             "username", "age", "email", "level_text", "depart", "roles", "extra", "email2"
    46.         ]
    47.         extra_kwargs = {
    48.             "age": {"read_only": True},
    49.             "email": {"validators": [EmailValidator, ]},
    50.         }
    52.     def get_extra(self, obj):
    53.         return 666
    55.     def validate_username(self, value):
    56.         return value
    58.     # 新增加数据时
    59.     def create(self, validated_data):
    60.         """ 如果有嵌套的Serializer，在进行数据校验时，只有两种选择：
    61.               1. 将嵌套的序列化设置成 read_only
    62.               2. 自定义create和update方法，自定义新建和更新的逻辑
    63.             注意：用户端提交数据的格式。
    64.         """
    65.         depart_id = validated_data.pop('depart')['id']
    67.         role_id_list = [ele['id'] for ele in validated_data.pop('roles')]
    69.         # 新增用户表
    70.         validated_data['depart_id'] = depart_id
    71.         user_object = models.UserInfo.objects.create(**validated_data)
    73.         # 在用户表和角色表的关联表中添加对应关系
    74.         user_object.roles.add(*role_id_list)
    76.         return user_object
    79. class UserView(APIView):
    80.     """ 用户管理 """
    82.     def get(self, request):
    83.         """ 添加用户 """
    84.         queryset = models.UserInfo.objects.all()
    85.         ser = UserModelSerializer(instance=queryset, many=True)
    86.         return Response({"code": 0, 'data': ser.data})
    88.     def post(self, request):
    89.         """ 添加用户 """
    90.         ser = UserModelSerializer(data=request.data)
    91.         if not ser.is_valid():
    92.             return Response({'code': 1006, 'data': ser.errors})
    94.         ser.validated_data.pop('email2')
    96.         instance = ser.save(age=18, password="123", depart_id=1)
    98.         # 新增之后的一个对象（内部调用UserModelSerializer进行序列化）
    99.         print(instance)
    100.         # ser = UserModelSerializer(instance=instance, many=False)
    101.         # ser.data
    103.         return Response({'code': 0, 'data': ser.data})