一、Request类源码分析

# Request源码
	-方法 __getattr__
		-在视图类的方法中，执行request.method ,新的request是没有method的，就触发了新的Request的__getattr__方法的执行
		def __getattr__(self, attr):
			try:
				# 从老的request中反射出 要取得属性
				return getattr(self._request, attr)
			except AttributeError:
				return self.__getattribute__(attr)
    
    
'接着我们发现下面有很多用伪装的语法糖装饰的函数，这样调用方法的时候可以伪装成数据

	-request.data--->这是个方法，包装成了数据属性
		-以后无论post，put。。放在body中提交的数据，都从request.data中取，取出来就是字典
		-无论是那种编码格式
        
        
	-request.query_params--->这是个方法，包装成了数据属性
		-request.GET请求携带的参数，以后从这里面取
		-query_params：查询参数--->restful规范请求地址中带查询参数
        
        
	-request.FILES--->这是个方法，包装成了数据属性
		-前端提交过来的文件，从这里取
    
    
    
    
    

 # Request类总结
	-1  新的request用起来，跟之前一模一样，因为新的取不到，会取老的__getattr__
	-2 request.data  无论什么编码，什么请求方式，只要是body中的数据，就从这里取，字典
	-3 request.query_params 就是原来的request._request.GET
	-4 上传的文件从request.FILES
    
    
    
    
    
# python 中有很多魔法方法,在类中，某种情况下触发，会自动执行
	-__str__:打印对象会调用
	-__init__:类() 会调用
	-__call__: 对象() 会调用
	-__new__:类()产生一个空对象
	-__getattr__：对象.属性，如果属性不存在，会触发它的执行

二、序列化组件介绍

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

三、序列化类的基本使用

• 1 创建book表模型
• 2 写查询所有图书的接口：APIVie+序列化类+Response

models.py表模型

from django.db import models


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

查询所有和查询单条

views.py视图层

class BookView(APIView):
    def get(self, request):
        book_list = Book.objects.all()
        # 使用序列化类，完成序列化  两个很重要参数： instance实例，对象      data：数据
        # 如果是多条many=True  如果是queryset对象，就要写
        # 如果是单个对象 many=False，默认是False
        serializer = BookSerializer(instance=book_list, many=True)
        # serializer.data  # 把qs对象，转成列表套字典  ReturnList
        # print(serializer.data)
        # print(type(serializer.data))
        # return Response(serializer.data)
        return Response({'code': 100, 'msg': '成功', 'data': serializer.data})


class BookDetailView(APIView):
    def get(self, request, pk):
        book = Book.objects.all().get(pk=pk)
        serializer = BookSerializer(instance=book)
        return Response({'code': 100, 'msg': '成功', 'data': serializer.data})

urls.py路由层

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

serializer.py序列化类

from rest_framework import serializers

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

总结

# 序列化类的使用
1 写一个类，继承serializers.Serializer
2 在类中写字段，要序列化的字段
3 在视图类中使用：（多条，单条）
    serializer = BookSerializer(instance=book_list, many=True)
    serializer = BookSerializer(instance=book)

四、常用字段类和参数（了解）

常用字段类

# IntegerField      CharField   DateTimeField  DecimalField

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

字段参数(校验数据来用的)

选项参数：（CharField,IntegerField）

通用参数：

# 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，才能保存

六、反序列化之保存

# 新增接口：
	-序列化类的对象，实例化的时候：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做一个判断

七、APIVIew+序列化类+Response写的五个接口代码

urls.py路由

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

views.py视图

from .models import Book
from .serializer import BookSerializer


class BookView(APIView):
    def get(self, request):
        book_list = Book.objects.all()
        # 使用序列化类，完成序列化  两个很重要参数： instance实例，对象      data：数据
        # 如果是多条many=True  如果是queryset对象，就要写
        # 如果是单个对象 many=False，默认是False
        serializer = BookSerializer(instance=book_list, many=True)
        # serializer.data  # 把qs对象，转成列表套字典  ReturnList
        # print(serializer.data)
        # print(type(serializer.data))
        # return Response(serializer.data)
        return Response({'code': 100, 'msg': '成功', 'data': serializer.data})

    # 新增
    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})


class BookDetailView(APIView):
    def get(self, request, pk):
        book = Book.objects.all().get(pk=pk)
        serializer = BookSerializer(instance=book)
        return Response({'code': 100, 'msg': '成功', 'data': serializer.data})

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

serializer.py序列化类

# from rest_framework.serializers import Serializer
from rest_framework import serializers

from rest_framework.exceptions import ValidationError
from .models import Book


