今日内容序列化类的高级用法

序列化类常用字段类和字段参数

常用字段类型：

字段	字段构造方式
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中看不到该字段，修改时，该字段需要传

序列化类高级用法之source，修改序列化字段名字

 # source的使用
	不使用source参数时，会默认  序列化表名.字段名
    	使用source参数时，序列化表名.source的参数  下方以Book表为例
class BookSerializer(serializers.Serializer):
    name_detail = serializers.CharField(max_length=8, min_length=3,source='name')  # 可以改字段名字
    # 或
    publish_name = serializers.CharField(max_length=8, min_length=3,source='publish.name') # 可以.跨表查
    # 或
    xx = serializers.CharField(max_length=8, min_length=3,source='xx') # 可以执行方法

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

 # 前端显示形式
{
        "name": "西游记",
        "price": 33,
        "publish": {name:xx,city:xxx,email:sss}
}
 
# 第一种：在【序列化类】中写SerializerMethodField
    publish = serializers.SerializerMethodField()
    def get_publish(self, obj):
        # obj 是当前序列化的对象
        return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}
# 第二种：在【表模型】中写方法（又多一些）  
    def publish_detail(self):
        return {'name': self.publish.name, 'city': self.publish.city, 'email': self.publish.email}
    在序列化中取
    publish_detail=serializers.DictField()

方式一：使用SerializerMethodField

 class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8, min_length=3)
    price = serializers.IntegerField(min_value=10, max_value=99)
    publish_date = serializers.DateField()
    # publish要序列化成 {name:北京出版社，city：北京，email:2@qq.com}
    # 方式一：SerializerMethodField必须配合一个方法(get_字段名,需要接受一个参数)，方法返回什么，这个字段就是什么
    publish = serializers.SerializerMethodField()
    def get_publish(self, obj):
        # obj 是当前序列化的对象
        return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}
 
    # 练习，用方式一，显示所有作者对象  []
    authors = serializers.SerializerMethodField()
    def get_authors(self, obj):
        res_list = []
        for author in obj.authors.all():
            res_list.append({'id': author.id, 'name': author.name, 'age': author.age})
        return res_list

方式二：在表模型中写

 # 表模型中
class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    publish_date = models.DateField(null=True)
 
    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    authors = models.ManyToManyField(to='Author')
 
    # 写了个方法，可以包装成数据属性，也可以不包
    def publish_detail(self):
        return {'name': self.publish.name, 'city': self.publish.city, 'email': self.publish.email}
 
    def author_list(self):
        res_list = []
        for author in self.authors.all():
            res_list.append({'id': author.id, 'name': author.name, 'age': author.age})
        return res_list

有关联关系表的反序列化的保存

 # 1 序列化字段和反序列化字段不一样  【序列化类中】
	# 反序列化用的
    publish = serializers.CharField(write_only=True)
    authors = serializers.ListField(write_only=True)
	#序列化用的
    publish_detail = serializers.DictField(read_only=True)
    author_list = serializers.ListField(read_only=True)
    
# 2 一定要重写create  【序列化类中】
	    def create(self, validated_data): 
            # validated_data 校验过后的数据  
              {"name":"三国1演义",
                "price":19,
                "publish_date": "2022-09-27",
                "publish":1,
                "authors":[1,2]
                }
            book = Book.objects.create(name=validated_data.get('name'),
                                       price=validated_data.get('price'),
                                       publish_date=validated_data.get('publish_date'),
                                       publish_id=validated_data.get('publish'),
                                       )
            authors = validated_data.get('authors')
            book.authors.add(*authors)
            return book

反序列化之数据校验

 # 跟forms很像
	-字段自己的校验规则
    -局部钩子
    -全局钩子
    
    
# 字段自己的校验规则
	-如果继承的是Serializer，写法如下
    	name=serializers.CharField(max_length=8,min_length=3,error_messages={'min_length': "太短了"})
    -如果继承的是ModelSerializer，写法如下
       extra_kwargs = {
            'name': {'max_length': 8, 'min_length': 3, 'error_messages': {'min_length': "太短了"}},
        }
        
        
# 局部钩子
    -如果继承的是Serializer，写法一样
    -如果继承的是ModelSerializer，写法一样
	def validate_name(self, name):
        if name.startswith('sb'):
            # 校验不通过，抛异常
            raise ValidationError('不能以sb卡头')
        else:
            return name
 
        
# 全局钩子
	-如果继承的是Serializer，写法一样
    -如果继承的是ModelSerializer，写法一样
	def validate(self, attrs):
        if attrs.get('name') == attrs.get('publish_date'):
            raise ValidationError('名字不能等于日期')
        else:
            return attrs

