entity framework 调用 oracle 序列_DRF（序列化器）

内容

• 定义序列化器
• 创建Serializer对象
• 序列化器的使用
• 序列化
• 反序列化
• 验证的三种方式
• 数据保存
• 附加参数
• 模型序列化器

知乎视频​www.zhihu.com

知乎视频​www.zhihu.com

restful就是一个接口开发的约定俗成的开发规范。不局限于django或者drf，即便我们不使用drf，其实也能实现符合restful规范的api接口。

同时，drf框架不是restful作者开发出来的！！！

7. 序列化器-Serializer

作用：

1. 序列化,序列化器会把模型对象转换成字典,将来提供给视图经过response以后变成json字符串
2. 反序列化,把客户端发送过来的数据,经过视图调用request以后变成python字典,序列化器可以把字典转成模型
3. 反序列化,完成数据校验功能和操作数据库

7.1 定义序列化器

Django REST framework中的Serializer使用类来定义，须继承自rest_framework.serializers.Serializer。

接下来，为了方便演示序列化器的使用，我们另外创建一个新的子应用sers

python manage.py startapp sers

先注册子应用到项目中，settings.py，代码：

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    'rest_framework', # 把drf框架注册到django项目中

    'students', # 注册子应用
    'sers',
]

因为我们已有了一个数据库模型类students/Student，我们直接在接下来的演示中使用这个模型。

class Student(models.Model):
    # 模型字段
    name = models.CharField(max_length=100,verbose_name="姓名")
    sex = models.BooleanField(default=1,verbose_name="性别")
    age = models.IntegerField(verbose_name="年龄")
    class_number = models.CharField(max_length=5,verbose_name="班级编号")
    description = models.TextField(max_length=1000,verbose_name="个性签名")

    class Meta:
        db_table="tb_student"
        verbose_name = "学生"
        verbose_name_plural = verbose_name

我们想为这个模型类提供一个序列化器，可以命名为StudentSerializer，

我们都会把序列化器代码保存到当前子应用下的serializers.py模块中，

可以定义如下：

from rest_framework import serializers

# 声明序列化器，所有的序列化器都要直接或者间接继承于 Serializer
# 其中，ModelSerializer是Serializer的子类，ModelSerializer在Serializer的基础上进行了代码简化
class StudentSerializer(serializers.Serializer):
    """学生信息序列化器"""
    # 1. 需要进行数据转换的字段
    id = serializers.IntegerField()
    name = serializers.CharField()
    age = serializers.IntegerField()
    sex = serializers.BooleanField()
    description = serializers.CharField()

    # 2. 如果序列化器集成的是ModelSerializer，则需要声明调用的模型信息

    # 3. 验证代码

    # 4. 编写添加和更新模型的代码

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

常用字段类型：

选项参数：

通用参数：

7.2 创建Serializer对象

定义好Serializer类后，就可以创建Serializer对象了。

Serializer的构造方法为：

Serializer(instance=None, data=empty, **kwarg)

说明：

1）用于序列化时，将模型类对象传入instance参数

2）用于反序列化时，将要被反序列化的数据传入data参数

3）除了instance和data参数外，在构造Serializer对象时，还可通过context参数额外添加数据，如

serializer = StudentSerializer(student, context={'request': request},many=False)

通过context参数附加的数据，可以通过Serializer对象的self.context属性获取。

1. 使用序列化器的时候一定要注意，序列化器声明了以后，不会自动执行，需要我们在视图中进行调用才可以。
2. 序列化器无法直接接收客户端的请求数据，需要我们在视图中创建序列化器对象时把使用的数据传递过来。
3. 序列化器的字段声明类似于我们前面使用过的表单系统。
4. 开发restful api时，序列化器会帮我们把模型数据转换成字典.
5. drf提供的视图会帮我们把字典转换成json,或者把客户端发送过来的数据转换字典.

7.3 序列化器的使用

序列化器的使用分两个阶段：

1. 在客户端请求时，使用序列化器可以完成对数据的反序列化。
2. 在服务器响应时，使用序列化器可以完成对数据的序列化。

7.3.1 序列化

7.3.1.1 基本使用

1） 先查询出一个学生对象

视图中获取模型对象，代码：

from students.models import Student

student = Student.objects.get(pk=3)

2） 构造序列化器对象

from .serializers import StudentSerializer

serializer = StudentSerializer(instance=student)

