Django中的序列化器

最新推荐文章于 2024-06-14 11:31:39 发布

fengyehongWorld

最新推荐文章于 2024-06-14 11:31:39 发布

阅读量3.6k

点赞数 14

分类专栏： Python 文章标签： django

本文链接：https://blog.csdn.net/feyehong/article/details/84395337

版权

Python 专栏收录该内容

4 篇文章 1 订阅

订阅专栏

一. 序列化器

序列化器的主要工作就是将前端传入后端的JSON数据转换为ORM模型映射

一个序列化器可以同时包含序列化和反序列化两个功能,想要用哪一个功能具体看你怎么调用

1.序列化器的两个功能

序列化: 将模型转换成json数据返回给前端,可以序列化一个模型类,也可以序列化多个模型类(many=True)

反序列化: 将json数据转换成模型,反序列化还可以用来进一步验证信息和保存数据

但验证的时候不一定保存数据入库,但是保存数据入库的时候一定要验证数据

序列化和反序列化的功能本质上都属于序列化器的功能

想要用到序列化器的序列化功能,就传入 ORM模型对象, 使之模型转JSON

想要用到序列化器的反序列化功能就传入 JSON数据,使之验证数据或者保存入库

2.序列化器的序列化功能

2.1有模型继承的序列化器

定义一个ORM模型

from django.db import models
# 导入系统自带的用户模型类,在此基础上对起进行继承重写
from django.contrib.auth.models import AbstractUser
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer, BadData
from django.conf import settings

# 继承系统自带的用户模型类,在原有的基础上重新拓展新的字段
class User(AbstractUser):
    """我们自己的用户的模型类"""

    # 给用户新增加手机号字段
    mobile = models.CharField(max_length=11, verbose_name='手机号', unique=True)
    # 给用户新增加邮箱验证状态属性
    email_active = models.BooleanField(default=False, verbose_name='邮箱验证状态')
    # 用户新增加默认的地址
    default_address = models.ForeignKey('Address', related_name='users', null=True, blank=True,on_delete=models.SET_NULL, verbose_name='默认地址')

    class Meta:
        # 数据库中显示的表的名称
        db_table = 'tb_users'
        # 在admin站点中显示的名称
        verbose_name = '用户'
        verbose_name_plural = verbose_name

定义一个序列化器(这个序列化器是有模型的)

from rest_framework import serializers
# 在序列化器中导入用户的ORM模型
from .models import User

# 因为有ORM USER 模型,所以继承了 serializers.ModelSerializer
class UserDetailSerializer(serializers.ModelSerializer):
    """用户个人中心详细信息序列化器"""
    
    class Meta:  # 由于要序列化的有模型,因此需要添加 class Meta:
        model = User  # 明确用的是 User 模型
        # 使用fields来明确字段，__all__表名包含所有字段，也可以写明具体哪些字段
        fields = ('id', 'username', 'mobile', 'email', 'email_active')

在视图中使用序列化器(用到了序列化器的序列化功能,把ORM模型转换为JSON数据类型返回给前端)

# 导入登录用户的认证信息
from rest_framework.permissions import IsAuthenticated

class UserDetailView(RetrieveModelMixin, GenericAPIView):
	
    permission_classes = [IsAuthenticated]
    serializer_class = UserDetailSerializer

    # 重写了get_object()方法
    # get_object()方法是用来获取用户模型类对象的
    # 但是前端返回的值只有加密之后的token
    # request可以获取请求的用户对象,这是前面的知识点
    # 所以重写get_object()方法,直接强制赋予用户模型类对象
    def get_object(self):
        return self.request.user

    # 通过get方法把用户模型转换为json之后数据传回前端
    def get(self, request):

        # 调用RetrieveModelMixin类内部的retrieve()方法,该方法内部会调用GenericAPIView类内部的get_serializer()方法,来获得json数据
        return self.retrieve(request)
 
############################################################################
最终把JSON数据类型返回给前端,前端接收到JSON数据进行页面展示

2.2 没有模型继承的序列化器

定义一个序列化器(这个序列化器没有模型)

from rest_framework import serializers

# 因为这个序列化器没有用到模型,所以继承自 serializers.Serializer
class BookInfoSerializer(serializers.Serializer):
    """图书数据序列化器"""
    id = serializers.IntegerField(label='ID', read_only=True)
    name = serializers.CharField(label='名称', max_length=20)
    pub_date = serializers.DateField(label='发布日期', required=False)
    readcount = serializers.IntegerField(label='阅读量', required=False)
    commentcount = serializers.IntegerField(label='评论量', required=False)
    image = serializers.ImageField(label='图片', required=False)

