console.log|
收藏闪存小组博问

clever-cat

园龄：2年5个月粉丝：19关注：34

drf序列化器使用详情，序列化高级用法，ModelSerializer使用

昨日内容回顾

APIView—》drf提供的，继承了原来的View，以后如果写视图类，都继承APIView及其子类

APIView执行流程

  1. 去除了csrf认证
  2. 重新包装了request–>视图类中使用的都是新的了，原来的在request._request中，新的request与老的一样，是因为_getattr_
    request.data—》put,post请求中携带的数据都在这里，无论什么编码，都是字典
    request.query_parms–>老的request.GET
    request.FILES–>老的request.FILES，是对老的文件对象的包装，功能更强大了，但是跟之前用法没区别，重写了文件类
  3. 执行三大认证（认证，权限，频率）在执行视图类之前
  4. 三大认证代码与视图类方法的代码如果出错，会被异常捕获，后期会做统一处理

序列化类—》APIView+序列化类+Reponse–>5个接口

序列化类的作用：做序列化，反序列化，反序列化校验

序列化过程：
写一个序列化类，继承Serializer,写一个个字段CharField，写的字段表示要序列化和反序列化的字段

​ 视图类中：导入，实例化得到对象，对查出来的queryset单个对象序列化，传入instance参数，如果是queryset，一定要加many=True

​ 序列化类对象，ser.data–>字典或列表–》Response–>json格式字符给前端

​ 序列化单条和序列化多条，路由不一样，携程两个视图类，分别两个get方法

反序列化过程：新增，修改

​ 新增：前端无论什么编码格式传数据，都早request.data中，是字典

​ 拿到前端传入的数据，进行反序列化–》序列化类的反序列化，完成，序列化类得到对象，传入参数–》校验数据》保存数据ser,save》序列化类中重写create方法

​ 修改拿到前端传入的数据，进行反序列化，查出要修改的对象》序列化的反序列化，完成》序列化类得到对象，传入参数instance=要修改的对象，data=request.data》校验数据》保存ser.data》序列化类中重新update方法

反序列化校验

只要在序列化类中写局部钩子和全局钩子

局部钩子

def validate_字段名(self,字段名):

​ 校验通过，返回字段名

​ 如果不通过，抛出异常

全局钩子

def validate(self,atts):

​ 校验通过，返回atts

​ 如果不通过，抛出异常

今日内容

序列化类常用字段和字段参数（了解）

序列化类》字段类 CharField

序列化类》字段类，字段类上，传属性，序列化类上，也可以写属性【models.CharField(max_length=32)】

常用字段类

#1 BooleanField	      BooleanField()
 
#2 NullBooleanField	  NullBooleanField()
 
#3 CharField	CharField(max_length=None, min_length=None, allow_blank=False, trim_whitespace=True)
 
#4 EmailField	EmailField(max_length=None, min_length=None, allow_blank=False)
 
#5 RegexField	RegexField(regex, max_length=None, min_length=None, allow_blank=False)
 
#6 SlugField	SlugField(max_length=50, min_length=None, allow_blank=False) 正则字段，验证正则模式 [a-zA-Z0-9-]+
 
#7 URLField	URLField(max_length=200, min_length=None, allow_blank=False)
 
#8 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"
 
#9 IPAddressField	IPAddressField(protocol=’both’, unpack_ipv4=False, **options)
 
#10 IntegerField	IntegerField(max_value=None, min_value=None)
 
#11 FloatField	FloatField(max_value=None, min_value=None)
 
#12 DecimalField	DecimalField(max_digits, decimal_places, coerce_to_string=None, max_value=None, min_value=None) max_digits: 最多位数 decimal_palces: 小数点位置
 
#13 DateTimeField	DateTimeField(format=api_settings.DATETIME_FORMAT, input_formats=None)
 
#14 DateField	DateField(format=api_settings.DATE_FORMAT, input_formats=None)
 
#15 TimeField	TimeField(format=api_settings.TIME_FORMAT, input_formats=None)
 
#16 DurationField	DurationField()
 
#17 ChoiceField	ChoiceField(choices) choices与Django的用法相同
 
#18 MultipleChoiceField	MultipleChoiceField(choices)
 
#19 FileField	FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
 
#20 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=)
记住的：

CharField(字符) IntegerField（整数） DecimalField（小数）

