RESTful-rest_framework应用第二篇（get、post的序列化与反序列化）

目的是：

　　利用rest_framework实现对数据库内容的查看get请求（序列化）、提交保存数据post请求 （反序列化）

rest_framework序列化组件（即查看和）

第一步：基于Django搭建RESTful框架

第二步：配置信息

settings.py配置

settings里面全局解析器：

 #设置解析器（对发送过来的数据信息格式进项校验并做进一步处理）
 #全局可以配好多个，局部配一个就行（先走局部的）
 REST_FRAMEWORK = {
     'DEFAULT_PARSER_CLASSES': ['rest_framework.parsers.JSONParser', 'rest_framework.parsers.FormParser']
 }

views.py局部解析器：

 #JSONParser,FormParser局部解析器，一般只需要写一个就行
 from rest_framework.parsers import JSONParser,FormParser
 class Book(APIView):

     #解析器：对浏览器发送post请求过来的数据类型做解析
     #当指向下面post请求，运行request.data的时候才会去执行解析器
     parser_classes = [JSONParser,FormParser]

     def get(self,request):                 #request是已经处理好的request

         ret = models.Book.objects.all()
         print(ret,type(ret)) #ret是QuerySet对象  <class 'django.db.models.query.QuerySet'>

         # 实例化上面的BookSerializer拿到一个book_ser对象
         # BookSerializer参数（ret：queryset对象，many=True代表序列化多条，many=False 代表序列化一条）
         book_ser=BookSerializer(ret,many=True)
         #book_ser.data不是json格式的字符串，而是个字典
         #所以Response内部一定是对book_ser.data做了序列化
         return Response(book_ser.data)

     def post(self,request):
         print('')
         print(request.data)
         return HttpResponse('ok')

         # 杂乱内容整理：
         # print(request.POST)
         #对请求过来的数据进项验证，检验每个字段是否符合录入要求，并保存
         ser = BookSerializer(data=request.data)

         #post请求过来数据符合每个字段要求，就允许写入数据库
         if ser.is_valid():
             ser.save()
             return Response(ser.save())

         #不符合要求就返回错误信息
         else:
             print(ser.errors)

             return HttpResponse(json.dumps(ser.errors))

