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 序列化器、序列化/反序列化