APIview的请求生命周期源码分析

Django项目启动=>加载settings文件=>加载models、views、urls文件，执行urls文件，调用视图类的as_view()方法。

APIview的as_view()方法继承父类的as_view()方法，并增加了局部禁用csrf中间件的功能

  1.  def as_view(cls, **initkwargs):
  2.         """
  3.         Store the original class on the view function.
  5.         This allows us to discover information about the view when we do URL
  6.         reverse lookups.  Used for breadcrumb generation.
  7.         """
  8.         if isinstance(getattr(cls, 'queryset', None), models.query.QuerySet):
  9.             def force_evaluation():
  10.                 raise RuntimeError(
  11.                     'Do not evaluate the `.queryset` attribute directly, '
  12.                     'as the result will be cached and reused between requests. '
  13.                     'Use `.all()` or call `.get_queryset()` instead.'
  14.                 )
  15.             cls.queryset._fetch_all = force_evaluation
  16.         #将父类as_view赋值给自己的view空间，并将其类名与参数添加到自己类的属性
  17.         view = super().as_view(**initkwargs)
  18.         view.cls = cls
  19.         view.initkwargs = initkwargs
  21.         # Note: session based authentication is explicitly CSRF validated,
  22.         # all other authentication is CSRF exempt.
  24.         #
  25.         #局部禁用csrf认证
  26.         return csrf_exempt(view)

APIview的父类就是Django的视图类view，as_view()继承父类的as_view功能调用dispatch方法分发请求，下面是父类的as_view()

  1.  @classonlymethod
  2.     def as_view(cls, **initkwargs):
  3.         """
  4.         Main entry point for a request-response process.
  5.         """
  6.         '''略去代码'''
  7.        ........................................................
  8.         def view(request, *args, **kwargs):
  9.             self = cls(**initkwargs)
  10.             if hasattr(self, 'get') and not hasattr(self, 'head'):
  11.                 self.head = self.get
  12.             self.request = request
  13.             self.args = args
  14.             self.kwargs = kwargs
  15.             #分发请求
  16.             return self.dispatch(request, *args, **kwargs)
  17.         # 这里的self是视图类实例化的对象，不要搞错了
  18.         view.view_class = cls
  19.         view.view_initkwargs = initkwargs
  21.         # take name and docstring from class
  22.         update_wrapper(view, cls, updated=())
  24.         # and possible attributes set by decorators
  25.         # like csrf_exempt from dispatch
  26.         update_wrapper(view, cls.dispatch, assigned=())
  27.         return view

视图类实例化的对象在自己的名称空间找dispatch方法，如果没有就去基类APIview里面查找，APIview的dispatch方法是对view类的dispatch方法的重写，对view类的dispatch方法进行了优化，具体优化一起来看APIview的dispatch方法源码：

  1.  def dispatch(self, request, *args, **kwargs):
  2.         """
  3.         `.dispatch()` is pretty much the same as Django's regular dispatch,
  4.         but with extra hooks for startup, finalize, and exception handling.
  5.         """
  6.         self.args = args
  7.         self.kwargs = kwargs
  8.         # initialize_request二次封装request对象，并对request对象的内容进行解析
  9.         request = self.initialize_request(request, *args, **kwargs)
  10.         self.request = request
  11.         self.headers = self.default_response_headers  # deprecate?
  13.         try:
  14.             #三大认证（认证、权限、频率），用来替换csrf安全认证，要比csrf认证强大得多
  15.             self.initial(request, *args, **kwargs)
  17.             # Get the appropriate handler method
  18.             if request.method.lower() in self.http_method_names:
  19.                 handler = getattr(self, request.method.lower(),
  20.                                   self.http_method_not_allowed)
  21.                 #如果wsgi的request里面有对应的方法，就用wsgi的，如果没有就用自己的,源码中常用的方法
  22.             else:
  23.                 handler = self.http_method_not_allowed
  24.                 #如果自己也没有就报http_method_not_allowed异常
  26.             response = handler(request, *args, **kwargs)
  28.         except Exception as exc:
  29.             #异常处理模块，处理异常分支
  30.             response = self.handle_exception(exc)
  31. 		#二次封装response，处理响应的内容，并对处理的结果进行渲染
  32.         self.response = self.finalize_response(request, response, *args, **kwargs)
  33.         return self.response

