本文主要是介绍Day81--drf02--序列化组件serializers，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

昨日回顾

# 1.web的两种开发模式
# 2.web api
# 3.posman的使用（路径必须完全正确）
# 4.restful规范 10条
# 5.drf的安装和使用
# 6.cbv源码分析
    -视图类，必须继承View（读View的源码）
    -在类里写get，post方法就可以了，只要get请求来，就会走get方法（方法跟之前的fbv写法完全一样）
    -路由：views.Books.as_view()---这个函数执行完一定是一个内存地址---》view（闭包函数）内层函数的地址
    -请求来了，路由匹配上执行view(request)--->self.dispatch(request, *args, **kwargs)
    -dispatch-->把请求方法转成小写---》通过反射，去对象中找，有没有get方法，有就加括号执行，并且把request传进去了
    
#7.APIView源码分析（drf提供的，扩展了View的功能）
    -视图类，继承APIView（读APIView的源码）
    -在类里写get，post方法就可以了，只要get请求来，就会走get方法（方法跟之前的fbv写法完全一样）
    -路由：views.Books.as_view()---这个函数执行完一定是一个内存地址---》view（闭包函数）内存函数的地址，解除了csrf校验，所有请求就都没有csrf校验了
    -请求来了，路由匹配上--->view(request)--->self.dispatch(request, *args, **kwargs)，现在这个dispatch不是View中的dispatch，而是APIView中的dispatch
    
    -def dispatch(self, request, *args, **kwargs):
        self.args = args
        self.kwargs = kwargs
        #  self.initialize_request(request, *args, **kwargs)  request是当次请求的request
        # request = self.initialize_request  request是一个新的Request对象
        request = self.initialize_request(request, *args, **kwargs)
        self.request = request
        self.headers = self.default_response_headers  # deprecate?

        try:
            # 三大认证模块(request是新的request)
            self.initial(request, *args, **kwargs)

            # Get the appropriate handler method
            if request.method.lower() in self.http_method_names:
                handler = getattr(self, request.method.lower(),
                                  self.http_method_not_allowed)
            else:
                handler = self.http_method_not_allowed

            # 响应模块
            response = handler(request, *args, **kwargs)

        except Exception as exc:
            # 异常模块
            response = self.handle_exception(exc)

        # 渲染模块
        self.response = self.finalize_response(request, response, *args, **kwargs)
        return self.response

今日内容

1.序列化组件介绍

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

# 注意：serializer不是只能为数据库模型类定义，也可以为非数据库模型类的数据定义。serializer是独立于数据库之外的存在。

2.查询数据(序列化)

# get请求： 从后端拿数据 (python对象 --序列化--> json)


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


# ser.py
from rest_framework import serializers

class BookSerializer(serializers.Serializer):
    # id = serializers.CharField()
    name = serializers.CharField()
    # price=serializers.DecimalField()
    price = serializers.CharField()
    author = serializers.CharField()  
    publish = serializers.CharField()
    
# views.py
from rest_framework.view import APIView
from rest_framework.response import Response
from app01 import models

class BookView(APIView):
    def get(self,request,pk):
        book = models.Book.objects.filter(id=pk).first()
        # 用一个类，毫无疑问，一定要实例化
        # 要序列化谁，就把谁传过来 
        book_ser = BookSerializer(book)  # 默认：序列化单条数据
        # book_ser.data   序列化对象.data就是序列化后的字典 (还不是json格式)
        # drf的Response，会自动将返回的数据json.dumps() 转json格式
        return Response(book_ser.data)  
    
# 故 视图类中返回的数据两种处理方式：
    1.采用drf的Response() 自动转json格式 但需要setting中配置 app='rest_framework'  # 推荐使用
    2.直接使用django原生的 JsonResponse 转json格式
    
# urls.py
re_path('books/(?P<pk>\d+)', views.BookView.as_view()),

3.字段类型

有很多，不需要都记住 
# 只需要记住：CharField，IntegerField，DateField。。。

字段类型

4.修改数据(反序列化)

# put请求： 修改数据 前端传数据给后端  ( json --反序列化--> python对象)


# 过程：
1.写一个反序列化的类，继承Serializer
2.在类中写要反序列化的字段、字段的属性(max_lenth等来校验数据) 以及重写update() 方法进行数据的保存 
3.在类中写数据校验规则 (1.字段属性 2.钩子函数 3.字段函数 具体见下)
4.在视图类中使用，导入--》实例化得到反序列化类的对象，把 要修改的对象传入 与 修改的数据 传入
	book_ser=BookSerializer(book,request.data)
    book_ser=BookSerializer(instance=book,data=request.data)    
5.进行数据校验 if book_ser.is_valid():
6.如果校验通过，就保存
	book_ser.save() # 注意不是book.save()	
