首页 > 编程语言 >drf整体内容 APIView执行流程 request对象源码分析 序列化器介绍和快速使用 反序列化的校验

drf整体内容 APIView执行流程 request对象源码分析 序列化器介绍和快速使用 反序列化的校验

时间:2023-02-01 21:47:41浏览次数:44  
标签:serializers self request --- 源码 序列化 data

目录

回顾

1.restful规范

https协议,保证安全
接口中带api标识
	api.baidu.com
  www.baidu.com/api
接口中带版本标识
接口及资源,尽量用名词,可以复数
请求方式决定操作资源的方式
	get查询
  post新增
  put修改
返回携带错误码
	http响应状态码:301 302 404 405
  自己规定的
返回中带错误信息
	{code:100,msg:'成功'}
返回中带链接
接口中带过滤条件(查询条件)
返回的数据符合如下规范
	查询所有:返回数组或列表
  查询单个:返回字典,对象
  修改:返回修改后的数据对象
  删除:返回空文档
  增加:返回增加后的对象

2.序列化和反序列化

就是数据格式的转换
前后端分离:
	序列化:查出的模型对象--->>转换成json格式字符串形式--->>>给前端	read
  反序列化:前端传入的json格式字符串--->>>转换成对象--->>>存贷数据库	write

3.使用Django原生编写5个接口

前后端分离了,写的都是接口,接口基本上都是基于这5个的变形
查询所有:JsonResponse	HttpResponse
新增:request.POST 取出前端传入body的数据,只能取出form-data,urlencoded
	不能取出json格式,reqeust.body	--->>>json---反序列化成字典,再用
  name=wyf&age=18
查询单个:根据pk查到单个对象,直接序列化后返回给前端
修改:put请求放到body中的数据,在request.POST取不出来,只能自己从request.body中取出来
删除:pk直接删除

4.drf介绍

Django的一个app(组件),最新版本3.x--->>>支持Django 3.x以上
框架,模板版本不一致导致程序运行不起来
方便我们快速的在Django框架上编写restful规范的接口

5.快速使用drf写了5个接口

路由:自动生成路由--->>>两个列表相加
视图:
序列化类:serializer

6.cbv源码分析

路由中:path('api/v1/books/',views.BookView.as_view())--->>>路由匹配成功就会执行--->>>views.BookView.as_view()(request)--->>>看一下BookView.as_view是怎么写的--->>>view这个类中的as_view类的绑定方法--->>>执行结果是view的内存地址[as_view中的内存函数,闭包函数]--->>本质请求来了,执行view(request)--->>>return self.dispatch(request,*args,**kwargs)--->>对象,谁的对象,View的对象,咱们从BookView--->>View--->>>self是BookView的对象--->>>发现BookView没有dispatch--->>>View类的dispatch
def dispatch(self,request,*args,**kwargs):
  if request,method.lower() in self.http_merthod_names:
    # self是BookView的对象,通过字符串get找方法或属性,找到了get方法
    # handler就是BookView类的get方法
    handler = getattr(self,request.method.lower(),self.http_method_not_allowed)
    else:
      handler = self.http_method_not_allowed
      # 执行 BookView的get(request)--->>get请求就会执行BookView的get方法,post请求就会执行BookView的post方法
      return handler(request,*args,**kwargs)

使用pycharm打开sqlite的问题

sqlite文件--->>>文件(xx.mp4,xx.txt)--->>>是一样的都是文件
我们选择的什么软件打开它,看到的东西是不一样的
解决:
	1.干脆不用pycharm打开,使用navicata打开
  2.使用pycharm正常连接

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.基于角色的访问控制,权限的控制

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)(request)
--->>View的as_view中的闭包函数view
--->>>self.dispatch
--->>>self是视图类的对象
--->>>BookView
--->>APIView的dispatch找到了
	def dispatch(self, reqeustm *args, **kwargs):
    # request是django原生的rquest,老的request
    # 把老的reqeust包装成了新的reqeust,这个是drf提供的Response类的对象
    request = self.initalize_request(request, *args, **kwargs)
    # 到此以后,这个request就新的了,老的request在哪?
    # request._request 这是老的
    
    # 把新的request放到了self对象【BookView的对象】
    self.request =  request
    try:
      # 执行了三大认证【认证、频率、权限】,使得用新的requesr,不读
      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_allowd
      response = handler(request, *args, **kwargs)
    except Exception as exc:
      # 在执行3大认证和视图类中的方法的过程中,如果出现了异常,都能捕获到--->>>全局异常捕获
      response = self.handle_excepption(exc)
    self.response = self.finalize_response(request, response, *args, **kwargs)
    return self.response
  
  # 总结:APIView的执行流程
	1 去除了所有的csrf
  2 包装了新的request,以后在视图类中用的request是新的request  Request类的对象,不是原生的了
    	-原生的在:新的requets._request
  3 在执行视图类的方法之前,执行了3大认证
  4 如果在3大认证或视图函数方法执行过程中出了错,会有异常捕获----》全局异常捕获
  5 以后视图类方法中的request都是新的了
  
  # 补充:装饰器的基本原来

def auth()  # 装饰器

def add()   # 函数

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

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

requset对象源码分析

# 新的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__: 对象() 会调用
    __new__:
	__getattr__:对象.属性,如果属性不存在,会触发它的执行

序列化器介绍和快速使用

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

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

基于序列化器编写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': '删除成功'})

反序列化的校验

# 序列化类反序列化,数据校验功能--->类比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

标签:serializers,self,request,---,源码,序列化,data
From: https://www.cnblogs.com/xiao-fu-zi/p/17084204.html

相关文章