3）获取序列化数据

通过data属性可以获取序列化后的数据

serializer.data
# {'id': 4, 'name': '小张', 'age': 18, 'sex': True, 'description': '猴赛雷'}

完整视图代码：

class Student2APIView(View):
    def get(self,request):
        """返回一个学生信息"""
        # 读取模型对象
        student = Student.objects.get(pk=1)
        # 实例化序列化器
        serializer = StudentSerializer(instance=student)
        print( serializer.data )
        """打印效果：
        {'id': 1, 'name': '张三', 'sex': True, 'age': 18}
        """
        return JsonResponse(serializer.data)

4）完整的serializer.py

from rest_framework import serializers


class StudentSerializer(serializers.Serializer):
    #　学生信息序列化器
    # 1.字段声明
    # 格式：
    # 字段名=serializers.数据类型（字段选项）
    # 注意：
    # １．把需要提供给客户端的字段才写进来，或者需要客户端提供的字段才写进来
    # ２．＝号左面的字段一定要和模型里面的字段对应
    # 3.　字段也可以不是先定义的，也可以是模型声明的属性方法
    # 4. 主要用在反序列化阶段验证数据
    id = serializers.IntegerField()
    name = serializers.CharField()
    age = serializers.IntegerField()
    sex = serializers.BooleanField()
    description = serializers.CharField() # TextField是数据才有的，前段没有这种说法
    # 2.如果使用的是模型类序列起，则需要继续的模型信息

    # 3.验证数据的相关代码
    # 3.1 validate(data) 验证所有字段，data则是客户端提交的数据，在实例化序列化器对
          象时的第二参数
    # 3.2 validate_字段(data) 验证指定字段，data则表示来自客户端数据的指定字段值

    # 4.保存数据到kd= id=数据库中的代码

4）如果要被序列化的是包含多条数据的查询集QuerySet，可以通过添加many=True参数补充说明

# Create your views here.

from django.views import View
from django.http.response import JsonResponse
from .serializers import StudentSerializer
from students.models import Student


class StudentsView(View):
    def get1(self, request):
        """序列化器的声明和使用"""

        # 0. 从数据库中查询模型对象
        student = Student.objects.get(pk=1)
        print(student)
        # 1. 实例化序列化器对象
        # 参数:
        # 1） instance 模型对象, 一般来自于ORM
        # 2)  data     字典数据, 一般来自客户端
        # 3） context  字典, 可以把视图中的信息传参给序列化器[context 执行上下文]
        # 4)  many     布尔值，如果instance是多个对象，则必须声明many=True，否则序列化器会报错

        serializer = StudentSerializer(instance=student)

        print(serializer.data)  # 转换后的字典数据

        return JsonResponse(serializer.data)

    def get2(self, request):
        """序列化单个数据"""
        # 1. 接受客户端的请求
        pk = request.GET.get("pk")
        print(pk)
        # 2. 操作数据
        student = Student.objects.get(pk=pk)

        # 3. 实例化序列化器对象
        serializer = StudentSerializer(instance=student)

        # 4. 返回结果
        return JsonResponse(serializer.data)

    def get(self, request):
        """序列化多个数据"""
        # 1. 操作数据
        student_list = Student.objects.all()

        # 2. 实例化序列化器对象
        # many=True的作用，就是告诉序列化器内部，当前instance的值是一个列表，所以需要循环
        serializer = StudentSerializer(instance=student_list, many=True)
        # 3. 返回结果
        # 通过data属性获取序列化器转换数据后的结果
        print(serializer.data)
        """打印效果
        [
            OrderedDict([('id', 1), ('name', '小明'), ('age', 17), ('sex', True), ('text', 100)]), 
            OrderedDict([('id', 2), ('name', '小明'), ('age', 17), ('sex', True), ('text', 100)]), 
            OrderedDict([('id', 3), ('name', '小明'), ('age', 17), ('sex', True), ('text', 100)]), 
            OrderedDict([('id', 4), ('name', '小明'), ('age', 17), ('sex', True), ('text', 100)]), 
            OrderedDict([('id', 5), ('name', '小明'), ('age', 17), ('sex', True), ('text', 100)]), 
            ....
        ]

        OrderedDict 是python的高级数据类型，叫有序字典
        from collections import OrderedDict
        因为python内置的基础类型的字典是无序的，所以这种无序字典无法不保证存储时的键值对顺序和提取时候的顺序一致
        有序字典和无序字典，除了声明不一样以外，对于成员的读取和操作是一样的。

        for item in serializer.data:
            # 获取有序字典的键值对
            print(item["name"])
        """

        # JsonResponse 只是支持返回字典，对于复杂的列表数据，需要设置参数safe=False
        return JsonResponse(serializer.data, safe=False)

