Django 序列化器、序列化/反序列化-PySuper

一、定义 Serializer 类

DRF 中的序列化器需要继承自：rest_framework.serializer.Serializer
在类中定义需要序列化的字段
serializer 不是只能为数据库模型类定义，也可以为非数据库模型类的数据定义（独立于数据库之外的存在）

# serializer.py

from rest_framework import serializers

# 声明序列化器，所有的序列化器都要直接或间接的继承于Serializer
class BookSerializer(serializers.Serializer):
    id = serializers.CharField()
    name = serializers.CharField()
    # price = serializers.DecimalField()  
    """
    可以将各个字段数据类型与数据库中的数据字段类型匹配，
    也可以将其装换称字符类型进行序列化传递到前段，在前段处理数据时再进行数据类型的变换
    """
    price = serializers.CharField()
    author = serializers.CharField()  
    publish = serializers.CharField()

二、创建 Serializer 对象

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

用于序列化时，将模型类对象传入 instance 参数
用于反序列化时，将要被反序列化的数据传入 data 参数
除了 instance 和 data 参数外，在构造 Serializer 对象时，还可通过 context 参数额外添加数据:
- 如除了 instance 和 data 参数外，在构造 Serializer 对象时，还可通过 context 参数额外添加数据：
- serializer = AccountSerializer(account, context={'request': request})
通过 context 参数附加的数据可以通过序列化对象的 context 属性获取。
注意：
- 使用序列化器的时候一定要注意，序列化器声明了以后，不会自动执行，需要我们在视图中进行调用才可以。
- 序列化器无法直接接收数据，需要我们在视图中创建序列化器对象时把使用的数据传递过来。
- 序列化器的字段声明类似于我们前面使用过的表单系统。
- 开发 restful api 时，序列化器会帮我们把模型数据转换成字典。
- drf 提供的视图会帮我们把字典转换成 json，或者把客户端发送过来的数据转换字典。

三、序列化器的使用

序列化器的使用分为两个阶段：
- 在客户端请求（提交）数据时，使用序列化器对数据的反序列化
- 在服务端响应时，使用序列化器对数据的序列化。将模型类数据装换和其他数据装换成 json 格式的数据。

3.1 序列化

假如客户端以 get put （查询 / 修改一条数据）的请求方式与服务端进行数据交互，其中 urls.py 中的路由匹配为：

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    re_path('books/(?P<pk>\d+)', views.BookView.as_view()),
]

即：127.0.0.1:8080/books/1 --> BookView ，并将 pk=1 作为关键字参数传递给它。

# views.py

from rest_framework.views import APIView
from books.models import Book
from .ser import BookSerializer

class BookView(APIView):
    def get(self,request,pk):
        # 获取一个book的对象
        book = Book.objects.filter(id=pk).first()

        # 将学生对象传入上面已经声明的Serializer类中，调用类的__init__方法，实例化一个serializer对象
        book_ser = BookSerializer(book)

        # book_ser.data   序列化对象.data----->就是序列化后的字典
        return Response(book_ser.data)
    
    def put(self,request,pk):
        response_msg = {'status':100,'msg':'成功'}
        # 找到这个对象
        book = Book.objects.filter(id=pk).first()
        # 得到一个序列化类的对象
        # book_ser = BookSerializer(book,request.data) # 按照位置传递参数
        book_ser = BookSerializer(instance=book,data=request.data)  # 按照关键字传递参数

        # 要进行数据验证
        if book_ser.is_valid():  # 返回True表示验证通过
            book_ser.save()  
            # 此处的save方法是序列化类提供的。
            # 如果没有重写父类的update方法会报错 这是因为抽象接口限制子类必须要重写该方法（多态）
            response_msg['data']=book_ser.data
        else:
            response_msg['status']=101
            response_msg['msg']='数据校验失败'
            response_msg['data']=book_ser.errors

        return Response(response_msg)

此时客户端获取到的数据即为序列化后的书数据。

在 ser.py 对应的序列化类中重写的 update 方法：

    def update(self, instance, validated_data):
        #instance是book这个对象
        #validated_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.save()   此处的save方法是django 的orm提供的
        return instance

3.2 反序列化

假如客户端以 post get （创建一条 / 查询所有）请求方式与服务端进行数据交互，其中 urls.py 的路由匹配为：

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    re_path('books/(?P<pk>\d+)', views.BookView.as_view()),
    path('books/', views.BooksView.as_view()),
]

即： url 127.0.0.1:8080/books/----> 视图类 BooksView 。

# view.py

class BooksView(APIView):
    def get(self,request):
        response_msg = {'status': 100, 'msg': '成功'}
        books=Book.objects.all()
        book_ser=BookSerializer(books,many=True)  #序列化多条,如果序列化一条，不需要写
        response_msg['data']=book_ser.data
        return Response(response_msg)
    
    def post(self,request):
        response_msg = {'status': 100, 'msg': '成功'}
        #修改才有instance，新增没有instance，只有data
        book_ser = BookSerializer(data=request.data)
        # book_ser = BookSerializer(request.data)  # 这个按位置传request.data会给instance，就报错了
        
