序列化器 Serializer

内容概要

  • 序列化器介绍
  • Serializer的使用
    • 基本使用(序列化)
    • 字段类型
    • 字段参数
  • 序列化
    • 定制序列化的字段
  • 反序列化
    • 反序列化之新增
    • 反序列化之修改
    • 反序列化之局部和全局钩子
  • ModelSerializer 模型类序列化器
  • ModelSerializer 额外添加参数

内容详细

序列化器介绍

QuerySet 对象 :queryset_obj = models.Book.objects.all()

为枞阳等地区用户提供了全套网页设计制作服务,及枞阳网站建设行业解决方案。主营业务为成都网站设计、成都网站制作、枞阳网站设计,以传统方式定制建设网站,并提供域名空间备案等一条龙服务,秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求,就会得到认可,从而选择与我们长期合作。这样,我们也可以走得更远!

单个对象:book = models.Book.objects.all().first()

  • 1、序列化:序列化器会将模型对象(QuerySet 对象、单个 book 对象)转成字典,在经过 response 的时候序列化成 json 格式返回给前端。
  • 2、反序列化:前端发送到后端的数据,经过request之变成程字典(request.data),序列化器再把字典转成模型,存到数据库中。
  • 3、反序列化中,序列化器有进行数据校验的功能,(前端传入的数据是否合法,长度够不够)

Serializer的使用

1、基本使用(序列化)

首先得在序列化器模块中书写序列化类。

然后在视图函数模块中书写 CBVget方法(获取数据)

序列化类的书写步骤和使用流程:

第一步:写一个类:必须继承drf中的Serializer及其子类
第二步:在类中写要序列化的字段-->要序列化哪些,就写哪些,不序列化的不写
第三步:使用序列化类,视图类中用
第四步:视图函数中得到序列化类对象 对象.data,通过Response返回给前端

模型类(models.py):

class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.DecimalField(decimal_places=2, max_digits=5)
    author = models.CharField(max_length=32)

序列化类(ser.py):

from rest_framework import serializers
from .models import Book

class BookSerializer(serializers.Serializer):
    # max_length=32,min_length=3  反序列化保存校验数据的时候用
    name = serializers.CharField(max_length=8, min_length=3)
    price=serializers.CharField() # models中使用了DecimalField,这个位置使用了CharField会把小数类型转成字符串
    author = serializers.CharField()

视图层类(views.py)

class BookView(APIView):
    def get(self,request):
        # 查出来的数据做序列化
        book_list=Book.objects.all()
        # instance:要序列化的对象  qs,单个对象
        # many:如果是qs对象,many=True,如果是单个对象many=False
        ser=BookSerializer(instance=book_list,many=True)  # 传入初始化的参数instance=None, data=empty
        # ser.data使用模型类对象序列化后的字典
        return Response(ser.data) # 字典,列表,字符串都行

路由:

from app01 import views
urlpatterns = [
    path('admin/', admin.site.urls),
    path('books/', views.BookView.as_view()),
]

2、字段类型

需要记忆:

CharField
IntegerField
FloatField
DecimalField
DateTimeField
DateField

了解:

反序列化时,前端发送进来的json数据中,也有值是列表或者字典的时候,那么这种数据我们需要用什么字段来反序列化?

{name:lqz,age:19,hobby:[篮球,足球],wife:{name:lyf,age:38}}
  • ListField 反序列化列表值
  • DictField 反序列化字典值
