Serializer和ModelSerializer

1.序列化器组件介绍

　　1. 序列化,序列化器会把模型对象转换成字典,经过response以后变成json字符串
　　2. 反序列化,把客户端发送过来的数据,经过request以后变成字典,序列化器可以把字典转成模型
　　3. 反序列化,完成数据校验功能

2 简单使用

　　1 写一个序列化的类，继承Serializer
　　2 在类中写要序列化的字段，想序列化哪个字段，就在类中写哪个字段
　　3 在视图类中使用，导入--》实例化得到序列化类的对象，把要序列化的对象传入
　　4 序列化类的对象.data 是一个字典
　　5 把字典返回，如果不使用rest_framework提供的Response,就得使用JsonResponse

2.1 序列化器实现get(查单个数据)接口

class book(models.Model):
    id = models.AutoField(primary_key=True,verbose_name='主键')
    name = models.CharField(max_length=32,verbose_name='书名')
    price = models.FloatField(verbose_name='价格')
    auth = models.CharField(max_length=32,verbose_name='作者')

　　新建一个py文件 （utils.py） 创建序列化器

from rest_framework import serializersclass BookSerializers(serializers.Serializer):
    id = serializers.CharField()
    name = serializers.CharField()
    price = serializers.CharField()
    auth = serializers.CharField()

　　urls.py中创建视图

url(r'^books/(?P<pk>d+)',views.Bookview.as_view()),

　　views.py

from app01 import models
from rest_framework.views import APIView
from app01.utils import BookSerializers
from rest_framework.response import Response

class Bookview(APIView):
    def get(self,request,pk):
        book_obj = models.book.objects.filter(pk=pk).first()
        book_ser = BookSerializers(book_obj)
        return Response(book_ser.data)

2.2 序列化器实现put修改数据接口

　　views.py

class BookView(APIView):
    ......
    def put(self,request,pk):
        response_msg={'status':100,'msg':'成功'}
        # 找到这个对象
        book = Book.objects.filter(id=pk).first()
        # 得到一个序列化类的对象
        # boo_ser=BookSerializer(book,request.data)
        boo_ser=BookSerializer(instance=book,data=request.data)

        # 要数据验证（回想form表单的验证）
        if boo_ser.is_valid():  # 返回True表示验证通过
            boo_ser.save()  # 要重写update不然会报错
            response_msg['data']=boo_ser.data
        else:
            response_msg['status']=101
            response_msg['msg']='数据校验失败'
            response_msg['data']=boo_ser.errors

        return Response(response_msg)

　　utiles.py     修改数据要重写update方法

class BookSerializer(serializers.Serializer):
    ............
    def update(self, instance, validated_data):
        #instance是book这个对象
        #validated_data是校验后的数据
        instance.name=validated_data.get('name')
        instance.price=validated_data.get('price')
        instance.auth=validated_data.get('auth')
        instance.save()  #book.save()   django 的orm提供的
        return instance

2.3 序列化器实现delete删除数据接口

　　views.py

class BookView(APIView):
    .........
    def delete(self,request,pk):
        ret=Book.objects.filter(pk=pk).delete()
        return Response({'status':100,'msg':'删除成功'})

2.4 序列化器实现get（查全部数据）接口

　　urls.py  新建一个路由

url(r'^books/',views.Booksview.as_view())

　　views.py 新建一个视图函数

class BooksView(APIView):
    def get(self,request):
        response_msg = {'status': 100, 'msg': '成功'}
        books=Book.objects.all()
        book_ser=BookSerializer(books,many=True)  #序列化多条,如果序列化一条，不需要写
        response_msg['data']=book_ser.data
        return Response(response_msg)

2.5 序列化器实现post添加数据接口

　　views.py

class BooksView(APIView):

    # 新增
    def post(self,request):
        response_msg = {'status': 100, 'msg': '成功'}
        #修改才有instance，新增没有instance，只有data
        book_ser = BookSerializer(data=request.data)
        # book_ser = BookSerializer(request.data)  # 这个按位置传request.data会给instance，就报错了
        # 校验字段
        if book_ser.is_valid():
            book_ser.save()
            response_msg['data']=book_ser.data
        else:
            response_msg['status']=102
            response_msg['msg']='数据校验失败'
            response_msg['data']=book_ser.errors
        return Response(response_msg)

