DRF--序列化

为什么要用序列化

当我们做前后端分离的项目时，前后端交互一般都是JSON格式的数据，那么我们给前端的数据就要转为JSON格式，就需要我们拿到数据库后的数据进行序列化。在看DRF的序列化之前，先来看看django的序列化

from django.db import models

# Create your models here.

__all__ = ["Book", "Publisher", "Author"]

class Book(models.Model):
    title = models.CharField(max_length=32)
    CHOICES = ((1, "python"), (2, "Liunux"), (3, "Go"))
    category = models.IntegerField(choices=CHOICES)
    pub_time = models.DateField()
    publisher = models.ForeignKey(to="Publisher")
    authors = models.ManyToManyField(to="Author")

class Publisher(models.Model):
    title = models.CharField(max_length=32)

    def __str__(self):
        return self.title

class Author(models.Model):
    name = models.CharField(max_length=32)

    def __str__(self):
        return self.name

model.py

from django.http import JsonResponse
from django.shortcuts import render
from django.views import View
from djangoDemo.models import Book, Publisher

# 第一版用values方法取数据
class BookView(View):
    def get(self, request):
        book_queryset = Book.objects.values("id", "title", "pub_time", "publisher")
        book_list = list(book_queryset)
        ret = []
        for book in book_list:
            book["publisher"] = {
                "id": book["publisher"],
                "title": Publisher.objects.filter(id=book["publisher"]).first().title,
            }
            ret.append(book)
        # ret = json.dumps(book_list, ensure_ascii=False)
        # return HttpResponse(ret)
        return JsonResponse(ret, safe=False, json_dumps_params={"ensure_ascii": False})

序列化

DRF的序列化

从上面的例子中可以看出来，这样我们序列化出来的数据，写法很麻烦。所以我们用DRF的序列化，要用别人的序列化就要遵守别人的规则，首先需要在app里注册

INSTALLED_APPS = [
    'django.contrib.admin',

    ...

    'rest_framework',
]

注册好了之后要声明序列化类，在当前app下创建一个py文件

 from rest_framework import serializers

 #  出版社的序列化器，前面的变量要和model里的变量名一样
 class PublisherSerializer(serializers.Serializer):
     id = serializers.IntegerField()
     title = serializers.CharField(max_length=32)

 class AuthorSerializer(serializers.Serializer):
     id = serializers.IntegerField()
     name = serializers.CharField(max_length=32)

 class BookSerializer(serializers.Serializer):
     id = serializers.IntegerField()
     title = serializers.CharField(max_length=32)
     pub_time = serializers.DateField()
     category = serializers.CharField(source="get_category_display")  # 选择的需要指定source

     publisher = PublisherSerializer()  # 一对多的表
     authors = AuthorSerializer(many=True)  # 多对多的表需要指定many=True

上面我们就写好了序列化的类，注意：匹配上的字段进行序列化，匹配不上则丢弃，所以前端需要哪些字段就写哪些，如果不写的就不序列化

外键关系的序列化是嵌套的序列化器对象 
注意many=True

然后再视图函数里写序列化对象

from django.shortcuts import render
from rest_framework.views import APIView
from rest_framework.response import Response
from djangoDemo.models import Book  # 导入表
from .serializers import BookSerializer

class BookView(APIView):
    def get(self, request):
        book_queryset = Book.objects.all()
        # 拿出来的是一个queryset，用序列化器进行序列化
        ser_obj = BookSerializer(book_queryset, many=True)
        return Response(ser_obj.data)  # 序列化后的数据在data里

注意：当查询出的数据是一个queryset时，需要加many=True，内部会认为是一个可迭代的对象，会去循环。当查询出的是一条数据时，不需要加many=True，会报错

当我们访问这个接口时，返回的数据就是如下的格式

{
        "id": 1,
        "title": "python从入门到放弃",
        "pub_time": "2019-09-10",
        "category": "python",
        "publisher": {
            "id": 1,
            "title": "清华"
        },
        "authors": [
            {
                "id": 1,
                "name": "马云"
            },
            {
                "id": 2,
                "name": "刘亦菲"
            }
        ]
    }

反序列化

当我们进行post请求的时候，我们需要定义数据格式，然后让前端的妹子传给我们对应的格式。格式确定之后我们还要校验前端妹子传过来的格式和字段，比如字段的类型还有长度，我们不能相信前端妹子的话，妹子说“我没事”。难道就真没事了吗？所以数据校验是必不可少的。

数据格式当然是json格式的，那怎么校验数据呢，在上面我们写了个序列化类，来序列化返回给前端的数据，我们也可以用来校验前端传给我们的数据。因为id是自动递增的，所以前端不需要传，我们也不需要校验，可以加个参数required=False，表示只序列化不反序列化。还有些字段，比如上面的category字段，我们序列化的时候返回的是后面的汉字，而反序列化的时候，我们希望是前面的数字，所以我们需要重写这个字段，如果字段里有read_only=True，表示只序列化。如果是write_only=True，表示只反序列化

