rest-framework序列化

1.get请求的序列化　

 1 # 1.导入模块
 2 from rest_framework import serializers
 3 
 4 
 5 from app01.models import Book
 6 # 2.创建一个序列化类，字段类型不一定要跟model的字段一样
 7 
 8 class BookSerializer(serializers.Serializer):
 9     nid = serializers.CharField(max_length=32,read_only=True)
10     title = serializers.CharField(max_length=32)
11     price = serializers.DecimalField(max_digits=5,decimal_places=2)
12     # 外键字段，显示__str__返回值
13     publish = serializers.CharField(max_length=32)
14     # 多对多字段需要自己手动获取数据，SerializerMethodField()
15     authors = serializers.SerializerMethodField()
16 
17     def get_authors(self,book_obj):
18         author_list = list()
19 
20         for author in book_obj.authors.all():
21             author_list.append(author.name)
22 
23         return author_list

 1 from rest_framework.views import APIView
 2 from rest_framework.response import Response
 3 
 4 from app01.app_serializers import BookSerializer
 5 from app01.models import (
 6     Book,
 7     Publish,
 8     Author,
 9 )
10 
11 class BookView(APIView):
12 
13     def get(self,request):
14         # 3.获取queryset
15         origin_data = Book.objects.all()
16         # 4.开始序列化
17         serialized_data = BookSerializer(origin_data,many=True)
18         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

 1     def post(self,request):
 2 
 3         verified_data = BookSerializer(data=request.data)
 4 
 5         if verified_data.is_valid():
 6 
 7             verified_data.save(authors = request.data['authors'])
 8 
 9             return Response(verified_data.data)
10         else:
11             return Response(verified_data.errors)

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

 1 class BookSerializer(serializers.ModelSerializer):
 2     class Meta:
 3         model = Book
 4         fields = '__all__'
 5         """
 6         [
 7             'title',
 8             'price',
 9             'publish',
10             'authors',
11             'publish_name',
12             'publish_city',
13             'authors'
14         ]
15         """
16 
17         extra_kwargs = {
18             "publish":{"write_only":True},
19             "authors":{"write_only":True}
20         }
21 
22     publish_name = serializers.CharField(max_length=32,read_only=True,source='publish.name')
23     publish_city = serializers.CharField(max_length=32,read_only=True,source='publish.city')
24 
25     authors_list = serializers.SerializerMethodField()
26 
27     def get_authors_list(self,book_obj):
28         authors_list = list()
29 
30         for authors in book_obj.authors.all():
31             authors_list.append(authors.name)##这个地方不能直接传authors
32 
33         return authors_list

　　继承APIView的序列化

 

 

 1 from rest_framework.views import APIView
 2 from rest_framework.response import Response
 3 
 4  path('books/', views.BookView.as_view()),
 5  re_path('books/(\d+)/', views.BookFilterView.as_view()),
 6 
 7 class BookView(APIView):
 8 
 9     def get(self,request):
10         book_list = Book.objects.all()
11         new_book_list = BookSerializer(book_list,many=True)
12 
13         return Response(new_book_list.data)
14 
15     def post(self,request):
16 
17         verfield = BookSerializer(data=request.data,many=False)
18 
19         if verfield.is_valid():
20             verfield.save()
21             return Response(verfield.data)
22         else:
23             return Response(verfield.errors)
24 
25 class BookFilterView(APIView):
26 
27     def get(self,request,nid):
28         origin_data = Book.objects.get(pk=nid)
29         serialized_data = BookSerializer(origin_data,many=False)
30 
31         return Response(serialized_data.data)
32 
33     def put(self,request,nid):
34         origin_data = Book.objects.get(pk=nid)
35 
36         verfield = BookSerializer(data=request.data,instance=origin_data,many=False)
37 
38         if verfield.is_valid():
39             verfield.save()
40             return Response(verfield.data)
41         else:
42             return Response(verfield.errors)
43 
44     def delete(self,request,nid):
45         Book.objects.filter(pk=nid).delete()
46 
47         return Response()

　　基于mixins的序列化

 1 from rest_framework.response import Response
 2 from rest_framework import generics
 3 from rest_framework.mixins import (
 4     ListModelMixin,
 5     RetrieveModelMixin,
 6     CreateModelMixin,
 7     UpdateModelMixin,
 8     DestroyModelMixin,
 9 )
10 
　　

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

11 class BookView(ListModelMixin,CreateModelMixin,generics.GenericAPIView):
12     queryset = Book.objects.all()
13     serializer_class = BookSerializer
14 
15     def get(self,request):
16         return self.list(self,request)
17 
18     def post(self,request):
19         return self.list(self,request)
20 
21 class BookFilterView(RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin,generics.GenericAPIView):
22     queryset = Book.objects.all()
23     serializer_class = BookSerializer
24 
25     def get(self,request,*args,**kwargs):
26         return self.retrieve(request,*args,**kwargs)
27 
28     def put(self,request,*args,**kwargs):
29         return self.update(request,*args,**kwargs)
30 
31     def delete(self,request,*args,**kwargs):
32         return self.destroy(request,*args,**kwargs)

　　　　基于ModelViewSet的序列化

 1 path('books/', views.BookView.as_view({
 2         'get':'list',
 3         "post":"create"
 4     })),
 5     re_path('books/(?P<pk>\d+)/', views.BookView.as_view({
 6         "get":"retrieve",
 7         "put":"update",
 8         "delete":"destroy"
 9     })),
10 
11 from rest_framework.viewsets import ModelViewSet
12 
13 class BookView(ModelViewSet):
14     queryset = Book.objects.all()
15     serializer_class = BookSerializer

 

转载于:https://www.cnblogs.com/qq849784670/p/10079829.html