python之路62 drf从入门到成神 3 序列化类常用字段和字段参数、序列化高级用法之source、序列化高级用法之定制字段的两种方式、多表关联反序列化保存新增、反序列化字段校验其他、ModelSerializer使用

作业

# 原生的django中request中没有data

from django.shortcuts import render,HttpResponse

import json

# 通过装饰器做,装饰器视图函数的，以后都会有request

def wrapper(func):
    def inner(request,*args,**kwargs):
        #造个新的reuqest
        # 如果是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(func)
def test(request):
    print(request.POST) # urlencoded,form-data ---->QueryDict
    print(request.data)  # request.POST有值就报错  这里执行不报错是因为加了异常捕获
    return HttpResponse('ok')

总结: 前端提交数据的编码格式
   urlencided：
       name=%E5%93%88%E5%93%88%E5%93%88&price=222 放在了请求体中
   form-data：分数据部分和文件部分
       '--------------------------585520151165741599946333\r\n
        Content-Disposition: form-data; 
        name="name"\r\n\r\nlqz\r\n
        ----------------------------585520151165741599946333--\r\n'
    json格式：{"name": "新聊斋11","price": "778","publish": "北京出版社"}

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

# 序列化类---》字段类 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)




# 记住：CharField  IntegerField  DecimalField  DateTimeField BooleanField
ListField  # 重要
DictField  # 重要

常用字段参数

选项参数
# 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(calidators=[方法，])
3.局部钩子校验规则
4.全局钩子校验规则

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

# 创建关联表

class Book(models.Model):
    name = models.CharField(max_length=32)
    peice = 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)

    # 指定在book中显示publish的名字方案一 用的不多
    # def __str__(self):
    #     return self.name
class Author(models.Model):
    name = models.CharField(max_length=32)
    phone = models.CharField(max_length=11)

执行数据迁移 连接数据库 后台手动创建数据

序列化定制字段名字(重点)

# 重点：source可以指定序列化字段的名字
    自有字段，直接写字段名字
        name_real = serializers.CharField(max_length=8,source='name')

    关联字段，一对多的关联，直接点
      publish = serializer.CharField(source='publish.name')
     或者在models里添加__str__fang方法
          # 指定在book中显示publish的名字方案一 用的不多
    def __str__(self):
        return self.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')  # 因为是序列化的 所以前端显示为一个个id

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

SerializerMethodField定制方式一序列化类中定制

# 定制关联字段的显示形式
    一对多的 显示字典
    多对多 显示列表套字典

#代码
from rest_framework import serializers
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

在表模型中定制

表模型代码

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')

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

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

序列化类

from rest_framework import serializers
class BookSerializer(serializers.Serializer):


    name = serializers.CharField(max_length=8)
    price = serializers.CharField()

    # 只能用来序列化 不能反序列化 用来配合表模型中的方法
    publish_detail = serializers.DictField()
    author_list = serializers.ListField()

多表关联反序列化保存

新增图书接口

# 新增图书接口
    前端传入的数据格式：{name:红楼梦，price:19，publish:1,authors:[1,2]}

# 视图类
from rest_framework.views import APIView
from .models import Book, Publish, Author
from .serializer import BookSerializer
from rest_framework.response import Response


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

        return Response(ser.data)
    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})

# 序列化类
from rest_framework import serializers
from .models import Book,Publish,Author
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

注意前端提交的数据格式
eg:
      {
    "name": "新聊斋11",
    "price": "778",
    "publish": 1,
    "authors":[1,2]
}

修改图书接口

# 新增图书接口
    前端传入的数据格式：{name:红楼梦,price:19,publish:1,authors:[1,2]}

视图类
class BookDetailView(APIView):
    def get(self, request, pk):
        books = Book.objects.filter(pk=pk).first()
        ser = BookSerializer(instance=books)
        return Response(ser.data)

    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})

序列化类

from rest_framework import serializers
from .models import Book, Publish, Author
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)

    # 修改要重写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

反序列化字段校验其他

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

ModelSerializer使用

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

from rest_framework import serializers
from .models import Book, Publish, Author
from rest_framework.exceptions import ValidationError

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 给字段类加属性  ----》方式1
        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