Django序列化器的简单使用

序列化器serializer的介绍： * 序列化，序列化器会把模型对象转换成字典，经过response 之后变成json 字符串。 * 反序列化，把客户端发送过来的数据，经过request 之后变成字典，序列化器可以把字典装换成模型。 * 反序列化，完成数据的校验功能

序列化器serializer的介绍：

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

为方便理解后面序列化器中的字段，我们先在创建的APP中的models.py 建立一个数据库模型类。

class Book(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    author = models.CharField(max_length=32)
    publish = models.CharField(max_length=32)

定义Serializer类

drf 中的序列化器使用类来定义，这个类必须继承rest_framework.serializer.Serializer 。在类中写需要序列化的字段，即需要序列化哪些字段就在类中写哪个字段。为使代码清晰、方便管理，我们可以新建一个ser.py 文件来存储序列化器的代码。简单定义代码如下所示：

# ser.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 是独立于数据库之外的存在。

它的常用字段：

字段	字段构造方式
BooleanField	BooleanField()
NullBooleanField	NullBooleanField()
CharField	CharField(max_length=None, min_length=None, allow_blank=False, trim_whitespace=True)
EmailField	EmailField(max_length=None, min_length=None, allow_blank=False)
RegexField	RegexField(regex, max_length=None, min_length=None, allow_blank=False)
SlugField	SlugField(maxlength=50, min_length=None, allow_blank=False) 正则字段，验证正则模式 [a-zA-Z0-9-]+
URLField	URLField(max_length=200, min_length=None, allow_blank=False)
UUIDField	UUIDField(format=’hex_verbose’) format: 1) 'hex_verbose' 如"5ce0e9a5-5ffa-654b-cee0-1238041fb31a" 2） 'hex' 如 "5ce0e9a55ffa654bcee01238041fb31a" 3）'int' - 如: "123456789012312313134124512351145145114" 4）'urn' 如: "urn:uuid:5ce0e9a5-5ffa-654b-cee0-1238041fb31a"
IPAddressField	IPAddressField(protocol=’both’, unpack_ipv4=False, **options)
IntegerField	IntegerField(max_value=None, min_value=None)
FloatField	FloatField(max_value=None, min_value=None)
DecimalField	DecimalField(max_digits, decimal_places, coerce_to_string=None, max_value=None, min_value=None) max_digits: 最多位数 decimal_palces: 小数点位置
DateTimeField	DateTimeField(format=api_settings.DATETIME_FORMAT, input_formats=None)
DateField	DateField(format=api_settings.DATE_FORMAT, input_formats=None)
TimeField	TimeField(format=api_settings.TIME_FORMAT, input_formats=None)
DurationField	DurationField()
ChoiceField	ChoiceField(choices) choices与Django的用法相同
MultipleChoiceField	MultipleChoiceField(choices)
FileField	FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
ImageField	ImageField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
ListField	ListField(child=, min_length=None, max_length=None)
DictField	DictField(child=)

选项参数：

参数名称	作用
max_length	最大长度
min_lenght	最小长度
allow_blank	是否允许为空
trim_whitespace	是否截断空白字符
max_value	最小值
min_value	最大值

通用参数：

参数名称	说明
read_only	表明该字段仅用于序列化输出，默认False
write_only	表明该字段仅用于反序列化输入，默认False
required	表明该字段在反序列化时必须输入，默认True
default	反序列化时使用的默认值
allow_null	表明该字段是否允许传入None，默认False
validators	该字段使用的验证器
error_messages	包含错误编号与错误信息的字典
label	用于HTML展示API页面时，显示的字段名称
help_text	用于HTML展示API页面时，显示的字段帮助提示信息

创建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属性获取。

注意：

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

序列化器的使用

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

序列化

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

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

即当所有请求url 为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.objects.filter(id=pk).first() #获取一个书的对象
        book_ser=BookSerializer(book)  #将学生对象传入上面已经声明的Serializer类中，调用类的__init__方法，实例化一个serializer对象。
        # 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

反序列化

假如客户端以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

补充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':'删除成功'})

数据验证

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响应。

validate_字段名

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

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

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

validators

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

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


class BookSerializer(serializers.Serializer):
       author=serializers.CharField(validators=[check_author])  # validators=[] 列表中写函数内存地址

模型类序列化器

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

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

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

定义

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

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

指定字段

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的使用
	1 可以改字段名字  xxx=serializers.CharField(source='title')
    2 可以.跨表publish=serializers.CharField(source='publish.email')
    3 可以执行方法pub_date=serializers.CharField(source='test') test是Book表模型中的方法


# SerializerMethodField(）的使用
	1 它需要有个配套方法，方法名叫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

Author：Laoqi