DateTimeField（日期）BooleanField(布尔)

ListField

DictField

常用字段参数

选项参数

CharField及其子类的(EmailField)》》反序列化的校验，字段自己的规则

max_length 最大长度

min_length 最小长度

allow_blank 是否允许为空

trim_whitespace 是否阶段空白字符

IntegerField

max_value 最大值

min_value 最小值

所有字典类都有的

required 表明该字段在反序列化时必须输入，默认True

default 反序列化时使用默认值

allow_null 表明该字段是否允许传入None，默认False

validators 该字段使用的验证器

error_message 包含错误编码与错误信息的字典

label 用于HTML展示API页面时，显示的字段名称

help_text 用于HTMl展示API页面时，显示的字段帮助提示信息

重点
read_only 表明该字段仅用于序列化输出，默认False
write_only 表明该字段仅用于反序列化输入，默认False

反序列化校验流程

  1. 先执行字段自己的校验规则》最大长度，最小长度，是否为空，是否必填，最小数字
  2. validators=[方法，]》单独给这个字段加校验规则
    name=serializers.CharField(validators=[方法,])
  3. 局部钩子校验规则
  4. 全局钩子校验规则

序列化高级用法之source(了解)

# 创建关联表
class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.CharField(max_length=32)
 
    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)  # 留住，还有很多
    authors = models.ManyToManyField(to='Author')
 
 
class Publish(models.Model):
    name = models.CharField(max_length=32)
    addr = models.CharField(max_length=32)
 
 
class Author(models.Model):
    name = models.CharField(max_length=32)
    phone = models.CharField(max_length=11)
 
# 迁移，录入数据

序列化定制字典名字

重点：source可以指定序列化字段的名字

# 重点：source可以指定序列化字段的名字
	-自有字段，直接写字段名字
    	-name_real = serializers.CharField(max_length=8, source='name')
    -关联字段，一对多的关联，直接点
    	-publish = serializers.CharField(source='publish.name')
    -多对多，搞不了,source不能用
    	-authors=serializers.CharField(source='authors.all')
        
        
# 序列化类
class BookSerializer(serializers.Serializer):
    # 字段参数，通用的，所有字段都可以写  通过source指定哪个字段
    # 自有字段，直接写字段名字
    name_real = serializers.CharField(max_length=8, source='name')
    real_price = serializers.CharField(source='price')
 
    # 关联字段，一对多的关联，直接点
    publish = serializers.CharField(source='publish.name')
 
    #多对多，搞不了,source不能用
    authors=serializers.CharField(source='authors.all')

image

序列化高级用法之定制字段的两种方式

定制关联字段的显示形式

一对多的，显示字典

多对多，显示列表套字典

方式一，定制返回格式

from rest_framework import serializers
 
 
class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8)
    price = serializers.CharField(max_length=8)
	# 序列化方法
    publish = serializers.SerializerMethodField()
    authors = serializers.SerializerMethodField()
 
    def get_publish(self, obj):
        return {'name': obj.publish.name, 'addr': obj.publish.addr}
 
    def get_authors(self, qs):
        return [{'name': obj.name, 'phone': obj.phone} for obj in qs.authors.all()]

image

方式二在模型表中定制

serializer.py

from rest_framework import serializers
 
 
class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8)
    price = serializers.CharField(max_length=8)
 
    #方式二模型类中写方法
     # 因为这里模型类中返回的是字典类型所以要用字典字段
    publish_detail = serializers.DictField()
    # 这个是列表套字典
    authors_detail = serializers.ListField()
    #不能用下面的，要记住，是一个小坑
    #publish_detail = serializers.CharField()
    #authors_detail = serializers.CharField()

models.py

from django.db import models
 
 
# Create your models here.
class Book(models.Model):
    name = models.CharField(max_length=32, verbose_name='书名')
    price = models.CharField(max_length=32, verbose_name='价格')
    authors = models.ManyToManyField(to='Author')
    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
 
    class Meta:
        verbose_name_plural = '书籍表'
 
    def __str__(self):
        return self.name
	#模型自定义字段返回数据】
	@property  # 可以加也可以不加
    def publish_detail(self):
        return {'name': self.publish.name, 'addr': self.publish.addr}
	@property  # 可以加也可以不加
    def authors_detail(self):
        return [{'name': obj.name, 'phone': obj.phone} for obj in self.authors.all()]

