序列化组件的使用

序列化组件的使用

序列化器的作用:

序列化:序列化器会将模型对象转换成字典，经过response变成json格式字符串
反序列化：把客户端发来的数据，经由response对象变成字典，序列化器可以将字典转换成模型对象
反序列化，可以完成数据的校验功能

1.1 定义序列化器

Django REST framework 中的序列化器，需要 继承于rest_framework.serializer.Serializer

序列化流程如下：

1写一个继承于Serializer类的序列化类;
2在类中写要序列化的字段，想要序列化的字段，就在类中写哪个字段
3在视图类中使用，导入实例化得到序列化器
4序列化器.data 是一个字典
5把字典返回，使用rest_framework中的Response

serializer.py

class BookSerializer(serializers.Serializer):
    id = serializers.CharField(read_only=True)
    book_name = serializers.CharField(source='name')
    book_price = serializers.DecimalField(max_digits=5, decimal_places=2, source='price')
    publish = serializers.CharField()
    author = serializers.CharField()

vierws.py

class Book1Detail(APIView):
    def get(self,request,pk):
        book_obj = BookModel.objects.filter(pk=pk).first()
        if book_obj:
            book_ser = BookSerializer(book_obj) # 调用类的__init__
            # book_ser.data 序列化对象.data就是序列化后的字典
            return Response(book_ser.data)
        else:
            return Response({'status':101,'msg':'无效的pk'})

class Book1View(APIView):
    def get(self,request):
        book = BookModel.objects.all()
        book_ser = BookSerializer(book,many=True)
        return Response(book_ser.data)

urls.py

path('books/<int:pk>/', views.Book1View.as_view()), # GET/PUT/DELETE 一条数据
path('books/',views.Book1Detail.as_view()), # GET/POST  或者所有的数据，或者新增加一条数据

反序列化流程如下：

使用序列化器进行反序列化的时，需要对客户端传过来的数据进行校验工作，数据校验通过后，才会操作保存模型对象，其通过book_ser.is_valid()来校验，若成功，返回True,可通过序列化器的validated_data属性来获取验证通过的数据;如果失败，则返回False,可通过序列化器的errors属性来获取错误的字段。

# 关于字段的校验:
(1)每个字段的序列化类型(Charfield)和选项参数(max_length,min_length,max_digits...)是第一道关卡
(2)钩子函数是第二道关卡，主要分为局部钩子函数，和全局钩子函数
def validated_price(self,price):
    if float(price)<10:
        raise ValidationError('价格不能低于10元')
    return price

def validated(self,validated_data):
    password = validated_data.get('password')
    re_password = validated_data.get('re_password')
    if not re_password == password:
        raise ValidationError('两次密码输入不一致')
    else:
        return Validated_data  

# 此外，在第一道关卡中，还有validator参数，可以使用外部函数做当前字段的校验方式
def check_author(name):
    if name.startswith('sb') or name.endswith('sb'):
        raise ValidationError('作者姓名中含有敏感词')
    else:
        return name
    
# 配置
author = serializers.CharField(validators=[check_author])

serializer.py

def check_name(name):
    if name.startswith('sb') or name.endswith('sb'):
        raise ValidationError('书籍名称中含有敏感词')
    else:
        return name

class BookSerializer(serializers.Serializer):
    id = serializer.CharField(read_only=True)
    book_name = serializer.CharField(source='name',validators=[check_name,])
    book_price = serializers.DecimalField(source='price',max_digits=5,decimal_place=2)
    publish = serializers.SerializerMethodField()
    author = serializers.CharField(source='author.name')
    
    def get_publish(self, instance):
        # instance 就是book对象
        publish_dict = {}
        attr_list = ['name', 'addr', 'email', 'phone']
        publish = instance.publish
        for attr in attr_list:
            if hasattr(publish, attr):
                publish_dict[attr] = getattr(publish, attr)
                return publish_dict
   
	def create(self, validated_data):  # 增加一条数据
        instance = BookModel.objects.create(**validated_data)
        return instance

    def update(self, instance, validated_data):  # 新增一条数据
        for attr, value in validated_data.items():
            if hasattr(instance, attr):
                setattr(instance, attr, value)
        instance.save()
        return instance