步骤：
1.接受客户端的请求 pk = request.GET.get("pk")
2.操作数据(数据库查询) student = Student.objects.get(pk=pk)
3.实例化序列化器对象 serializer = StudentSerializer(instance=student)
4.返回结果 return JsonResponse(serializer.data)

7.3.2 反序列化

7.3.2.1 数据验证

开发中，用户的数据都是不可信任的。

使用序列化器进行反序列化时，需要对数据进行验证后，才能获取验证成功的数据或保存成模型类对象。

在获取反序列化的客户端数据前，必须在视图中调用序列化对象的is_valid()方法，序列化器内部是在is_valid方法内部调用验证选项和验证方法进行验证，验证成功返回True，否则返回False。

验证失败，可以通过序列化器对象的errors属性获取错误信息，返回字典，包含了字段和字段的错误提示。如果是非字段错误，可以通过修改REST framework配置中的NON_FIELD_ERRORS_KEY来控制错误字典中的键名。

验证成功，可以通过序列化器对象的validated_data属性获取数据。

在定义序列化器时，指明每个字段的序列化类型和选项参数，本身就是一种验证行为。

为了方便演示，我们这里采用另一个图书模型来完成反序列化的学习。当然也创建一个新的子应用unsers。

python manage.py startapp unsers

注册子应用，setting.py注册子应用，代码：

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    'rest_framework', # 把drf框架注册到django项目中

    'students', # 注册子应用
    'sers',     # 演示序列化
    'unsers',     # 演示反序列化
]

注意：

接下来的内容涉及到postman post提交数据，所以在此时我们没有学习到drf视图方法时，我们把settings.py中的中间件的csrf关闭.

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

模型代码：

from django.db import models

# Create your models here.
class BookInfo(models.Model):
    """图书信息"""
    title = models.CharField(max_length=20, verbose_name='标题')
    pub_date = models.DateField(verbose_name='发布日期')
    # upload_to="avatar" 设置存储文件的子目录为avatar，总目录在settings中配置，不填写没有
    image = models.ImageField(upload_to="avatar",verbose_name='图书封面')
    price = models.DecimalField(max_digits=8, decimal_places=2, verbose_name="价格")
    read = models.IntegerField(verbose_name='阅读量')
    comment = models.IntegerField(verbose_name='评论量')
    class Meta:
        # db_table = "表名"
        db_table = "tb_book_info"
        verbose_name = "图书"
        verbose_name_plural = verbose_name

注意：因为当前模型中， 设置到图片上传处理，所以我们需要安装PIL库

pip install Pillow

数据迁移

python manage.py makemigrations
python manage.py migrate

经过上面的准备工作，我们接下来就可以给图书信息增加图书的功能，那么我们需要对来自客户端的数据进行处理，例如，验证和保存到数据库中，此时，我们就可以使用序列化器的反序列化器，接下来，我们就可以参考之前定义学生信息的序列化器那样，定义一个图书的序列化器，当然，不同的是，接下来的序列化器主要用于反序列化器阶段，在unsers子应用，创建serializers.py，代码如下：

from rest_framework import serializers

class BookInfoSerializer(serializers.Serializer):
    # 这里声明的字段用于进行反序列化器
    # 字段名 = serializers.字段类型(验证选项)
    title = serializers.CharField(max_length=20, label="标题", help_text="标题")
    # required=True 当前字段必填
    pub_date = serializers.DateField(required=True,label="发布日期", help_text="发布日期")
    image = serializers.ImageField(max_length=3*1024*1024, label="图书封面", help_text="图书封面")
    price = serializers.DecimalField(max_digits=8, decimal_places=2, required=True, label="价格", help_text="价格")
    read  = serializers.IntegerField(min_value=0, default=0, label="阅读量", help_text="阅读量")
    comment = serializers.IntegerField(min_value=0, default=0, label="评论量", help_text="评论量")

    # 关于继承数据库选项

    # 验证部分的代码

    # 数据库