image

image

多表关联反序列化保存

新增图书接口

views.py

class BookView(APIView):
    def post(self, request):
        ser = BookSerializer(data=request.data)
        if ser.is_valid():
            ser.save()  # 需要在序列化类中重写create方法
            return Response(ser.data)
        else:
            return Response({'code': 101, 'msg': ser.errors})

serializer.py

from rest_framework import serializers
from .models import Book, Author, Publish
 
 
class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8)
    price = serializers.CharField(max_length=8)
    #只做反序列化  只写 write_only
    publish_id = serializers.CharField(write_only=True)
    authors = serializers.ListField(write_only=True)
    # # 方式一：定制返回格式
    # publish = serializers.SerializerMethodField()
    # authors = serializers.SerializerMethodField()
    #
    # def get_publish(self, obj):
    #     return {'name': obj.publish.name, 'addr': obj.publish.addr}
    #
    # def get_authors(self, qs):
    #     return [{'name': obj.name, 'phone': obj.phone} for obj in qs.authors.all()]
 
    # 方式二模型类中写方法
    # 因为这里模型类中返回的是字典类型所以要用字典字段
    # 只做序列化， 只读 write_only
    publish_detail = serializers.DictField(read_only=True)
    # 这个是列表套字典
    authors_detail = serializers.ListField(read_only=True)
	# 新增要重写create方法
    def create(self, validated_data):
        # validated_data 校验过后的数据，{name:红楼梦,price:19,publish_id:1,authors:[1,2]}
        authors = validated_data.pop('authors')
        book = Book.objects.create(**validated_data)
        # 作者也要关联上
        # book.authors   add remove set clear....
        book.authors.add(*authors)
        return book

image

修改图书接口

# 新增图书接口
	-前端传入的数据格式：{name:红楼梦,price:19,publish_id:1,authors:[1,2]}
   #开设新路由 
path('api/v1/books/<int:pk>/', views.BookDetailView.as_view()),

views.py

class BookDetailView(APIView):
    def put(self, request, pk):
        book = Book.objects.filter(pk=pk).first()
        ser = BookSerializer(instance=book, data=request.data)
        if ser.is_valid():
            ser.save()  # 需要重写update方法
            return Response(ser.data)
        else:
            return Response({'code': 101, 'msg': ser.errors})

serializer.py

class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8)
    price = serializers.CharField(max_length=8)
    publish_id = serializers.CharField(write_only=True)
    authors = serializers.ListField(write_only=True)
    # # 方式一：定制返回格式
    # publish = serializers.SerializerMethodField()
    # authors = serializers.SerializerMethodField()
    #
    # def get_publish(self, obj):
    #     return {'name': obj.publish.name, 'addr': obj.publish.addr}
    #
    # def get_authors(self, qs):
    #     return [{'name': obj.name, 'phone': obj.phone} for obj in qs.authors.all()]
 
    # 方式二模型类中写方法
    # 因为这里模型类中返回的是字典类型所以要用字典字段
    publish_detail = serializers.DictField(read_only=True)
    # 这个是列表套字典
    authors_detail = serializers.ListField(read_only=True)
 
    def create(self, validated_data):
        authors = validated_data.pop('authors')
        book = Book.objects.create(**validated_data)
        book.authors.add(*authors)
        return book
 
    def update(self, instance, validated_data):
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.publish_id = validated_data.get('publish_id')
        # 先清除然后在重新添加
        # instance.authors.clear()
        # instance.authors.add(*validated_data.get('authors'))
        # 可以直接使用set来进行数据的修改，与上面一样的
        instance.authors.set(validated_data.get('authors'))
        # 最后记得保存到数据库
        instance.save()
        return instance

image

可以使用set来进行数据的修改

image

反序列化字段校验其他

字段校验的4层按顺序依次校验

  1. 自己字段的校验

  2. validators=[方法,] 不常使用

    		from rest_framework.validators import UniqueValidator
    		username=serializers.CharField(required=True,allow_blank=False,
    		                                   validators=[UniqueValidator(queryset=User.objects.all(),message="用户已存在")],help_text="用户名")

  3. 局部钩子

  4. 全局钩子

image

自定义错误信息error_messages

image

ModelSerializer使用

ModelSerializer继承自Serializer,帮我们完成了很多操作

跟表模型强关联

大部分请求，不用写create和update方法了