模型类序列化器(ModelSerializer)的使用

 class BookModelSerializer(serializers.ModelSerializer): #ModelSerializer继承Serializer
    # 不需要写字段了，字段从表模型映射过来
    class Meta:
        model = Book  # 要序列化的表模型
        # fields='__all__' # 所有字段都序列化
        fields = ['name', 'price', 'publish_date', 'publish', 'authors', 'publish_detail',
                  'author_list']  # 列表中有什么，就是序列化哪个字段
        # 给authors和publish加write_only属性
        # name加max_len属性
        extra_kwargs = {
            'name': {'max_length': 8},
            'publish': {'write_only': True},
            'authors': {'write_only': True},
        }

总结

 #  如何使用
	1 定义一个类继承ModelSerializer
    2 类内部写内部内 class Meta:
    3 在内部类中指定model(要序列化的表)
    4 在内部类中指定fields(要序列化的字段，写__all__表示所有，不包含方法，写[一个个字段])
    5 在内部类中指定extra_kwargs，给字段添加字段参数的
    6 在序列化类中，可以重写某个字段，优先使用你重写的
        name = serializers.SerializerMethodField()
    	def get_name(self, obj):
        	return 'sb---' + obj.name
 
    7 以后不需要重写create和update了
    	-ModelSerializer写好了，兼容性更好，任意表都可以直接存

反序列化数据校验源码分析(了解)

点击查看

  
# 先校验字段自己的规则(最大，最小)，走局部钩子校验，走全局钩子
# 局部：validate_name，全局叫：validate 为什么？
# 入口：从哪开始看，哪个操作，执行了字段校验ser.is_valid()
	-BaseSerializer内的is_valid()方法
	    def is_valid(self, *, raise_exception=False):
            if not hasattr(self, '_validated_data'):
                try:
                    # 真正的走校验，如果成功，返回校验过后的数据
                    self._validated_data = self.run_validation(self.initial_data)
                except ValidationError as exc:
            return not bool(self._errors) 
    """内部执行了：self.run_validation(self.initial_data)---》本质执行的Serializer的
    	如果你按住ctrl键，鼠标点击，会从当前类中找run_validation，找不到会去父类找
    	这不是代码的执行，代码执行要从头开始找，从自己身上再往上找 """
    	    def run_validation(self, data=empty):
                #局部钩子的执行
                value = self.to_internal_value(data)
                try:
                    # 全局钩子的执行，从根上开始找着执行，优先执行自己定义的序列化类中得全局钩子
                    value = self.validate(value)
                except (ValidationError, DjangoValidationError) as exc:
                    raise ValidationError(detail=as_serializer_error(exc))
                return value
  # 全局钩子看完了，局部钩子---》 self.to_internal_value---》从根上找----》本质执行的Serializer的
     def to_internal_value(self, data):
        for field in fields: # fields：序列化类中所有的字段，for循环每次取一个字段对象
            # 反射：去self：序列化类的对象中，反射 validate_字段名 的方法
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            try:
                # 这句话是字段自己的校验规则（最大最小长度）
                validated_value = field.run_validation(primitive_value)
                # 局部钩子
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail
        return ret  
 # 你自己写的序列化类---》继承了ModelSerializer---》继承了Serializer---》BaseSerializer---》Field

图书的5个接口(增删改查)
models.py

 from django.db import models
 
class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    publish_date = models.DateField(null=True)
 
    publish = models.ForeignKey(to='Publish',on_delete=models.CASCADE)
    authors = models.ManyToManyField(to='Author')
 
    def __str__(self):
        return self.name
 
    def publish_detail(self):
        return {'name': self.publish.name, 'city': self.publish.city, 'emial': self.publish.email}
 
    def author_list(self):
        res_list = []
        for author in self.authors.all():
            res_list.append({'id': author.id, 'name': author.name,'age': author.age})
        return res_list
 
class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)
 
    def __str__(self):
        return self.name
 
class AuthorDetail(models.Model):
    telephone = models.BigIntegerField()
    birthday = models.DateField()
    address = models.CharField(max_length=64)
 
class Publish(models.Model):
    name = models.CharField(max_length=32)
    city = models.CharField(max_length=32)
    email = models.EmailField()

ser.py

 class BookModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['name','price','publish', 'author', 'publish_date', 'publish_detail',
                  'author_list']
        extra_kwargs = {
            'name': {'max_length': 8, 'min_length': 3},
            'price': {'max_value': 199, 'min_value': 9},
            'publish': {'write_only': True},
            'authors': {'write_only': True}
        }
    def validate_name(self,name):
        if 'sb' in name:
            raise ValidationError('名字不能有sb')
        else:
            return name
 
    def validate_price(self,price):
        if price == 66:
            raise ValidationError('价格不能是66')
        else:
            return price