总结一下重写的dispatch里面所完成的功能：

1.二次封装request对象，并对request对象的内容进行解析

2.调用函数initial对请求进行三大认证，并在这个过程中进行异常捕获

3.通过反射的方法执行通过认证的自定义请求如get、post、patch、delete等

4.如果上面2、3步执行过程中有异常，就调用handle_exception方法处理捕获到的异常。

5.通过finalize_response方法进行处理响应的内容，以及是否对内容进行渲染

以上就是Django rest framework源码的请求流程，下面我们粗略看一下请求模块、解析模块、相应模块、异常处理模块、渲染模块的源码。

请求模块

请求模块大致的功能如下：

1.将wsgi的request对象转换成drf的request类的对象

2.封装后的request对象完全兼容wsgi的request对象，并且将原来request对象保存在新request._request

3.重新格式化请求数据存放位置

拼接参数：request.query_params

数据包参数：request.data

  1. # 源码分析：
  2. # 入口：APIVIew的dispatch方法的 request=self.initialize_request(request, *args, **kwargs)
  3. # print(request._request.method)  # 在内部将wsgi的request赋值给request._request
  5. class Request:
  6.     """
  7.     Wrapper allowing to enhance a standard `HttpRequest` instance.
  9.     Kwargs:
  10.         - request(HttpRequest). The original request instance.
  11.         - parsers_classes(list/tuple). The parsers to use for parsing the
  12.           request content.
  13.         - authentication_classes(list/tuple). The authentications used to try
  14.           authenticating the request's user.
  15.     """
  17.     def __init__(self, request, parsers=None, authenticators=None,
  18.                  negotiator=None, parser_context=None):
  19.         assert isinstance(request, HttpRequest), (
  20.             'The `request` argument must be an instance of '
  21.             '`django.http.HttpRequest`, not `{}.{}`.'
  22.             .format(request.__class__.__module__, request.__class__.__name__)
  23.             #将wsgi的request类的名称空间全部存入自己的名称空间中达到对wsgi的request完全兼容。
  24.         )
  26.         self._request = request
  27.         #将父类的request存放在了自己的_request中，这样我们可以通过对象点属性的方法方法wsgi request的属性和方法也可以通过对象点_request直接操作wsgi request对象。
  28.         self.parsers = parsers or ()
  29.         self.authenticators = authenticators or ()
  30.         self.negotiator = negotiator or self._default_negotiator()
  31.         self.parser_context = parser_context
  32.         self._data = Empty
  33.         self._files = Empty
  34.         self._full_data = Empty
  35.         self._content_type = Empty
  36.         self._stream = Empty
  38.         if self.parser_context is None:
  39.             self.parser_context = {}
  40.         self.parser_context['request'] = self
  41.         self.parser_context['encoding'] = request.encoding or settings.DEFAULT_CHARSET
  43.         force_user = getattr(request, '_force_auth_user', None)
  44.         force_token = getattr(request, '_force_auth_token', None)
  45.         if force_user is not None or force_token is not None:
  46.             forced_auth = ForcedAuthentication(force_user, force_token)
  47.             self.authenticators = (forced_auth,)
  49.     def _default_negotiator(self):
  50.         return api_settings.DEFAULT_CONTENT_NEGOTIATION_CLASS()
  52.     @property
  53.     def content_type(self):
  54.         meta = self._request.META
  55.         return meta.get('CONTENT_TYPE', meta.get('HTTP_CONTENT_TYPE', ''))
  57.      @property
  58.     def query_params(self):
  59.         """
  60.         More semantically correct name for request.GET.
  61.         """
  62.         #对_request.GET属性重新命名为query_params
  63.         return self._request.GET
  65.     @property
  66.     def data(self):
  67.         if not _hasattr(self, '_full_data'):
  68.             self._load_data_and_files()
  69.             #对_full_data进行重新命名
  70.         return self._full_data
  72.      def __getattr__(self, attr):
  73.         """
  74.         If an attribute does not exist on this instance, then we also attempt
  75.         to proxy it to the underlying HttpRequest object.
  76.         """
  77.         try:#通过__getattr__的方法获得_request的属性和方法
  78.             return getattr(self._request, attr)
  79.         except AttributeError:
  80.             return self.__getattribute__(attr)

