标签：ModelSerializer name models max publish length 序列化 drf

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

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

序列化类的字段类

字段名 = serializers.字段类型(字段参数)

主要的字段类

CharField
BooleanField
IntegerField
DecimalField

其他的字段类

NullBooleanField	    NullBooleanField()
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)
FloatField	            FloatField(max_value=None, min_value=None)
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=)

常用字段参数

选项参数(只能作用于专门的字段类上)

选项参数(给CharField字段类使用的参数)

max_length	    最大长度
min_lenght	    最小长度
allow_blank	    是否允许为空
trim_whitespace	是否截断空白字符

选项参数(给IntergerField字段类使用的参数)

max_value	最小值
min_value	最大值

通用参数(放在那个字段类上都可以)

read_only和write_only很重要


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

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

序列化高级用法之sourse

定义一个大表

from django.db import models


# Create your models here.
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


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()
    addr = models.CharField(max_length=64)


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

定义一个视图类

from app01.serializer import BookSerializer
from .models import Book
from rest_framework.views import APIView
from rest_framework.response import Response


# Create your views here.


class BookView(APIView):
    def get(self, request):
        book_list = Book.objects.all()
        ser = BookSerializer(instance=book_list, many=True)
        return Response(ser.data)

添加字段，如果想在django admin中操作需要创建超级用户

createsuperuser

在admin.py中注册一下字段

* 是将models中的所有字段导进来，我们也可以到单个字段 from .models import 字段名1，字段名2...

from django.contrib import admin

# Register your models here.
from .models import *
admin.site.register(Book)
admin.site.register(Author)
admin.site.register(AuthorDetail)
admin.site.register(Publish)

serializer.py

source指定字段

from rest_framework import serializers


class BookSerializer(serializers.Serializer):
    # book = serializers.CharField()
    book_name = serializers.CharField(source='name') # 这句话的意思就是book_name最后的值就是source='name'的值
    price = serializers.CharField()
    publish_date = serializers.DateField(source='publish.name')

source修改序列化字段名字

1. source指定的可以是字段，

2. 也可以是方法，用于重命名

3. 使用source，字段参数，可以指定序列化表中得哪个字段(任意的字段)

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 scx_name(self):
        return 'scx>>'+self.name

source指定任意字段（跨表查询）

source指定方法

注意

source指定的字段名不能和前面的变量名一致

publish_date = serializers.DateField(source='publish_date')

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

方式一：在【序列化类】中写SerializerMethodField

SerializerMethodField必须配合一个方法(get_字段名,需要接受一个参数)

这个方法返回啥字段名publish就会接收啥

obj就是当前序列化的对象也就是上面的Book

所以说在序列化类中的字段名都是一个个的对象因为字段类()就会产生一个个的对象

如果是多对多的关系，obj直接去点的话会出现多个对象，所以要弄成列表的形式返回出去

author = serializers.SerializerMethodField()
def get_author(self,obj):
    res_list = []
    res = obj.authors.all()
    for authors in res:
        res_list.append({'name':authors.name,'age':authors.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}

在class BookSerializer(serializers.Serializer): 直接去取

如果用publish_detail = serializers.CharField()这种方法去取会是字符串的形式我们要用DictField转换成字典的形式

publish_detail = serializers.DictField()

# 在模型类中写逻辑代码，称之为ddd，领域驱动模型

在models模型类中编写方法，拿到所有的作者信息

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

book_authors = serializers.ListField()

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

序列化字段和反序列化字段不一样【序列化类中】

反序列化用的 write_only=True

publish = serializers.CharField(write_only=True)
authors = serializers.ListField(write_only=True)

序列化用的 read_only=True

publish_detail = serializers.DictField(read_only=True)
author_list = serializers.ListField(read_only=True)

一定要重写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

缺点
1 在序列化中每个字段都要写，无论是序列化还是反序列化
2 如果新增或者修改，在序列化类中都需要重写create或update

反序列化之数据校验

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

# 给name字段加局部钩子，一定不要写在内部类中
def validate_name(self, name):
    if name.startswith('sb'):
        # 校验不通过，抛异常
        raise ValidationError('不能以sb卡头')
    else:
        return name

def validate_price(self, price):
    if price == 44:
        raise ValidationError('不能是44，没有为什么')
    else:
        return price

-全局钩子

def validate(self, attrs):
    if attrs.get('name') == attrs.get('publish_date'):
        raise ValidationError('名字不能等于日期')
    else:
        return attrs

-如果继承的是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': "太短了"}},
}

模型类序列化器（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},
        }  
   publish_detail = serializers.SerializerMethodField(read_only=True)
	 ...
   author_list = serializers.SerializerMethodField(read_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写好了，兼容性更好，任意表都可以直接存

断言assert

# 框架的源码中，大量使用断言


# assert :断言，作用的判断，断定一个变量必须是xx，如果不是就报错

# 你的土鳖写法
# name = 'lqz1'
# if not name == 'lqz':
#     raise Exception('name不等于lqz')
#
# print('程序执行完了')

# assert的断言写法
name = 'lqz1'
assert name == 'lqz', 'name不等于lqz'
print('程序执行完了')

标签：ModelSerializer,name,models,max,publish,length,序列化,drf
From： https://www.cnblogs.com/scx-xiaochun/p/16736197.html

drf ModelSerializer模型类序列化器