基于django的序列化

最新推荐文章于 2023-11-05 12:02:44 发布
最新推荐文章于 2023-11-05 12:02:44 发布
阅读量560 收藏 1
点赞数
文章标签： django
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39062385/article/details/94459920
版权

1.序列化组件

前后端分离不能直接返回对象，json只能序列化列表和字典，所以我们在jango中使用序列化组件。

首先要导入利用我们安装好的djangorestframework（后面简称drf）中的一些模块。

from rest_framework import APIView # 我们重写的cbv继承APIview的一些方法和属性

from rest_framework.serializers import Serializer # 序列化的类，帮助我们使用序列化

from rest_framework.response import Response  # 继承了HttpRespose，1.传字典使其序列化2.将数据返回给前端页面

django自带的序列化组件（不推荐使用）：

from django.core import serializers # django自带的序列化组件
from rest_framework.views import APIView

class Books(APIView):
    
    def get(self, request):
        response = {'code':100, 'msg': '查询成功'}
        books = models.Book.objects.all()
        ret = serializers.serialize('json', books)
        return HttpResponse(ret)

得到的结果：

难以控制json返回的信息。

使用drf的序列化组件：

1.新建一个序列化类继承Serializer

2.在类中要序列化的字段

在新建文件app01serializer中序列化要序列化的字段。 

from app01 import models
from rest_framework import serializers


class BookSerializer(serializers.Serializer):
    book_name = serializers.CharField()
    price = serializers.CharField()

 

在视图中使用序列化的类：

1.实例化序列化的类产生的对象，在产生对象的时候，传入需要序列化的对象。

2.对象.data

3.return Response(对象.data)

 在视图中:

class Books(APIView):

    def get(self, request):
        response = {'code': 100, 'msg': '查询成功'}
        books = models.Book.objects.all()
        # ret = serializers.serialize("json", books)
        # 如果序列化多条,many=True(是queryset对象就要写)
        # 如果序列化一条,many=False,也可以不写
        bookser = BookSerializer(books, many=True)
        return HttpResponse(bookser)

为何many=true为序列化多条源码分析：

如果many=true执行 cls.many_init(*args, **kwargs).

调用Respose：

from rest_framework.response import Response


class Books(APIView):

    def get(self, request):
        response = {'code': 100, 'msg': '查询成功'}
        books = models.Book.objects.all()
        # ret = serializers.serialize("json", books)
        # 如果序列化多条,many=True(是queryset对象就要写)
        # 如果序列化一条,many=False,也可以不写
        bookser = BookSerializer(books, many=True)
        return Response(bookser.data)  # data并不是一个字符串,是一个对象，

结果：返回一个列表。

[
    {
        "book_name": "apple",
        "price": "12.00"
    },
    {
        "book_name": "banana",
        "price": "3.00"
    }
]

将数据放到字典中就可以得到一个简易版本的cbv:

class Books(APIView):

    def get(self, request):
        response = {'code': 100, 'msg': '查询成功'}
        books = models.Book.objects.all()
        # ret = serializers.serialize("json", books)
        # 如果序列化多条,many=True(是queryset对象就要写)
        # 如果序列化一条,many=False,也可以不写
        bookser = BookSerializer(books, many=True)
        print(type(bookser.data))
        response['data'] = bookser.data
        return Response(response)

.data为一个对象类型，将这个对象作为字典的值。

高级用法：

source：可以指定字段（name publish.name），可以指定方法

SerializerMethodField搭配方法使用：（get_字段名字）

publish_detail = serializers.SerializerMethodField(read_only=True)

def get_authors(self, obj):
    ret = AuthorSerializer(instance=obj.authors.all(), many=True)
    return ret.data

read_only:反序列化时，不传

write_only:序列化时，不显示

利用source='name5'，修改序列化模型表中的字段名（保证安全性，是字段名不暴露给外界）。


class BookSerializer(serializers.Serializer):
    #指定source='name' ，表示序列化模型表中的name字段，重名命为name5（name和source='name'指定的name不能重名）
    name5=serializers.CharField(source='name')

source不仅可以指定字段，还可以指定方法：

#如果要取 出版社的city source='publish.city'
publish=serializers.CharField(source='publish.name')

source不但可以指定一个字段，还可以指定一个方法
book_type = serializers.CharField(source='get_xx_display',read_only=True)

# 在模型层新增一个xx的字段
xx=models.IntegerField(choices=((0,'文学类'),(1,'情感类')),default=1,null=True)
# 这个地方隐藏了一个display的方法。

通过1对多获取数据，和通过多对多获取数据。