解析模块

解析模块只处理数据包参数

  1. # 源码分析：
  2. # 入口：APIVIew的dispatch方法的 request=self.initialize_request(request, *args, **kwargs)
  3. # 获取解析类：parsers=self.get_parsers(),
  4. # 进行局部全局默认配置查找顺序进行查找：return [parser() for parser in self.parser_classes]
  5.     def get_parsers(self):
  6.         """
  7.         Instantiates and returns the list of parsers that this view can use.
  8.         """
  9.         return [parser() for parser in self.parser_classes]
  10.     #我们点击parser_classes就会到达self.parser_classes属性，
  11. class APIView(View):
  13.     # The following policies may be set at either globally, or per-view.
  14.     renderer_classes = api_settings.DEFAULT_RENDERER_CLASSES
  15.     parser_classes = api_settings.DEFAULT_PARSER_CLASSES#这里是可以看出解析器在api_settings配置里配置
  16.     authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES
  17.     throttle_classes = api_settings.DEFAULT_THROTTLE_CLASSES
  18.     permission_classes = api_settings.DEFAULT_PERMISSION_CLASSES
  19.     content_negotiation_class = api_settings.DEFAULT_CONTENT_NEGOTIATION_CLASS
  20.     metadata_class = api_settings.DEFAULT_METADATA_CLASS
  21.     versioning_class = api_settings.DEFAULT_VERSIONING_CLASS
  23.     #在settings里面可以看到默认的解析器配置如下，也就是默认的解析器支持的数据类型有form-data，urlencoded，json
  24.     DEFAULTS = {
  25.     # Base API policies
  26.     'DEFAULT_RENDERER_CLASSES': [
  27.         'rest_framework.renderers.JSONRenderer',
  28.         'rest_framework.renderers.BrowsableAPIRenderer',
  29.     ],
  30.     'DEFAULT_PARSER_CLASSES': [
  31.         'rest_framework.parsers.JSONParser',#json
  32.         'rest_framework.parsers.FormParser',#urlencoded
  33.         'rest_framework.parsers.MultiPartParser'#文件 form-data
  34.     ],
  35.    #这里是全局配置，我们可以在项目的settings文件中自定义配置我们使用的解析器

全局配置解析器

当我们将drf settings文件中进行如下配置后再启动项目就会优先使用我们自己的配置。

  1. REST_FRAMEWORK = {
  2.     'DEFAULT_PARSER_CLASSES': [
  3.         'rest_framework.parsers.JSONParser',#json
  4.         'rest_framework.parsers.FormParser',#urlencoded
  5.         'rest_framework.parsers.MultiPartParser'#文件 form-data
  6.     ]
  7. }

局部配置解析器

我们还可以直接将解析器导入到自己的视图类中，直接使用这时会优先使用自己类中的parser_classes

  1. from rest_framework.views import APIView
  2. from rest_framework.parsers import JSONParser, FormParser, MultiPartParser
  3. class Book(APIView):
  4.     parser_classes = [JSONParser,FormParser,MultiPartParser]

综上我们可以知道 解析器配置的查找顺序：局部(视图类的类属性) => 全局(settings文件的drf配置) => 默认(drf的默认配置)

响应模块

  1.  class Response(SimpleTemplateResponse):
  2.     """
  3.     An HttpResponse that allows its data to be rendered into
  4.     arbitrary media types.
  5.     """
  7.     def __init__(self, data=None, status=None,
  8.                  template_name=None, headers=None,
  9.                  exception=False, content_type=None):
  10.         """
  11.         Alters the init arguments slightly.
  12.         For example, drop 'template_name', and instead use 'data'.
  14.         Setting 'renderer' and 'media_type' will typically be deferred,
  15.         For example being set automatically by the `APIView`.
  16.         """
  17.         super().__init__(None, status=status)
  19.         if isinstance(data, Serializer):
  20.             msg = (
  21.                 'You passed a Serializer instance as data, but '
  22.                 'probably meant to pass serialized `.data` or '
  23.                 '`.error`. representation.'
  24.             )
  25.             raise AssertionError(msg)
  27.         self.data = data
  28.         self.template_name = template_name
  29.         self.exception = exception
  30.         self.content_type = content_type
  32.         if headers:
  33.             for name, value in headers.items():
  34.                 self[name] = value
  36.     @property
  37.     def status_text(self):
  38.         """
  39.         Returns reason text corresponding to our HTTP response status code.
  40.         Provided for convenience.
  41.         """
  42.         return responses.get(self.status_code, '')
  44.     def __getstate__(self):
  45.         """
  46.         Remove attributes from the response that shouldn't be cached.
  47.         """
  48.         state = super().__getstate__()
  49.         for key in (
  50.             'accepted_renderer', 'renderer_context', 'resolver_match',
  51.             'client', 'request', 'json', 'wsgi_request'
  52.         ):
  53.             if key in state:
  54.                 del state[key]
  55.         state['_closable_objects'] = []
  56.         return state
  58. # data：响应数据
  59. # status：响应的网络状态码
  60. # -------------------------
  61. # template_name：drf完成前后台不分离返回页面，但是就不可以返回data(了解)
  62. # headers：响应头，一般不规定，走默认
  63. # exception：一般异常响应，会将其设置成True，默认False（不设置也没事）
  64. # content_type：默认就是 application/json，不需要处理

异常处理模块

  1.  def dispatch(self, request, *args, **kwargs):
  2.         '''
  3.        ...
  4.        '''
  5.         try:
  6.             #三大认证（认证、权限、频率），用来替换csrf安全认证，要比csrf认证强大得多
  7.             self.initial(request, *args, **kwargs)
  9.             # Get the appropriate handler method
  10.             if request.method.lower() in self.http_method_names:
  11.                 handler = getattr(self, request.method.lower(),
  12.                                   self.http_method_not_allowed)
  13.                 #如果wsgi的request里面有对应的方法，就用wsgi的，如果没有就用自己的,源码中常用的方法
  14.             else:
  15.                 handler = self.http_method_not_allowed
  16.                 #如果自己也没有就报http_method_not_allowed异常
  18.             response = handler(request, *args, **kwargs)
  20.         except Exception as exc:
  21.             #异常处理模块，处理异常分支
  22.             response = self.handle_exception(exc)
  23. 		#二次封装response，处理响应的内容，并对处理的结果进行渲染
  24.         self.response = self.finalize_response(request, response, *args, **kwargs)
  25.         return self.response

从源码可以看出当请求进入三大认证时就已经引入了异常捕获的范围，但是这里的异常不会对于客户端的异常处理较好，而对于服务端异常就会返回前端一波代码，我们进入handle_exception，看看异常处理的代码。

  1.  def handle_exception(self, exc):
  2.         """
  3.         Handle any exception that occurs, by returning an appropriate response,
  4.         or re-raising the error.
  5.         """
  6.         #对认证异常的处理响应头
  7.         if isinstance(exc, (exceptions.NotAuthenticated,
  8.                             exceptions.AuthenticationFailed)):
  9.             # WWW-Authenticate header for 401 responses, else coerce to 403
  10.             auth_header = self.get_authenticate_header(self.request)
  12.             if auth_header:
  13.                 exc.auth_header = auth_header
  14.             else:
  15.                 exc.status_code = status.HTTP_403_FORBIDDEN
  16. 		#获取异常处理的函数exception_handler
  17.         exception_handler = self.get_exception_handler()
  19.         context = self.get_exception_handler_context()
  21.         #给异常处理提供额外的参数，其实就是获取抛异常的视图对象和请求的参数，可看下面get_exception_handler_context的源码
  22.         response = exception_handler(exc, context)#异常对象、视图对象和请求的参数
  24.         #默认的exception_handler函数只处理客户端异常形成的response对象，服务器异常不作处理，返回None
  25.         if response is None:
  26.             #当response为none时交给Django中间件处理
  27.             self.raise_uncaught_exception(exc)
  29.         response.exception = True
  30.         return response
  32.     #视图对象和请求的参数
  33.      def get_exception_handler_context(self):
  34.         """
  35.         Returns a dict that is passed through to EXCEPTION_HANDLER,
  36.         as the `context` argument.
  37.         """
  38.         return {
  39.             'view': self,
  40.             'args': getattr(self, 'args', ()),
  41.             'kwargs': getattr(self, 'kwargs', {}),
  42.             'request': getattr(self, 'request', None)
  43.         }

重写异常处理函数

为了自定义服务器异常时系统所抛的异常的内容，我们需要重写异常处理函数，步骤：

1.在settings的drf配置中配置EXCEPTION_HANDLER，指向自定义的exception_handler函数

2.drf出现异常会回调exception_handler函数，携带异常对象和异常相关信息，在exception_handler函数中完成异常信息的返回以及异常信息的logging日志。

在Django的settings文件中进行配置：

  1.    REST_FRAMEWORK = {'EXCEPTION_HANDLER': 'api.exception_handler.exception_handler'}

在exception_handler文件中重写exception_handler

  1. # 一定要在settings文件中将异常模块配置自己的异常处理函数
  2. from rest_framework.views import exception_handler as drf_exception_handler
  3. from rest_framework.response import Response
  5. # 先交个drf处理客户端异常，如果结果response为None代表服务器异常，自己处理
  6. # 最终一定要在日志文件中记录异常现象
  7. def exception_handler(exc, context):
  8.     response = drf_exception_handler(exc, context)
  9.     detail = '%s - %s - %s' % (context.get('view'), context.get('request').method, exc)
  10.     if not response:  # 服务端错误
  11.         response =  Response({'detail': detail})
  12.     else:
  13.         response.data = {'detail': detail}
  15.     # 核心：要将response.data.get('detail')信息记录到日志文件
  16.     # logger.waring(response.data.get('detail'))
  18.     return response

渲染模块

渲染模块在APIView中的导入方式renderer_classes = api_settings.DEFAULT_RENDERER_CLASSES，它的作用是Postman请求返回结果是json，浏览器请求结果是经过渲染的页面，实际项目中应用场景不大可以像解析模块一样进行局部和全局配置。

APIview的请求生命周期源码分析的更多相关文章

  1. DRF框架（一）——restful接口规范、基于规范下使用原生django接口查询和增加、原生Django CBV请求生命周期源码分析、drf请求生命周期源码分析、请求模块request、渲染模块render

    DRF框架    全称:django-rest framework 知识点 1.接口:什么是接口.restful接口规范 2.CBV生命周期源码 - 基于restful规范下的CBV接口 3.请求组件 ...

  2. drf复习（一）--原生djangoCBV请求生命周期源码分析、drf自定义配置文件、drf请求生命周期dispatch源码分析

    admin后台注册model  一.原生djangoCBV请求生命周期源码分析 原生view的源码路径(django/views/generic/base.py) 1.从urls.py中as_view ...

  3. APIView 的请求生命周期

    目录 APIView 的请求生命周期 请求解析模块 响应渲染模块 序列化组件 Django 配置 """ 1)应用是否需要在INSTALLED_APPS中注册 在没有使用 ...

  4. DRF 请求生命周期以及各模块解析

    目录 rest_framework框架的封装特点 原生Django与DRF比较 APIView 的请求生命周期 请求模块(request) 解析模块(parser_classes) 异常模块(exce ...

  5. drf框架，restful接口规范，源码分析

    复习 """ 1.vue如果控制html 在html中设置挂载点.导入vue.js环境.创建Vue对象与挂载点绑定 2.vue是渐进式js框架 3.vue指令 {{ }} ...

  6. drf框架概况-resful接口规范-请求模块-渲染模块-Postman-drf请求生命周期

    drf框架 全称:django-rest- framework 知识点: """ 1.接口:什么是接口.restful接口规范 2.CBV生命周期源码-基于restful ...

  7. drf 简介以及部分源码分析

    目录 复习 drf框架 全称:django-rest framework 知识点 接口 restful接口规范 基于restful规范的原生Django接口 主路由:url.py api组件的子路由: ...

  8. Flask系列之源码分析（一）

    目录: 涉及知识点 Flask框架原理 简单示例 路由系统原理源码分析 请求流程简单源码分析 响应流程简单源码分析 session简单源码分析 涉及知识点 1.装饰器 闭包思想 def wapper( ...

  9. okHttp3 源码分析

    一, 前言 在上一篇博客OkHttp3 使用详解里,我们已经介绍了 OkHttp 发送同步请求和异步请求的基本使用方法. OkHttp 提交网络请求需要经过这样四个步骤: 初始化 OkHttpClie ...

随机推荐

  1. nova计算服务

    1. nova介绍 Nova 是 OpenStack 最核心的服务,负责维护和管理云环境的计算资源.OpenStack 作为 IaaS 的云操作系统,虚拟机生命周期管理也就是通过 Nova 来实现的. ...

  2. C#学习笔记一（概念，对象与类型，继承）

    一.基础 1.CLR为公共语言运行库,类似于JVM 2..NET Framwork是一个独立发布的程序包,其包含了CLR,类库及相关的语言编辑器等工具,类似于JDK,除了C#,还有其他几种语言在CLR ...

  3. HCL试验2

    PC端配置:配置ip地址 交换机1配置:①创建VLAN system-view vlan 10 vlan 20 ②配置PC端接口 interface gi 1/0/1 port link-type a ...

  4. ubuntu系统熄屏无法唤醒

    ubuntu系统熄屏无法唤醒 解决办法:重启后,安装laptop-mode-tools工具包. 1.检查是否安装了grep laptop-mode-tools 工具包 $ dpkg -l | grep ...

  5. Java学习开发第三阶段总结

    第三阶段的学习总结: 在这次学习我学习了面向对象和封装的知识. ①类的定义 package day01; public class student { //成员变量 String name; //姓名 ...

  6. C# 字符串、字节数组互相转换

    /// <summary> /// MD5加密 /// </summary> /// <param name="sender"></par ...

  7. 面试题 | 数据库笔试题集合·之·SQL语句（2）

    第2章 SQL 语句 2.1 选择2.1.1 DELETE FROM S WHERE 年龄>60 语句的功能是( A ) A.从 S 表中彻底删除年龄大于 60 岁的记录B.S 表中年龄大于 6 ...

  8. P1550打井

    这是USACO2008年的一道最小生成树题,感谢dzj老师那天教的图论. 要引渠让每一个村庄都可以接到水,然后从某一个村庄到另一个村庄修剪水道要花费w元,并且还要打井(至少一个)(而输入数据也包括了在 ...

  9. Python爬虫之简单的爬取百度贴吧数据

    首先要使用的第类库有 urllib下的request  以及urllib下的parse  以及 time包  random包 之后我们定义一个名叫BaiduSpider类用来爬取信息 属性有 url: ...

  10. Java Script 基本知识点

                          JavaScript是一种基于对象和事件驱动的脚本语言,它提供了一些专有的类.对象及函数 1.基本数据类型 JavaScript提供了4种基本的数据类型用来 ...