序列化和反序列化

序列化模块

序列化模块是 drf 的核心

为什么要使用序列化

后台数据大多以后台类的对象存在,无法直接传给前端,所以经过序列化后,就可以格式化成能返回给前台的数据。

所以要如何完成序列化,就要靠他的三种类了

Serializer类(了解)- 偏底层,开发效率不高
ModelSerializer类(重中之重) - 开发运用阶段才有的序列化方式,开发效率高
ListSerializer类(正常)- 完成群增,群改接口的辅助序列化类

首先来用Serializer类实现序列化。

序列化实例

urls

from django.conf.urls import url
from . import views

urlpatterns = [
    url(r'^v1/users/$', views.UserAPIView.as_view()),
    url(r'^v1/users/(?P<pk>\d+)/$', views.UserAPIView.as_view()),
]

这里接收无论你是get 还是post 请求。两条url 都可以匹配get和post请求。至于为什么,看下面的代码

views

#这个类用来实现单查,群查和单增
class UserAPIView(APIView):
    #判断来的请求是get的话就会走这个方法
    def get(self, request, *args, **kwargs):
        #这里为什么能从kwargs里面拿到pk?看下面注释1.
        pk = kwargs.get('pk')
    
		#这里判断pk存在之后就意味着这是一个单增。
        if pk:
            #查找到这个数据库里的记录,拿到的就是一个对象。
            user_obj = models.User.objects.filter(pk=pk).first()
            #判断你拿到的数据是不是空,也就是传进来查询的pk值存不存在对应记录,不存				在就报错。
            if not user_obj:
                return Response({
                    'status': 1,
                    'msg': '单查 error'
                })
			#走到这里就代表数据库里存在记录,然后就是通过自己写的继承serializers			的类来做序列化。
            user_ser = serializers.UserSerializer(user_obj, many=False)
            user_data = user_ser.data
            #返回查询成功的结果。
            return Response({
                'satatus':0,
                'msg':'单查 ok',
                'result':user_data
            })
		#如果pk不存在的话就代表是群查了
        user_query = models.User.objects.all()
        #群查的话就把这里的many参数的值改成True,内部会列表推导式来循环序列化一个个			对象。
        user_list_data = serializers.UserSerializer(user_query, many=True).data
		#返回群查结果
        return Response({
            'satatus': 0,
            'msg': '群查 ok',
            'result': user_list_data
        })
    
	 #判断来的请求是post的话就会走这个方法,就代表是单增
    def post(self, request, *args, **kwargs):
        #先从data里面拿取数据包
        request_data = request.data
		#直接把数据包塞进自己写的类里面进行校验和反序列化。
        #为什么要校验,因为前段传过来的东西可能不符合要求
        user_ser = serializers.USerDeserializer(data=request_data)
        #获取is_valid方法的值
        result = user_ser.is_valid()
		#判断是否全部符合要求
        if result:
           #符合的话调用,但是这里我们得在自己写的类中重写create方法。
            user_obj = user_ser.save()
            #返回保存成功结果,并且返回保存内容,只需再去调用一下
            return Response({
                'status':0,
                'msg':'ok',
                'results':serializers.UserSerializer(user_obj).data
            })
        else:
            #否则就返回错误结果
            return Response({
                'status': 1,
                'msg': user_ser.errors
            },status=status.HTTP_400_BAD_REQUEST)

注释1:为什么能从kwargs里面拿到pk?

解释:因为 url(r'^v1/users/(?P<pk>\d+)/$', views.UserAPIView.as_view()) ,这里调用的是as_view,相当于就是 views.view ,当路由匹配上的时候,就会自己加括号调用,然后有名分组的pk就传进这个方法,在上面得栗子是单查的时候,调用的就相当于是 get方法,所以kwargs里面就有pk了。你反问的url里面后面带上的是多少,这里的pk就是多少。

然后就看一下到底是怎么序列化,反序列化,和校验数据的。

把我们自己写的UserSerializer类卸载api下,api就是应用。

from rest_framework import serializers
#序列化方法
class UserSerializer(serializers.Serializer):
    # model已有的属性字段
    #   如果要参与序列化,名字一定要与model的属性同名
    #   如果不参与序列化的model属性,在序列化类中不做声明
    
    #有哪些不要序列化的属性呢?比如说密码就是,总不可能把密码返回回去给用户看了吧。

    name = serializers.CharField()
    age = serializers.IntegerField()
    height = serializers.DecimalField(max_digits=5, decimal_places=2)
    #如果我们sex这样返回的话,那用户拿到的就是 1 或者 0 了,不合理。所以要用自定义序列化字段
    # sex = serializers.IntegerField()

    # 自定义序列化字段,序列化的属性值由方法来提供,
    #   方法的名字:固定为 get_属性名,
    #   方法的参数:序列化对象,序列化的model对象
    #   强烈建议自定义序列化字段名不要与model已有的属性名重名

    #固定写法
    gender = serializers.SerializerMethodField()
    def get_gender(self, obj):

        return obj.get_sex_display()