序列化出版社的详情,指定SerializerMethodField之后，可以对应一个方法，返回什么内容，publish_detail就是什么内容
    publish_detail=serializers.SerializerMethodField(read_only=True)
     #对应的方法固定写法get_字段名
     def get_publish_detail(self,obj):
         print(type(obj))
         return {'name':obj.publish.name,'city':obj.publish.city}

# 通过类的的对象来拿取数据（对于宽展模型表的字段的修改不太友好）
authors = serializers.SerializerMethodField()
    def get_authors(self, obj):
        return [{'name': author.name, 'age': author.age} for author in obj.authors.all()]

取数据的第二种方式：

# 将外键所关联的表的字段序列化
class AuthorSerializer(serializers.Serializer):
    name = serializers.CharField()
    age = serializers.IntegerField()
    


    # 不必通过多对多关系，直接查询表的数据
    def get_authors(self, obj):     
        authorser = AuthorSerializer(obj.authors.all(), many=True)
        return authorser.data

 

 wiite_only=True:序列化的字段不显示（页面不显示该字段）

read_only=True 反序列化的时候，该字段不传

2.序列化的两种方式

Serializers：没有指定表模型

source：指定要序列化哪个字段，可以是字段，可以是方法

SerializerMethodField的用法

# 序列化出版社的详情,指定SerializerMethodField之后，可以对应一个方法，返回什么内容，publish_detail就是什么内容
    publish_detail=serializers.SerializerMethodField(read_only=True)
     # 对应的方法固定写法get_字段名
     def get_publish_detail(self,obj):
         return {'name':obj.publish.name,'city':obj.publish.city}

#返回所有作者信息
    authors=serializers.SerializerMethodField(read_only=True)
     def get_authors(self,obj):
         # return [ {'name':author.name,'age':author.age} for author in obj.authors.all()]
         authorser=AuthorSerializer(obj.authors.all(),many=True)
         return authorser.data

 

ModelSerializers：指定了表模型

class Meta:
                model=表模型
                #要显示的字段
                fields='__all__'
                fields=('id','name')或fields=['id', 'name']
                #要排除的字段
                exclude=('name')
                #深度控制
                depth=1

重写某个字段：

在Meta外部，重写某些字段，方式同Serializers

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model=models.Book
        # fields=('nid','name')
        #不能跟fields同时使用
        # exclude=['name',]
        fields='__all__'
        #深度是1，官方建议不要超过10，个人建议不要超过3
        # depth=1
    # xx=serializers.CharField(source='get_xx_display')
    # authors=serializers.SerializerMethodField()
    # def get_authors(self,obj):
    #     ret=AuthorSerializer(instance=obj.authors.all(),many=True)
    #     return ret.data
    # name=serializers.CharField()

fields 表示显示那几个字段；exclude标识除了指定字段，其他都显示；depth表示跨表查显示，depth=1表示查一张相关联的表的信息（所有信息都会被显示出来），比较难以控制，而且depth查多张表，影响性能。

3.反序列化

Serializers：没有指定表模型

使用继承了Serializers序列化类的对象，反序列化
            -在自己写的序列化类中重写create方法
            -重写create方法，实现序列化
                -在序列化类中：
                    def create(self, validated_data):
                        ret=models.Book.objects.create(**validated_data)
                        return ret
                -在视图中：
                    def post(self,request):
                        bookser=BookSerializer(data=request.data)
                        if bookser.is_valid():
                            ret=bookser.create(bookser.validated_data)
                        return Response()

ps：继承了Serializers,就要重写create和update方法（方法名不能为save，必须为create或update）因为save会重写继承的save方法：

判断用create方法或update方法：

不能走save方法的原因：

序列化逻辑：

class BookSerializer(serializers.Serializer):
    # source=book_name 修改模型表中的book_name字段名，修改的字段名和指定的字段名不能重复
    name = serializers.CharField(source='book_name')
    price = serializers.DecimalField(max_digits=8, decimal_places=2)
    # book_type = serializers.CharField(source='get_classification_display', write_only=True) # 影响is_valid校验不过去，因为与模型表类型不同，且对应的值不一样
    publish_detail = serializers.SerializerMethodField(read_only=True)
    def get_publish_detail(self, obj):
        return {'name':obj.publish.name, 'city':obj.publish.city}
    # authors = serializers.SerializerMethodField(read_only=True)
    def get_authors(self, obj):
        # return [{'name': author.name, 'age': author.age} for author in obj.authors.all()]
        authorser = AuthorSerializer(obj.authors.all(), many=True)
        return authorser.data

    def create(self, validated_data): # 函数名必须为create
        ret=models.Book.objects.create(**validated_data)
        return ret

视图层逻辑：