使用序列化器序列化一个模型对象

from book.models import BookInfo

# 查询出 id = 4 的时候的 模型对象
book = BookInfo.objects.get(id=4)

# 构造序列化器对象
from book.serializers import BookInfoSerializer
serializer = BookInfoSerializer(book)

# 通过 serializer.data 可以获取 序列化之后的 json 数据
serializer.data ---> {'is_delete': False, 'pub_date': '1987-11-11', 'readcount': 58}

使用序列化器序列化多个模型对象

from book.models import BookInfo

# 查询出所有的模型类对象(多个)
books = BookInfo.objects.all()
# 序列化多个的时候需要通过加上many=True
serializer = BookInfoSerializer(books, many=True)  

serializer.data
[OrderedDict([('id', 3), ('name', '笑傲江湖'), ('pub_date', '1995-12-24'), ('readcount', 28)), OrderedDict([('id', 4), ('name', '雪山飞狐'), ('pub_date', '1987-11-11'), ('readcount', 58))]

3.序列化器的反序列化功能

反序列化主要有两个功能:

1.验证数据

2.保存数据入库

3.1 验证数据

在获取反序列化的数据前，必须调用**is_valid()**方法进行验证，验证成功返回True，否则返回False。

验证失败，可以通过序列化器对象的errors属性获取错误信息，返回字典，包含了字段和字段的错误。

验证成功，可以通过序列化器对象的validated_data属性获取数据。

之前定义过的 BookInfoSerializer 序列化器

class BookInfoSerializer(serializers.Serializer):
    """图书数据序列化器"""
    id = serializers.IntegerField(label='ID', read_only=True)
    name = serializers.CharField(label='名称', max_length=20)
    pub_date = serializers.DateField(label='发布日期', required=False)
    readcount = serializers.IntegerField(label='阅读量', required=False)
    commentcount = serializers.IntegerField(label='评论量', required=False)
    image = serializers.ImageField(label='图片', required=False)

通过构造序列化器对象，并将要反序列化的数据传递给data构造参数，进而进行验证

错误
>>> from book.serializers import BookInfoSerializer
>>> data = {'pub_date':123}
>>> serializer = BookInfoSerializer(data=data)
>>> serializer.is_valid()
False

# 验证失败，可以通过序列化器对象的errors属性获取错误信息，返回字典，包含了字段和字段的错误
>>> serializer.errors
{'pub_date': [ErrorDetail(string='Date has wrong format. Use one of these formats instead: YYYY[-MM[-DD]].', code='invalid')], 'name': [ErrorDetail(string='This field is required.', code='required')]}
# 因为出现了错误,所以获取不到任何数据
>>> serializer.validated_data
{}


正确
>>> from book.serializers import BookInfoSerializer
>>> data = {'pub_date':'2010-1-1','name':'python高级'}
# 传入json数据进行验证
>>> serializer = BookInfoSerializer(data=data)

# 在获取反序列化的数据前，必须调用is_valid()方法进行验证，验证成功返回True，否则返回False。
# is_valid()方法还可以在验证失败时抛出异常serializers.ValidationError，可以通过传递raise_exception=True参数开启，REST framework接收到此异常，会向前端返回HTTP 400 Bad Request响应。
>>> serializer.is_valid()
True
>>> serializer.errors
{}

# 可以通过序列化器对象的validated_data属性获取数据(字典格式)
>>> serializer.validated_data
OrderedDict([('name', 'python高级'), ('pub_date', datetime.date(2010, 1, 1))])

3.2 保存数据入库(必须验证数据)

如果创建序列化器对象的时候，没有传递instance实例，则调用save()方法的时候，create()被调用，相反，如果传递了instance实例，则调用save()方法的时候，update()被调用。

定义一个 ORM 模型

# 导入系统自带的用户模型类,在此基础上对起进行继承重写
from django.contrib.auth.models import AbstractUser

class User(AbstractUser):
    """我们自己的用户的模型类"""

    # 给用户增加手机号字段
    mobile = models.CharField(max_length=11, verbose_name='手机号', unique=True)
    # 给用户增加邮箱验证状态属性
    email_active = models.BooleanField(default=False, verbose_name='邮箱验证状态')
    # 用户默认的地址
    default_address = models.ForeignKey('Address', related_name='users', null=True, blank=True,on_delete=models.SET_NULL, verbose_name='默认地址')

    class Meta:
        # 数据库中显示的表的名称
        db_table = 'tb_users'
        # 在admin站点中显示的名称
        verbose_name = '用户'
        verbose_name_plural = verbose_name

定义一个序列化器,使用里面的校验和入库功能

# 因为需要进行校验入库的是数据是有模型的,所以需要继承自 ModelSerializer
class RegisterCreateSerializer(serializers.ModelSerializer):

    # 用户再一次进行提交的时候有三个数据: 校验的密码,短信验证码,用户是否同意协议
    # write_only 表明该字段仅用于反序列化输入,也就是说不需要入库,默认False
    password2 = serializers.CharField(label='校验密码', allow_null=False, allow_blank=False, write_only=True)
    sms_code = serializers.CharField(label='短信验证码', max_length=6,min_length=6, allow_null=False, allow_blank=False, write_only=True)
    allow = serializers.CharField(label='是否同意协议', allow_null=False, allow_blank=False, write_only=True)
    # 增加对token的字段,因为token是jwt自动生成的,我们只需要把他序列化成模型状态就好了,不需要反序列化进行校验
    token = serializers.CharField(label='登录状态的token', read_only=True)  # token不能被修改,也不需要反序列化校验,只需要入库就可以了

    class Meta:
        # model 指明参照哪个模型类
        model = User

        # 使用fields来明确字段，__all__表名包含所有字段
        fields = ('id', 'username', 'password', 'mobile', 'password2', 'sms_code', 'allow', 'token')

        # 使用extra_kwargs参数为ModelSerializer添加或修改原有的选项参数
        extra_kwargs = {
            'id': {'read_only': True},
            'username': {
                'min_length': 5,
                'max_length': 20,
                'error_messages': {
                    'min_length': '仅允许5-20个字符的用户名',
                    'max_length': '仅允许5-20个字符的用户名',
                }
            },
            'password': {
                'write_only': True,
                'min_length': 8,
                'max_length': 20,
                'error_messages': {
                    'min_length': '仅允许8-20个字符的密码',
                    'max_length': '仅允许8-20个字符的密码',
                }
            }
        }

    # 开始进行校验

    # 先进行单字段校验(手机号,是否同意协议)
    # 进行手机号校验
    def validate_mobile(self,value):
        if not re.match(r'1[345789]\d{9}', value):
            raise serializers.ValidationError('手机号格式不正确')

        return value

    # 检查用户是否同意协议
    def validate_allow(self, value):

        # 在前端部分,我们已经把同意的格式从二进制转换为字符串
        if value != 'true':
            raise serializers.ValidationError('您尚未同意本协议')

        return value

    # 多个字段校验(手机验证码的校验,两次密码输入的是否一致)
    def validate(self, attrs):

        # 现获取出来两次输入的密码进行比较
        password = attrs.get('password')
        password2 = attrs.get('password2')

        if password != password2:
            raise serializers.ValidationError('两次密码输入不一致')

        # 获取用户的手机号和用户输入短信验证码,通过手机号取出redis中验证码,然后二者进行比较
        mobile = attrs.get('mobile')
        sms_code = attrs.get('sms_code')

        redis_conn = get_redis_connection('code')
        redis_sms_code = redis_conn.get('sms_%s' % mobile)

        # 从redis中获取出来的手机验证码有过期的可能性,需要校验是否为空
        if redis_sms_code is None:
            raise serializers.ValidationError('验证码已经过期')

        # 从redis中获取到的短信验证码和用户输入的短信验码进行比较
        if sms_code != redis_sms_code.decode():
            raise serializers.ValidationError('验证码输入有误')

        # 把校验之后的结返回回去
        return attrs

 ###################################################################################
 ## 若数据校验没有问题的话,则create 中的 validated_data 和 单字段校验中的attrs 是一个数据  ##  
 ###################################################################################
    
    # 重写入库的方法
    def create(self, validated_data):
        # 删除多余字段 ---> 因为在创建用户模型类的时候下面的三个字段并没有创建,
        # 因为这个三个字段只是为了校验用户注册并不包含用户的具体信息
        # 但是却需要对这三个字段进行校验
        # 用户的模型类里面不包含这三个字段,这三个字段却要辅助用户模型类校验,因此在序列化器的最上面
        # 添加字段,但是在入库的时候却删除这三个字段

        del validated_data['password2']
        del validated_data['sms_code']
        del validated_data['allow']

        # 调用这个方法会返回一个用户模型对象
        user = super().create(validated_data)

        # 对密码进行加密
        user.set_password(validated_data['password'])
        # 保存入库
        user.save()

        # 我们在创建了用户之后,需要通过后端jwt产生token,传递给前端
        # 这样用户登录的时候就可以携带token了
        from rest_framework.settings import api_settings

        # 获取两方法
        # JWT_PAYLOAD_HANDLER可以从api_settings的源代码里面获取
        jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
        jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER

        # 调用这两个方法,把用户的信息传递给方法之中,然后通过加密产生了token
        payload = jwt_payload_handler(user)
        token = jwt_encode_handler(payload)

        # 把token消息传递给token,我们在进行序列化的时候把token传递给浏览器
        user.token = token

        return user

定义一个序列化器

# 因为就验证一个字段,也没有模型,所以继承serializers.Serializer
# 这个序列化器主要对用户浏览商品时的商品编号 sku_id 进行验证并校验存入redis
class UserHistorySerializer(serializers.Serializer):
    sku_id = serializers.CharField(label='商品id', required=True)
	
    # 对单字段进行验证
    def validate_sku_id(self, value):
        try:
            SKU.objects.get(pk=value)
        except SKU.DoesNotExist:
            raise serializers.ValidationError('商品不存在')

        return value

    # 去重写create()方法,把数据保存在redis中,不去重写的话,就要保存mysql中了,但是我们没有定义mysql的模型
    def create(self, validated_data):
        # 通过context把放入的user给取出来
        user = self.context.get('request').user
        sku_id = validated_data.get('sku_id')

        # 连接redis
        redis_conn = get_redis_connection('history')
        # LREM key count value---> count = 0 : 移除表中所有与 value 相等的值
        # 也就是说移除所有与sku_id相同的值
        redis_conn.lrem('history_%s' % user.id, 0, sku_id)

        # 先移除旧的数据,然后添加新的数据
        redis_conn.lpush('history_%s' % user.id, sku_id)

        # 只保留5条记录(redis不能保留太多的记录)
        # LTRIM key start stop 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
        redis_conn.ltrim('history_%s' % user.id, 0, 4)

        return validated_data

定义一个把展示商品的ORM模型转换为JSON的序列化器

# 因此涉及到展示商品,而展示商品是有模型的,所以继承ModelSerializer
class SKUSerializer(serializers.ModelSerializer):

    class Meta:
        model = SKU
        fields = ('id', 'name', 'price', 'default_image_url', 'comments')

定义一个视图来使用序列化器

# 导入序列化器
from .serializer import UserHistorySerializer
from goods.models import SKU

# 记录用户浏览历史的类
class UserHistoryView(GenericAPIView):

    # 登录用户才能访问
    permission_classes = [IsAuthenticated]
    # 添加序列化器,对信息尽心校验
    serializer_class = UserHistorySerializer

    def post(self, request):

        # 在构造序列化器对象时,可以通过context参数添加额外的数据给序列化器
        # request里面有user,把request传递给序列化器,可以在序列化器中通过request
        # 取出user,然后作为redis的唯一辨识度的键来使用
        serializer = self.get_serializer(data=request.data, context={'request': request})
        serializer.is_valid(raise_exception=True)
        # 向序列化器中传入的data而没有传入instance,说明serializer.save()的时候,只会调用create()方法,而不会调用update()方法
        serializer.save()

        return Response({'message': 'OK'})

    # 查看用户浏览历史的方法
    def get(self, request):
        # 获取出当前查看浏览历史的对象
        user = request.user

        # 连接redis
        redis_conn = get_redis_connection('history')
        # 通过用的id把浏览记录给获取出来(获取出来的是列表数据)
        ids = redis_conn.lrange('history_%s' % user.id, 0, 5)

        skus = []  # skus列表中存储着多个模型类对象
        for id in ids:
            sku = SKU.objects.get(pk=id)
            skus.append(sku)

       	# 用到了序列化器的序列化功能,把模型转换成json
        serializer = SKUSerializer(skus, many=True)

        # 把模型转换成的json返回给前端
        return Response(serializer.data)

二. 模型类序列化器ModelSerializer

如果我们想要使用序列化器对应的是Django的模型类，DRF为我们提供了ModelSerializer模型类序列化器来帮助我们快速创建一个Serializer类。

ModelSerializer与常规的Serializer相同，但提供了：

基于模型类自动生成一系列字段
基于模型类自动为Serializer生成validators，比如unique_together
包含默认的create()和update()的实现

1. 定义

比如我们创建一个BookInfoSerializer

class BookInfoSerializer(serializers.ModelSerializer):

    class Meta:
        model = BookInfo
        fields = '__all__'

model 指明参照哪个模型类
fields 指明为模型类的哪些字段生成

我们可以在python manage.py shell中查看自动生成的BookInfoSerializer的具体实现

>>> from book.serializers import BookInfoSerializer
>>> serializer = BookInfoSerializer()
>>> serializer
BookInfoSerializer():
    id = IntegerField(label='ID', read_only=True)
    name = CharField(label='名称', max_length=20)
    pub_date = DateField(label='发布日期', required=True)
    readcount = IntegerField(label='阅读量', required=True)
    commentcount = IntegerField(label='评论量', required=True)
    image = ImageField(label='图片', required=False)
    peopleinfo_set = PrimaryKeyRelatedField(many=True, read_only=True)

2. 指定字段

使用fields来明确字段，__all__表名包含所有字段，也可以写明具体哪些字段，如

class BookInfoSerializer(serializers.ModelSerializer):

    class Meta:
        model = BookInfo
        fields = '__all__'

使用exclude可以明确排除掉哪些字段

class BookInfoSerializer(serializers.ModelSerializer):

    class Meta:
        model = BookInfo
        exclude = ('image',)

默认ModelSerializer使用主键作为关联字段，但是我们可以使用depth来简单的生成嵌套表示，depth应该是整数，表明嵌套的层级数量。如：

class PeopleInfoSerializer(serializers.ModelSerializer):

    class Meta:
        model = PeopleInfo
        fields = '__all__'
        depth = 1

形成的序列化器如下：

>>> from book.serializers import PeopleInfoSerializer
>>> serializer = PeopleInfoSerializer()
>>> serializer
PeopleInfoSerializer():
    id = IntegerField(label='ID', read_only=True)
    name = CharField(label='名称', max_length=20)
    gender = ChoiceField(choices=((0, 'male'), (1, 'female')), label='性别', required=False, validators=[<django.core.vidators.MinValueValidator object>, <django.core.validators.MaxValueValidator object>])
    description = CharField(allow_null=True, label='描述信息', max_length=200, required=False)
    is_delete = BooleanField(label='逻辑删除', required=False)
    book = NestedSerializer(read_only=True):
        id = IntegerField(label='ID', read_only=True)
        name = CharField(label='名称', max_length=20)
        pub_date = DateField(label='发布日期')
        readcount = IntegerField(label='阅读量', max_value=2147483647, min_value=-2147483648, required=False)
        commentcount = IntegerField(label='评论量', max_value=2147483647, min_value=-2147483648, required=False)
        is_delete = BooleanField(label='逻辑删除', required=False)
        image = ImageField(allow_null=True, label='图片', max_length=100, required=False)

显示指明字段，如：

class BookInfoSerializer(serializers.ModelSerializer):

    class Meta:
        model = BookInfo
        fields = ('id','name', 'readcount', 'commentcount')

指明只读字段

可以通过read_only_fields指明只读字段，即仅用于序列化输出的字段

class BookInfoSerializer(serializers.ModelSerializer):

    class Meta:
        model = BookInfo
        fields = ('id','name', 'readcount', 'commentcount')
        read_only_fields = ('id', 'readcount', 'commentcount')

3. 添加额外参数

我们可以使用extra_kwargs参数为ModelSerializer添加或修改原有的选项参数

class BookInfoSerializer(serializers.ModelSerializer):

    class Meta:
        model = BookInfo
        fields = ('id','name', 'readcount', 'commentcount')
        read_only_fields = ('id', 'readcount', 'commentcount')
        extra_kwargs = {
            'readcount': {'min_value': 0, 'required': True},
            'commentcount': {'max_value': 0, 'required': True},
        }

>>> from book.serializers import BookInfoSerializer
>>> serializer = BookInfoSerializer()
>>> serializer
BookInfoSerializer():
    id = IntegerField(label='ID', read_only=True)
    name = CharField(label='名称', max_length=20)
    readcount = IntegerField(label='阅读量', min_value=0, read_only=True)
    commentcount = IntegerField(label='评论量', max_value=0, read_only=True)

fengyehongWorld

关注

14
点赞
踩
22

收藏

觉得还不错? 一键收藏
1
评论
Django中的序列化器

一. 序列化器序列化器的主要工作就是将前端传入后端的JSON数据转换为ORM模型映射一个序列化器可以同时包含序列化和反序列化两个功能,想要用哪一个功能具体看你怎么调用1.序列化器的两个功能序列化: 将模型转换成json数据返回给前端,可以序列化一个模型类,也可以序列化多个模型类(many=True)反序列化: 将json数据转换成模型,反序列化还可以用来进一步验证信息和保存数据但...
复制链接

扫一扫

专栏目录