from . import models
#反序列化方法
class UserDeserializer(serializers.Serializer):
    # 系统校验规则

    # 系统必须反序列化的字段
    # 序列化属性名不是必须与model属性名对应,但是与之对应会方便序列化将校验通过的数据与数据库进行交互
    
    #那些设置了默认值的字段可以不用反序列化。
    name = serializers.CharField(min_length=3, max_length=64, error_messages={
        'required': '姓名必填',
        'min_length': '太短',
    })
    #这里我们没有自己配置错误信息,所以不会像name一样报中文错误。
    pwd = serializers.CharField(min_length=3, max_length=64)

    # 系统可选的反序列化字段:没有提供不进行校验(数据库中有默认值或可以为空),提供了就进行校验,这里的required设置成了 False ,所以我们前端可以不传 age
    age = serializers.IntegerField(min_value=0, max_value=150, required=False)

    # 自定义反序列化字段:一定参与校验,且要在校验过程中,将其从入库的数据中取出,剩余与model对应的数据才会入库
    #简言之,这个字段是我们自己自定义的,要求前端传来的数据中一定要有re_pwd,但是我们 model表里没有这个字段,所以判断完之后要把这个re_pwd从数据包中删除,然后在存入数据库。
    re_pwd = serializers.CharField(min_length=3, max_length=64)

    # 自定义校验规则:局部钩子,全局钩子
    # 局部钩子:validate_字段名(self, 字段值)
    # 规则:成功返回value,失败抛异常
    def validate_aaa(self, value):
        if 'g' in value.lower():
            raise serializers.ValidationError('名字中不能有g')
        return value

    # 全局钩子:validate(self, 所有校验的数据字典)
    # 规则:成功返回attrs,失败抛异常
    def validate(self, attrs):
        # 取出联合校验的字段们:需要入库的值需要拿到值,不需要入库的需要从校验字段中取出
        pwd = attrs.get('pwd')
        #pop方法会删除re_pwd对应的值,然后返回这个值
        re_pwd = attrs.pop('re_pwd')
        if pwd != re_pwd:
            raise serializers.ValidationError({'re_pwd': '两次密码不一致'})
        return attrs

    # create重写,完成入库
    #这里为什么要重写create方法? 因为在views里面调用了save方法,save里面会进行判断是执行update还是create,这里是执行self.create,self代表的就是这个类本身,如果我们没有重写的话,就要往上蹭找,找Serializer中的create,发现也没有,再往上找serializers,发现里面也没有create方法,在往上找BaseSerializer进去一看,发现里面只有一句抛出异常,所以这就是强制我们必须要重写create方法,我们只好重写了。
    def create(self, validated_data):
        return models.User.objects.create(**validated_data)


以上就实现了单查、群查和单增的功能,但是发现步骤有点繁琐,开发效率并不高。

于是就应该使用 ModelSerializer 类,这个类可以把序列化和反序列化写成一个类。

首先把views里的代码改一点点

from rest_framework.views import APIView
from rest_framework.response import Response
from . import models, serializers
from rest_framework import status
class UserV2APIView(APIView):
    # 单查群查
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            user_obj = models.User.objects.filter(pk=pk).first()
            if not user_obj:
                return Response({
                    'status': 1,
                    'msg': '单查 error'
                })

            # 完成序列化
            user_data = serializers.UserModelSerializer(user_obj, many=False).data

            return Response({
                'status': 0,
                'msg': '单查 ok',
                'results': user_data
            })

        # 群查
        user_query = models.User.objects.all()
        # 完成序列化
        user_list_data = serializers.UserModelSerializer(user_query, many=True).data
        return Response({
            'status': 0,
            'msg': '群查 ok',
            'results': user_list_data
        })

    # 单增
    def post(self, request, *args, **kwargs):
        request_data = request.data

        user_ser = serializers.UserModelSerializer(data=request_data)

        # 配置了 raise_exception=True ,校验失败,直接抛异常,反馈异常信息给前台,只要校验通过,代码才会往下执行,所以直接删除我们自己写的else
        result = user_ser.is_valid( raise_exception=True)
        if result:
            user_obj = user_ser.save()
            return Response({
                'status': 0,
                'msg': 'ok',
                'results': serializers.UserModelSerializer(user_obj).data
            })
from rest_framework.serializers import ModelSerializer
from . import models
# 整合序列化与反序列化,都整合到这个类里面
class UserModelSerializer(ModelSerializer):
    #一共是这三步骤
    # 将序列化类与Model类进行绑定
    # 设置序列化与反序列化所有字段(并划分序列化字段与反序列化字段)
    # 设置反序列化的局部与全局钩子

    # 自定义反序列化字段,校验规则只能在声明自定义反序列化字段时设置,且一定是write_only
    re_pwd = serializers.CharField(min_length=3, max_length=64, write_only=True)
	#写一个 Meta 类
    class Meta:
        #绑定model类,形成对应
        model = models.User
        #所有参与了序列化和反序列化的字段都要写进去,这里的gender就是插头,插上了,就能用了,可插拔式字段。
        fields = ['name', 'age', 'height', 'gender', 'pwd', 're_pwd']
        #系统校验规则
        extra_kwargs = {
            'name': {
                'required': True,
                'min_length': 3,
                'error_messages': {
                    'min_length': '太短'
                }
            },
            'age': {
                'required': True,  # 数据库有默认值或可以为空字段,required默认为False
                'min_value': 0
            },
            'pwd': {
                'required': True,
                'write_only': True,  # 只参与反序列化,只能写,不会返回
            },
            'gender': {
                'read_only': True,  # 只参与序列化,自定义字段不会参与反序列化
            },
        }
	#钩子函数不变
    def validate_name(self, value):
        if 'g' in value.lower():
            raise serializers.ValidationError('名字中不能有g')
        return value

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

