首页 > 其他分享 >serializers.Serializer and ModelSerializer

serializers.Serializer and ModelSerializer

时间:2023-02-02 17:22:55浏览次数:43  
标签:serializers name publish length CharField ModelSerializer 序列化 Serializer

昨日回顾

# 1 APIView---->drf 提供的,继承了原来的View,以后如果写视图类,都继承APIView及其子类
# 2 APIView执行流程
	-1 去除了csrf认证
    -2 包装了新的Request对象---》视图类中使用的request都是drf的Request
    	-原来的哪? 
        -用起来跟之前一样---》__getattr__ -----》学过的魔法方法
        -request.data ---->put,post..请求体中携带的数据,无论什么编码,都是字典
        -request.query_params--->老的request.GET
        -request.FILES --->跟之前一样,重写了文件类
   -3 执行了三大认证(认证,权限,频率)---》在执行视图类的方法之前执行的
   -4 三大认证的代码,视图类方法的代码,如果出了异常,会有异常捕获----》后期会做统一处理
# 3 Request源码分析


# 4 序列化类---》APIView+序列化类+Response----》5个接口
	-序列化类的作用:做序列化,反序列化,反序列化校验
    -序列化过程:
    	-写一个序列化类,继承Serializer,写一个个字段 CharField,写的字段表示要序列化和反序列化的字段
    	-视图类中:导入,实例化得到对象,对查出来的qs,单个对象序列化,传入instance参数,如果是qs,一定要传many=True
        -序列化类对象  ser.data ----> 字典或列表---》Resonse---》json格式字符给前端
        
        -序列化单条和序列化多条,路由不一样,写成了两个视图类,分别两个get方法
        
        
        
    -反序列化过程:新增,修改
    	-新增:
        	-前端传入的无论什么编码格式,都在request.data中,是字典
            	-request.data:
                	-urlencoded,form-data---》QueryDict
                    -json-----》dict
           -拿到前端传入的数据,进行反序列化---》序列化类的反序列化,完成
        		-序列化类得到对象,传入参数,  data=request.data
            	-校验数据 
                -保存:ser.save()  --->序列化类中重写create方法
        -修改:
        	-拿到前端传入的数据,进行反序列化,查出要修改的对象---》序列化类的反序列化,完成
        		-序列化类得到对象,传入参数,  instance=要修改的对象,data=request.data
            	-校验数据 
                -保存:ser.save()  --->序列化类中重写update方法
                
                
                
 # 4 反序列化的校验
	-只要在序列化类中写局部和全局钩子
    -局部钩子
    	def validate_字段名(self,name):
            校验通过,返回name,
            如果不通过,抛出异常
            
   -全局钩子
		# attr,前端传入的数据,走完局部钩子校验后的数据
		def validate(self,attrs):
            校验通过,返回attrs
            如果不通过,抛出异常

作业

# 原生的djagno的request中没有data


import json


# 通过装饰器做,装饰器视图函数的,以后都会有request
def wrapper(func):
    def inner(request, *args, **kwargs):
        # 造个新的requeset
        # 如果是 urlencoded,form-data ----》request.POST 就有值
        # 如果request.POST 就有值没有值,就是json格式编码
        try:
            print(request.body)
            request.data = json.loads(request.body)  # 表示是json格式编码
        except Exception as e:
            request.data = request.POST

        res = func(request, *args, **kwargs)
        return res

    return inner


@wrapper  # test=wrapper(func)------>以后执行test()本质是---》wrapper(func)(request)---》本质是inner(request)
def test(request):
    print(request.POST)  # urlencoded,form-data----->QueryDict
    print(request.data)  # 报错了
    return HttpResponse('ok')

# 总结:前端提交数据的编码格式
	-urlencoded:  
    	name=lqz&age=19&price=999 放在了请求体中
    -formdata:  分数据部分和文件部分
        '----------------------------585520151165741599946333\r\n
        Content-Disposition: form-data; 
        name="name"\r\n\r\nlqz\r\n
        ----------------------------585520151165741599946333--\r\n'
        
   -json格式:{"name":"lqz","age":19}

9点55 上课

今日内容

1 序列化类常用字段和字段参数(了解)

# 序列化类---》字段类 CharField,除此之外还有哪些其他的

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

1.1 常用字段类

#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

1.2 常用字段参数

选项参数:

# CharField及其子类的(EmailField) ---》反序列化的校验,字段自己的规则
    max_length	最大长度
    min_lenght	最小长度
    allow_blank	是否允许为空
    trim_whitespace	是否截断空白字符

# IntegerField
    max_value	最小值
    min_value	最大值

    
# 所有字段类都有的
required	表明该字段在反序列化时必须输入,默认True
default	    反序列化时使用的默认值
allow_null	表明该字段是否允许传入None,默认False
validators	该字段使用的验证器
----看一眼忘掉-----
error_messages	包含错误编号与错误信息的字典
label	用于HTML展示API页面时,显示的字段名称
help_text	用于HTML展示API页面时,显示的字段帮助提示信息


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


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

2 序列化高级用法之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)

# 迁移,录入数据

2.1 序列化定制字段名字

# 重点: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')	

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

3.1 SerializerMethodField定制

