drf从入门到精通 03

今日内容详细

1.drf整体内容

# 1 入门规范
	-web开发模式
	-api接口
	-接口测试工具
	-restful规范
	-序列化反序列化
	-drf快速使用
	-APIView，Request类
	-drf把django的好多东西都重写了
# 2 序列化组件
	-基本序列化类
	-模型类序列化类
	-如何序列化
	-如何反序列化
	-如何反序列化
	-反序列化的数据校验功能
# 3 请求与响应
	-drf的request已经不是原来django的request了
	-drf的response已经不是原来django的response了
	-指定可以接收请求的编码方式
	-指定响应格式
# 4 视图组件 View
	-两个视图基类
	-5个视图扩展类
	-9个视图子类
	-视图集
# 5 路由
	-自动生成路由
# 6 认证(登录认证)，权限，频率，
# 7 过滤，排序，分页
# 8 自动生成接口文档
------------------------
# 9 JWT 登录认证的，区别与cookie和session，主流
# 10 后台管理美化（django原生的很丑，simpleui二次开发）
# 11 基于角色的访问控制，权限的控制

2.APIView执行流程

基于APIView+JsonResponse编写接口

# 原来基于django原生的View编写接口
# drf提供给咱们的一个类，以后使用drf写视图类，都是继承这个类及其子类，APIView本身就是继承了Django原生的VIew

class BookView(APIView):
    def get(self, request):
        books = Book.objects.all()
        book_list = []
        for book in books:
            book_list.append({'name': book.name, 'price': book.price, 'publish': book.publish})

        return JsonResponse(book_list, safe=False)

基于APIView+Response写接口

class BookView(APIView):
    def get(self, request):
        books = Book.objects.all()
        book_list = []
        for book in books:
            book_list.append({'name': book.name, 'price': book.price, 'publish': book.publish})

        return Response(book_list)  # 无论是列表还是字典都可以序列化

APIView的执行流程

# 路由中写的： path('books/', views.BookView.as_view()),--->>请求来了，执行views.BookView.as_view()()--->>现在的as_view是APIView的as_view

# APIView的as_view方法：view还是原来的view，但是以后再也没有csrf认证了
	@classmethod
	def as_view(cls, **initkwargs):
		# 调用父类的as_view，父类是django原生的View
		# 把django原生View的as_view方法中的闭包函数view拿出来了
		view = super().as_view(**initkwargs)
		# csrf_exempt 排除所有csrf的认证
		# 相当于在所有的方法上面加了这个装饰器
		return csrf_exempt(view)
    
# 路由匹配成功，执行 csrf_exempt(view)(requets)--->View的as_view中的闭包函数view--->> self.dispatch--->self是视图类的对象--->BookView --->APIView的dispatch，找到了
	def dispatch(self, request, *args, **kwargs):
		# request是django原生的request，老的request
		# 把老的request包装成了新的request，这个是drf提供的Request类的对象
		request = self.initialize_request(request, *args, **kwargs)
		# 到此以后，这个request就是新的了，老的request在哪？
		# request._request 这是老的
		# 把新的request放到了self对象【BookView的对象】
		self.request = request
		try:
			# 执行了三大认证【认证，频率，权限】 使用新的request
			self.initial(request, *args, **kwargs)
			# 跟之前一样
			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
			# 把新的request传入了，视图类的方法中get的request也是新的
			response = handler(request, *args, **kwargs)
		except Exception as exc:
			# 在执行3大认证和视图类中方法的过程中，如果出了异常，都能捕获到---> 全局异常捕获
			response = self.handle_exception(exc)
		self.response = self.finalize_response(request, response, *args, **kwargs)
		return self.response
    
    
# 总结：APIView的执行流程
	1 去除了所有csrf
	2 包装了新的request，以后在视图类中用的request是新的request Request类的对象，不是原生的了
		-原生的在新的request._request中
	3 在执行视图类的方法之前，执行了3大认证
	4 如果在3大认证或视图函数方法执行过程中出了错，会有异常捕获--->> 全局异常捕获
	5 以后视图类方法中的request都是新的了
    

# 补充：装饰器的基本原理
def auth()  # 装饰器
def add()  # 函数

# 使用auth装饰add函数
@auth  #  本质是 add = auth(add)
def add()

# 以后再使用add 其实就是在使用 auth(add) 的返回结果

3.Request对象源码分析

# 新的Request--->> 区别于老的
# 老的：django.core.handlers.wsgi.WSGIRequest
# 新的：from rest_framework.request import Request
	-request._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--->这是个方法，包装成了数据属性
		-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__:对象()会调用
	-__getattr__:对象.属性 如果属性不存在 会触发它的执行

4.序列化器介绍和快速使用

# 因为我们在写接口时，需要序列化，需要反序列化，而且反序列化的过程中要做数据校验---> drf直接提供了固定的写法，只要按照固定写法使用，就能完成上面的三个需求

# 提供了两个类 Serializer ModelSerializer
	-以后我们只需要写自己的类，继承drf提供的序列化类，使用其中的某些方法，就能完成上面的操作
    
# 使用APIView+序列化类+Response 完成接口的编写

5.基于序列化器编写5个接口

序列化类基本使用，序列化多条

serializer.py-->BookSerializer类

from rest_framework import serializers

