序列化组建

一、什么是序列化组件？

　　 本质上为了实现前后端分离，而进行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解析器实现的，通过内部的多继承关系方便实现进行数据序列化的实现
二、使用方法