models

from django.db import models

class User(models.Model):
    CHOICES_SEX = ((0, '男'), (1, '女'))
    name = models.CharField(max_length=64)
    age = models.IntegerField(default=0)
    height = models.DecimalField(max_digits=5, decimal_places=2, default=0)
    icon = models.ImageField(upload_to='icon', default='default.png')
    sex = models.IntegerField(choices=CHOICES_SEX, default=0)
    # 已经迁移的数据库,新增字段需要允许为空或者设置默认值
    pwd = models.CharField(max_length=64, null=True)



    # 自定义插拔序列化字段:替换了在Serializer类中自定义的序列化字段(SerializerMethodField)
    # 自定义插拔序列化字段一定不参与反序列化过程,用来多表的时候作用尤其明显
    @property
    def gender(self):
        return self.get_sex_display()


    class Meta:
        db_table = 'ob_user'
        verbose_name = '用户表'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


总结:

""" 序列化
一、视图类的三步操作
1)ORM操作数据库拿到资源数据
2)格式化(序列化)成能返回给前台的数据
3)返回格式化后的数据

二、视图类的序列化操作
1)直接将要序列化的数据传给序列化类
2)要序列化的数据如果是单个对象,序列化的参数many为False,数据如果是多个对象(list,queryset)序列化的参数many为True

三、序列化类
1)model了中要反馈给前台的字段,在序列化类中要进行声明,属性名必须就是model的字段名,且Field类型也要保持一致(不需要明确规则)
2)model了中不需要反馈给前台的字段,在序列化类中不需要声明(省略)
3)自定义序列化字段用 SerializerMethodField() 作为字段类型,该字段的值来源于 get_自定义字段名(self, obj) 方法的返回值
"""

""" 反序列化
一、视图类的三步操作
1)从请求对象中拿到前台的数据
2)校验前台数据是否合法
3)反序列化成后台Model对象与数据库交互

二、视图类的反序列化操作
1)将要反序列化的数据传给序列化类的data参数
2)要反序列化的数据如果是单个字典,反序列化的参数many为False,数据如果是多个字典的列表,反序列化的参数many为True

三、反序列化类
1)系统的字段,可以在Field类型中设置系统校验规则(name=serializers.CharField(min_length=3))
2)required校验规则绝对该字段是必校验还是可选校验字段(默认required为True,数据库字段有默认值或可以为空的字段required可以赋值为False)
3)自定义的反序列字段,设置系统校验规则同系统字段,但是需要在自定义校验规则中(局部、全局钩子)将自定义反序列化字段取出(返回剩余的数据与数据库交互)
4)局部钩子的方法命名 validate_属性名(self, 属性的value),校验规则为 成功返回属性的value 失败抛出校验错误的异常
5)全局钩子的方法命名 validate(self, 所有属性attrs),校验规则为 成功返回attrs 失败抛出校验错误的异常
"""

单表序列化总结:

""" 单表序列化总结
1)序列化与反序列功能可以整合成一个类,该类继承ModelSerializer
2)继承ModelSerializer类的资源序列化类,内部包含三部分
    Meta子类、局部钩子、全局钩子
    注:create和update方法ModelSerializer已经重写了,使用不需要重写
3)在Meta子类中:
    用model来绑定关联的Model类
    用fields来设置所有的序列化反序列化字段
    用extra_kwargs来设置系统的校验规则
4)重要的字段校验规则:
    read_only校验规则,代表该字段只参与序列化
    write_only校验规则,代表该字段只参与反序列化
    required校验规则,代表该字段在反序列化是是否是必填(True)还是选填(False),不能和read_only一起使用(规则冲突)
    规则细节:
        如果一个字段有默认值或是可以为空,没设置required规则,默认为False,反之默认值为True
        如果一个Model字段即没有设置read_only也没设置write_only,该字段默认参与序列化及反序列化
5)自定义序列化字段:在Model类中,定义方法属性(可以返回特殊值,还可以完成连表操作),在序列化类的fields属性中可以选择性插拔
6)自定义反序列化字段:在Serializer类中,自定义校验字段,校验规则也只能在声明字段时设置,自定义的反序列化字段(如re_pwd),
必须设置write_only为True
"""


posted @ 2019-11-21 18:48  chanyuli  阅读(346)  评论(0编辑  收藏  举报