drf之序列化

1 新的request有个data属性，以后只要是在请求body体中的数据，无论什么编码格式，无论什么请求方式
2 取文件还是从：request.FILES
3 取其他属性，跟之前完全一样 request.method  ....
	-原理是：新的Request重写了__getattr__，通过反射获取老的request中的属性
4 request.GET 现在可以使用 request.query_params
	   @property
        def query_params(self):
            return self._request.GET

-老的request在新的request._request
-照常理来讲，如果取method，应该request._request.method,但是我现在可以request.method

from django.db import models

# Create your models here.

class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.IntegerField()

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

from rest_framework import serializers

class BookSerializer(serializers.Serializer):
    # 要序列化的字段
    # id = serializers.IntegerField()
    name = serializers.CharField()
    # price = serializers.IntegerField()

# IntegerField      CharField   DateTimeField  DecimalField

# ListField和DictField---》比较重要，但是后面以案例形式讲

# read_only   write_only   很重要，后面以案例讲

# 反序列化，有三层校验
    -1 字段自己的（写的字段参数：required   max_length 。。。）
    -2 局部钩子：写在序列化类中的方法，方法名必须是 validate_字段名
    	def validate_name(self, name):
            if 'sb' in name:
                # 不合法，抛异常
                raise ValidationError('书名中不能包含sb')
            else:
                return name
    -3 全局钩子：写在序列化类中的方法 方法名必须是 validate
       def validate(self, attrs):
            price = attrs.get('price')
            name = attrs.get('name')
            if name == price:
                raise ValidationError('价格不能等于书名')
            else:
                return attrs
            
  # 只有三层都通过，在视图类中：
	ser.is_valid():  才是True，才能保存

from rest_framework import serializers

from rest_framework.exceptions import ValidationError



class BookSerializer(serializers.Serializer):
    # 要序列化的字段
    id = serializers.IntegerField(required=False)    # required=false表示可以不填
    name = serializers.CharField(allow_blank=True, required=False, max_length=8,
                                 min_length=3, error_messages={'max_length': '太长了'}) # allow_blank 这个字段传了，value值可以为空

    price = serializers.IntegerField(max_value=100, min_value=10, error_messages={'max_value': '必须小于100'})


    # 局部钩子， 给某个字段做个校验
    # 书名中不能包含sb
    # 一定要写成validate_字段名的形式
    def validate_name(self, name):
        if 'sb' in name:
            # 不合法，抛异常
            raise ValidationError('书名中不能包含sb')
        else:
            return name



    def validate_price(self, price):
         if price == 88:
             raise ValidationError('价格不能等于88')
         else:
             return price

    # 全局钩子
    # 价格和书名不能一样 validate
    def validate(self, attrs):
        price = attrs.get('price')
        name = attrs.get('name')
        if name == price:
            raise ValidationError('价格不能等于书名')
        else:
            return attrs

-序列化类的对象，实例化的时候：ser = BookSerializer(data=request.data)
-数据校验过后----》调用  序列化类.save()--->但是要在序列化类中重写  create方法
    def create(self, validated_data):
        book=Book.objects.create(**validated_data)
        return book

-序列化类的对象，实例化的时候：ser = BookSerializer(instance=book,data=request.data)
-数据校验过后----》调用  序列化类.save()--->但是要在序列化类中重写  update方法
    def update(self, book, validated_data):
        for item in validated_data:  # {"name":"jinping","price":55}
            setattr(book, item, validated_data[item])
        book.save()
        return book

在视图类中，无论是保存还是修改，都是调用序列化类.save()，底层实现是根据instance做一个判断

    def create(self, validated_data):
        # validated_data校验过后的数据，字典
        book = Book.objects.create(**validated_data)
        return book

  # 新增
    def post(self, request):
        # 前端会传入数据，request.data--->把这个数据保存到数据库中
        # 借助于序列化类，完成 校验和反序列化
        # data 前端传入的数据 {"name":"三国演义","price":88}
        ser = BookSerializer(data=request.data)
        # 校验数据
        if ser.is_valid():  # 三层：字段自己的校验，局部钩子校验，全局钩子校验
            # 校验通过，保存
            print(ser.validated_data)  # validated_data：校验过后的数据
            # 如果没有save，如何保存，自己做
            # Book.objects.create(**ser.validated_data)
            ser.save()  # 会保存，但是会报错,因为它不知道你要保存到那个表中
            return Response({'code': 100, 'msg': '新增成功'})
        else:
            print(ser.errors)  # 校验失败的错误
            return Response({'code': 101, 'msg': '新增失败', 'errors': ser.errors})

    # def update(self, book, validated_data):
    #     # instance 要修改的对象
    #     # validated_data：前端传入，并且校验过后的数据
    #     book.name = validated_data.get('name')
    #     book.price = validated_data.get('price')
    #     # 一定不要忘了
    #     book.save()
    #     return book
	#更高级的写法
    def update(self, book, validated_data):

        for item in validated_data:  # {"name":"jinping","price":55}
            setattr(book, item, validated_data[item])
            # 等同于下面
            # setattr(book,'name','jinping')
            # setattr(book,'price',55)
            # 等同于
            #     book.name = validated_data.get('name')
            #     book.price = validated_data.get('price')
        book.save()
        return book

    def put(self, request, pk):
        book = Book.objects.get(pk=pk)
        ser = BookSerializer(instance=book, data=request.data)
        if ser.is_valid():
            ser.save() # 也会报错，重写update
            return Response({'code': 100, 'msg': '修改成功'})
        else:
            return Response({'code': 101, 'msg': '修改失败', 'errors': ser.errors})