drf(序列化器）

一 序列化器组件介绍(Serializer)

1 序列化器组件介绍

序列化组件，又称序列化器，是处理对象和字典的数据格式转换，json的序列化和反序列化，在Request和Response处理了。

'''
1 序列化，序列化器会把模型对象转换成字典，经过response以后变成json字符串
2 反系列化，把客户端发送过来的数据，经过request以后变成字典，序列化器可以把字典转成模型
3 反序列化，完成数据校验功能
'''

2 简单使用

# 在应用下新建一个ser.py文件
1 写一个序列化的类，继承Serializer
2 在类中写序列化的字段，需要序列化哪些字段，就写哪些字段
3 在视图函数中使用，从ser.py中导入类，在把序列化的对象传入
4 序列化的对象.data，是一个字典
5 把字典返回，如果不使用rest_framework提供的Response,就得使用JsongRsponse

记得在settings.py中的应用注册下，注册'rest_framework'

3 序列化的字段类型

重点记住CharField，IntegerField,DateField

注意：serializer不是只能为数据库模型类定义，也可以为非数据库模型类的数据定义。serializer是独立于数据库之外的存在。

常用字段类型：

4 序列化字段选项参数

数据校验，给新增和修改数据，用的

如果字段的校验规则不够，可以写钩子函数（局部和全局），原理和forms组件一样。

除了局部钩子和全局钩子校验数据，还可以用validators=[check_author]，author = serializers.CharField(validators=[check_author]) # validators=[]写的函数内存地址

5 通用参数

read_only 与 write_only

read_only  表明该字段仅用于序列化输出，默认False,如果设置成True,postman中可以看到该字段，修改时，不需要传该字段

write_only 表明该字段仅用于反序列化输入，默认False，如果设置成True,postman看不到该字段，修改时，该字段需要传该字段

6 获取单条数据（get)和修改数据（put）

7 获取多条数据（get)和新增数据(put)

8 删除一条数据（delete)

9 自己封装的Response对象

总结

1 get单条数据和多条数据的区别(序列化），如果序列化一条，不需要写many=True，序列化多条，需要加many=True

在序列化类中，对应模型表，写对应的序列化字段，序列化对象book_ser,book_ser.data是字典，最后通过Response返回序列后的字典

2 修改数据put（反序列化），需要序列化传入BookSerializer(instance=book_obj, data=request.data)，instance是要被修改的对象，data是前端发送过来的修改数据。

序列化对象book_ser要先经过book_ser.is_valid()校验，校验通过字段校验、钩子函数校验以及自定义函数校验validators=[check_author]，校验通过后，

在.save()前 ，面向对象接口思想，要求重写update方法，传入instance和校验通过的数据validated_data

先instance.save(),再返回instance,再book_ser.save(),通过Response返回修改数据情况。

3 新增数据put（反序列化），新增数据传入books_ser = BookSerializer(data=request.data)，反序列化，一样要经过校验，

同上，重写ceatef方法，返回新增对象instance,返回，同上

4 删除delete（），直接操作模型表。

源码

models.py

class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=6, decimal_places=2)
    author = models.CharField(max_length=32)
    publish = models.CharField(max_length=32)

urls.py

from django.contrib import admin
from django.urls import path, re_path, include
from app01 import views

urlpatterns = [
    path('admin/', admin.site.urls),
    # 查询单个
    path('book/<int:pk>/', views.BookView.as_view()),
    # 查询多个
    path('books/', views.BooksViews.as_view()),
    # 模型类序列化器
    path('book1/', views.Books1Views.as_view()),
    # 路由分发
    path('app02/', include('app02.urls'))
]

views.py

from django.shortcuts import render
from rest_framework.views import APIView
from rest_framework.views import Response
from app01 import models
from app01.ser import BookSerializer
from app01.ser import BookModelSerializer
# 自定义返回字段的类
from app01.utils import BackMsg


class BookView(APIView):
    # 通过序列化器获得数据
    def get(self, request, pk):
        # 自定义的封装返回字典类
        back_obj = BackMsg()
        book_obj = models.Book.objects.filter(pk=pk).first()
        # 要序列化谁，就把随传过去
        book_ser = BookSerializer(book_obj)
        # book_ser.data   序列化对象.data就是序列化后的字典
        back_obj.data = book_ser.data
        print(book_ser.data)
        return Response(back_obj.get_msg)

    # 通过序列化器修改数据
    def put(self, request, pk):
        response_dic = {'status': 1000, 'msg': '成功'}
        # 找到需要修改的对象
        book_obj = models.Book.objects.filter(pk=pk).first()
        # 得到一个序列化对象，request.data是前端发过的要修改的数据
        # book_ser = BookSerializer(book_obj, request.data)
        # 标准写法
        print(request.data)
        import json
        print(json.dumps(request.data))  # request.data已是普通字典格式，已经被新的封装处理后的request反序列化
        book_ser = BookSerializer(instance=book_obj, data=request.data)
        # 进行数据验证（类似于form组件的验证）
        if book_ser.is_valid():
            # book_ser.save()只写会报错，用面向对象的继承里的接口，要求子类必须有父类的方法（ABC模块）
            # 所有需要在要在BookSerializer写update()方法，才能写book_ser.save()
            book_ser.save()
            response_dic['data'] = book_ser.data
        else:
            response_dic['status'] = 2000
            response_dic['msg'] = '数据校验失败'
            response_dic['data'] = book_ser.errors
        return Response(response_dic)

    # 删除数据
    def delete(self, request, pk):
        response_dic = {'status': 100, 'msg': '删除成功'}
        models.Book.objects.filter(pk=pk).delete()
        return Response(response_dic)

    # 查多条，也可以用第一个视图，但要做判断，简单点，就用低下这个


