单表序列化与反序列化

一、自定义序列化：

所有的逻辑写在单查群查这个视图类里，如果业务逻辑复杂，视图类会超级大。

class UserV1APIView(APIView):
    #单查群查
    def get(self,request,*args,**kwargs):
        pk=kwargs.get(\'pk\')
        if pk:
            user_dic=models.User.objects.filter(is_delete=False,pk=pk).values(\'username\',\'sex\',\'img\').first()
            if not user_dic:
                return Response({
                    \'status\':1,
                    \'msg\':\'pk error\',
                },status=400)
            user_dic[\'img\']=\'%s%s%s\'%(settings.BASE_URL,settings.MEDIA_URL,user_dic.get(\'img\'))  #拼接子资源
            return Response({
                \'status\':0,
                \'msg\':\'ok\',
                \'results\':user_dic
            })
        else:
            user_query=models.User.objects.filter(is_delete=False).values(\'username\',\'sex\',\'img\').all()
            for user_dic in user_query:
                user_dic[\'img\']=\'%s%s%s\'%(settings.BASE_URL,settings.MEDIA_URL,user_dic.get(\'img\'))
                user_list=list(user_query)
                return Response({
                    \'status\':0,
                    \'msg\':\'ok\',
                    \'results\':user_list
                })

二、drf序列化过程：

• 视图类序列化过程
  • orm操作得到数据
  • 将数据序列化成可以返回给前台的数据
  • 返回数据给前台
• 视图类反序列化过程
  • 从请求对象中获取前台提交的数据
  • 交给序列化类完成反序列化（数据的校验）
  • 借助序列化类完成数据入库
  • 反馈给前台处理结果

序列化过程：将序列化模块封装起来

• 序列化总结：

  • 设置序列化字段，字段名与字段类型要与处理的model类属性名对应（只参与序列化的类型不需要设置条件）
  • model类中有的字段，但在序列化中没有对应字段，该类字段不参与序列化
  • 自定义序列化字段（方法一），字段类型为SerializerMethodField(),值由get_自定义字段名(self,model_obj)方法提供，不建议自定义字段名与数据库字段名重名
  • 一般值都与参与序列化的model对象有关

• 反序列化总结

  • 系统校验字段与自定义校验字段没有区别：字段=serializers.字段类型（条件）
  • 自定义校验字段是不能直接入库的，需要设置入库规则，或将其移除不入库（这类字段就是参与全局校验用的）
  • 所有字段都可以设置对应局部钩子进行校验，钩子方法validate_字段名（self,字段值value)
  • 规则：成功直接返回value,失败抛出校验失败信息VaildationError(\'错误信息‘)
  • 重写create方法实现增入库，返回入库成功的对象
  • 重写update方法实现改入库，返回入库成功的对象

实例instance转换成数据data是序列化（instance参与序列化），数据转换成实例是反序列化（data参与反序列化）

from . import serializers
class UserV2APIView(APIView):
    #单查群查
    def get(self,request,*args,**kwargs):
        pk=kwargs.get(\'pk\')
        if pk:
            user_obj=models.User.objects.filter(is_delete=False,pk=pk).first()
            if not user_obj:
                return Response({
                    \'status\':1,
                    \'msg\':\'pk error\',
                },status=400)
            user_ser=serializers.UserSerializer(user_obj,many=False)
            user_obj_data=user_ser.data
            return Response({
                \'status\':0,
                \'msg\':\'ok\',
                \'results\':user_obj_data
            })
        else:
            #将对象对外提供的字段，以及整个序列化过程封装，形成序列化类
            user_query=models.User.objects.filter(is_delete=False).all()
            user_ser=serializers.UserSerializer(user_query,many=True)  #many默认为False，指操作的对象是单个还是多个
            user_list_data=user_ser.data  #最终将序列化结果放data里
            return Response({
                \'status\':0,
                \'msg\':\'ok\',
                \'results\':user_list_data
            })
    #单增
    def post(self,request,*args,**kwargs):
        request_data=request.data  #前台提交的数据
        user_ser=serializers.UserSerializer(data=request_data)  #序列化对象
        if user_ser.is_valid():
            #入库
            user_obj=user_ser.save()
            return Response({
                \'status\':0,
                \'msg\':\'ok\',
                \'results\':serializers.UserSerializer(user_obj).data #将入库得到的user对象重新序列化的数据返回给前台
            })
        else:
            return Response({
                \'status\':1,
                \'msg\':user_ser.errors,
            })

class UserDeSerializer(serializers.Serializer):
    #系统校验字段
    username=serializers.CharField(min_length=3,max_length=11,error_messages={
        \'min_length\': \'太短\',
        \'max_length\': \'太长\'
    })
    password=serializers.CharField(min_length=3,max_length=16)

    #required=false的字段，前台不提供，走默认值，提供就一定进行校验，不写前台是否提供都采用默认值
    #不写，不参与反序列化，写就必须参与反序列化（但可以设置requires=false取消必填）
    sex=serializers.BaseSerializer(required=False)

    #自定义校验字段：从设置语法与系统字段没有区别，但是这些字段不能参与入库操作；需要在全局钩子中将其取出
    re_password=serializers.CharField(min_length=3,max_length=8)

    #局部钩子：
    #方法就是validate_校验的字段名（self，校验的字段数据）
    #校验规则：成功直接返回value，失败抛出校验失败信息
    def validate_username(self, value):
        if \'g\' in value.lower():
            raise serializers.ValidationError(\'名字中不能有g\')
        return value

    #全局钩子：
    #方法就是validate(self,所有的校验数据）
    #校验规则：成功直接返回attrs,失败抛出校验失败信息
    def validate(self, attrs):
        password=attrs.get(\'password\')
        re_password=attrs.pop(\'re_password\')
        if password!=re_password:
            raise serializers.ValidationError({\'re_password\':\'两次密码不一致\'})
        return attrs
    #在视图类中调用序列化类的save方法完成入库，Serializer类能做的增入库走create方法，改入库走update方法
    #但Serializer没有提供两个方法的实现体
    def create(self,validated_data):
        return models.User.objects.create(**validated_data)

    #instance要被修改的对象，validated_data代表校验后用来改instance的数据
    def update(self,instance:models.User,validated_data):
        #用户名不能修改
        validated_data.pop(\'username\')
        models.User.objects.filter(pk=instance.id).update(**validated_data)
        return instance

三、（核心）单表序列化与反序列化操作：

ModelSerializer类序列化与反序列化总结

• 序列化类继承ModelSerializer，所有需要在配置类Meta中进行配置
• model配置：绑定序列化相关的Model表
• fields配置：采用插拔式设置所有参与序列化与反序列化字段
• extra_kwargs配置：
  • 划分系统字段为三种：只读（read_only）、只写（write_only）、可读可写（不设置）
  • 字段是否必须：required
  • 选填字段：在extra_kwargs进行配置，但不设置required，且有默认值
• 自定义序列化字段：
  • 第一种（不提倡）：在序列化类中用SerializerMethodField()来实现
  • 第二种（提倡）：在模型类中用@property来实现，可插拔
• 自定义反序列化字段：
  • 同Serializer类，且规则只能在此声明中设置，或是在钩子中设置，在extra_kwargs中对其设置的无效
  • 自定义反序列化字段与系统字段，设置规则一样，所以必须设置write_only
• 局部钩子，全局钩子同Serializer类
• 不需要重写create和update方法

自定义的永远不参与反序列化

class UserModelSerializer(serializers.ModelSerializer):
    #第一种自定义序列化字段：该字段必须在field中设置
    gender=serializers.SerializerMethodField()
    def get_gender(self,obj):
        return obj.get_sex_display()
    #自定义反序列化字段与系统字段，设置规则一样，所以必须设置write_only在此声明中
    re_password=serializers.CharField(min_length=3,max_length=16,write_only=True)
    class Meta:
        model=models.User
        fields=(\'username\',\'gender\',\'icon\',\'password\',\'sex\',\'re_password\')
        extra_kwargs={
            \'username\':{ #系统字段不设置read_only,write_only,默认序列化和反序列化都可以参加
                \'min_length\':3,
                \'max_length\':10,
                \'error_message\':{
                    \'min_length\':\'太短\',
                    \'max_length\':\'太长\'
                }
            },
            \'gender\':{
                \'read_only\':True,  #自定义的序列化字段默认就是read_only，且不能修改，可以省略
            },
            \'password\':{
                \'write_only\':True,
            },
            \'sex\':{  #像sex有默认值的选填字段，\'required\':True可以将其变为必填字段
                \'write_only\':True,
                #\'required\': True
            }
        }
    # 局部钩子：
    # 方法就是validate_校验的字段名（self，校验的字段数据）
    # 校验规则：成功直接返回value，失败抛出校验失败信息

    def validate_username(self, value):
        if \'g\' in value.lower():
            raise serializers.ValidationError(\'名字中不能有g\')
        return value

    # 全局钩子：
    # 方法就是validate(self,所有的校验数据）
    # 校验规则：成功直接返回attrs,失败抛出校验失败信息

    def validate(self, attrs):
        password = attrs.get(\'password\')
        re_password = attrs.pop(\'re_password\')
        if password != re_password:
            raise serializers.ValidationError({\'re_password\': \'两次密码不一致\'})
        return attrs

    #create和update方法不需要再重写，ModelSerializer类已提供，且支持所有关系下的连表操作

#models.py表
#第二种自定义序列化字段（插拔式，建议使用）
    @property
    def gender(self):
        return self.get_sex_display()

    @property
    def icon(self):
        from django.conf import settings
        return \'%s%s%s\' %(settings.BASE_URL,settings.MEDIA_URL,self.img)