通过构造序列化器对象，并将要反序列化的数据传递给data构造参数，进而进行验证，view.py

# Create your views here.
from django.views import View
from django.http.response import HttpResponse
from .serializers import BookInfoSerializer
class BookInfoView(View):
    def get(self,request):
        """模拟客户端发送过来的数据"""
        data = {
            "title":"西厢记",
            "pub_date":"1980-10-10",
            "price": 19.80,
            "read": 100,
            "comment": -1,
        }

        # 对上面的数据进行反序列化器处理
        # 1. 初始化，填写data属性
        serializer = BookInfoSerializer(data=data)
        # 2. 调用序列化器提供的is_valid方法进行验证
        # raise_exception=True 表示终断程序，直接抛出错误
        ret = serializer.is_valid(raise_exception=True)
        print(ret) # is_valid的方法值就是验证结果，只会是True/False
        if ret:
            # 3.1 验证通过后，可以通过validated_data得到数据
            print("验证成功，ret=%s" % ret)
            print(serializer.validated_data)  # 验证处理后的数据
            """打印结果：
            OrderedDict([('title', '西厢记'), ('pub_date', datetime.date(1980, 10, 10)), ('price', Decimal('19.80')), ('read', 100), ('comment', 15)])
            """
        else:
            print("验证失败，ret=%s" % ret)
            # 3.1 验证没通过，可以通过
            print( serializer.errors )
            """打印结果：
            {'comment': [ErrorDetail(string='Ensure this value is greater than or equal to 0.', code='min_value')]}
            """
        return HttpResponse("ok")

is_valid()方法还可以在验证失败时抛出异常serializers.ValidationError，可以通过传递raise_exception=True参数开启，REST framework接收到此异常，会向前端返回HTTP 400 Bad Request响应。

# Return a 400 response if the data was invalid.
serializer.is_valid(raise_exception=True)

如果觉得这些还不够，需要再补充定义验证行为，可以使用以下三种方法：

1) validate_字段名

单个字段的验证，方法名必须： validate_<字段名>(self,data), data 就是当前字段中客户端提交的数据
最后返回data

对<field_name>字段进行验证，如

class BookInfoSerializer(serializers.Serializer):
    """图书数据序列化器"""
    ...

    # 单个字段的验证，方法名必须： validate_<字段名>(self,data)    # data 就是当前字段中客户端提交的数据
    # validate_price 会被is_valid调用
    def validate_price(self, data):
        """"""
        if data < 0:
            raise serializers.ValidationError("对不起，价格不能低于0元")
        # 验证通过以后，必须要返回验证的结果数据，否则序列化器的validated_data无法得到当前字段的结果
        return data

把前面的例子的price改为-19.80，运行就可以测试了。

2) validate

多个字段的验证，必须方法名叫 "validate", data 表示客户端发送过来的所有数据，字典格式
最后return data

在序列化器中需要同时对多个字段进行比较验证时，可以定义validate方法来验证，如

class BookInfoSerializer(serializers.Serializer):
    """图书数据序列化器"""

    # 多个字段的验证，必须方法名叫 "validate"
    # data 表示客户端发送过来的所有数据，字典格式
    def validate(self, data):
        # 判断图书的阅读量不能低于评论量
        read = data.get("read")
        comment = data.get("comment")
        if read < comment:
            raise serializers.ValidationError("对不起，阅读量不能低于评论量")

        return data

运行之前的例子，把read改为1，comment改为100，访问测试。

3) validators验证器

外部定义def about_django(data): 在里面写上判断逻辑代码，最后也要返回data
在字段控制括号里面写validators=[about_django]

验证器类似于验证方法，但是验证方法只属于当前序列化器，如果有多个序列化器共用同样的验证功能，则可以把验证代码分离到序列化器外部，作为一个普通函数，由validators加载到序列化器中使用。

在字段中添加validators选项参数，也可以补充验证行为，如

from rest_framework import serializers

# 可以把验证函数进行多次使用，提供不用的字段或者不同的序列化器里面使用
def about_django(data):
    if "django" in data:
        raise serializers.ValidationError("对不起，图书标题不能出现关键字django")
    # 返回验证以后的数据
    return data