class Books(APIView):

    def get(self, request):
        response = {'code': 100, 'msg': '查询成功'}
        books = models.Book.objects.all()
        # ret = serializers.serialize("json", books)
        # 如果序列化多条,many=True(是queryset对象就要写)
        # 如果序列化一条,many=False,也可以不写
        bookser = BookSerializer(books, many=True)
        print(type(bookser.data))
        response['data'] = bookser.data
        return Response(response)

    # 反序列化
    def post(self, request):
        # 实例化产生一个序列化的对象，data是要反序列化的字典
        print(request.data)
        bookser = BookSerializer(data=request.data)
        # print(bookser.is_valid())
        if bookser.is_valid(raise_exception=True):
            bookser.save()
            # 这里的save方法，本质上就是create方法，所以要在序列化的时候重写save方法
        return Response()

ModelSerializers：指定了表模型

使用继承了ModelSerializers序列化类的对象，反序列化
            -在视图中：
                def post(self,request):
                    bookser=BookSerializer(data=request.data)
                    if bookser.is_valid():
                        ret=bookser.save()
                    return Response()

ModelSerializers在自己类中写了ceate和update方法，所以我们用的时候不必重写这两个方法。

Ps: 在从postman传传数据的时候，不能根据本表的外键关系，来添加数据，分析发现 is_valid(), 将这个表外键关系对应的表的信息自动过滤，解决这个问题，要我们自己在后端手动将这个id，添加到validdated_data.

 

4.反序列化的校验

-validate_字段名(self,value):
            -如果校验失败，抛出ValidationError（抛出的异常信息需要去bookser.errors中取）
            -如果校验通过直接return value


-validate(self,attrs)
            -attrs所有校验通过的数据，是个字典
            -如果校验失败，抛出ValidationError
            -如果校验通过直接return attrs

一般在ModelSerializersz 内指定字段名(不建议使用__all__),使用全局钩子和局部钩子做校验。

#反序列化的校验（局部校验，全局校验）
    def validate_name(self,value):

        print(value)
        raise exceptions.ValidationError('不能以sb开头')
        # if value.startswith('sb'):
        #     raise ValidationError('不能以sb开头')
        # return value

    def validate(self,attrs):
        print(attrs)
        # if attrs.get('price')!=attrs.get('xx'):
        #     raise exceptions.ValidationError('name和price相等，不正常')
        return attrs

因为我们用drf，遵循rest_ful规范，所以后端做校验的时候，在后端抛出异常信息。

 

#使用继承了ModelSerializers序列化类的对象，反序列化
    def post(self,request):
        #实例化产生一个序列化类的对象，data是要反序列化的字典
        bookser=BookSerializer(data=request.data)
        # bookser.data
        if bookser.is_valid(raise_exception=True):  # 给前端抛出异常
            #清洗通过的数据
            bookser.save()
        else:  # 后端抛出异常
            print(bookser.errors['name'][0])
        return Response()

钩子函数通过is_valid()这个入口函数进行如下源码校验：

 

校验字段：

5.源码阅读

 

 

 

 

 

 

