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('111')
        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 '555'


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('111')
        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