class BookInfoSerializer(serializers.Serializer):
    # 这里声明的字段用于进行反序列化器
    # 字段名 = serializers.字段类型(验证选项)
    title = serializers.CharField(max_length=20,validators=[about_django], label="标题", help_text="标题")
    # required=True 当前字段必填
    pub_date = serializers.DateField(required=True, label="发布日期", help_text="发布日期")
    # max_length 文件的大小
    # allow_null=True 允许传递的image数据为None
    image = serializers.ImageField(required=False, allow_null=True, max_length=3*1024*1024, label="图书封面", help_text="图书封面")
    price = serializers.DecimalField(max_digits=8, decimal_places=2, required=True, label="价格", help_text="价格")
    # min_value 数值大小
    # default 设置默认值
    read  = serializers.IntegerField(min_value=0, default=0, label="阅读量", help_text="阅读量")
    comment = serializers.IntegerField(min_value=0, default=0, label="评论量", help_text="评论量")

把前面的例子修改成title=“西厢记django版本”，然后运行测试

视图代码：

# Create your views here.
from django.views import View
from django.http.response import HttpResponse
from .serializers import BookInfoSerializer
class BookInfoView(View):
    def get(self,request):
        """模拟客户端发送过来的数据"""
        data = {
            "title":"西厢记django版本",
            "pub_date":"1980-10-10",
            "price": 19.80,
            "read": 10000,
            "comment": 100,
        }

        # 对上面的数据进行反序列化器处理
        # 1. 初始化，填写data属性
        serializer = BookInfoSerializer(data=data)
        # 2. 调用序列化器提供的is_valid方法进行验证
        # raise_exception=True 表示终断程序，直接抛出错误
        ret = serializer.is_valid(raise_exception=True)
        print(ret) # is_valid的方法值就是验证结果，只会是True/False
        if ret:
            # 3.1 验证通过后，可以通过validated_data得到数据
            print("验证成功，ret=%s" % ret)
            print(serializer.validated_data)  # 验证处理后的数据
            """打印结果：
            OrderedDict([('title', '西厢记'), ('pub_date', datetime.date(1980, 10, 10)), ('price', Decimal('19.80')), ('read', 100), ('comment', 15)])
            """
        else:
            print("验证失败，ret=%s" % ret)
            # 3.1 验证没通过，可以通过
            print( serializer.errors )
            """打印结果：
            {'comment': [ErrorDetail(string='Ensure this value is greater than or equal to 0.', code='min_value')]}
            """
        return HttpResponse("ok")
is_valid实际上内部执行(循环三个方法)了三种不同的验证方式：
1. 先执行了字段内置的验证选项
2. 在执行了validators自定义选项
3. 最后执行了validate自定义验证方法[包含了validate_<字段>, validate]

7.3.2.2 数据保存

通过序列化器来完成数据的更新或者添加，把视图中对于模型中的操作代码移出视图中，放入到序列化器。

前面的验证数据成功后,我们可以使用序列化器来完成数据反序列化的过程.这个过程可以把数据转成模型类对象.

可以通过实现create()和update()两个方法来实现。

1.在序列化类文件中先声明create和update
2.create中自带一个validated_data一个被验证过的数据（字典），用数据库创建新的数据
3.update中带两个参数，instance要修改的原数据，validated_data被验证过的新数据， 直接用instance.字段名=validated_data.get('字段名')来重置。
4.接收并实例化序列化器对象serializer = BookInfoSerializer(data=request.POST)， 如果是更新再加上instance参数
5.验证serializer.is_valid(raise_exception=True)
6.返回数据
serializer = BookInfoSerializer(instance=instance)
return JsonResponse(serializer.data)

from rest_framework import serializers

# 可以把验证函数进行多次使用，提供不用的字段或者不同的序列化器里面使用
def about_django(data):
    if "django" in data:
        raise serializers.ValidationError("对不起，图书标题不能出现关键字django")
    # 返回验证以后的数据
    return data