草丛是我家QAQ
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Django rest_framework序列化many=True参数解释
qq_41502780的博客
05-19 2599
many=True 时传入的参数需要包含多个对象,默认many=False,用first()取出一个对象是使用many=True会报错，需要用all()。many=False可以与fist()搭配使用 serializers.py """ @File : serializers.py @Modify Time @Author ------------ ------- 2020/5/19 10:43 上午 三也先生 """ from rest_fra
Django REST framework - 序列化组件、source、钩子函数
qq_43520820的博客
08-26 1161
[Django REST framework - 序列化组件、source、钩子函数] 序列化器-Serializer 什么是rest_framework序列化？ 在写前后端不分离的项目时： 我们有form组件帮我们去做数据校验 我们有模板语法，从数据库取出的queryset对象不需要人为去转格式 当我们写前后端分离项目的时： 我们需要自己去做数据校验 我们需要手动去转数据格式，因为跨平台数据传输都用json字符串，不能直接jsonqueryset对象 序列化器的作用 1 序列化：把python中的对象转
Django系列之Serializer的source参数使用、自定义序列化方法
最新发布
CSDN1csdn1的博客
11-05 739
用于显示 choices 参数对应的文本信息。的 0 和 1 改成字符串形式再试试。使用默认的序列化器时，视图函数访问。还是没有显示出对应文本信息？当然，也可以在视图函数中，使用。来获取choices文本值。字段时，返回的数据只有。字段对应的文本信息。自定义序列化输出方法。
django 中 serializer 用法
weixin_42534880的博客
07-04 3159
安装rest_framework – pip install djangorestframework – 注册rest_framework 序列化 – Python–json – 第一版 用values以及JsonResponse实现序列化 – 第二版 用Django的serialize实现的序列化 – 缺点 不能序列化外键关系 – 第三版用DRF实现序列化 – 第一步声明序列化器 – 第二步 ...
Django - DRF - serializers 序列化组件
LIN的博客
12-11 1867
目录 一、Django内置的serializers模块 - 将对象序列化 1-1 单表操作（单表的get获取以及数据化） 二、DRF框架 - Serializer 组件 2-1 单表操作 2-1-1 缺少 safe=False 的错误信息 - 防止序列化的字典内套了列表 2-2 多表操作 2-2-1 models结构 2-2-2 View视图函数 2-2-3 serializer...
django序列化serializers过程解析
01-20
这篇文章主要介绍了django序列化serializers过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 DRF的核心 就是 前后端分离的核心 前后端分离开发的核心：...
Django框架序列化与反序列化操作详解
01-20
在Django REST Framework中，序列化（Serialization）和反序列化（Deserialization）是关键功能，它们用于在Python对象和JSON、XML等可传输的数据格式之间进行转换。这对于API开发尤其重要，因为它们允许服务器接收...
django Serializer序列化使用方法详解
09-20
此外，`Serializer`还可以与`ModelSerializer`一起使用，后者会自动生成基于模型的序列化器，简化代码： ```python class BookInfoModelSerializer(serializers.ModelSerializer): class Meta: model = BookInfo ...
通过代码简单了解django model序列化作用
12-16
`ModelSerializer`是基于Django Model自动生成的序列化器，它可以自动映射模型字段到序列化字段，简化了工作流程。而`Serializer`则更加灵活，允许你手动定义序列化的字段和行为。 为了将`AutomationHeadRaw`和`...
Python的Django REST框架中的序列化及请求和返回
09-21
在Django REST框架中，序列化类允许我们将Django模型实例转换为字典或其他可序列化的格式。在`serializers.py`中创建一个`SnippetSerializer`： ```python from rest_framework import serializers from snippets....
django-source:django源码剖析
03-24
序 使用django俩年之余，给大家分享下相关的原始码知识。 故而总结为相关笔记。 如果如下有任何错误，请指正，谢谢〜 基于2.1.x版本。 目录 章节01：django是如何做到自动重启的 章节02：django运行服务器 章节03：django wsgi 章节04：django asgi 章节05：django请求来了 章节06：django应用及模型加载 章节07：django命令解析 章节08：django设置懒加载 章节09：django路由匹配 第10章：django FBV＆CBV 章节11：未完待续... 支持 2020年的刘志超。
Django的序列化
weixin_44805274的博客
10-23 191
*.Serializer与ModelSerializer都可以序列化与反序列化 序列化中的字段要与models表中的字段一致否则会报错 many=True实际上是使用了for循环 一对多序列化的思路 一对多序列化，首先创建外键表的序列化器，再创建本表的序列化器，在本表的序列化器中引用外键表的序列化 Serializer序列化 单表序列化 from rest_framework.respon...
[django] Serializers序列化
Moke
11-14 288
liwenzhou yuan
Django的serializers使用
weixin_34377919的博客
02-27 536
Serializer 在这里通过一个验证用户身份的例子说明rest_framework中serializer.Serializer的使用。 编写serializer Serializer的使用不需要依赖于模型，所以可以不要编写model，直接编写serializer文件。 from rest_framework import serializers class TestSerializer(s...
django source code-http(1)
toyijiu的专栏
02-13 237
The source code path:django/django/http cookie.py from http import cookies # For backwards compatibility in Django 2.1. SimpleCookie = cookies.SimpleCookie # Add support for the SameSite attribute (...
Django 序列化manytomany外键
qq_46170664的博客
08-08 781
Django 序列化manytomany外键 + 建立manytomany外键模型
为django写的一个source的tag
weixin_30600197的博客
04-10 93
#coding=utf-8 from django import template register = template.Library() #register.tag('source', do_source) @register.tag(name="source") def do_source(parser, token): """ source ...
Python-Django虚拟环境激活报错“‘source‘ 不是内部或外部命令，也不是可运行的程序或批处理文件。”
kuwola的博客
01-08 2437
Django虚拟环境激活失败
django自带serializers序列化返回指定字段
qq_42473568的博客
11-16 5756
django orm 有个defer方法，指定模型排除的字段。 如下返回的Queryset, 排除‘username’, 'id'。 users=models.UserInfo.objects.defer('username','id') 或users=models.UserInfo.objects.filter(...).defer('username','id') 再如下，使用djan...
django 序列化 案例
04-05
我们可以使用Django内置的序列化工具将其序列化为JSON格式的数据。首先，我们需要在视图中导入`JsonResponse`和`serializers`： ```python from django.http import JsonResponse from django.core import ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值