class BooksViews(APIView):
    # 获取多条
    def get(self, request):
        response_dic = {'status': 100, 'msg': '成功'}
        books_obj = models.Book.objects.all()
        # 序列化
        books_ser = BookSerializer(books_obj, many=True)  # 序列化多条，如果序列化一条，不需要写many=True
        response_dic['data'] = books_ser.data
        return Response(response_dic)

    # 新增
    def put(self, request):
        response_dic = {'status': 100, 'msg': '成功'}
        books_ser = BookSerializer(data=request.data)  # 用关键字参数形式，如果用位置参数，就给instance传参
        # 校验数据
        if books_ser.is_valid():
            # 新增，需要Book序列化器中写create()方法，才能save
            books_ser.save()
            response_dic['data'] = books_ser.data
        else:
            response_dic['status'] = 200
            response_dic['msg'] = '校验有误'
            response_dic['data'] = books_ser.errors
        return Response(response_dic)

ser.py

from rest_framework import serializers
from rest_framework.exceptions import ValidationError

from app01 import models


def check_author(data):
    if data.startswith('sb'):
        raise ValidationError('作者姓名不能以sb开头')
    else:
        return data


# 需要继承,序列化器组件
class BookSerializer(serializers.Serializer):
    id = serializers.CharField(read_only=True)  # postman可以看到该字段，修改不用传给字段
    name = serializers.CharField()
    price = serializers.CharField()
    author = serializers.CharField(validators=[check_author])  # validators=[]写的函数内存地址
    publish = serializers.CharField()

    # 局部钩子，对序列化器字段进行校验,钩子函数要记得返回数据(类似于form组件中，clean_字段名，局部钩子函数）
    def validate_price(self, data):  # validate_字段名，接受一个参数
        # 假设价格小于10，校验不通过
        print(type(data), data)  # 字符串
        if float(data) > 10:
            return data
        else:
            # forms组件是self.add_error()
            raise ValidationError('价格太低')

    # 全局钩子，对序列化器字段进行校验,钩子函数，记得要返回数据（类似于form组件中，clean全局钩子函数）
    def validate(self, validate_data):
        print(validate_data)
        author = validate_data.get('author')
        publish = validate_data.get('publish')
        if author == publish:
            raise ValidationError('作者名和出版社名不能一样')
        else:
            return validate_data

    # 修改数据
    def update(self, instance, validated_data):
        # instance是book对象
        # validated_data是校验后的数据，是字典，类似于forms组件中的cleaned_data
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.author = validated_data.get('author')
        instance.publish = validated_data.get('publish')
        instance.save()  # 就是book_obj保存，ORM提供的
        return instance

    # 新增数据
    def create(self, validated_data):
        # **validated_data，把字典打散成关键字参数的形式
        # book_obj = models.Book(**validated_data)
        # book_obj.save()
        # return book_obj
        # 第二种创建方式
        instance = models.Book.objects.create(**validated_data)
        return instance

utils.py 自定义封装返回字典对象

class BackMsg(object):
    def __init__(self):
        self.status = 100
        self.msg = '成功'

    @property
    def get_msg(self):
        return self.__dict__

10 源码分析

序列化多条，为什么需要many=True

'''
元类的思想
对象的生成--->先调用类的__new__方法，生成空对象
类的实例化，触发类的__init__方法
类的__new__方法控制对象的生成
'''
book_ser = BookSerializer(book_obj)
books_ser = BookSerializer(books_obj, many=True)
book_ser是<class 'rest-framework.serializors.ListSerializor'>
books_ser是<class 'app01.ser.BookModelSerializor'>

# 同一个类，为什么生成了两个不同的对象
    def __new__(cls, *args, **kwargs):
        if kwargs.pop('many', False):
            return cls.many_init(*args, **kwargs)
        # 没有写many=True，就下面，正常的对象实例化
        return super().__new__(cls, *args, **kwargs)
    
    @classmethod
    def many_init(cls, *args, **kwargs):
        meta = getattr(cls, 'Meta', None)
        list_serializer_class = getattr(meta, 'list_serializer_class', ListSerializer)
        # list_serializer_class多个序列化对象的一个列表
        return list_serializer_class(*args, **list_kwargs)        

接口：统一子类的行为，怎么统一，要么用ABC模块，要么就抛出异常

（save()方法，重写update和create方法，是用的抛出异常的方法）

鸭子类型，是反过来的，子类的行为一样，就叫鸭子类型