返回的数据是上面格式的，我们如果新增数据，希望数据是下面这个格式的

{

        "title": "HTML",
        "pub_time": "2019-09-10",
        "post_category": 1,
        "publisher_id":1,
        "author_list": [1,2]
}

注意，前面的key是序列化器里对应的字段

先来改写序列化器

class BookSerializer(serializers.Serializer):
    id = serializers.IntegerField(required=False)  # 只序列化，不走校验
    title = serializers.CharField(max_length=32)
    pub_time = serializers.DateField()
    category = serializers.CharField(source="get_category_display", read_only=True)  # 只序列化用
    # 因为前端传的是数字，所以需要重写
    post_category = serializers.IntegerField(write_only=True)  # 只反序列化用

    publisher = PublisherSerializer(read_only=True)  # 一对多的表  只序列化用
    authors = AuthorSerializer(many=True, read_only=True)  # 多对多的表需要指定many=True 只序列化用

    publisher_id = serializers.IntegerField(write_only=True)  # 只反序列化用
    author_list = serializers.ListField(write_only=True)  # 只反序列化用

    def create(self, validated_data):
        # validated_data校验通过的数据
        # 通过ORM操作给book表增加数据
        book_obj = Book.objects.create(title=validated_data['title'],
                                       pub_time=validated_data['pub_time'],
                                       category=validated_data['post_category'],
                                       publisher_id=validated_data['publisher_id'])
        book_obj.authors.add(*validated_data['author_list'])  # 这个参数可能是一个列表
        return book_obj

在来改写视图函数，新增post请求

class BookView(APIView):
    def get(self, request):
        book_queryset = Book.objects.all()
        # 拿出来的是一个queryset，用序列化器进行序列化
        ser_obj = BookSerializer(book_queryset, many=True)
        return Response(ser_obj.data)  # 序列化后的数据在data里

    def post(self, request):
        # 确定数据类型以及数据结构
        # 对前端传来的数据进行校验
        book_obj = request.data  # post传来的数据
        ser_obj = BookSerializer(data=book_obj) # 有data参数，表示反序列化
        if ser_obj.is_valid():
            ser_obj.save()
            return Response(ser_obj.validated_data)
        return Response(ser_obj.errors)  # 返回错误

这样，当我们提交像上面一样的数据格式之后，在看get请求，就返回如下的数据

[
    {
        "id": 1,
        "title": "python从入门到放弃",
        "pub_time": "2019-09-10",
        "category": "python",
        "publisher": {
            "id": 1,
            "title": "清华"
        },
        "authors": [
            {
                "id": 1,
                "name": "马云"
            },
            {
                "id": 2,
                "name": "刘亦菲"
            }
        ]
    },
    {
        "id": 2,
        "title": "Linux跑路",
        "pub_time": "2019-09-18",
        "category": "Liunux",
        "publisher": {
            "id": 2,
            "title": "北大"
        },
        "authors": [
            {
                "id": 2,
                "name": "刘亦菲"
            }
        ]
    },
    {
        "id": 3,
        "title": "HTML",
        "pub_time": "2019-09-10",
        "category": "python",
        "publisher": {
            "id": 1,
            "title": "清华"
        },
        "authors": [
            {
                "id": 1,
                "name": "马云"
            },
            {
                "id": 2,
                "name": "刘亦菲"
            }
        ]
    }
]

序列化返回给前端的数据

put反序列化

上面的序列化是post请求的，那我们修改数据的时候可能是只对某一个字段进行修改

路由：

urlpatterns = [
    url(r'^book/$', BookView.as_view()),
    url(r'^book/(?P<id>\d+)', BookEditView.as_view()),
]

在 BookSerializer 序列化类里添加一个update方法

def update(self, instance, validated_data):
    # instance 更新的book_obj对象
    # validated_data 校验通过的数据
    instance.title = validated_data.get("title",instance.title)
    instance.pub_time = validated_data.get("pub_time",instance.pub_time)
    instance.category = validated_data.get("post_category",instance.category)
    instance.publisher_id = validated_data.get("publisher_id",instance.publisher_id)
    if validated_data.get("author_list"):  # 可能有多个值
        instance.author.set(validated_data["author_list"])
    instance.save()  # 保存
    return instance

因为不知道修改的是哪个字段，所以都要写

在写put请求

class BookEditView(APIView):
    def get(self, request, id):
        book_obj = Book.objects.filter(id=id).first()
        ser_obj = BookSerializer(book_obj)  # 查询出的是一条数据，不需要加 many=True
        return Response(ser_obj.data)

    def put(self, request, id):
        book_obj = Book.objects.filter(id=id).first()
        # instance必传,data=request.data前端传的参数,partial=True部分修改
        ser_obj = BookSerializer(instance=book_obj, data=request.data, partial=True)
        if ser_obj.is_valid():
            ser_obj.save()
            return Response(ser_obj.data)  # 返回数据，注意不是ser_obj.validated_data
        return Response(ser_obj.errors)