字段 字段构造方式
BooleanField BooleanField()
NullBooleanField NullBooleanField()
CharField CharField(max_length=None, min_length=None, allow_blank=False, trim_whitespace=True)
EmailField EmailField(max_length=None, min_length=None, allow_blank=False)
RegexField RegexField(regex, max_length=None, min_length=None, allow_blank=False)
SlugField SlugField(maxlength=50, min_length=None, allow_blank=False) 正则字段,验证正则模式 [a-zA-Z0-9-]+
URLField URLField(max_length=200, min_length=None, allow_blank=False)
UUIDField UUIDField(format=’hex_verbose’) format: 1) 'hex_verbose'"5ce0e9a5-5ffa-654b-cee0-fb31a" 2) 'hex'"5ce0e9a55ffa654bcee0fb31a" 3)'int' - 如: "" 4)'urn' 如: "urn:uuid:5ce0e9a5-5ffa-654b-cee0-fb31a"
IPAddressField IPAddressField(protocol=’both’, unpack_ipv4=False, **options)
IntegerField IntegerField(max_value=None, min_value=None)
FloatField FloatField(max_value=None, min_value=None)
DecimalField DecimalField(max_digits, decimal_places, coerce_to_string=None, max_value=None, min_value=None) max_digits: 最多位数 decimal_palces: 小数点位置
DateTimeField DateTimeField(format=api_settings.DATETIME_FORMAT, input_formats=None)
DateField DateField(format=api_settings.DATE_FORMAT, input_formats=None)
TimeField TimeField(format=api_settings.TIME_FORMAT, input_formats=None)
DurationField DurationField()
ChoiceField ChoiceField(choices) choices与Django的用法相同
MultipleChoiceField MultipleChoiceField(choices)
FileField FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
ImageField ImageField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
ListField ListField(child=, min_length=None, max_length=None)
DictField DictField(child=)

3、字段参数

序列化器中字段参数是用来在反序列化时做校验数据的功能作用

max_length 是限制数据的字符长度

重点记忆:

  • read_only :该字段只能序列化,后端发送给前端看
  • write_only:该字段只能反序列化,由前端发送到后端保存

例子:

# 什么都不写,表示 name 字段既序列化,又反序列化
name=serializers.CharField(max_length=32,min_length=3)

# 只反序列化,author 字段只能由前端把作者信息发到后端保存
author=serializers.CharField(write_only=True)

# 这是错误写法,write_only=True,read_only=True 逻辑矛盾
price=serializers.CharField(write_only=True,read_only=True)

选项参数:

参数名称 作用
max_length 最大长度(CharField)
min_lenght 最小长度(CharField)
allow_blank 是否允许为空(CharField)
trim_whitespace 是否截断空白字符(CharField)
max_value 最小值 (IntegerField)
min_value 最大值(IntegerField)

通用参数

参数名称 说明
read_only 表明该字段仅用于序列化输出,默认False
write_only 表明该字段仅用于反序列化输入,默认False
required 表明该字段在反序列化时必须输入,默认True
default 反序列化时使用的默认值
allow_null 表明该字段是否允许传入None,默认False
validators 该字段使用的验证器(不太用)
error_messages 包含错误编号与错误信息的字典
label 用于HTML展示API页面时,显示的字段名称
help_text 用于HTML展示API页面时,显示的字段帮助提示信息

序列化

1、定制序列化的字段

方式一:在序列化类中写

使用 serializersSerializerMethodField()来定制,但必须配合一个方法,方法名get_字段名,方法返回什么,字段就是什么,obj是当前序列化到的模型类中的单个对象(queryset 或 单个 book

from rest_framework import serializers
from .models import Book

class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8, min_length=3)
    price=serializers.CharField()
    author = serializers.CharField()
    # 在序列化后返回给前端时,前端就可以多看到一个 price_info 值
    price_info = serializers.SerializerMethodField()
    def get_price_info(self, obj):  # obj是当前序列化到的单个对象
        return "价格是:"+str(obj.price)

方式二:在模型类中写

表模型中写方法,并且把方法包装成数据属性,在序列化类中使用的时候把该方法当作普通字段

class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.DecimalField(decimal_places=2, max_digits=5)
    author = models.CharField(max_length=32)
    @property   # 把方法包装成数据属性
    def price_info(self):
       return "价格是:" + str(self.price)

在序列化类中使用:

只能给前端看,前端不能传送该字段的值(只序列化)

price_info=serializers.CharField(read_only=True)  # 只用来做序列化

反序列化

1、反序列化之新增

反序列化同时可以进行数据校验

具体步骤如下:

第一步:把前端传入的数据,放到Serializer对象中:ser=BookSerializer(data=request.data)
第二步:校验数据:ser.is_valid():
第三步:保存,ser.save()---》必须重写create,在序列化类中

# 校验通过的数据都存放在 validated_data 中
    def create(self, validated_data):
        book=Book.objects.create(**validated_data)
        return book

如果instance为None,调用save本质会调用create,父类create是直接抛异常的,所以我们要重写

视图层类:

class BookView(APIView):
    def post(self,request):
        # 反序列化,保存---》使用data参数
        ser=BookSerializer(data=request.data) #
        # 校验数据
        if ser.is_valid():  # 如果是true表示数据校验通过,通过,就保存
            ser.save()  # 就会保存,重写create方法,如果不重写,我们不知道存到哪个表中
            return Response(ser.data)
        return Response({'code':101,'msg':'数据校验失败','err':ser.errors})

序列化类:

注意:重写 create 方法后 不要忘记返回book对象

from rest_framework import serializers
from .models import Book

# drf提供的类:Serializer
class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8, min_length=3)
    price=serializers.CharField()
    author = serializers.CharField()
    price_info=serializers.CharField(read_only=True)  # 只用来做序列化


    def create(self, validated_data):
        # validated_data校验过后的数据
        # 手动存到book表中
        book=Book.objects.create(**validated_data)
        # book=Book.objects.create(name=validated_data.get('name'))
        return book  # 不要忘记返回book对象

2、反序列化之修改

视图层类:

写 put 方法,与 get 方法很像,但 put 方法序列化器中要有 instance 参数

class BookDetailView(APIView):

    def put(self, request, pk):
        # 修改:用什么数据,修改哪个对象?
        book = Book.objects.filter(pk=pk).first()
        # 既有instance,又有data,表示修改
        ser = BookSerializer(instance=book, data=request.data)
        if ser.is_valid():
            # 重写update方法
            ser.save()  # 调用save---》内部根据instance判断是触发create还是update
            return Response(ser.data)
        return Response({'code': 102, 'msg': '修改出错', 'err': ser.errors})

序列化类:

修改,需要重写 序列化类 中的update 方法,否则和新增一样也会报错

from rest_framework import serializers
from .models import Book

class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8, min_length=3)
    price=serializers.CharField()
    author = serializers.CharField()
    
    def update(self, instance, validated_data):
        # validated_data校验过后的数据,instance 是要修改的对象
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.author = validated_data.get('author')
        instance.save()  # 模型对象自带的save,保存到数据库中
        return instance  # 要忘记返回instance对象

3、反序列化之局部和全局钩子

forms 组件类中的校验局部钩子全局钩子书写方法几乎一样。

需要在序列化类中书写局部和全局钩子

from rest_framework import serializers
from .models import Book

class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8, min_length=3)
    price=serializers.CharField()
    author = serializers.CharField()
    
        # 局部钩子
    # 字段有自己的校验:max_length .... ,再校验,就可以写局部钩子
    def validate_name(self, attr):
        # attr就是前端传入的数据
        # 名字不能以sb开头
        if attr.startswith('sb'):
            raise ValidationError("名字不能以sb开头")
        else:
            return attr  # 没有问题,正常返回

    # 先走字段自己规则,再走局部钩子,再走全局钩子
    # 全局钩子
    def validate(self, attrs):
        # attrs校验过后的数据
        if attrs.get('name') == attrs.get('author'):
            raise ValidationError('作者名不能等于书名')
        else:
            return attrs

ModelSerializer 模型类序列化器

以后我们在实际开发中会使用ModelSerializer跟表模型做绑定比较多,不需要重写updatecreate方法了

序列化类:

class BookSerializer2(serializers.ModelSerializer):
    class Meta:
        model = Book  # 跟哪个表有关系
        fields='__all__' # 所有字段
        # id是从表模型中映射过来的,auto,它会不要求你传
        # price_info:它不是数据库中字段
        # 即便扩写的字段,也要在fields中注册
        # fields = ['id', 'name', 'price', 'author', 'price_info']
  
  # 重写字段
  # 局部和全局钩子跟之前一样