views.py

 class BookView(APIView):
    # 获取所有
    def get(self, request):
        book_list = models.Book.objects.all()
        res = BookModelSerializer(instance=book_list, many=True)
        return  Response(res.data)
    # 新增
    def post(self, request):
        res = BookModelSerializer(data=request.data)
        if res.is_valid():
            res.save()
            return Response({'code': 100, 'msg': '新增成功'})
        else:
            return Response({'code': 1000, 'msg': res.errors})
 
class BookDetailView(APIView):
    # 获取单个
    def get(self, request,pk):
        book = models.Book.objects.filter(pk=pk).first()
        res = BookModelSerializer(instance=book)
        return Response(res.data)
    # 删除
    def delete(self,request,pk):
        models.Book.objects.filter(pk=pk).delete()
        return Response()
    # 修改
    def put(self,request,pk):
        book = models.Book.objects.filter(pk=pk).first()
        res = BookModelSerializer(instance=book, data=request.data)
        if res.is_valid():
            res.save()
            return Response({'code': 100, 'msg':'修改成功'})
        else:
            return Response({'code': 1000, 'msg': res.errors})

posted @ 2022-09-27 21:51 你好你好你好丶阅读(52) 评论(0) 编辑收藏举报

刷新页面返回顶部

（评论功能已被禁用）

相关博文：

· 今日内容序列化与反序列化实现增删改查

· 今日内容，课程板块相关表的创建以及课程接口的编写

· 序列化类常用字段类和字段参数,序列化类高级用法之source,反序列化之数据校验, 模型类序列化器（ModelSerializer）的使用

· 1 序列化类常用字段和字段参数（了解）、 2 序列化高级用法之source(了解) 、3 序列化高级用法之定制字段的两种方式、4 多表关联反序列化保存、 5 反序列化字段校验其他、 6 ModelSerializer使用

· 序列化类常用字段和字段参数、序列化高级用法——source、序列化高级用法之定制字段的两种方式、多表关联反序列化保存、序列化字段校验其他、ModelSerializer的使用

公告

昵称：你好你好你好丶
园龄： 2年8个月
粉丝： 4
关注： 6

+加关注

2025年3月

日

一

二

三

四

五

六

随笔分类

随笔档案

阅读排行榜

评论排行榜

1. 今日内容爬取京东网站数据(3)

tai-yang77

今日内容序列化类的高级用法

序列化类常用字段类和字段参数

序列化类高级用法之source，修改序列化字段名字

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

反序列化之数据校验

模型类序列化器(ModelSerializer)的使用

