序列化组建

一、什么是序列化组件？

　　 本质上为了实现前后端分离，而进行json序列化的一个组件形式，极大方便了解析数据的作用

   　 所有序列化是基于APIView解析器实现的，通过内部的多继承关系方便实现进行数据序列化的实现

二、使用方法　　

   1、基于APIView 引入 from rest_framework.views import APIView

　　2、返回的请求用 Response：  from rest_framework.response import Response

　　3、开始进行创建序列化类的方式：from rest_framework import serializers    

第一步：创建序列化类

创建出返回页面显示的字段，一对多关系同创建普通字段一样，无需特意声明关系，但需要引入：

source=publish.city

重命名：用source ：xx = serializers.CharField(source='name')；将name命名为xx

第二步：创建需要解析的数据类，继承APIView方法

创建 的方法要遵循rest请求规范

1、获取需要传递的数据

2、将数据 传到序列化类中，返回一个实例化对象

3、通过返回return Response（实例化对象.data）返回给页面

视图层（views.py）

from django.shortcuts import render

# Create your views here.

from app01 import models
from rest_framework.views import APIView
from app01.mySer import BookSerializer
from django.http import JsonResponse


class Books(APIView):
    def get(self, request, *args, **kwargs):
        ret = models.Book.objects.all()
        # 生成一个序列化的对象，传参数
        # 序列化多条，记住 many=True
        book_ser = BookSerializer(ret, many=True)
        print(book_ser.data)
        return JsonResponse(book_ser.data, safe=False)

新建的py文件

from rest_framework import serializersclass BookSerializer(serializers.Serializer):
    name = serializers.CharField()
    # 可以用source修改别名
    # xxx = serializers.CharField(source='name')
    price = serializers.CharField()
    # 可以用source拿出出版社内的各个字段
    # publish=serializers.CharField(source='publish.name')
    # publish = serializers.CharField(source='publish.city')
    # 指定函数，test在models中
    test = serializers.CharField(source='publish.test')
    publish_id = serializers.CharField()
    # 拿出出版社的所有信息
    # SerializerMethodField可以指定一个方法
    publish = serializers.SerializerMethodField()

    # 方法名：叫get_ 字段名，要传参数，参数是：当前book对象
    def get_publish(self, obj):
        # obj是当前book对象
        dic = {'name': obj.publish.name, 'email': obj.publish.email}
        return dic

模板层（models）

from django.db import models


# Create your models here.

class Book(models.Model):
    nid = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    publish_date = models.DateField()

    publish = models.ForeignKey(to='Publish', to_field='nid', on_delete=models.CASCADE)
    authors = models.ManyToManyField(to='Author')

    def __str__(self):
        return self.name


class Author(models.Model):
    nid = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    author_detail = models.OneToOneField(to='AuthorDatail', to_field='nid', unique=True, on_delete=models.CASCADE)


class AuthorDatail(models.Model):
    nid = models.AutoField(primary_key=True)
    telephone = models.BigIntegerField()
    birthday = models.DateField()
    addr = models.CharField(max_length=64)


class Publish(models.Model):
    nid = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    city = models.CharField(max_length=32)
    email = models.EmailField()

    def __str__(self):
        return self.name

    def test(self):
        return self.email

拿出这本书的所有作者（在新建的py文件 中）

# 写作者序列化的类
class AuthorSerializer(serializers.Serializer):
    nid = serializers.CharField()
    name = serializers.CharField()
    age = serializers.CharField()


class BookSerializer(serializers.Serializer):

　　authors = serializers.SerializerMethodField()

    #方法一
    def get_authors(self, book):
        # 拿出这本书的所有作者
        aus = book.authors.all()
        # 拼出一个列表，列表中套字典 ，每个字典是一个作者
        l1 = []
        for i in aus:
            l1.append({'name': i.name, 'age': i.age})
        return l1

    # 方法二
    def get_authors(self,book):
        aus=book.authors.all()
        # 可以继续用序列化类，来处理
        auth_ser=AuthorSerializer(aus,many=True)
        return auth_ser.data

# class BookSerializer(serializers.ModelSerializer):
#     # 必须写一个内部类，名字叫 Meta
#     class Meta:
#         # 查询Book该表中的所有字段
#         model = Book
#         fields = '__all__'
#         # 重写属性
#     publish = serializers.CharField(source='publish.name')
#     authors = serializers.SerializerMethodField()
#
#     def get_authors(self, book):
#         aus = book.authors.all()
#         # 可以继续用序列化类，来处理
#         auth_ser = AuthorSerializer(aus, many=True)
#         return auth_ser.data




class BookSerializer(serializers.ModelSerializer):
    # 必须写一个内部类，名字叫 Meta
    class Meta:
        # 查询Book该表中的所有字段
        model = Book
        # fields = '__all__'
        # 指定取出的字段
        fields = ['nid', 'authors']


        # 去掉指定的字段
        exclude = ['publish', 'name']
        # 重写属性
        # 指定深度（官方建议小于10，个人建议小于3）
        # depth=1

 

 本质上为了实现前后端分离，而进行json序列化的一个组件形式，极大方便了解析数据的作用
    所有序列化是基于APIView解析器实现的，通过内部的多继承关系方便实现进行数据序列化的实现
二、使用方法