drf知识--03

内容回顾

# APIView的执行流程总结：

    1、去除了csrf：csrf攻击原理是浏览器会自动携带cookie，前后端分离后发送ajax请求，cookie是否携带取决于我们代码如何写，不取决于浏览器，于是不存在csrf攻击了
    2、包装了新的request：drf提供的requset：data，用起来跟之前一样
    3、在实现视图类方法之前：执行了三大认证
    4、处理了全局异常

# 新的Request类总结：

 · 老的request还在新的request内部  request._request
 · 新的用起来跟老的一样:

                原因是重写了魔法方法  __getattr__ 
                对象.属性，属性不存在会触发 __getattr__的执行，内部通过反射找到老的request中对应的属性
 ·  request.data  多了这个属性，以后无论何种编码和何种请求方式，都能取出携带的数据
        post，put，get：要放在body体中，都能取出来，当字典用
        如果是urlencoded，form-data编码：OrderedDict，原来的request.POST 对象
        如果是json编码：dict
  · 如果form-data编码：取数据：request.data      取文件：request.FILES中取
  · 请求地址栏中参数：request.GET中取 / request.query_params 中取
        query_params：查询参数
        请求地址中带查询参数: query_params

序列化类

# drf提供的一种可以帮助我们快速，序列化，校验数据，反序列化的组件
# 序列化：
        -1 写个py文件 serializer.py
        -2 在py文件中写类--》PublishSerializer
        -3 在类中写字段：serializers.CharField
        -4 在字段上写字段属性：CharField(max_length=12, min_length=3, required=True, allow_null=True)
        -5 视图类中使用
            serializer=PublishSerializer(instance=要序列化的数据qs,单个对象,many=True)
            serializer.data  # 字典
            return Response(serializer.data )
# 校验：三层
在序列化类中写:

字典自己的：字段属性来控制
局部钩子：def validate_name(self, name)
    校验通过返回该字段
    校验失败，抛：ValidationError
全局钩子：def validate(self, attrs):
    attrs：校验过后的数据，前端携带的数据多，经过它以后，就没了
    校验多个字段

视图类中使用:

新增:
serializer=PublishSerializer(data=request.data)
ser.is_valid()
ser.save()   # 后续还要写
修改:
serializer=PublishSerializer(instance=单个对象，data=request.data)
ser.is_valid()
ser.save() # 后续还要写

保存(新增，修改)：

序列化类中写两个方法
create：publish = Publish.objects.create(**validated_data)
update：instance, validated_data
for key in validated_data:
    setattr(instance,key,validated_data[key])
instance.save()
视图类方法中使用：
ser.save()# 根据是否有instance决定执行create还是update

序列化类常用字段

# 序列化的常用字段和表模型的  models.CharField字段基本一一对应
# 如果跟表模型中对不上统一用  CharField

# 重要：
        ListField
        DictField

字段	字段构造方式
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=)

序列化字段常用参数

### 字段参数

CharField(max_length=None, min_length=None, allow_blank=False, trim_whitespace=True)
max_length :校验，最大长度
min_length：校验最短长度
allow_blank：是否允许为空
trim_whitespace：去掉前后的空白

DateTimeField(format=api_settings.DATETIME_FORMAT)
format:格式化成的样子
    
IntegerField(max_value=None, min_value=None)
max_value ：数字
min_value：数字

### 通用参数(所有字段类上都可以加)
read_only    表明该字段仅用于序列化输出，默认False
write_only    表明该字段仅用于反序列化输入，默认False
required    表明该字段在反序列化时必须输入，默认True
default         反序列化时使用的默认值
allow_null     表明该字段是否允许传入None，默认False
validators     该字段使用的验证器：validators=[方法]，方法对该字段做校验
error_messages    包含错误编号与错误信息的字典
label         用于HTML展示API页面时，显示的字段名称
help_text     用于HTML展示API页面时，显示的字段帮助提示信息
# 字段校验有四层：
            -1 字段自己
            -2 validators校验  忽略
            -3 局部钩子
            -4 全局钩子

修改项目或文件名字操作

# 修改项目名字：
修改项目名---能顺利运行，按照如下图操作:

改文件夹名---如果改了文件夹名，全局替换:

序列化高级用法之soruce

#1 修改字段，映射字段：
        publish_name表中不存在
        publish_name = serializers.CharField(source='name')

#2 修改字段，映射方法：
        sb_name是表模型中一个方法
        name = serializers.CharField(source='sb_name')

#3 修改字段，跨表查询
        book表中可以链表查询
        publish=models.ForeignKey(to='Publish.name')

序列化高级用法之定制返回字段

# 多表关联序列化