7.如果不通过，逻辑自己写


"""
数据校验规则(三种):
1.序列化类 字段的选项参数 来校验 (最基本的校验)
	max_length	最大长度
    min_lenght	最小长度
    allow_blank	是否允许为空
    trim_whitespace	是否截断空白字符
    max_value	最小值   针对数据类型
    min_value	最大值   

2.写钩子函数（局部和全局）  # 推荐使用
    # 局部钩子：如果价格小于10，就校验不通
    def validate_price(self, data):  # validate_字段名  接收一个参数data 就是该局部钩子字段对应的值
        # print(type(data))  # str
        # print(data)  # 33.10
        if float(data)>10:
            return data
        else:
            # 校验失败，抛异常
            raise ValidationError('价格太低')
       
    # 全局钩子：作者名字跟出版社不能一样 
    def validate(self, validate_data):   # validate  接收一个参数validate_data 就是验证通过的数据字典
        print(validate_data)
        author=validate_data.get('author')
        publish=validate_data.get('publish')
        if author == publish:
            raise ValidationError('作者名字跟出版社一样')
        else:
            return validate_data
                    
3.使用字段的选项参数： validators=[校验函数地址]  来校验数据   # 通常不使用这种，知道就行
 	# author=serializers.CharField(validators=[check_author])
	- 1.自定义写一个普通校验函数
    	def check_author(data):
            if data.startswith('sb'):
                raise ValidationError('作者名字不能以sb开头')
            else:
                return data
    - 2. 配置在字段的选项参数中：
    	validators=[check_author]
"""


# models.py
class Book(models.Model):
    id=models.AutoField(primary_key=True)
    name=models.CharField(max_length=32)
    price=models.DecimalField(max_digits=5,decimal_places=2)
    author=models.CharField(max_length=32)
    publish=models.CharField(max_length=32)

    
# ser.py
from rest_framework import serializers
from rest_framework.exceptions import ValidationError

# 普通校验函数 放 字段的选项参数 来校验数据
def check_author(data):
    if data.startswith('sb'):
        raise ValidationError('作者名字不能以sb开头')
    else:
        return data

class BookSerializer(serializers.Serializer):
    name=serializers.CharField(max_length=16,min_length=4)
    price=serializers.CharField()
    author=serializers.CharField(validators=[check_author])  # validators=[] 列表中写函数内存地址 这种了解就行
    publish=serializers.CharField()
	
    # 局部钩子：如果价格小于10，就校验不通过
    def validate_price(self, data):   # validate_字段名  参数data 就是该局部钩子字段对应的值
        # print(type(data))  # str
        # print(data)  # 33.10
        if float(data)>10:
            return data
        else:
            # 校验失败，抛异常
            raise ValidationError('价格太低')
            
    # 全局钩子：作者名字跟出版社不能一样 
    def validate(self, validate_data):  # validate  参数validate_data 就是验证通过的数据字典
        # print(validate_data)
        author=validate_data.get('author')
        publish=validate_data.get('publish')
        if author == publish:
            raise ValidationError('作者名字跟出版社一样')
        else:
            return validate_data
        
    # 必须 重写保存方法 (原因：1.因为父类接口的规定--接口的规范与统一 2.数据保存时也需要和校验通过的字段名一一对应上)
    def update(self, instance, validated_data):
        # instance是book这个对象
        # validated_data是校验后的数据
        instance.name=validated_data.get('name')
        instance.price=validated_data.get('price')
        instance.author=validated_data.get('author')
        instance.publish=validated_data.get('publish')
        instance.save()  # 实质就是book.save() 由django的orm提供的对象.save()
        return instance
    
# views.py
class BookView(APIView): 
    
    def put(self,request,pk):
        response_msg={'status':100,'msg':'成功'}
        # 找到需要修改的对象
        book = Book.objects.filter(id=pk).first()
        # 得到一个序列化类的对象
        # book_ser=BookSerializer(book,request.data)
        book_ser=BookSerializer(instance=book,data=request.data)

        # 进行数据验证（对照form组件的验证）
        if book_ser.is_valid():  # 返回True 表示前端传递的数据验证通过
            book_ser.save()  # 注意：不是对象.save()  是序列化对象.save()
            response_msg['data']=book_ser.data
        else:
            response_msg['status']=101
            response_msg['msg']='数据校验失败'
            response_msg['data']=book_ser.errors
        return Response(response_msg)
    
# urls.py
re_path('books/(?P<pk>\d+)', views.BookView.as_view()),

5.字段选项参数

校验参数：是反序列化时，进行数据的校验

通用参数：

6.字段通用参数