　　utils.py   新增和修改一样要重写方法

class BookSerializer(serializers.Serializer):
    .........
    def create(self, validated_data):
        instance=Book.objects.create(**validated_data)
        return instance

3 序列化类的字段类型

　　上面我们创建的全是CharField类的字段类型（实际上任何形式的数据都可以创建成CharField类的字段类型）

　　序列化类的字段类型有很多记住几个就好：CharField，IntegerField，DateField。。。

4 序列化字段选项

　　字段的属性也有很多

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

　　如果字段的校验规则不够，可以写钩子函数（局部和全局）

4.1 局部钩子函数

def validate_price(self, data):   # validate_字段名  接收一个参数
　　#如果价格小于10，就校验不通过
　　# print(type(data))
　　# print(data)
　　if float(data)>10:
　　　　return data
　　else:
　　　　#校验失败，抛异常
　　　　raise ValidationError('价格太低')

4.2 全局钩子函数

def validate(self, validate_data):   # 全局钩子
　　print(validate_data)
　　author=validate_data.get('author')
　　publish=validate_data.get('publish')
　　if author == publish:
　　　　raise ValidationError('作者名字跟出版社一样')
　　else:
　　　　return validate_data

4.3 不推荐的效验方法

#可以使用字段的author=serializers.CharField(validators=[check_author]) ，来校验
    -写一个函数
        def check_author(data):
            if data.startswith('sb'):
                raise ValidationError('作者名字不能以sb开头')
            else:
                return data
#配置：validators=[check_author]

5 read_only和write_only

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

以下的了解
　　required 表明该字段在反序列化时必须输入，默认True
　　default 反序列化时使用的默认值
　　allow_null 表明该字段是否允许传入None，默认False
　　validators 该字段使用的验证器
　　error_messages 包含错误编号与错误信息的字典

6 ModelSerializer（模型类序列化器）

class BookModelSerializer(serializers.ModelSerializer):
    class Meta:
        model=Book  # 对应上models.py中的模型
        fields='__all__' 全部序列化
        # fields=('name','price','id','author') # 只序列化指定的字段
        # exclude=('name',) #跟fields不能都写，写谁，就表示排除谁
        # read_only_fields=('price',)
        # write_only_fields=('id',) #弃用了，使用extra_kwargs
        extra_kwargs = {  # 类似于这种形式name=serializers.CharField(max_length=16,min_length=4)
            'price': {'write_only': True},
        }
        
# 其他使用一模一样
#不需要重写create和updata方法了

7 Serializer高级用法

# source的使用
    1 可以改字段名字  xxx=serializers.CharField(source='title')
    2 可以.跨表publish=serializers.CharField(source='publish.email')
    3 可以执行方法pub_date=serializers.CharField(source='test') test是Book表模型中的方法
    

# SerializerMethodField(）的使用
    1 它需要有个配套方法，方法名叫get_字段名，返回值就是要显示的东西
    authors=serializers.SerializerMethodField() #它需要有个配套方法，方法名叫get_字段名，返回值就是要显示的东西
    def get_authors(self,instance):
        # book对象
        authors=instance.authors.all()  # 取出所有作者
        ll=[]
        for author in authors:
            ll.append({'name':author.name,'age':author.age})
        return ll

8 many=True的实际用途

# 序列化多条，需要传many=True
# 
book_ser=BookModelSerializer(books,many=True)
book_one_ser=BookModelSerializer(book)
print(type(book_ser))
#<class 'rest_framework.serializers.ListSerializer'>
print(type(book_one_ser))
#<class 'app01.ser.BookModelSerializer'>

# 对象的生成--》先调用类的__new__方法，生成空对象
# 对象=类名(name=lqz)，触发类的__init__()
# 类的__new__方法控制对象的生成


def __new__(cls, *args, **kwargs):
    if kwargs.pop('many', False):
        return cls.many_init(*args, **kwargs)
    # 没有传many=True,走下面，正常的对象实例化
    return super().__new__(cls, *args, **kwargs)