# 定制序列化返回的字段格式
方案一：在表模型中写，在序列化类中映射(可以使用source）

models.py:

serializer.py:            # 返回值用Dict, 列表用Li

前端看到:

方案二：在序列化类中写SerializerMethodField，必须配合一个方法 get_字段名，方法返回什么，前端就看到什么，只在序列化类中写就行，模型层不用写
 Serializer.py:

前端看到：

# 代码总结：

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 = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    authors = models.ManyToManyField(to='Author')
    def __str__(self):
        return self.name
    # def book_name(self):
    #     return self.name+'sb'
    # def publish_detail(self):
    #     return {'name': self.publish.name, 'city': self.publish.city}
    #
    # def author_list(self):
    #     l = []
    #     for author in self.authors.all():
    #         l.append({'name': author.name, 'age': author.age})
    #     return l
、
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()
    def __str__(self):
        return self.name
    class Meta:
        verbose_name = '出版社'
        verbose_name_plural = verbose_name

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

serializer.py
### 定制返回字段
class BookSerializer(serializers.Serializer):
    name = serializers.CharField()
    price = serializers.CharField()
    #方案一：在表模型中写方法，在序列化类中做映射
    # publish_detail = serializers.DictField()  # publish_detail 会映射表模型中 publish_detail方法，方法返回值是 字典，用DictField接收
    # author_list = serializers.ListField()

    #方案二：在序列化类中写  SerializerMethodField
    # 只要写了这个字段类SerializerMethodField，必须配合一个方法：get_字段名，这个方法返回什么，前端这个字段就显示什么
    publish_detail = serializers.SerializerMethodField()
    def get_publish_detail(self, obj):
        # 当前序列化到的book对象
        return {'name': obj.publish.name, 'city': obj.publish.city}

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

    book_name = serializers.SerializerMethodField()
    def get_book_name(self, obj):
        return obj.name + 'sb'

多表关联反序列化

# 反序列化保存
# 使用同一个序列化类会出现，序列化字段和反序列化字段不一致
  序列化字段：name、price、publish_detail、author_list
  反序列化字段：name、price、publish、author
# 如果是共同的，不需要额外处理
   如果是不同的，需要通过字段参数控制
        read_only    表明该字段仅用于序列化输出，默认False，序列化过程
        write_only    表明该字段仅用于反序列化输入，默认False，反序列化过程

# 多表反序列化校验跟之前一样

serializer.py
class BookSerializer(serializers.Serializer):
    name = serializers.CharField()  # 公共的
    price = serializers.CharField()  # 公共的
    publish = serializers.IntegerField(write_only=True)  # 只用来做反序列化
    authors = serializers.ListField(write_only=True)  # 只用来做反序列化
    publish_detail = serializers.SerializerMethodField(read_only=True)  # 只用来做序列化
    author_list = serializers.SerializerMethodField(read_only=True)  # 只用来做序列化

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

    def create(self, validated_data):
        # {name,price,publish:1,authors:[1,2]}
        authors = validated_data.pop('authors')
        book = Book.objects.create(name=validated_data.get('name'), price=validated_data.get('price'),publish_id=validated_data.get('publish'))
        book.authors.add(*authors)
        return book

    def update(self, instance, validated_data):
        # {name,price,publish:1,authors:[1,2]}
        authors = validated_data.pop('authors')
        validated_data['publish_id'] = validated_data.pop('publish')
        for key in validated_data:
            setattr(instance, key, validated_data[key])

        instance.save()
        # 先清空在放入
        # instance.authors.clear()
        # instance.authors.add(*authors)
        # 直接存
        instance.authors.set(authors)
        return instance

views.py
class BookView(APIView):
    def post(self, request):
        ser = BookSerializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response(ser.data)
        else:
            return Response(ser.errors)

class BookDetail(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()
            return Response(ser.data)
        else:
            return Response(ser.errors)

urls.py
urlpatterns = [
    path('books/', views.BookView.as_view()),
    path('books/<int:pk>/', views.BookDetail.as_view()),
]

ModelSerializer使用

# 之前写的序列化类，继承了serializers.Serializer，跟表没有必然联系
# ModelSerializer跟表一一对应,以后基本需要重写create和update

serializer.py
# 继承ModelSerializer--->少写代码
class Meta:
   model = Book  # 写了这两句，会把表模型中Book，所有字段映射过来
   # fields='__all__'
   fields = ['name', 'price', 'publish', 'authors', 'publish_detail', 'author_list']
   extra_kwargs = {  # 给某个或某几个字段设置字段属性
       'name': {'max_length': 18, 'min_length': 3},
       'publish': {'write_only': True},
       'authors': {'write_only': True},
       'publish_detail': {'read_only': True},
       'author_list': {'read_only': True},
    }
    # 一般不需要写create和update了---》ModelSerializer帮咱们实现了
    # 局部钩子和全局钩子，该怎么写还怎么写
    # def validate_name(self,name):
    #     pass

今日思维导图：