# 校验字段
        if book_ser.is_valid():
            book_ser.save()  #没有重写create方法会报错 原因同上
            response_msg['data'] = book_ser.data
        else:
            response_msg['status'] = 102
            response_msg['msg'] = '数据校验失败'
            response_msg['data'] = book_ser.errors
        return Response(response_msg)

此时服务端保存的就是经过校验和反序列化的客户端发送来的序列化数据。

在 ser.py 对应的序列化类中重写的 create 方法：

def create(self, validated_data):
    instance=Book.objects.create(**validated_data)
    return instance

3.3 补充 delete

假如客户端以 post get （创建一条 / 查询所有）请求方式与服务端进行数据交互，其中 urls.py 的路由匹配为：

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    re_path('books/(?P<pk>\d+)', views.BookView.as_view()),
]

# view.py

class BookView(APIView):
    def delete(self,request,pk):
        Book.objects.filter(pk=pk).delete()
        return Response({'status':100,'msg':'删除成功'})

四、数据验证

4.1 is_valid () 方法

使用序列化器进行反序列化时，需要对数据进行验证后，才能获取验证成功的数据或保存成模型类对象
在获取反序列化的数据前，必须调用 is_valid () 方法进行验证，验证成功返回 True，否则返回 False
验证失败：
- 可以通过序列化器对象的 errors 属性获取错误信息，返回字典，包含了字段和字段的错误
- 如果是非字段错误，可以通过修改 REST framework 配置中的 NON_FIELD_ERRORS_KEY 来控制错误字典中的键名
验证成功，可以通过序列化器对象的 validated_data 属性获取数据。
在定义序列化器时，指明每个字段的序列化类型和选项参数，本身就是一种验证行为。如我们前面定义过的 BookSerializer 。

class BookSerializer(serializers.Serializer):
    id=serializers.CharField(read_only=True)
    name=serializers.CharField(max_length=16,min_length=4)
    # price=serializers.DecimalField()
    price=serializers.CharField(write_only=True,required=True)
    author=serializers.CharField(validators=[check_author])  # validators=[] 列表中写函数内存地址
    publish=serializers.CharField()

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

4.2 validate_字段名

例如对 price 字段进行验证，在 BookSerializer 中定义方法：

def validate_price(self, data):   # validate_字段名  接收一个参数
    #如果价格小于10，就校验不通过
    # print(type(data))
    # print(data)
    if float(data)>10:
        return data
    else:
        #校验失败，抛异常
        raise ValidationError('价格太低')

4.3 validate

    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

4.4 validators

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

def check_author(data):
    if data.startswith('sb'):
        raise ValidationError('作者名字不能以sb开头')
    else:
        return data
    
class BookSerializer(serializers.Serializer):
       # validators=[] # 列表中写函数内存地址
       author = serializers.CharField(validators=[check_author])

五、模型类序列化器

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

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

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

5.1 定义

class BookModelSerializer(serializers.ModelSerializer):
    class Meta:
        model=Book  # 对应上models.py中的模型
        fields='__all__'

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

5.2 指定字段

class BookModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book  # 对应上models.py中的模型
        fields = '__all__'
        # fields=('name','price','id','author') # 只序列化指定的字段
        # exclude=('name',) # 跟fields不能都写，写谁，就表示排除谁
        # read_only_fields=('price',)
        # write_only_fields=('id',) # 弃用了，使用extra_kwargs
        extra_kwargs = {  
            # 类似于这种形式：name=serializers.CharField(max_length=16,min_length=4)
            'price': {'write_only': True},
        }

我们可以使用 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},
        }

# 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)

六、补充

many=True 的实际用途

# 序列化多条，需要传many=True
# 
book_ser=BookModelSerializer(books,many=True)
book_one_ser=BookModelSerializer(book)
print(type(book_ser))
#<class 'rest_framework.serializers.ListSerializer'>
print(type(book_one_ser))
#<class 'app01.ser.BookModelSerializer'>

# 对象的生成--》先调用类的__new__方法，生成空对象
# 对象=类名(name=lqz)，触发类的__init__()
# 类的__new__方法控制对象的生成


def __new__(cls, *args, **kwargs):
    if kwargs.pop('many', False):
        return cls.many_init(*args, **kwargs)
    # 没有传many=True,走下面，正常的对象实例化
    return super().__new__(cls, *args, **kwargs)

Serializer 高级用法

source 的使用

可以改字段名字 xxx=serializers.CharField (source=‘title’)
可以。跨表 publish=serializers.CharField (source=‘publish.email’)
可以执行方法 pub_date=serializers.CharField (source=‘test’) test 是 Book 表模型中的方法

SerializerMethodField()

它需要有个配套方法，方法名叫 get_字段名，返回值就是要显示的东西

    authors=serializers.SerializerMethodField() #它需要有个配套方法，方法名叫get_字段名，返回值就是要显示的东西
    def get_authors(self,instance):
        # book对象
        authors=instance.authors.all()  # 取出所有作者
        ll=[]
        for author in authors:
            ll.append({'name':author.name,'age':author.age})
        return ll

参考：
- Django 序列化器的简单使用
- Django Serializer 序列化使用方法详解

目录 CONTENT

Django 序列化器、序列化 / 反序列化