read_only	表明该字段仅用于序列化输出，默认False, 如果设置成True，postman中查询时可看到该字段，修改时，不需要传该字段
write_only	表明该字段仅用于反序列化输入，默认False，如果设置成True，postman中查询时看不到该字段，修改时，该字段需要传

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

7.查询所有(序列化)

# views.py

# 最好新建视图 View 因为restful规范，查询都是get请求，虽然也可以都写在get氢气 再根据参数判断，但写在一起比较混乱
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)
    
#urls.py
path('books/', views.BooksView.as_view()),

8.新增数据(反序列化)

# 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)
    
# ser.py 序列化类重写 create方法
    def create(self, validated_data):
        instance=Book.objects.create(**validated_data)
        return instance
    
# urls.py
path('books/', views.BooksView.as_view()),

9.删除一个数据

# 删除数据，就不需要用序列化组件
# 直接使用orm 对象.delete() 根据pk 删除就行

# views.py
class BookView(APIView):
    def delete(self,request,pk):
        Book.objects.filter(pk=pk).delete()
        return Response({'status':100,'msg':'删除成功'})
    
# urls.py
re_path('books/(?P<pk>\d+)', views.BookView.as_view()),

10.模型类序列化器

form rest_framework import serializers

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

11.源码分析

many=True的实际用途

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

book_one_ser=BookModelSerializer(book)
print(type(book_one_ser))  # <class 'app01.ser.BookModelSerializer'>

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

# 源码：肯定是根据many=True进行处理，触发生成不同类的对象
def __new__(cls, *args, **kwargs):
    if kwargs.pop('many', False):  # 字典.pop(key, default) 要删除的键值 如果没有 key，返回default值
        return cls.many_init(*args, **kwargs)
    # 没有传many=True,走下面，正常的对象实例化
    return super().__new__(cls, *args, **kwargs)

Serializer的高级用法

# source的选项参数使用--指向来自哪个表的哪个字段

# 作用：
    # 1.字段名字可以自定义，不用再和表字段名对应上   
    xxx=serializers.CharField(source='title')
    
    # 2.通过'.' 跨表  可指向关联表的字段
    publish=serializers.CharField(source='publish.email')
    
    # 3.可以执行models中表的方法，使得 字段 对应 该方法的返回值
    # test是Book表模型中的方法 
    pub_date=serializers.CharField(source='test')  
    

# SerializerMethodField() 字段的使用--定制化字段的返回值
    # 它需要有个配套方法，方法名叫get_字段名，返回值就是返回给前端的 该字段的对应值
    authors=serializers.SerializerMethodField() 
    def get_authors(self,instance):
        # instance 就是使用该序列化类时，传入的对象
        authors=instance.authors.all()  # 取出所有作者
        ll=[]
        for author in authors:
            ll.append({'name':author.name,'age':author.age})
        return ll
    
    # 测试 如果不使用SerializerMethodField() 怎么展示 作者字段：[{作者1.name 作者1.age},{作者2.name 作者2.age}]
    # 思路，在view中 自己根据 orm操作数据库，把关联数据找出来，再自定义样式，最后放进book_ser.data 中
     	# 1.获取外键字段author的详细数据
        authors_obj_set = models.Author.objects.filter(book=book_obj).all()
        # 2.包装成指定的样式
        authors = []
        for author_obj in authors_obj_set:
            authors.append({'name': author_obj.name, 'age': author_obj.age})
        # 3.修改book_ser.data 中对应的字段 'authors'
        book_ser.data['authors'] = authors
        print(book_ser.data) 
    # 结果：失败，book_ser.data 是内部封装好的字典，不能进行修改、添加或删除数据

补充

1.如果有这个错（把rest_framework在app中注册一下）

2.补充自己封装Respons对象

# 在实际中，除了使用框架封装好的方法，也会自己写一些方法工具

# 例如：因为需要重复返回这个字典:  response_msg={'status':100,'msg':'成功'}
# 将字典 封装成一个 类， 使用时，就可以'.'操作，修改'status'或'msg' 和 新增 data

class MyResponse():
    def __init__(self):
        self.status=100  # 初始化，封装对象两个属性
        self.msg='成功'
        
    @property
    def get_dict(self):
        return self.__dict__  # 返回的对象.__dict__

if __name__ == '__main__':
    res=MyResponse()
    res.status=101
    res.msg='查询失败'
    res.data={'name':'lqz'} 
    print(res.get_dict)

3.你在实际开发中碰到的问题及如何解决的

write_only_fields 不能使用了，使用extra_kwargs解决了
extra_kwargs = {
            'id': {'write_only': True},
        }

作业：

# 1.图书的5个接口写完（使用序列化组件）

# 2.尝试修改一下返回的字段名字

这篇关于Day81--drf02--序列化组件serializers的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！