class BookInfoSerializer(serializers.Serializer):
    # 这里声明的字段用于进行反序列化器
    # 字段名 = serializers.字段类型(验证选项)
    title = serializers.CharField(max_length=20,validators=[about_django], label="标题", help_text="标题")
    # required=True 当前字段必填
    pub_date = serializers.DateField(required=True, label="发布日期", help_text="发布日期")
    # max_length 文件的大小
    # allow_null=True 允许传递的image数据为None
    image = serializers.ImageField(required=False, allow_null=True, max_length=3*1024*1024, label="图书封面", help_text="图书封面")
    price = serializers.DecimalField(max_digits=8, decimal_places=2, required=True, label="价格", help_text="价格")
    # min_value 数值大小
    # default 设置默认值
    read  = serializers.IntegerField(min_value=0, default=0, label="阅读量", help_text="阅读量")
    comment = serializers.IntegerField(min_value=0, default=0, label="评论量", help_text="评论量")

    # 关于继承数据库选项

    # 自定义验证的代码
    # 单个字段的验证，方法名必须： validate_<字段名>(self,data)    # data 就是当前字段中客户端提交的数据
    # validate_price 会被is_valid调用
    def validate_price(self, data):
        """"""
        if data < 0:
            raise serializers.ValidationError("对不起，价格不能低于0元")
        # 验证通过以后，必须要返回验证的结果数据，否则序列化器的validated_data无法得到当前字段的结果
        return data

    # 多个字段的验证，必须方法名叫 "validate"
    # data 表示客户端发送过来的所有数据，字典格式
    def validate(self, data):
        # 判断图书的阅读量不能低于评论量
        read = data.get("read")
        comment = data.get("comment")
        if read < comment:
            raise serializers.ValidationError("对不起，阅读量不能低于评论量")

        return data

    # 数据库操作
    # 这里会在调用时，由序列化器补充验证成功以后的数据进来
    def create(self, validated_data): 
        """完成添加操作"""
        print(validated_data) # 字典
        # 导入模型
        from .models import BookInfo
        # 添加数据
        book = BookInfo.objects.create(
            title=validated_data.get("title"),
            price=validated_data.get("price"),
            pub_date=validated_data.get("pub_date"),
            read=validated_data.get("read"),
            comment=validated_data.get("comment"),
        )

        return book

    # instance就是要修改的模型，系统会自动从对象初始化时的instance提取过来
    # validated_data 就是经过验证以后的客户端提交的数据
    def update(self, instance, validated_data):
        """更新操作"""
        num = validated_data.get("num")
        print(num)
        instance.title = validated_data.get('title')
        instance.pub_date = validated_data.get('pub_date')
        instance.comment = validated_data.get('comment')
        instance.price = validated_data.get('price')
        instance.read = validated_data.get('read')
        # ORM提供的数据保存方法
        instance.save()

        return instance

视图代码（get）：

# Create your views here.
from django.views import View
from django.http.response import HttpResponse
from .serializers import BookInfoSerializer
class BookInfoView(View):
    # ...
    def get(self,request):
        """保存数据[更新]"""
        # 客户端提交数据过来
        id = 2
        data = { # 模拟客户端发送过来的数据
            "title": "东游记",
            "pub_date": "1998-10-01",
            "price": 19.98,
            "read": 330,
            "comment": 100,
        }
        from .models import BookInfo
        book = BookInfo.objects.get(pk=id)

        # 使用序列化器验证数据[如果是更新操作，需要传入2个参数，分别是instance和data]
        serializer = BookInfoSerializer(instance=book,data=data)
        serializer.is_valid()
        book = serializer.save() # 此时，我们必须在序列化器中预先声明update方法
        """
        serailzier对象调用的save方法是什么？怎么做到自动调用update和create?
        1. 这里的save不是数据库ORM模型对象的save，是BaseSerializer定义的。
        2. save方法中根据实例化serializer时是否传入instance参数来判断执行update还是create的
           当传入instance时，则instance.save调用的就是update方法
           没有传入instance，则instance.save调用的就是create方法
        3. serializer.save使用前提是必须在序列化器中声明create或者update方法，否则报错！！！
        """
        print(book)
        """打印结果：
        BookInfo object (2)
        """
        return HttpResponse("ok")

视图代码（post， put）