二 模型类序列化器(ModelSerializer)

如果我们想要使用序列化器对应的是Django的模型类，DRF为我们提供了ModelSerializer模型类序列化器来帮助我们快速创建一个Serializer类。

ModelSerializer与常规的Serializer相同，但提供了：

• 基于模型类自动生成一系列字段

• 基于模型类自动为Serializer生成validators，比如unique_together

• 包含默认的create()和update()的实现

# 其他使用一模一样
# 不需要重写create和update方法了

views.py

# 模型类序列化器
class Books1Views(APIView):
    def get(self, request):
        back_dic = BackMsg()
        books_obj = models.Book.objects.all()
        books_ser = BookModelSerializer(books_obj, many=True)
        back_dic.data = books_ser.data
        return Response(back_dic.get_msg)

ser.py

# 模型类序列化器
# 要用局部钩子和全局钩子校验，validate_字段名和validate和class Meta同级，不要写到内部了
class BookModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Book  # 对应上models.py中的模型
        fields = '__all__'  # 对所有的字段进行序列化
        # fields = ('name', 'price')  # 序列化指定的字段
        # exclude = ('name',)  # 排除谁
        read_only_fields = ('id',)  # 不能单独使用，要和上面的结合用
        # write_only_fields = ('author', 'id')  # 不能单独使用，要和上面的结合用
        # 添加额外参数
        extra_kwargs = {
            'price': {'write_only': True}
        }

三 Serializer高级用法

多表的序列化和反序列化

复习了一下路由分发

# source的用法
1 可以该字段名字
price = serializers.CharField(write_only=True, required=True, source='price11')
2 可以跨表查询（一对多）
publish = serializers.CharField(source='publish.address')
3 可以执行模型表中的方法
title = serializers.CharField(max_length=16, min_length=4, source='test')    # test是模型表Book的方法

# SerializerMethodField()的使用（多对多关系）
# 需要有个配套方法，方法名叫get_字段名，返回一个列表

models.py

from django.db import models


class Book(models.Model):
    title = models.CharField(max_length=64)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    # pub_date = models.DateField(auto_now_add=True)
    publish = models.ForeignKey(to='Publish', null=True,
                                on_delete=models.CASCADE
                                )
    authors = models.ManyToManyField(to='Author')

    def __str__(self):
        return self.title

    def test(self):
        return '今天好开心'


class Publish(models.Model):
    name = models.CharField(max_length=64)
    address = models.CharField(max_length=64)
    email = models.EmailField()

    class Meta:
        verbose_name = '出版社'

    def __str__(self):
        return self.name


class Author(models.Model):
    name = models.CharField(max_length=64)
    age = models.IntegerField()
    author_detail = models.OneToOneField(to='AuthorDetail', null=True,
                                         on_delete=models.CASCADE
                                         )

    def __str__(self):
        return self.name


class AuthorDetail(models.Model):
    mobile = models.CharField(max_length=11)

    class Meta:
        verbose_name = '作者详情'

    def __str__(self):
        return '%s的详情' % self.author.name

views.py

from django.shortcuts import render
from rest_framework.views import APIView
from rest_framework.response import Response
from app02 import models
from app02.ser import BookSerializer
from app02.utils import BackMsg


# Create your views here.
class App02BookView(APIView):
    # 通过序列化器获得数据
    def get(self, request, pk):
        # 自定义的返回字典类
        back_obj = BackMsg()
        book_obj = models.Book.objects.filter(pk=pk).first()
        print(book_obj)
        # 要序列化谁，就把随传过去
        book_ser = BookSerializer(book_obj)
        # book_ser.data   序列化对象.data就是序列化后的字典
        back_obj.data = book_ser.data
        print(book_ser.data)
        return Response(back_obj.get_msg)

ser.py

'''
@作者：xiaobao
@联系方式：[email protected]
'''
from rest_framework import serializers


# 需要继承,序列化器组件
class BookSerializer(serializers.Serializer):
    id = serializers.CharField(read_only=True)  # postman可以看到该字段，修改不用传给字段
    title = serializers.CharField(max_length=16, min_length=4, source='test')
    # source='test'，"title": "今天好开心", test是book模型表的函数，可以固定返回数据
    price = serializers.CharField(write_only=True, required=True, source='price11')
    # authors = serializers.CharField()  # validators=[]写的函数内存地址
    # "authors": "app02.Author.None"，多对多，跨表查询，需要用其他方法
    authors = serializers.SerializerMethodField()
    # 需要有个配套方法，方法名叫get_字段名，返回一个列表
    publish = serializers.CharField(source='publish.address')

    # "publish": "渝中区",和orm的子查询一样，一对多的关系
    def get_authors(self, instance):
        # 这里的instance，就是视图类中的book_obj
        query_authors = instance.authors.all()  # 基于子对象查询，正向按字段名，多个加.all()
        l = []
        for author_obj in query_authors:
            l.append({'name': author_obj.name, 'age': author_obj.age, 'addr': author_obj.author_detail.mobile})
            # 用的方法和orm一样
        return l