models.py

from django.db import models

# Create your models here.
from django.db.models import CASCADE

GENDER_CHOICE = (
    (0, 'male'),
    (1, 'female'),
    (2, 'secret'),
)


class BookModel(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32, verbose_name='书名')
    price = models.DecimalField(max_digits=5, decimal_places=2, verbose_name='价格')
    publish = models.ForeignKey(to='Publish', on_delete=CASCADE)
    authors = models.ManyToManyField(to='Author')

    def __str__(self):
        return self.name

    class Meta:
        verbose_name_plural = '书名表'

views.py

class Book1View(APIView):
    def post(self,request):
        # 新增没有instance,更新才有instance
        book_ser = BookSerializer(data=request.data)
        if book_ser.is_valid():
            book_ser.save()
            return Resposne(book_ser.data)
        else:
            return Response({'status':101,'msg':'数据检验未通过'})

class Book1Detail(APIView):
    def put(self, request, pk):
        # 修改需要instance
        instance = BookModel.objects.filter(pk=pk).first()
        book_ser = BookSerializer(instance=instance, data=request.data)
        if book_ser.is_valid():
            book_ser.save()
            return Response(book_ser.data)
        else:
            return Response({'status': 101, 'smg': '数据校验未通过'})

    def delete(self, request, pk):
        book = BookModel.objects.filter(pk=pk)
        if book:
            book.delete()
            return Response({'status': 200, 'msg': '删除成功'})
        else:
            return Response({'status': 101, 'msg': '无效的pk'})

1.2 序列化的字段类型

字段	字段构造方式
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页面时，显示的字段帮助提示信息

read_only	表明该字段仅用于序列化输出，默认False,如果设置成True，postman中可以看到该字段，修改时，不需要传该字段
write_only	表明该字段仅用于反序列化输入，默认False，如果设置成True，postman中看不到该字段，修改时，该字段需要传

# 以下的了解
required	表明该字段在反序列化时必须输入，默认True
default	反序列化时使用的默认值
allow_null	表明该字段是否允许传入None，默认False
validators	该字段使用的验证器
error_messages	包含错误编号与错误信息的字典

1.3 模型类序列化器ModelSerializer

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},
        }
        
# 其他使用和Serializer的使用方法一模一样
# 不需要重写create和updata方法了
# 注意：write_only_fields弃用了，使用extra_kwargs
# id此时默认是read_only的，不能给id使用write_only

1.4 序列化器的高级用法

#1 source的作用及其使用
	1 可以改字段名字  book_name=serializers.CharField(source='name')
    2 可以.跨表publish=serializers.CharField(source='publish.email')[基于对象的跨表查询，子查询]
    3 可以执行方法pub_date=serializers.CharField(source='test') test是在Book表模型中定义的方法
    

#2 SerializerMethodField(）的使用
	1 它需要有个配套方法，方法名叫get_字段名，返回值就是要显示的东西
    authors=serializers.SerializerMethodField() 
    
    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
    
# 注意：
	- 如果在模型类序列化器中使用source和SerializerMethodField, 需要重写字段，把class Meta中的fields覆盖掉
    class BookModelSerializer(ModelSerializer):
        class Meta:
            model = models.Book
            # exclude = ('authors', )
            fields = '__all__'
            extra_kwargs = {
                'pub_date': {'read_only': True},
                # 'publish': {'source': 'publish.email'},
            }
        publish = serializers.CharField(source='publish.name')
        authors = serializers.SerializerMethodField()
        def get_authors(self, instance):
            authors = instance.authors.all()  # 取出所有作者
            ll = []
            for author in authors:
                ll.append({'name': author.name, 'age': author.age})
            return ll

1.5 源码分析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)