# 定制关联字段的显示形式
	-一对多的,显示字典
    -多对多,显示列表套字典
    
    
    
# 代码
class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8)
    price = serializers.CharField()

    # 定制返回格式---》方式一
    publish_detail = serializers.SerializerMethodField()

    def get_publish_detail(self, obj):
        return {'name': obj.publish.name, 'addr': obj.publish.addr}

    author_list = serializers.SerializerMethodField()

    def get_author_list(self, obj):
        l = []
        for author in obj.authors.all():
            l.append({'name': author.name, 'phone': author.phone})
        return l

3.2 在表模型中定制

#### 表模型
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')

    def publish_detail(self):
        return {'name': self.publish.name, 'addr': self.publish.addr}

    def author_list(self):
        l = []
        for author in self.authors.all():
            l.append({'name': author.name, 'phone': author.phone})
        return l
    
    
 # 序列化类
class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8)
    price = serializers.CharField()

    # publish_detail = serializers.CharField()
    publish_detail = serializers.DictField()
    author_list = serializers.ListField()

4 多表关联反序列化保存

4.1 新增图书接口

# 新增图书接口
	-前端传入的数据格式:{name:红楼梦,price:19,publish:1,authors:[1,2]}
# 视图类
class BookView(APIView):
    def post(self, request):
        ser = BookSerializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '新增成功'})
        else:
            return Response({'code': 101, 'msg': ser.errors})


# 序列化类
class BookSerializer(serializers.Serializer):
    # name和price  既用来序列化,又用来反序列化   即写又读 ,不用加read_only,write_only
    name = serializers.CharField(max_length=8)
    price = serializers.CharField()

    # 只用来做序列化   只读  read_only
    publish_detail = serializers.DictField(read_only=True)
    author_list = serializers.ListField(read_only=True)

    # 只用来做反序列化  只写  write_only
    publish = serializers.CharField(write_only=True)
    authors = serializers.ListField(write_only=True)

    # 新增要重写create方法
    def create(self, validated_data):
        # validated_data 校验过后的数据,{name:红楼梦,price:19,publish:1,authors:[1,2]}
        # 新增一本图书
        book = Book.objects.create(name=validated_data.get('name'), price=validated_data.get('price'),
                                   publish_id=validated_data.get('publish'))

        # 作者也要关联上
        # book.authors   add remove set clear....
        book.authors.add(*validated_data.get('authors'))
        # book.authors.add(1,2)
        return book

4.2 修改图书接口

# 新增图书接口
	-前端传入的数据格式:{name:红楼梦,price:19,publish:1,authors:[1,2]}
###视图类
class BookDetailView(APIView):
    def put(self, request, pk):
        book = Book.objects.filter(pk=pk).first()
        ser = BookSerializer(data=request.data, instance=book)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '修改成功'})
        else:
            return Response({'code': 101, 'msg': ser.errors})
        
        
        
 # 序列化类
#### 反序列化的多表关联的保存
class BookSerializer(serializers.Serializer):
    # name和price  既用来序列化,又用来反序列化   即写又读 ,不用加read_only,write_only
    name = serializers.CharField(max_length=8)
    price = serializers.CharField()

    # 只用来做反序列化  只写  write_only
    publish = serializers.CharField(write_only=True)
    authors = serializers.ListField(write_only=True)


    # 修改要重写update
    def update(self, instance, validated_data):
        # validated_data 校验过后的数据,{name:红楼梦,price:19,publish:1,authors:[1,2]}
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.publish_id = validated_data.get('publish')

        # 先清空,再add
        authors = validated_data.get('authors')
        instance.authors.clear()
        instance.authors.add(*authors)

        instance.save()

        return instance

    
    
	

5 反序列化字段校验其他

# 4层
	-1 字段自己的:举例:name = serializers.CharField(max_length=8, error_messages={'max_length': '太长了'})
    -2 validators=[方法,]   忽略掉
    -3 局部钩子
    -4 全局钩子

6 ModelSerializer使用

# ModelSerializer 继承自Serializer,帮咱们完成了很多操作
	-跟表模型强关联
	-大部分请求,不用写create和update了
    
# 如何使用

### ModelSerializer的使用
class BookSerializer(serializers.ModelSerializer):
    # 跟表有关联
    class Meta:
        model = Book  # 跟book表建立了关系     序列化类和表模型类
        # fields = '__all__'  # 序列化所有Book中的字段  id name price publish authors
        fields = ['name', 'price', 'publish_detail', 'author_list', 'publish', 'authors']  # 序列化所有Book中的name和price字段字段

        # 定制name反序列化时,最长不能超过8   给字段类加属性---方式一
        extra_kwargs = {'name': {'max_length': 8},
                        'publish_detail': {'read_only': True},
                        'author_list': {'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字段
    # name = serializers.CharField(max_length=8)

    # 同理,所有的read_only和wirte_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":男
            }
        ]
    },
        
    -新增和修改写完
    
    
    
 # 2 继承ModelSerializer 把上面再写一遍
    

标签:serializers,name,publish,length,CharField,ModelSerializer,序列化,Serializer
From: https://www.cnblogs.com/yong-wu/p/17086721.html

相关文章