class BookSerializer(serializers.Serializer):
	# 序列化某些字段，这里写要序列化的字典
	name = serializers.CharField()  # serializers下大致跟models下的类是对应的
	# price = serializers.CharField()
	publish = serializers.CharField()

views.py-->BookView类

class BookView(APIView):
	def get(self, request):
		# 只是为了验证之前讲过的
		print(request.method)
		print(request._request)
		print(type(self.request))

		books = Book.objects.all()
		# 使用序列化类来完成---> 得有个序列化类
		# instance要序列化的数据books queryset对象
		# many=True 只要是queryset对象要传many=True，如果是单个对象就不用传
		ser = BookSerializer(instance=books, many=True)
		return Response(ser.data)  # 无论是列表还是字典都可以序列化

序列化单条

序列化类

from rest_framework import serializers

class BookSerializer(serializers.Serializer):
    # 序列化某些字段，这里写要序列化的字典
    name = serializers.CharField()  # serializers下大致跟models下的类是对应的
    # price = serializers.CharField()
    publish = serializers.CharField()

视图类-->BookDetailView

class BookDetailView(APIView):
    # def get(self, request,pk):
    def get(self, request, *args, **kwargs):
        book = Book.objects.filter(pk=kwargs.get('pk')).first()
        # 序列化
        ser = BookSerializer(instance=book)
        return Response(ser.data)

url添加新的路由

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

反序列化

反序列化的新增

序列化类

class BookSerializer(serializers.Serializer):
    # 序列化某些字段，这里写要序列化的字典
    name = serializers.CharField()  # serializers下大致跟models下的类是对应的
    price = serializers.CharField()
    publish = serializers.CharField()

    def create(self, validated_data):
        # 保存的逻辑
        # validated_data 校验过后的数据 {name,price,publish}
        # 保存到数据库
        book = Book.objects.create(**validated_data)
        # 一定不要返回新增的对象
        return book

视图类

class BookView(APIView):
    def post(self, request):
        # requset.data  # 前端提交的要保存的数据----》校验数据---》存
        ser = BookSerializer(data=request.data)  # 把前端传入的要保存的数据，给data参数
        # 校验数据
        if ser.is_valid():
            # 保存---->需要自己写，要在序列化类BookSerializer中写----》create方法
            ser.save()  # 调用ser.save,自动触发咱们写的create，保存起来
            return Response({'code': 100, 'msg': '新增成功', 'result': ser.data})
        else:
            return Response({'code': 101, 'msg': ser.errors})

反序列化的修改

序列化类

class BookSerializer(serializers.Serializer):
    # 序列化某些字段，这里写要序列化的字典
    name = serializers.CharField()  # serializers下大致跟models下的类是对应的
    price = serializers.CharField()
    publish = serializers.CharField()

    def create(self, validated_data):
        # 保存的逻辑
        # validated_data 校验过后的数据 {name,price,publish}
        # 保存到数据库
        book = Book.objects.create(**validated_data)
        # 一定不要忘了返回新增的对象
        return book

    def update(self, instance, validated_data):
        # instance 要修改的对象
        # validated_data 校验过后的数据
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.publish = validated_data.get('publish')
        instance.save()  # orm的单个对象，修改了单个对象的属性，只要调用对象.save,就能把修改保存到数据库

        return instance  # 不要忘了把修改后的对象返回

视图类

class BookDetailView(APIView):
    def put(self, request, pk):
        book = Book.objects.filter(pk=pk).first()
        # 反序列化保存 ---借助于序列化类
        ser = BookSerializer(data=request.data, instance=book)
        if ser.is_valid():
            ser.save()  # 如果没有重写update，会报错
            return Response({'code': 100, 'msg': '修改成功', 'result': ser.data})
        else:
            return Response({'code': 101, 'msg': ser.errors})

删除单条

视图类

class BookDetailView(APIView):
    def delete(self, requset, pk):
        Book.objects.filter(pk=pk).delete()
        return Response({'code': 100, 'msg': '删除成功'})

6.反序列化的校验

# 序列化类可以反序列化 数据校验功能--->类比forms组件
	-局部钩子
	-全局钩子
    
class BookSerializer(serializers.Serializer):
    # 序列化某些字段，这里写要序列化的字典
    name = serializers.CharField()  # serializers下大致跟models下的类是对应的
    price = serializers.CharField()
    publish = serializers.CharField()

    def create(self, validated_data):
        # 保存的逻辑
        # validated_data 校验过后的数据 {name,price,publish}
        # 保存到数据库
        book = Book.objects.create(**validated_data)
        # 一定不要忘返回新增的对象
        return book

    def update(self, instance, validated_data):
        # instance 要修改的对象
        # validated_data 校验过后的数据
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.publish = validated_data.get('publish')
        instance.save()  # orm的单个对象，修改了单个对象的属性，只要调用对象.save,就能把修改保存到数据库

        return instance  # 不要忘了把修改后的对象返回

    # 反序列化校验的局部钩子 ，名字不能以sb开头
    def validate_name(self, name):
        # 校验name是否合法
        if name.startswith('sb'):
            # 校验不通过，抛异常
            raise ValidationError('不能以sb开头')
        else:
            return name

    # 全局钩子
    def validate(self, attrs):
        # 校验过后的数据，书名跟出版社名字不能一致
        if attrs.get('name') == attrs.get('publish'):
            raise ValidationError('书名跟出版社名字不能一致')
        else:
            return attrs