序列化组件的使用

一、序列化组件的简单使用

1、作用

把python中的对象转成json格式的字符串，一定要注意，如果前后端分离

json不能序列化对象，只能序列化列表和字典，所以这时候就用到了序列化组件

2、使用

①先在settings里注册rest_frameword

②新建一个py文件，序列化类继承Serializer，在类中写要序列化的字段

③在视图函数中使用序列化的类

from app01 import models
from rest_framework.views import APIView
from rest_framework.response import Response
from app01.myser import BookSerializer

# 把对象转成json格式字符串
class Books(APIView):
    def get(self, request):
        response = {'code': 100, 'msg': '查询成功'}
        books = models.Book.objects.all()
        # 如果序列化多条，many=True（也就是queryset对象，就需要写）
        # 如果序列化一条（可以不写）,instance是要序列化的对象
        bookser = BookSerializer(instance=books, many=True)   # instance指的是序列化的对象
        print(bookser.data)  # [OrderedDict([('name', '三国演义'), ('price', '11.00')]), OrderedDict([('name', '西游记'), ('price', '22.00')])]
        print(type(bookser.data))  # <class 'rest_framework.utils.serializer_helpers.ReturnList'>
        response['data'] = bookser.data
        return Response(response)

前端显示：

二、高级用法

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

①source='name'

②source='publish.name'

要拿choices的中文名，必须要指定source='get_字段名_display'

③source指定方法：可以和SerializerMethodField搭配使用（get_字段名字）

2、write_only：序列化时，不显示（后端序列化到前端不显示）

　read_only:反序列化时，不传（read_only=True  就是前段传给后端可以不传）

3、重写create方法，实现序列化（新增数据）

在序列化类当中，如果不写create方法会调父类的create方法，直接进入父类的create方法，但是会直接抛异常，所以必须重写create方法，会把校验通过的数据传过来，然后再返回

　　在序列化类中：

def create(self, validated_data):
    res = models.Book.objects.create(**validated_data)
    return res

　　在视图函数中：继承了Serializers序列化类的对象，反序列化

def post(self, request):
    # 实例化产生一个序列化类的对象，data是要反序列化的字典
    bookser = BookSerializer(data=request.data)   # 这里的data指的是反序列化的字典
    if bookser.is_valid():
        # 清洗通过的数据,校验通过之后才会调用create方法
        # 注意：重写create方法的时候，一定要先校验通过了之后才能调用create方法
        res = bookser.create(bookser.validated_data)
    return Response()                

　　 Postman新增数据：

三、序列化的两种方式

1、Serializers:没有指定表模型。以上的用法都是这种方式

模型表：

from django.db import models


# Create your models here.


class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8, decimal_places=2)
    publish_data = models.DateField(null=True)
    category = models.IntegerField(choices=((0, '文学类'), (1, '情感类')), default=1, null=True)
    publish = models.ForeignKey(to='Publish', null=True)
    authors = models.ManyToManyField(to='Author')

    def __str__(self):
        return self.name


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

    def __str__(self):
        return self.name


class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()

    def __str__(self):
        return self.name

详情见代码

在序列化类中：

from app01 import models
from rest_framework import serializers
class AuthorSerializer(serializers.Serializer):
    name = serializers.CharField()
    age = serializers.CharField()


class BookSerializer(serializers.Serializer):
    # source可以指定字段（name, publish.name），可以指定方法

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

    # write_only序列化的时候，该字段不显示
    # price = serializers.CharField(write_only=True)

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

    # 要拿choices的中文名，必须要指定source='get_字段名_display'
    book_type = serializers.CharField(source='get_category_display')

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

    # 返回作者所有信息
    authors = serializers.SerializerMethodField()
    def get_authors(self, obj):
        # 这里可以用列表推导式，我们还可以在视图函数中使用序列化的类，
        # 序列化类继承Serializer，在类中写要序列化的字段
        authorser = AuthorSerializer(obj.authors.all(), many=True)
        return authorser.data

    def create(self, validated_data):
        res = models.Book.objects.create(**validated_data)
        return res

详情见代码

在视图函数中：

from django.shortcuts import render, HttpResponse

# Create your views here.


from app01 import models
from rest_framework.views import APIView
from rest_framework.response import Response
from app01.myser import BookSerializer

# 把对象转成json格式字符串
class Books(APIView):
    def get(self, request):
        response = {'code': 100, 'msg': '查询成功'}
        books = models.Book.objects.all()
        # 如果序列化多条，many=True（也就是queryset对象，就需要写）
        # 如果序列化一条（可以不写）,instance是要序列化的对象
        bookser = BookSerializer(instance=books, many=True)
        # print(bookser.data)  # [OrderedDict([('name', '三国演义'), ('price', '11.00')]), OrderedDict([('name', '西游记'), ('price', '22.00')])]
        # print(type(bookser.data))  # <class 'rest_framework.utils.serializer_helpers.ReturnList'>
        response['data'] = bookser.data
        return Response(response)

    def post(self, request):
        # 实例化产生一个序列化类的对象，data是要反序列化的字典
        bookser = BookSerializer(data=request.data)
        if bookser.is_valid():
            # 清洗通过的数据,校验通过之后才会调用create方法
            # 注意：重写create方法的时候，一定要先校验通过了之后才能调用create方法
            res = bookser.create(bookser.validated_data)
        return Response()

详情见代码

2、ModelSerializers：指定了表模型

使用serializer需要写很多字段，尽可能简洁的就要使用ModelSerializer

总结：