class BookSerializer(serializers.Serializer):
    # 要序列化的字段
    id = serializers.IntegerField(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'})

    # price = serializers.CharField()

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

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

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

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

    # 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

models.py表模型

from django.db import models


# Create your models here.

class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.BigIntegerField()
    # 面试题：BigIntegerField跟IntegerField有什么区别

八、序列化高级用法之source(了解)

• source指定的可以是字段,也可以是方法,用于重命名
• source可以做跨表查询
• source的名称跟变量的名称如果一样会报错

# 创建关联表
class Book(models.Model):
	name = models.CharField(max_length=32)
	price = models.CharField(max_length=32)
	
	publish = models.ForeignKey(t0='Publish', on_delete=models.CASCADE)
	authors = models.ManyToManyField(to='Author')


class Publish(models.Model):
	name = models.CharField(max_length=32)
	addr = models.CharField(max_length32)
	

class Author(models.Model):
	name = models.CharFeld(max_length=32)
	phone = models.CharField(max_length=11)

# 迁移,录入数据

总结

-1 修改前端看到的字段key值---》source指定的必须是对象的属性
    	book_name = serializers.CharField(source='name')
    -2 修改前端看到的value值，---》source指定的必须是对象的方法
    	表模型中写方法
          def sb_name(self):
        	return self.name + '_sb'
        序列化类中
        	book_name = serializers.CharField(source='sb_name')
            
     -3 可以关联查询（得有关联关系）
    	publish_name = serializers.CharField(source='publish.name')

九、序列化高级用法之定制字段的两种方式(非常重要)

方式一:SerializerMethodField定制
定制关联字段的显示形式

一对多,显示字典
多对多,显示列表套字典

serializer.py序列化类

class BookSerializer(serializers.Serializer):
	name = serializers.CharField(max_length=8)
	price = serializers.CharField()
	
	# 定制返回格式--->方式一
	publish_detail = serializers.SerializerMethodField()
'''这里相当于orm进行查询了'''
	def get_publish_detail(self, obj):
		return {'name': obj.publish.name, 'addr': obj.publish.addr}
	
	author_list = serializer.SerializerMethodField()
	
	def get_author_list(self, obj):
		l = []
		for author in obj.authors.all():
			l.append({'name': author.name, 'phone': author.phone})
		return l

models.py表模型

# 表模型
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')
	
	def publish_detail(self):
		return {'name': self.publish.name, 'addr': self.publish.addr}
	
	def author_list(self):
		l = []
		for author in self.authors.all():
			l.append({'name': author.name, 'phone': author.phone})
		return l


# 序列化类
class BookSerializer(serializers.Serializer):
	name = serializers.CharField(max_lenght=8)
	price = serializers.CharField()
	
	# publish_detail = serializers.CharField()
	publish_detail = serializers.DictField()
	author_list = serializers.ListField()

十、多表关联反序列化保存

# 序列化和反序列化，用的同一个序列化类
	-序列化的字段有：name，price ，   publish_detail，author_list
	-反序列化字段：name，price    ，publish，author

反序列化之保存

views.py视图类

class BookView(APIView):
	def post(self, request):
		ser = BookSerialzier(data=request.data)
		if ser.is_valid():
			ser.save()
			return Response({'code': 100, 'msg': '成功'})
		else:
			return Response({'code': 100, 'msg': ser.errors})

serializer.py序列化类

class BookSerialzier(serializers.Serializer):
	# 即用来做序列化，又用来做反序列化
	name = serializers.CharField(max_length=8)
	price = serializers.CharField()

	# 这俩，只用来做序列化
	publish_detail = serializers.DictField(read_only=True)
	author_list = serializers.ListField(read_only=True)

	# 这俩，只用来做反序列化
	publish_id = serializers.IntegerField(write_only=True)
	authors = serializers.ListField(write_only=True)

	def create(self, validated_data):  # {name:西游记，price:88,publish:1,authors:[1,2]
		authors = validated_data.pop('authors')
		book = Book.objects.create(**validated_data)
		book.authors.add(*authors)
		book.save()
		return book

反序列化之修改

views.py视图类

class BookDetailView(APIView):

	def put(self, request,pk):
		book=Book.objects.get(pk=pk)
		ser = BookSerialzier(data=request.data,instance=book)
		if ser.is_valid():
			ser.save()
			return Response({'code': 100, 'msg': '更新成功'})
		else:
			return Response({'code': 100, 'msg': ser.errors})

serializer.py序列化类

class BookSerialzier(serializers.Serializer):
	# 即用来做序列化，又用来做反序列化
	name = serializers.CharField(max_length=8)
	price = serializers.CharField()

	# 这俩，只用来做序列化
	publish_detail = serializers.DictField(read_only=True)
	author_list = serializers.ListField(read_only=True)

	# 这俩，只用来做反序列化
	publish_id = serializers.IntegerField(write_only=True)
	authors = serializers.ListField(write_only=True)


	def update(self, instance, validated_data):
		authors = validated_data.pop('authors')
		for item in validated_data:
			setattr(instance, item, validated_data[item])
			instance.authors.set(authors)
			instance.save()
			return instance

十一、反序列化字段校验其他

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

十二、ModelSerializer使用

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

# 如何使用

### ModelSerializer的使用
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  给字段加属性---方式一
		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_length32)

# 定制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

本栏目推荐文章
• 代码随想录 day18 找树左下角的值 路径总和 从中序与后序遍历序列构造二叉树
• 字节微服务HTTP框架Hertz使用与源码分析｜拥抱开
• 2024-01-13 记录react-dnd拖拽组件的用法
• AQS源码解析
• 【LeetCode 2701. 连续递增交易】MySQL用户变量编程得到严格递增连续子序列的开始位置，结束位置，长度等统计信息
• k8s核心组件介绍
• python经典有序序列的list列表推导式
• 【Leetcode 2474. 购买量严格增加的客户】MySQL用户变量编程解决严格递增连续子序列问题
• 解题报告P2501 [HAOI2006] 数字序列
• 如何让spring扫描到自定义注解的组件

序列 字段 ModelSerializer 组件 源码序列 字段modelserializer源码 序列 字段modelserializer组件 序列 字段modelserializer框架 序列 字段modelserializer source 字段 序列modelserializer常用 作者modelserializer序列 源码 django-rest-framework modelserializer序列 modelserializer组件02 字段 序列 源码 序列 组件 源码 流程