# Create your views here.
from django.views import View
from .models import BookInfo
from django.http.response import JsonResponse
from .serializers import BookInfoSerializer
class BookInfoView(View):
    def post(self,request):
        """反序列化,验证和添加数据"""
        # 接收并实例化序列化器对象
        serializer = BookInfoSerializer(data=request.POST)
        # 启动验证
        # is_valid 有个可选参数raise_exception，用于显示序列化器抛出的异常，直接终止视图代码的执行
        # 如果设置了raise_exception=True,则下面的18~21行代码，就不要开发者自己编写，系统会自动根据请求的方式自动返回错误给客户端。
        # 如果是ajax请求，则自动返回json格式的错误信息，
        # 如果是表单请求，则自动返回html格式的错误信息
        result = serializer.is_valid(raise_exception=True)
        print(result) # 验证结果，True表示验证通过了，开发时一般不需要接收
        if not result:
            # 当验证失败，则错误信息属性就有内容
            print(serializer.errors)
            return JsonResponse(serializer.errors)
        else:
            # 获取验证完成后的客户端数据 如果验证失败，则vcalidated_data是空字典
            print(serializer.validated_data)

            # 把数据保存到数据库中
            # instance = BookInfo.objects.create(**serializer.validated_data)
            # instance = serializer.create(serializer.validated_data)
            # 序列化器实例化时，如果有save参数，则save相当于update，否则就是create
            instance = serializer.save()
            # 返回结果，也是需要使用序列化进行转换的
            serializer = BookInfoSerializer(instance=instance)

            return JsonResponse(serializer.data)

    def put(self,request):
        """修改操作"""
        # 查询要修改的模型对象
        pk = request.GET.get("pk")
        try:
            instance = BookInfo.objects.get(pk=pk)
        except BookInfo.DoesNotExist:
            return JsonResponse("对不起，当前图书不存在！")

        # 接受客户端修改的数据
        data = request.body
        # 针对django接受ajax的json数据，我们应该进行json序列化处理
        import json
        data = json.loads(data.decode())

        # 使用序列化器验证数据
        serialzier = BookInfoSerializer(instance=instance, data=data)
        serialzier.is_valid(raise_exception=True)

        # 使用序列化器更新数据
        # instance = serialzier.update(instance=instance, validated_data=serialzier.validated_data)
        # 序列化器提供的自动调用create和update方法
        instance = serialzier.save(num=200)

        # 返回结果
        serialzier = BookInfoSerializer(instance=instance)
        return JsonResponse(serialzier.data)

在序列化器实现了create和update两个方法后，在反序列化数据的时候，就可以通过save()方法返回一个数据对象实例了

book = serializer.save()

如果创建序列化器对象的时候，没有传递instance实例，则调用save()方法的时候，create()被调用，相反，如果传递了instance实例，则调用save()方法的时候，update()被调用。

serailzier对象调用的save方法是什么？怎么做到自动调用update和create?
1. 这里的save不是数据库ORM模型对象的save，是BaseSerializer定义的。
2. save方法中根据实例化serializer时是否传入instance参数来判断执行update还是create的
当传入instance时，则instance.save调用的就是update方法
没有传入instance，则instance.save调用的就是create方法
3. serializer.save使用前提是必须在序列化器中声明create或者update方法，否则报错！！！

BaseSerializer中定义的save方法源码：

总路由：urls.py

from django.contrib import admin
from django.urls import path, include

# 新版本的django把url拆分成了两个路由函数
# django.urls.path 专门编写字符串路由
# django.urls.re_path 专门编写正则路由

urlpatterns = [
    path('admin/', admin.site.urls),
    path('students/', include("students.urls")),
    path('sers/', include("sers.urls")),
    path("unsers/", include("unsers.urls")),
]

子应用路由：urls.py

from django.urls import path
from . import views


urlpatterns = [
    path("books/", views.BookInfoView.as_view())
]

7.3.2.3 附加参数说明

1） 在对序列化器进行save()保存时，可以额外传递数据，这些数据可以在create()和update()中的validated_data参数获取到

# 可以传递任意参数到数据保存方法中
# 例如：request.user 是django中记录当前登录用户的模型对象
serializer.save(owner=request.user)

2）默认序列化器必须传递所有必填字段[required=True]，否则会抛出验证异常。但是我们可以使用partial参数来允许部分字段更新

# Update `BookInfo` with partial data
# partial=True 设置序列化器只是针对客户端提交的字段进行验证，没有提交的字段，
# 即便有验证选项或方法也不进行验证。
serializer = BookInfoSerializer(book, data=data, partial=True)

7. 序列化器-Serializer

序列化和反序列化就是一个概念，表示转换数据的2个不同的场景而已。 序列化主要表示我们把当前数据转换成别人需要的数据，反序列化表示把别人提供的数据转换成我们需要的。 而drf框架中提供的序列化器只是为了让我们把这两部分代码分离出来而已。 所以，即便没有drf框架，我们使用python的json模块也可以理解它有序列化和反序列化的阶段。
那么data就用于保存提供给客户端的数据，而validated_data就是用于保存提供给数据库的数据了。 data和validated_data的值都是字典。