models.py里面的设置：

 from django.db import models

 # Create your models here.

 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

     #我了验证可以覆盖重写字段的方法
     def test(self):
         return ''

 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.py配置:

 from django.shortcuts import render,HttpResponse,redirect
 import json
 from api import models
 # Create your views here.

 # from api.models import Book

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

 from rest_framework.serializers import SerializerMethodField

 #为了验证方式三
 class AuthorsSerializer(serializers.Serializer):
     id = serializers.CharField()
     name = serializers.CharField()
     age = serializers.CharField()

 class PublishSerializer(serializers.Serializer):
    id = serializers.CharField()
    name = serializers.CharField()
    email = serializers.CharField()

 #RESful提供的一个序列化组件BookSerializer，可以控制传入的参数
 class BookSerializer(serializers.Serializer):
     #指定字段重命名，例如:将title重命名为xx
     xx = serializers.CharField(source='title')
     #添加新字段：只要models里面指定一个test方法，就会执行并显示一条新的字段
     qqq=serializers.CharField(source='test')

     title=serializers.CharField()
     price=serializers.CharField()
     pub_date=serializers.DateField()
     #publish是个object对象,所以可以.name查看里面的内容
     publish=serializers.CharField(source="publish.name")

     #查询所有作者：
     #方式一：
     authors=serializers.CharField(source="authors.all")

     #方式二：for循环拿到作者对象
     authors=serializers.SerializerMethodField()
     def get_authors(self,obj):
         ll=[]
         for author in obj.authors.all():
             print(author)
             ll.append({'name':author.name,'age':author.age})
         return ll

     #方式三：将作者实例化
     authors=serializers.SerializerMethodField()
     def get_authors(self,obj):
         ret_authors = obj.authors.all()

         ser=AuthorsSerializer(ret_authors,many=True)
         return ser.data

 #方式四：
 class BookSerializer(serializers.ModelSerializer):
     class Meta:
         #第一步：先拿到所有字段
         model = models.Book
         #__all__要去所有字段
         fields = '__all__'
         # 指定显示要取的字段 (注意指定和去除不能同时用)
         # fields=('id','title')
         # 去除某个或某几个字段不显示
         # exclude=('id','publish')

     # 重新tiltle字段，进行重命名
     # xx = serializers.CharField(source='title')

     #第二步：查看书对应的所有作者，（再重写authors字段，让其所以作者信息，而不只是显示序列号）
     authors=serializers.SerializerMethodField()
     def get_authors(self,obj):
         ret_authors = obj.authors.all()
         # print(ret_authors,type(ret_authors))

         ser=AuthorsSerializer(ret_authors,many=True)
         return ser.data

     #同理，查看书对应的的出版社
     publish=serializers.SerializerMethodField()
     def get_publish(self,obj):
         ret_publish= obj.publish
         print(ret_publish,type(ret_publish))   #Publish object
         ser = PublishSerializer(ret_publish,many=False)
         print(ser.data)
         return ser.data

     #设置title字段为必填字段，并设计中文提示信息
     title = serializers.CharField(error_messages={'required':'标题为必填字段'})

 #字段校验和反序列化：

     #局部钩子：用来校验1个字段
     def validate_title(self,value):
         from rest_framework.exceptions import ValidationError
         print(value)
         # raise ValidationError('就是看你不爽')
         return value

     #全局钩子：多个字段间对比检验
     def validate(self,attrs):
         from rest_framework.exceptions import ValidationError
         if attrs.get('title') == attrs.get('price'):
             return attrs
         else:
             raise ValidationError('书名和价格不一样')

 class Book(APIView):
     def get(self,request):
         ret = models.Book.objects.all()
         # BookSerializer可以获取请求的数据
         book_ser = BookSerializer(ret,many=True)
         print(book_ser.data)
         return Response(book_ser.data)
     #post请求，及实现保存数据
     def post(self,request):
         # BookSerializer也可以保存数据信息到数据库
         ser=BookSerializer(data=request.data)
         if ser.is_valid():
             ser.save()
             return HttpResponse('提交的post请求数据符合要求，已成功录入后台')

         else:
             print(ser.errors)
             # return Response(ser.errors)
             return HttpResponse(json.dumps(ser.errors))

 #RESTfu自带的处理请求的模块方法
 #JSONParser,FormParser局部解析器，一般只需要写一个就行
 from rest_framework.parsers import JSONParser,FormParser
 class Book(APIView):

     #解析器：对浏览器发送post请求过来的数据类型做解析
     #当指向下面post请求，运行request.data的时候才会去执行解析器
     parser_classes = [JSONParser,FormParser]

     def get(self,request):                 #request是已经处理好的request

         ret = models.Book.objects.all()
         print(ret,type(ret)) #ret是QuerySet对象  <class 'django.db.models.query.QuerySet'>

         # 实例化上面的BookSerializer拿到一个book_ser对象
         # BookSerializer参数（ret：queryset对象，many=True代表序列化多条，many=False 代表序列化一条）
         book_ser=BookSerializer(ret,many=True)
         #book_ser.data不是json格式的字符串，而是个字典
         #所以Response内部一定是对book_ser.data做了序列化
         return Response(book_ser.data)

     def post(self,request):
         print('')
         print(request.data)
         return HttpResponse('ok')

         # 杂乱内容整理：
         # print(request.POST)
         #对请求过来的数据进项验证，检验每个字段是否符合录入要求，并保存
         ser = BookSerializer(data=request.data)

         #post请求过来数据符合每个字段要求，就允许写入数据库
         if ser.is_valid():
             ser.save()
             return Response(ser.save())

         #不符合要求就返回错误信息
         else:
             print(ser.errors)

             return HttpResponse(json.dumps(ser.errors))

知识点分解，如下：

rest-framework序列化之ModelSerializer

 class BookSerializer(serializers.ModelSerializer):
     class Meta:
         #第一步：先拿到所有字段
         model = models.Book
         #__all__要去所有字段
         fields = '__all__'
         # 指定显示要取的字段 (注意指定和去除不能同时用)
         # fields=('id','title')
         # 去除某个或某几个字段不显示
         # exclude=('id','publish')

         #下面这个方法不建议使用（因为不是字段都是要展示给客户看的，还是要使用下面那个方法，可以指定显示哪些字段）
         # depth = 1 #深度控制，写 几 往里拿几层，层数越多，响应越慢，官方建议0--10之间，个人建议最多3层

     # 重新tiltle字段，进行重命名
     # xx = serializers.CharField(source='title')

     #第二步：查看书对应的所有作者，（再重写authors字段，让其所以作者信息，而不只是显示序列号）
     authors=serializers.SerializerMethodField()
     def get_authors(self,obj):             #obj是一个book对象
         ret_authors = obj.authors.all()
         # print(ret_authors,type(ret_authors))

         ser=AuthorsSerializer(ret_authors,many=True)
         return ser.data

     #同理，查看书对应的的出版社
     publish=serializers.SerializerMethodField()
     def get_publish(self,obj):
         ret_publish= obj.publish
         print(ret_publish,type(ret_publish))   #Publish object
         ser = PublishSerializer(ret_publish,many=False)
         print(ser.data)
         return ser.data