DRF之序列化

• 序列化

把Python中对象转换为json格式字符串

• 反序列化

把json格式转为为Python对象。

• 序列化两大功能：

对请求数据进行验证
对Queryset对象进行序列化

rest framework序列化之Serializer

• 建表 models.py

from django.db import models


class Book(models.Model):
    title=models.CharField(max_length=32)
    price=models.IntegerField()
    pub_date=models.DateField()
    publish=models.ForeignKey("Publish")
    authors=models.ManyToManyField("Author")
    def __str__(self):
        return self.title

class Publish(models.Model):
    name=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

• views

写一个restframework接口拿到数据（所有图书）
方式一：如果没有序列化组件的话，要先转成字典，然后再用json.dumps()再转。
方式二：用序列化组件。
首先你要序列化谁，先写一个类。这个类继承一个东西，然后用的时候，在视图类中直接用这个类生成一个对象。

from django.shortcuts import render,HttpResponse
from rest_framework.views import APIView
from rest_framework.response import Response


from api import models

# 想用这个类，需要导入
from api.MySerializer import BookSerializer

class BookView(APIView):

    def get(self,request,*args,**kwargs):
        ret = {
            'code':100,
            'msg':'成功了'
        }
        books = models.Book.objects.all()
        # 第一个参数是要序列化的对象，如果序列化多条，必须指定many=True
        books_ser = BookSerializer(instance=books,many=True)
        # 当序列化的对象是单个对象的时候many=False book = models.Book.objects.all().first()
        # books_ser.data  就是序列化后的结果 是个字典
        print(books_ser.data)
        ret['books']=books_ser.data
        # return Response(books_ser.data)
        return Response(ret)

• 写的格式化的类在另外的文件夹或文件：

# 自己写一个序列化的类
from rest_framework import serializers
class BookSerializer(serializers.Serializer):
    # 序列化哪个字段,必须跟数据库字段一样，都想序列化就一个一个排着写
    id = serializers.CharField()
    title = serializers.CharField()
    price = serializers.CharField()

ModelSerializer

'''
基于ModelSerializer的序列化器
'''

from rest_framework import serializers
from SerDemo.models import Book

class BookSerializer(serializers.ModelSerializer):
    # SerializerMethodField() 方法字段，返回值是该字段方法的返回值
    # SerializerMethodField() 一般用于正序列化
    newcategory = serializers.SerializerMethodField(read_only=True)
    newpublisher = serializers.SerializerMethodField(read_only=True)
    newauthors = serializers.SerializerMethodField(read_only=True)

    # 字段方法，必须有obj参数,返回值给category_text字段
    def get_newcategory(self,obj):
        return obj.get_category_display()

    # 外键关系的展示方法
    def get_newpublisher(self,obj):
        return {"id":obj.publisher_id,"title":obj.publisher.title}

    # 多对多关系的展示方法
    def get_newauthors(self,obj):
        return [{"id":author.id,"name":author.name} for author in obj.authors.all()]

    class Meta:
        model = Book        # 序列化的模型
        fields = "__all__"  # 序列化所有字段

        # fields = ['id','title']   序列化列表内的字段
        # exclude = ['publisher','authors']     序列化模型内排除列表内的字段
        # depth = 1       根据外键关系往内找1层，但所有的外键都变成read_only = True

        # 给原来的字段添加属性
        extra_kwargs = {
            "category":{"write_only":True},     # 字段: {参数：参数值}
            "publisher":{"write_only":True},
            "authors":{"write_only":True},
        }

from utils.model_serializers import BookSerializer       # 导入序列化组件
from .models import Book
from rest_framework.views import APIView
from rest_framework.response import Response

class BookView(APIView):
    def get(self,request):
        # 找到所有的模型对象
        book_queryset = Book.objects.all()

        # 对模型对象进行序列化，返回序列化对象
        ser_obj = BookSerializer(book_queryset,many=True)       # 多个模型对象使用many=True
        return Response(ser_obj.data)

    def post(self,request):
        # 将前端获取的数据，返回序列化对象
        ser_obj = BookSerializer(data=request.data)

        # 对序列化对象进行校验
        if ser_obj.is_valid():
            # 校验通过，创建对象
            ser_obj.save()
            return Response(ser_obj.data)   # 返回新增的对象
        else:
            return Response(ser_obj.errors) # 返回错误信息

# 带id的查询、更新、删除
class EditBookView(APIView):
    # 根据id查看数据
    def get(self,request,id):
        # 根据ip找到模型对象
        book_obj = Book.objects.filter(pk=id).first()

        # 对模型对象进行序列化，返回序列化对象
        ser_obj = BookSerializer(book_obj)

        # 返回序列化对象的数据
        return Response(ser_obj.data)

    # 根据id更新数据
    def put(self,request,id):
        # 根据ip找到模型对象
        book_obj = Book.objects.filter(pk=id).first()

        # 将获取的数据根据模型对象进行序列化，返回序列化对象
        ser_obj = BookSerializer(instance=book_obj,data=request.data,partial=True)
        # partial=True 部分匹配
        # data=request.data 前端提交的数据
        # instance=book_obj根据id找到的实例化对象

        # 对实例化对象进行校验
        if ser_obj.is_valid():
            # 校验通过,调用save进行更新
            ser_obj.save()      # 内部调用序列化器的update方法
            return Response(ser_obj.data)
        else:
            return Response(ser_obj.errors)     # 返回错误信息

    # 根据id删除数据
    def delete(self,request,id):
        # 根据ip找到模型对象
        book_obj = Book.objects.filter(pk=id).first()

        if book_obj:
            book_obj.delete()
            return Response("删除成功")
        else:
            return Response("删除失败")