7.3.3 模型类序列化器

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

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

• 基于模型类自动生成一系列序列化器字段[基于模型自动生成序列化器的字段声明]
• 基于模型类自动为Serializer生成validators，比如unique_together
• 包含默认的create()和update()的实现

7.3.3.1 定义

比如我们创建一个BookInfoSerializer

class BookInfoSerializer(serializers.ModelSerializer):
    """图书数据序列化器"""
    class Meta:
        model = BookInfo
        fields = '__all__'

• model 指明参照哪个模型类
• fields 指明为模型类的哪些字段生成

我们可以在python manage.py shell中查看自动生成的BookInfoSerializer的具体实现

>>> from booktest.serializers import BookInfoSerializer
>>> serializer = BookInfoSerializer()
>>> serializer
BookInfoSerializer():
    id = IntegerField(label='ID', read_only=True)
    btitle = CharField(label='名称', max_length=20)
    bpub_date = DateField(allow_null=True, label='发布日期', required=False)
    bread = IntegerField(label='阅读量', max_value=2147483647, min_value=-2147483648, required=False)
    bcomment = IntegerField(label='评论量', max_value=2147483647, min_value=-2147483648, required=False)
    image = ImageField(allow_null=True, label='图片', max_length=100, required=False)

7.3.3.2 指定字段

1) 使用fields来明确字段，__all__表名包含所有字段，也可以写明具体哪些字段，如

class BookInfoSerializer(serializers.ModelSerializer):
    """图书数据序列化器"""
    class Meta:
        model = BookInfo
        fields = ('id', 'btitle', 'bpub_date')

2) 使用exclude可以明确排除掉哪些字段

class BookInfoSerializer(serializers.ModelSerializer):
    """图书数据序列化器"""
    class Meta:
        model = BookInfo
        exclude = ('image',)

3) 显示指明字段，添加额外的字段，序列化器的嵌套如：

# class AuthorModelSerializer(serializer.ModelSerializer):
#     class Meta:
#        model = Author
#        fields = ("id", "name", "avatar")
        
class HeroInfoSerializer(serializers.ModelSerializer):
    # 添加额外字段 比如re_password
    num = serializers.IntegerFidlds()
​
    # 序列化器嵌套操作
    # 必须先声明才可以调用，指在当前模型数被序列化时顺便把外键的数据也查询出来，
    # 否则只会查询到外键的ID信息
    # author = AuthorModelSerializer()
    
    class Meta:
        model = HeroInfo
        fields = ('id', 'hname', 'hgender', 'hcomment', 'num')
        # fields = ('id', 'hname', 'hgender', 'hcomment', 'num'， 'author')
​

4) 指明只读字段

可以通过read_only_fields指明只读字段，即仅用于序列化输出的字段

class BookInfoSerializer(serializers.ModelSerializer):
    """图书数据序列化器"""
    class Meta:
        model = BookInfo
        fields = ('id', 'title', 'pub_date'， 'read', 'comment')
        read_only_fields = ('id', 'read', 'comment')

7.3.3.3 添加额外参数

我们可以使用extra_kwargs参数为ModelSerializer添加或修改原有的选项参数

class BookInfoSerializer(serializers.ModelSerializer):
    """图书数据序列化器"""
    class Meta:
        model = BookInfo
        fields = ('id', 'btitle', 'bpub_date', 'bread', 'bcomment')
        # 这是额外声明
        extra_kwargs = {  
            'bread': {'min_value': 0, 'required': True},
            'bcomment': {'min_value': 0, 'required': True},
            'bpub_date': {"write_only": True},  # 只写操作
        }
    
    # 依然可以使用验证方法
    def validata(self, data):
        '''可以继续使用验证方法'''
        title = data.get("title")
        if "666" in title:
            raise serialzers.ValidationError("图书标题出现关键字")
        return data

# BookInfoSerializer():
#    id = IntegerField(label='ID', read_only=True)
#    btitle = CharField(label='名称', max_length=20)
#    bpub_date = DateField(allow_null=True, label='发布日期', required=False)
#    bread = IntegerField(label='阅读量', max_value=2147483647, min_value=0, required=True)
#    bcomment = IntegerField(label='评论量', max_value=2147483647, min_value=0, required=True)