ModelSerializer使用

view.py 没有变化

serializer.py

# ModelSerializer使用
class BookSerializer(serializers.ModelSerializer):
    class Meta:
        # 跟模型表Book关联，序列化类和表模型类
        model = Book
        # 序列化Book所有字段 id name price publish authors
        # fields = '__all__'  # 这样是只加字段，不能加自己自定写的属性方法字段
        # fields = ['id','name','price']  # 序列化所有Book中的id,name,price字段
        fields = ['id', 'name', 'price', 'publish_detail', 'authors_detail', 'publish', 'authors']
        # 定制name反序列化是，最长不能超过8 给字段加属性
        # 方式一
        extra_kwargs = {'name': {'max_length': 8},
                        'publish_detail': {'read_only': True},  # 这两个可不写但是还是建议写上，语义更加明确
                        'authors_detail': {'read_only': True},
                        'publish': {'write_only': True},
                        'authors': {'write_only': True},
                        }
        
    # 如果Meta中写了__all__，就相当于复制了表模型中的所有字段，放在了这里，做了个映射
        # name = serializers.CharField(max_length=32)
    # price = serializers.CharField(max_length=32)
    # 定制name反序列化时，最大不能超过8给字段类加属性的方式二
    name = serializers.CharField(max_length=8)

方式一定制name反序列化是，最长不能超过8 给字段加属性（extra_kwargs方式）

    # 方式一
    extra_kwargs = {'name': {'max_length': 8},
                    'publish_detail': {'read_only': True},  # 这两个可不写但是还是建议写上，语义更加明确
                    'authors_detail': {'read_only': True},
                    'publish': {'write_only': True},
                    'authors': {'write_only': True},
                    }

image

方式二定制name反序列化是，最长不能超过8 给字段加属性（重写方式）

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        # 跟模型表Book关联，序列化类和表模型类
        model = Book
        # 序列化Book所有字段 id name price publish authors
        # fields = '__all__'  # 这样是只加字段，不能加自己自定写的属性方法字段
        # fields = ['id','name','price']  # 序列化所有Book中的id,name,price字段
        fields = ['id', 'name', 'price', 'publish_detail', 'authors_detail', 'publish', 'authors']     
    # 如果Meta中写了__all__，就相当于复制了表模型中的所有字段，放在了这里，做了个映射
        # name = serializers.CharField(max_length=32)
    # price = serializers.CharField(max_length=32)
    # 定制name反序列化时，最大不能超过8给字段类加属性的方式二
    name = serializers.CharField(max_length=8)
    # 同理，所有的read_only和write_only都可以通过重写或使用extra_kwargs传入
    # 终极，把这个序列化类写的跟之前一模一样
    # publish_detail = serializers.SerializerMethodField(read_only=True)
    # def get_publish_detail(self, obj):
    #     return {'name': obj.publish.name, 'addr': obj.publish.addr}
    # author_list = serializers.SerializerMethodField(read_only=True)
    # def get_author_list(self, obj):
    #     l = []
    #     for author in obj.authors.all():
    #         l.append({'name': author.name, 'phone': author.phone})
    #     return l
    # 局部钩子和全局钩子跟之前一样

局部钩子和全局钩子跟之前一样

def validate_name(self, name):
    if name.startswith('sb'):
        raise ValidationError('不能sb')
    else:
         return name

作业

#1 Serializer的方式1book,author,authordetail,publish
	-book的查询所有，查询单个
    	{
        "name": "红楼梦",
        "price": "66",
        "publish_detail": {
            "name": "北京出版社",
            "addr": "北京"
        },
        "author_list": [
            {
                "name": "lqz",
                "phone": "1234455"，
                "gender":男
            },
            {
                "name": "罗贯中",
                "phone": "12342412"，
                 "gender":男
            }
        ]
    },
        
    -新增和修改写完
    
    
def authors_detail(self):
    return [{'name': obj.name, 'phone': obj.phone,'gender':obj.author_detail.gender } for obj in self.authors.all()]

继承ModelSerializer把上面在写一遍

上面已经写过了

本文作者：clever-cat

本文链接：https://www.cnblogs.com/clever-cat/p/17087587.html

版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   clever-cat  阅读(351)  评论(0)  编辑  收藏  举报
点击右上角即可分享
微信分享提示
评论
收藏
关注
推荐
深色
回顶
收起