rest-framework序列化

1.get请求的序列化　

# 1.导入模块
from rest_framework import serializers


from app01.models import Book
# 2.创建一个序列化类，字段类型不一定要跟model的字段一样

class BookSerializer(serializers.Serializer):
    nid = serializers.CharField(max_length=32,read_only=True)
    title = serializers.CharField(max_length=32)
    price = serializers.DecimalField(max_digits=5,decimal_places=2)
    # 外键字段，显示__str__返回值
    publish = serializers.CharField(max_length=32)
    # 多对多字段需要自己手动获取数据，SerializerMethodField()
    authors = serializers.SerializerMethodField()

    def get_authors(self,book_obj):
        author_list = list()

        for author in book_obj.authors.all():
            author_list.append(author.name)

        return author_list

from rest_framework.views import APIView
from rest_framework.response import Response

from app01.app_serializers import BookSerializer
from app01.models import (
    Book,
    Publish,
    Author,
)

class BookView(APIView):

    def get(self,request):
        # 3.获取queryset
        origin_data = Book.objects.all()
        # 4.开始序列化
        serialized_data = BookSerializer(origin_data,many=True)
        return Response(serialized_data.data)

 2.post请求（post请求需要自己手动写一个create的方法）

    def create(self, validated_data):
        authors = validated_data.pop("authors")
        BookObj = Book.objects.create(**validated_data)
        BookObj.authors.set(authors)

        return BookObj

    def post(self,request):

        verified_data = BookSerializer(data=request.data)

        if verified_data.is_valid():

            verified_data.save(authors = request.data['authors'])

            return Response(verified_data.data)
        else:
            return Response(verified_data.errors)

 3.基于ModelSerializer创建的序列化类

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = '__all__'
        """
        [
            'title',
            'price',
            'publish',
            'authors',
            'publish_name',
            'publish_city',
            'authors'
        ]
        """

        extra_kwargs = {
            "publish":{"write_only":True},
            "authors":{"write_only":True}
        }

    publish_name = serializers.CharField(max_length=32,read_only=True,source='publish.name')
    publish_city = serializers.CharField(max_length=32,read_only=True,source='publish.city')

    authors_list = serializers.SerializerMethodField()

    def get_authors_list(self,book_obj):
        authors_list = list()

        for authors in book_obj.authors.all():
            authors_list.append(authors.name)##这个地方不能直接传authors

        return authors_list

　　继承APIView的序列化

from rest_framework.views import APIView
from rest_framework.response import Response

 path('books/', views.BookView.as_view()),
 re_path('books/(d+)/', views.BookFilterView.as_view()),

class BookView(APIView):

    def get(self,request):
        book_list = Book.objects.all()
        new_book_list = BookSerializer(book_list,many=True)

        return Response(new_book_list.data)

    def post(self,request):

        verfield = BookSerializer(data=request.data,many=False)

        if verfield.is_valid():
            verfield.save()
            return Response(verfield.data)
        else:
            return Response(verfield.errors)

class BookFilterView(APIView):

    def get(self,request,nid):
        origin_data = Book.objects.get(pk=nid)
        serialized_data = BookSerializer(origin_data,many=False)

        return Response(serialized_data.data)

    def put(self,request,nid):
        origin_data = Book.objects.get(pk=nid)

        verfield = BookSerializer(data=request.data,instance=origin_data,many=False)

        if verfield.is_valid():
            verfield.save()
            return Response(verfield.data)
        else:
            return Response(verfield.errors)

    def delete(self,request,nid):
        Book.objects.filter(pk=nid).delete()

        return Response()

　　基于mixins的序列化

from rest_framework.response import Response
from rest_framework import generics
from rest_framework.mixins import (
    ListModelMixin,
    RetrieveModelMixin,
    CreateModelMixin,
    UpdateModelMixin,
    DestroyModelMixin,
)

　　

　　# path('books/', views.BookView.as_view()),
　　# re_path('books/(?P<pk>d+)/', views.BookFilterView.as_view()),

class BookView(ListModelMixin,CreateModelMixin,generics.GenericAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

    def get(self,request):
        return self.list(self,request)

    def post(self,request):
        return self.list(self,request)

class BookFilterView(RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin,generics.GenericAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

    def get(self,request,*args,**kwargs):
        return self.retrieve(request,*args,**kwargs)

    def put(self,request,*args,**kwargs):
        return self.update(request,*args,**kwargs)

    def delete(self,request,*args,**kwargs):
        return self.destroy(request,*args,**kwargs)

　　　　基于ModelViewSet的序列化

path('books/', views.BookView.as_view({
        'get':'list',
        "post":"create"
    })),
    re_path('books/(?P<pk>d+)/', views.BookView.as_view({
        "get":"retrieve",
        "put":"update",
        "delete":"destroy"
    })),

from rest_framework.viewsets import ModelViewSet

class BookView(ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer