【DRF框架】序列化组件——ModelSerializer

ModelSerializer

　　1.ModelSerializer类似于ModelForm

　　2.根据模型自动生成一组字段

　　3.自带实现了.update()以及.create()方法

 

ModelSerializer的使用

1.创建原信息   class Meta：

2.指定序列化的模型类 model = "XX"

3.序列化的字段列表  fields = ["xxx"]　

4.序列化不包含指定字段的列表 exclude = ["xxx"]　

5.找到外键关系，并将所有的外键都变为read_only=true

6.给指定的字段添加参数属性  extra_kwargs = {}

ModelSerializer的方法字段   dserializers.SerializerMethodField（）

一般用于正序列化
1.自定义字段方法 get_字段
2.返回值是 SerializerMethodField（）的返回值

'''
基于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("删除失败")