ModelSerializer 额外添加参数

class BookSerializer2(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['id', 'name', 'price', 'author', 'price_info']
        
        # 原来的字段参数,通过extra_kwargs传进去
        extra_kwargs = {
            'name': {'write_only': True, 'max_length': 8, 'min_length': 3}
        }

序列化多表操作

  • 实现跨表查询,添加定制序列化字段
  • 在 models 模型表类中添加定制序列化字段

模型类:

图书表:跨表查询出版社表和作者表

定制序列化字段:

  • 书本的出版社名称和出版地址(多条信息)
  • 书本的作者详情(多条信息)

注意:在 sqlite 这中数据库中如果存时间字段,查询时会报错

class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    authors = models.ManyToManyField(to='Author')

    def __str__(self):
        return self.name

    @property
    def publish_detail(self):  # 定制序列化字段,想查询什么就返回什么结果
        return {'name': self.publish.name, 'addr': self.publish.city}

    @property
    def author_list(self):
        l = []
        print(self.authors.all())   # 查询改图书对应的作者对象
        for author in self.authors.all():
            print(author.author_detail)
            l.append({'name': author.name,'age':author.age,'addr':author.author_detail.addr})
        return l

作者表、作者详情表、出版社表:

class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    author_detail = models.OneToOneField(to='AuthorDatail', on_delete=models.CASCADE)
    # OneToOneField 就是ForeignKey+unique=True


class AuthorDatail(models.Model):
    telephone = models.BigIntegerField()
    # birthday = models.DateField()
    addr = models.CharField(max_length=64)


class Publish(models.Model):
    name = models.CharField(max_length=32)
    city = models.CharField(max_length=32)
    email = models.EmailField()

序列化类

图书表的序列化类:

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['id', 'name', 'price', 'authors', 'publish', 'publish_detail', 'author_list']
        # depth=1  # 尽量不要用,关联表一层全部取出来
        extra_kwargs = {
            'publish': {'write_only': True},  # 这两个字段数据只能反序列化
            'authors': {'write_only': True},
        }
class AuthorSerialzier(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = '__all__'


class AuthorDetailSerialzier(serializers.ModelSerializer):
    class Meta:
        model = AuthorDatail
        fields = '__all__'


class PublishSerialzier(serializers.ModelSerializer):
    class Meta:
        model = Publish
        fields = '__all__'

视图层类:

不需要传入参数 pk 的操作:获取所有资源(get 请求)、新增一个资源(post)请求

class BookView(APIView):
    def get(self, request):
        book_list = Book.objects.all()
        ser = BookSerializer(instance=book_list, many=True)
        return Response(ser.data)

    def post(self, request):
        ser = BookSerializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({"code": 100, 'msg': '新增成功', 'data': ser.data})
        return Response({"code": 101, 'msg': '新增出错', 'err': ser.errors})

需要传入 pk 参数,并且只操作单个资源对象的操作:获取单个资源(get请求)、修改资源(put请求)、删除资源(delete请求)

class BookDetailView(APIView):
    def get(self, request, pk):
        book = Book.objects.all().filter(pk=pk).first()
        ser = BookSerializer(instance=book)
        return Response(ser.data)

    def put(self, request, pk):
        book = Book.objects.all().filter(pk=pk).first()
        ser = BookSerializer(instance=book, data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({"code": 100, 'msg': '修改成功', 'data': ser.data})
        return Response({"code": 101, 'msg': '修改出错', 'err': ser.errors})

    def delete(self, request, pk):
        Book.objects.filter(pk=pk).delete()
        return Response({"code": 100, 'msg': '删除成功'})

路由层:

urlpatterns = [
    path('admin/', admin.site.urls),
    path('books/', views.BookView.as_view()),
    path('books/', views.BookDetailView.as_view()),
]

新增测试:


网页题目:序列化器 Serializer
文章转载:http://scyanting.com/article/dsoghii.html