反序列化数据校验源码分析(了解)

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

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

	# source的使用
	不使用source参数时，会默认序列化表名.字段名
	使用source参数时，序列化表名.source的参数下方以Book表为例
	class BookSerializer(serializers.Serializer):
	name_detail = serializers.CharField(max_length=8, min_length=3,source='name') # 可以改字段名字
	# 或
	publish_name = serializers.CharField(max_length=8, min_length=3,source='publish.name') # 可以.跨表查
	# 或
	xx = serializers.CharField(max_length=8, min_length=3,source='xx') # 可以执行方法

	# 前端显示形式
	{
	"name": "西游记",
	"price": 33,
	"publish": {name:xx,city:xxx,email:sss}
	}

	# 第一种：在【序列化类】中写SerializerMethodField
	publish = serializers.SerializerMethodField()
	def get_publish(self, obj):
	# obj 是当前序列化的对象
	return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}
	# 第二种：在【表模型】中写方法（又多一些）
	def publish_detail(self):
	return {'name': self.publish.name, 'city': self.publish.city, 'email': self.publish.email}
	在序列化中取
	publish_detail=serializers.DictField()

	class BookSerializer(serializers.Serializer):
	name = serializers.CharField(max_length=8, min_length=3)
	price = serializers.IntegerField(min_value=10, max_value=99)
	publish_date = serializers.DateField()
	# publish要序列化成 {name:北京出版社，city：北京，email:2@qq.com}
	# 方式一：SerializerMethodField必须配合一个方法(get_字段名,需要接受一个参数)，方法返回什么，这个字段就是什么
	publish = serializers.SerializerMethodField()
	def get_publish(self, obj):
	# obj 是当前序列化的对象
	return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}

	# 练习，用方式一，显示所有作者对象 []
	authors = serializers.SerializerMethodField()
	def get_authors(self, obj):
	res_list = []
	for author in obj.authors.all():
	res_list.append({'id': author.id, 'name': author.name, 'age': author.age})
	return res_list

	# 表模型中
	class Book(models.Model):
	name = models.CharField(max_length=32)
	price = models.DecimalField(max_digits=5, decimal_places=2)
	publish_date = models.DateField(null=True)

	publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
	authors = models.ManyToManyField(to='Author')

	# 写了个方法，可以包装成数据属性，也可以不包
	def publish_detail(self):
	return {'name': self.publish.name, 'city': self.publish.city, 'email': self.publish.email}

	def author_list(self):
	res_list = []
	for author in self.authors.all():
	res_list.append({'id': author.id, 'name': author.name, 'age': author.age})
	return res_list

	# 1 序列化字段和反序列化字段不一样【序列化类中】
	# 反序列化用的
	publish = serializers.CharField(write_only=True)
	authors = serializers.ListField(write_only=True)
	#序列化用的
	publish_detail = serializers.DictField(read_only=True)
	author_list = serializers.ListField(read_only=True)

	# 2 一定要重写create 【序列化类中】
	def create(self, validated_data):
	# validated_data 校验过后的数据
	{"name":"三国1演义",
	"price":19,
	"publish_date": "2022-09-27",
	"publish":1,
	"authors":[1,2]
	}
	book = Book.objects.create(name=validated_data.get('name'),
	price=validated_data.get('price'),
	publish_date=validated_data.get('publish_date'),
	publish_id=validated_data.get('publish'),
	)
	authors = validated_data.get('authors')
	book.authors.add(*authors)
	return book

	# 跟forms很像
	-字段自己的校验规则
	-局部钩子
	-全局钩子


	# 字段自己的校验规则
	-如果继承的是Serializer，写法如下
	name=serializers.CharField(max_length=8,min_length=3,error_messages={'min_length': "太短了"})
	-如果继承的是ModelSerializer，写法如下
	extra_kwargs = {
	'name': {'max_length': 8, 'min_length': 3, 'error_messages': {'min_length': "太短了"}},
	}


	# 局部钩子
	-如果继承的是Serializer，写法一样
	-如果继承的是ModelSerializer，写法一样
	def validate_name(self, name):
	if name.startswith('sb'):
	# 校验不通过，抛异常
	raise ValidationError('不能以sb卡头')
	else:
	return name


	# 全局钩子
	-如果继承的是Serializer，写法一样
	-如果继承的是ModelSerializer，写法一样
	def validate(self, attrs):
	if attrs.get('name') == attrs.get('publish_date'):
	raise ValidationError('名字不能等于日期')
	else:
	return attrs

	class BookModelSerializer(serializers.ModelSerializer): #ModelSerializer继承Serializer
	# 不需要写字段了，字段从表模型映射过来
	class Meta:
	model = Book # 要序列化的表模型
	# fields='__all__' # 所有字段都序列化
	fields = ['name', 'price', 'publish_date', 'publish', 'authors', 'publish_detail',
	'author_list'] # 列表中有什么，就是序列化哪个字段
	# 给authors和publish加write_only属性
	# name加max_len属性
	extra_kwargs = {
	'name': {'max_length': 8},
	'publish': {'write_only': True},
	'authors': {'write_only': True},
	}

	# 如何使用
	1 定义一个类继承ModelSerializer
	2 类内部写内部内 class Meta:
	3 在内部类中指定model(要序列化的表)
	4 在内部类中指定fields(要序列化的字段，写__all__表示所有，不包含方法，写[一个个字段])
	5 在内部类中指定extra_kwargs，给字段添加字段参数的
	6 在序列化类中，可以重写某个字段，优先使用你重写的
	name = serializers.SerializerMethodField()
	def get_name(self, obj):
	return 'sb---' + obj.name

	7 以后不需要重写create和update了
	-ModelSerializer写好了，兼容性更好，任意表都可以直接存


	# 先校验字段自己的规则(最大，最小)，走局部钩子校验，走全局钩子
	# 局部：validate_name，全局叫：validate 为什么？
	# 入口：从哪开始看，哪个操作，执行了字段校验ser.is_valid()
	-BaseSerializer内的is_valid()方法
	def is_valid(self, *, raise_exception=False):
	if not hasattr(self, '_validated_data'):
	try:
	# 真正的走校验，如果成功，返回校验过后的数据
	self._validated_data = self.run_validation(self.initial_data)
	except ValidationError as exc:
	return not bool(self._errors)
	"""内部执行了：self.run_validation(self.initial_data)---》本质执行的Serializer的
	如果你按住ctrl键，鼠标点击，会从当前类中找run_validation，找不到会去父类找
	这不是代码的执行，代码执行要从头开始找，从自己身上再往上找 """
	def run_validation(self, data=empty):
	#局部钩子的执行
	value = self.to_internal_value(data)
	try:
	# 全局钩子的执行，从根上开始找着执行，优先执行自己定义的序列化类中得全局钩子
	value = self.validate(value)
	except (ValidationError, DjangoValidationError) as exc:
	raise ValidationError(detail=as_serializer_error(exc))
	return value
	# 全局钩子看完了，局部钩子---》 self.to_internal_value---》从根上找----》本质执行的Serializer的
	def to_internal_value(self, data):
	for field in fields: # fields：序列化类中所有的字段，for循环每次取一个字段对象
	# 反射：去self：序列化类的对象中，反射 validate_字段名的方法
	validate_method = getattr(self, 'validate_' + field.field_name, None)
	try:
	# 这句话是字段自己的校验规则（最大最小长度）
	validated_value = field.run_validation(primitive_value)
	# 局部钩子
	if validate_method is not None:
	validated_value = validate_method(validated_value)
	except ValidationError as exc:
	errors[field.field_name] = exc.detail
	return ret
	# 你自己写的序列化类---》继承了ModelSerializer---》继承了Serializer---》BaseSerializer---》Field

	from django.db import models

	class Book(models.Model):
	name = models.CharField(max_length=32)
	price = models.DecimalField(max_digits=5, decimal_places=2)
	publish_date = models.DateField(null=True)

	publish = models.ForeignKey(to='Publish',on_delete=models.CASCADE)
	authors = models.ManyToManyField(to='Author')

	def __str__(self):
	return self.name

	def publish_detail(self):
	return {'name': self.publish.name, 'city': self.publish.city, 'emial': self.publish.email}

	def author_list(self):
	res_list = []
	for author in self.authors.all():
	res_list.append({'id': author.id, 'name': author.name,'age': author.age})
	return res_list

	class Author(models.Model):
	name = models.CharField(max_length=32)
	age = models.IntegerField()
	author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)

	def __str__(self):
	return self.name

	class AuthorDetail(models.Model):
	telephone = models.BigIntegerField()
	birthday = models.DateField()
	address = models.CharField(max_length=64)

	class Publish(models.Model):
	name = models.CharField(max_length=32)
	city = models.CharField(max_length=32)
	email = models.EmailField()

	class BookModelSerializer(serializers.ModelSerializer):
	class Meta:
	model = Book
	fields = ['name','price','publish', 'author', 'publish_date', 'publish_detail',
	'author_list']
	extra_kwargs = {
	'name': {'max_length': 8, 'min_length': 3},
	'price': {'max_value': 199, 'min_value': 9},
	'publish': {'write_only': True},
	'authors': {'write_only': True}
	}
	def validate_name(self,name):
	if 'sb' in name:
	raise ValidationError('名字不能有sb')
	else:
	return name

	def validate_price(self,price):
	if price == 66:
	raise ValidationError('价格不能是66')
	else:
	return price

	class BookView(APIView):
	# 获取所有
	def get(self, request):
	book_list = models.Book.objects.all()
	res = BookModelSerializer(instance=book_list, many=True)
	return Response(res.data)
	# 新增
	def post(self, request):
	res = BookModelSerializer(data=request.data)
	if res.is_valid():
	res.save()
	return Response({'code': 100, 'msg': '新增成功'})
	else:
	return Response({'code': 1000, 'msg': res.errors})

	class BookDetailView(APIView):
	# 获取单个
	def get(self, request,pk):
	book = models.Book.objects.filter(pk=pk).first()
	res = BookModelSerializer(instance=book)
	return Response(res.data)
	# 删除
	def delete(self,request,pk):
	models.Book.objects.filter(pk=pk).delete()
	return Response()
	# 修改
	def put(self,request,pk):
	book = models.Book.objects.filter(pk=pk).first()
	res = BookModelSerializer(instance=book, data=request.data)
	if res.is_valid():
	res.save()
	return Response({'code': 100, 'msg':'修改成功'})
	else:
	return Response({'code': 1000, 'msg': res.errors})

tai-yang77

今日内容 序列化类的高级用法

序列化类常用字段类和字段参数

序列化类高级用法之source，修改序列化字段名字

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

反序列化之数据校验

模型类序列化器(ModelSerializer)的使用

反序列化数据校验源码分析(了解)

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

今日内容序列化类的高级用法