序列化组件serializer基本使用

标签：小数点   instance   作者   ram   字段名   param   name   efi   int   

1. 序列化组件使用原理

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

2. 序列化组件serializer的简单使用

• 写一个序列化类

• 在类中写要序列化的字段，想序列化哪个字段，就在类中写哪个字段

• 在视图类中导入该序列化类，实例化序列化类得到序列化类的对象，将需要序列化的对象传入

• 序列化类的对象.data 是一个字典

• 把字典返回，如果不使用rest_framework提供的Response,就得使用JsonResponse

3.序列化组件使用 --- 序列化之查询指定id书籍的接口

• 准备书籍表

from django.db import models


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

• 创建任意名称的py文件，在该文件中创建序列化类,该序列化类需要继承APIView

from rest_framework.views import APIView
from rest_framework import seriaizers

class BookSerializer(serializers.Serializer):
    id = serializers.CharField()
    price = serializers.CharField()
    publish = serializers.CharField()

• 在views.py中创建视图类，并使用自定义的序列化类对数据进行序列化，使用rest_framework的Response返回数据

from app01.ser import BookSerializer
from app01 import models


class BookView(APIView):
    def get(self,request,pk):
        dic = {‘code‘:100,‘status‘:‘成功‘}
        book = models.Book.objects.filter(pk=pk).first()
        book_ser = BookSerializer(book)
        dic[‘data‘] = book_ser.data
        return Response(dic)

• 在urls.py中写好路由与视图类的对应关系

re_path(r‘^book/(?P<pk>\d+)‘,views.BookView.as_view()),

4. 序列化组件使用---反序列化之修改数据

• 需要在序列化类中定义校验规则，如果客户端返回给后端的数据符合校验规则，就需要将数据保存到数据库，当数据通过校验的时候，如果不在序列化类中重写update方法就会抛出异常

# 序列化类文件
from rest_framework import serializers
from rest_framework.exceptions import ValidationError

# 校验规则也可以写在序列化类的外面，哪个字段需要这个校验规则就加入到哪个字段的后面，使用validators=[check_book,]的格式
def check_book(data):
    # data是浏览器客户端传过来的对应的字段的数据，因为该方法加在了name字段后面，所以data就是浏览器传到后端的name
    print(data)
    
    
class BookSerializer(serializers.Serializer):
    id = serializers.CharField(read_only=True)
    name = serializers.CharField(validators=[check_book,])
    price = serializers.CharField()
    publish = serializers.CharField()
    # 局部校验，适用于单个字段
    def validate_name(self, instance):
        # instance是浏览器返回的要修改的数据
        if instance.startswith(‘xxx‘):
            raise ValidationError(‘不能以xxx开头‘)
        else:
            return instance
    # 全局校验，适用于多个字段的校验
    def validate(self, attrs):
        # attrs是客户端要返回给后端的数据对象
        if attrs.get(‘name‘) == attrs.get(‘publish‘):
            raise ValidationError(‘二者不能相同‘)
        else:
            return attrs
    # 重写update方法
    def update(self, instance, validated_data):
        ‘‘‘
        :param instance: 修改的对象
        :param validated_data: 更新的数据
        :return:
        ‘‘‘
        instance.name = validated_data.get(‘name‘)
        instance.price = validated_data.get(‘price‘)
        instance.publish = validated_data.get(‘publish‘)
        return instance
    
# 视图文件
class BookView(APIView):
    。...

    def put(self,request,pk):
        dic = {‘code‘:100,‘status‘:‘‘}
        book = models.Book.objects.filter(pk=pk).first()
        # instance是修改的对象，data是浏览器客户端返回的数据
        book_ser = BookSerializer(instance=book,data=request.data)
        # 判断数据是否通过校验
        if book_ser.is_valid():
            # 如果数据通过校验就需要在序列化类中重写update方法
            book_ser.save()
            dic[‘status‘] = ‘修改成功‘
            dic[‘data‘] = book_ser.data
        else:
            dic[‘status‘] = ‘修改失败‘
            dic[‘data‘] = book_ser.errors
        return Response(dic)

5. 删除数据

删除数据无需使用序列化组件

def delete(self,request,pk):
    dic = {‘code‘:100,‘status‘:‘‘}
    book = models.Book.objects.filter(pk=pk).delete()
    dic[‘status‘] = ‘删除成功‘
    return Response(dic)

6. 序列化查询所有所有书籍

在序列化数据的时候，需要指定many=True,因为查到的数据是多条

def get(self,request):
    books = models.Book.objects.all()
    book_ser = BookSerializer(books,many=True)
    return Response(book_ser.data)

7. 反序列化 --- 新增书籍

新增书籍需要通过序列化类的校验，并且需要重写create方法

# 序列化类
    # 重写update方法
    def update(self, instance, validated_data):
        ‘‘‘
        :param instance: 修改的对象
        :param validated_data: 更新的数据
        :return:
        ‘‘‘
        instance.name = validated_data.get(‘name‘)
        instance.price = validated_data.get(‘price‘)
        instance.publish = validated_data.get(‘publish‘)
        return instance

    def create(self,validated_data):
        # 客户端新增的数据是一个字典
        print(validated_data)
        instance = models.Book.objects.create(**validated_data)
        return instance
    
    # views.py
    def post(self,request):
        # 增加数据,data是客户端返回给服务端的用户数据对象
        dic = {‘code‘:100,‘status‘:‘‘}
        book_ser = BookSerializer(data=request.data)
        if book_ser.is_valid():
            book_ser.save()
            book_ser.save()
            dic[‘data‘] = book_ser.data
        else:
            dic[‘data‘] = book_ser.errors
        return Response(dic)

8. 模型类序列化器

class BookModelSerializer(serializers.ModelSerializer):
    class Meta:
        model=Book  # 对应上models.py中的模型
        fields=‘__all__‘  # models中的所有字段
        # 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},
        }
        
# 其他使用一模一样
#不需要重写create和updata方法了

9. 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)

10. Serializer高级用法

# source的使用
	1 可以改字段名字  xxx=serializers.CharField(source=‘title‘)
    2 可以.跨表publish=serializers.CharField(source=‘publish.email‘)
    3 可以执行models表中的方法pub_date=serializers.CharField(source=‘test‘) test是Book表模型中的方法
    

# SerializerMethodField(）的使用，当表关系是多对多的关系的字段
	它需要有个配套方法，方法名叫get_字段名，返回值就是要显示的东西
    authors=serializers.SerializerMethodField() #它需要有个配套方法，方法名叫get_字段名，返回值就是要被序列化的数据
    def get_authors(self,instance):
        # book对象
        authors=instance.authors.all()  # 取出所有作者
        l = []
        for author in authors:
            l.append({‘name‘:author.name,‘age‘:author.age})
        return l

11. 简单封装Response对象返回的状态码信息

class MyResponse():
    def __init__(self):
        self.status=100
        self.msg=‘成功‘
    @property
    def get_dict(self):
        return self.__dict__

if __name__ == ‘__main__‘:
    res=MyResponse()
    res.status=101
    res.msg=‘查询失败‘
    # res.data={‘name‘:‘lqz‘}
    print(res.get_dict)

补充

• 序列化类的字段类型

• 序列化字段选项参数

• 序列化字段通用参数

序列化组件serializer基本使用

标签：小数点   instance   作者   ram   字段名   param   name   efi   int   

原文地址：https://www.cnblogs.com/Kathrine/p/13340902.html