Django-rest Framework(三)

今天看了drf的五个组件的源码,可读性还是很高的,只是读组件的时候要注意的是 大部分的组件都是由dispatch分发出去的,所以看源码的时候一定要抓住dispatch这条主线,一步一步看下去

一. drf的请求模块(重点)

1. drf的request是在wsgi的request的基础上进行再次封装

2. wsgi的request作为drf的request一个属性:_request(下面附源码解释)

#源码:
	#在rest-framework 的views.py文件中
     def dispatch(self, request, *args, **kwargs):
        """
        `.dispatch()` is pretty much the same as Django's regular dispatch,
        but with extra hooks for startup, finalize, and exception handling.
        """
        self.args = args
        self.kwargs = kwargs
        # 在下面这行代码中 django原来的request传入 self.initialize_request 这个方法
        request = self.initialize_request(request, *args, **kwargs)

    #self.initialize_request方法源码分析
        def initialize_request(self, request, *args, **kwargs):
            """
                Returns the initial request object.
                """
            parser_context = self.get_parser_context(request)
		# 在下面这个函数的返回结果可以看出来 传入的原生django(wsgi)的request当做初始化参数传入Request这个类中 返回的就是Request这个类的实例化对象
            return Request(
                request,
                parsers=self.get_parsers(),
                authenticators=self.get_authenticators(),
                negotiator=self.get_content_negotiator(),
                parser_context=parser_context
            )

        # 由于Request是实例化 所以走的是 __init__方法 下面就是Request的__init__方法代码
            def __init__(self, request, parsers=None, authenticators=None,
                 negotiator=None, parser_context=None):
        assert isinstance(request, HttpRequest), (
            'The `request` argument must be an instance of '
            '`django.http.HttpRequest`, not `{}.{}`.'
            .format(request.__class__.__module__, request.__class__.__name__)
        )

        self._request = request   #只看这一行 我们就可以得出结果 Request实例传进来的原生的django(wsgi)的request在 Request的__init__方法中 重新赋值给self._request 而这个self就是我们在rest-framework中的request

1. 新的request对旧的request做了完全兼容(下面附源码分析)

#源码
	#在rest-framework的request.py中
        def __getattr__(self, attr):
        """
        If an attribute does not exist on this instance, then we also attempt
        to proxy it to the underlying HttpRequest object.
        """
        try:
            return getattr(self._request, attr)  # 通过反射获取属性,如果self._request存在,则使用self._request
        except AttributeError:    # 不存在 则使用 rest-framework的request
            return self.__getattribute__(attr)

1. 新的request对数据解析更规范化 :所有的拼接参数都解析到 requery_params中,所有数据包数据都被解析到了data中, query_params和 data属于QueryDict类型,可以使用.dict()转化为原生的dict类型

2. drf的APIView类:重写了as_view(),但主题逻辑还是调用父类View的as_view()方法 ,最大的改动就是局部禁用了csrf认证(下面附源码解释)

 def as_view(cls, **initkwargs):   #目录:rest-framework/views.py
        if isinstance(getattr(cls, 'queryset', None), models.query.QuerySet):
            def force_evaluation():
                raise RuntimeError(
                    'Do not evaluate the `.queryset` attribute directly, '
                    'as the result will be cached and reused between requests. '
                    'Use `.all()` or call `.get_queryset()` instead.'
                )
            cls.queryset._fetch_all = force_evaluation

        view = super().as_view(**initkwargs)  # 调用父类View的as_view()方法
        view.cls = cls
        view.initkwargs = initkwargs
        return csrf_exempt(view)  # 局部禁用csrf

二. drf的渲染模块(了解)

1. 可以在视图;类中通过rendere_classes类类属性对该视图的数据响应渲染做配置 --局部配置

2. 可以在项目的配资文件的drf配置中通过DEFAULT_RENDERER_CLASSES对该视图的数据响应渲染做配置 --全局配置(下面附渲染模块源码分析)

   注:如果在一个视图类在有全局配置下,还进行了局部配置,优先走自己的局部配置

   局部(views中) :renderer_classes = [JSONRenderer, BrowsableAPIRenderer]

   全局(项目配置文件中) : DEFAULT_RENDERER_CLASSES = [JSONRenderer, BrowsableAPIRenderer]

""" 渲染模块源码分析
1、二次处理响应对象：APIView的dispatch方法 - self.finalize_response(request, response, *args, **kwargs)
2、获取渲染类对象：进入finalize_response方法 - self.perform_content_negotiation(request, force=True)
3、从配置文件中得到渲染类对象：perform_content_negotiation -> self.get_renderers() -> [renderer() for renderer in self.renderer_classes]
"""
"""
核心：可以全局和局部配置视图类支持的结果渲染：默认可以json和页面渲染，学习该模块的目的是开发可以全局只配置json方式渲染
"""

 #详细分析
    #位置 rest-framework/views.py中的dispatch函数中  507行
  # 下面这行代码利用finalize_response这个函数 对响应对象进行二次处理(规定返回数据的样式)
    self.response = self.finalize_response(request, response, *args, **kwargs)
  # 再来看看 finalize_response 这个函数做了什么
  # 位置:rest-framework/views.py/finalize_response 414行
    def finalize_response(self, request, response, *args, **kwargs):
        """
        Returns the final response object.
        """
        # Make the error obvious if a proper response is not returned
        # 下面这行代码的作用是:判断返回的是否是HttpResponseBase的对象,不是则报错
        assert isinstance(response, HttpResponseBase), (
            'Expected a `Response`, `HttpResponse` or `HttpStreamingResponse` '
            'to be returned from the view, but received a `%s`'
            % type(response)
        )

        if isinstance(response, Response):
            #先通过反射到request中寻找accepted_renderer是否存在 如果不存在,就用自己默认的
            if not getattr(request, 'accepted_renderer', None): 

                # 利用perform_content_negotiation函数 找到全局或者默认的渲染规则(项目中没有在					settings中设置全局的渲染规则的话 就用rest-framework默认的渲染规则)
                neg = self.perform_content_negotiation(request, force=True)
                request.accepted_renderer, request.accepted_media_type = neg

                response.accepted_renderer = request.accepted_renderer
                response.accepted_media_type = request.accepted_media_type
                response.renderer_context = self.get_renderer_context()

    #perform_content_negotiation 函数
    # 位置 rest-framework/view.py/perform_content_negotiation  302行
        def perform_content_negotiation(self, request, force=False):
        renderers = self.get_renderers()  #通过get_renderers方法获取配置

  	# 位置 rest-framework/view.py/get_renderers  256行
    	def get_renderers(self):
        # 又通过renderer_classes 获取配置 通过列表推导式实例化返回
        return [renderer() for renderer in self.renderer_classes]

        # 位置 rest-framework/view.py 107行
        # 获取全局DEFAULT_RENDERER_CLASSES配置
        renderer_classes = api_settings.DEFAULT_RENDERER_CLASSES 

三. drf的解析模块 (了解)

作用:服务与数据包数据

1. 可以在视图类中通过parser_classes类属性对该视图的数据包解析做配置 --局部配置

2. 可在项目的配置文件的drf配置中通过DEFAULT_PARSER_CLASSES对该视图的数据响应渲染做配置 --全局配置

3. 解析模块源码分析

   1. APIVIEW的dispatch方法:self.initialize_request(request, *args, **kwargs)内部还提供了数据解析

   2. self.get_parser_context(request)提供要解析的数据,self.get_parsers() 提供解析的类对象(内部从配置中找到解析类)

      核心: 请求的数据包格式会有三种(json urlencoded form-data), drf默认支持三种数据的解析,可以全局或局部配置驶入类具体支持的解析方式

四. 异常模块(重点)

1. 在settings的drf配置中配置EXCEPTION_HANDLER,指向之定义的exception_handle函数

2. drf出现异常了,都会回调exception_handle函数,携带异常对象和异常相关信息内容,

   在exception_handle函数完成异常信息的返回以及异常信息的logging日志

3. 源码分析

   1. 在APIView的dispatch方法中,有一个超大的try...except..., 将代码运行异常都交给异常处理self.handle_exception(exc)

      try:
          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:    #捕捉错误信息 将错误信息交给handle_exception
           response = self.handle_exception(exc)
      

   2. 从配置中映射出配置处理异常的函数(自定义异常模块就是自定义配置指向自己的函数): self.get_exception_handle()

          def handle_exception(self, exc):
              """
              Handle any exception that occurs, by returning an appropriate response,
              or re-raising the error.
              """
              if isinstance(exc, (exceptions.NotAuthenticated,
                                  exceptions.AuthenticationFailed)):
                  # WWW-Authenticate header for 401 responses, else coerce to 403
                  auth_header = self.get_authenticate_header(self.request)
      
                  if auth_header:
                      exc.auth_header = auth_header
                  else:
                      exc.status_code = status.HTTP_403_FORBIDDEN
      
              exception_handler = self.get_exception_handler()  #获取错误处理函数 自定义了就用你自定义的 没有自定义就用系统的
      
              context = self.get_exception_handler_context()
              response = exception_handler(exc, context)
      
              if response is None:
                  self.raise_uncaught_exception(exc)
      
              response.exception = True
              return response
      
          # drf默认的错误处理函数
          def exception_handler(exc, context):
          if isinstance(exc, Http404):
              exc = exceptions.NotFound()
          elif isinstance(exc, PermissionDenied):
              exc = exceptions.PermissionDenied()
      
          if isinstance(exc, exceptions.APIException):
              headers = {}
              if getattr(exc, 'auth_header', None):
                  headers['WWW-Authenticate'] = exc.auth_header
              if getattr(exc, 'wait', None):
                  headers['Retry-After'] = '%d' % exc.wait
      
              if isinstance(exc.detail, (list, dict)):
                  data = exc.detail
              else:
                  data = {'detail': exc.detail}
      
              set_rollback()
              # 处理的错误 就返回错误结果
              return Response(data, status=exc.status_code, headers=headers)
      		# 处理不了的就返回none
          return None
      

   3. 异常函数exception_handle(exc,context)处理异常 就会走自己的先交给系统处理(客户端的异常),系统没处理(服务器异常),再自己处理

      # 自定义异常处理文件可以放在项目任何位置，你找得到就行，不过建议放在根目录或者应用目录
      from rest_framework.response import Response
      from rest_framework.views import exception_handler as drf_exception_handler
      from rest_framework import status
      def exception_handler(exc, context): # 重写错误处理方法
          response = drf_exception_handler(exc, context) #先执行系统定义的错误函数 ，过滤掉请求错误
      
          if response is None: # drf没有处理的异常(服务器异常)
              return Response(status=status.HTTP_500_INTERNAL_SERVER_ERROR, data={
                  'status': 7,
                  'exc': '%s' % exc
              })
      
          # 项目阶段，要记录到日志文件
          return Response(status=response.status_code, data={
              'status': 7,
              # drf处理的客户端异常，原始处理方式是将异常信息放在response对象的data中，data的格式是{'datail': '具体的异常信息'}
              'exc': '%s' % response.data.get('detail')
          })
      
      

   核心:异常信息都需要被logging记录,所以需要自定义;drf只处理客户端异常,服务器异常需要手动处理,统一处理结果

五. drf响应模块

Response类生成对象需要的参数，以及Response类的对象可以使用的属性

1. 参数： Response(data=响应的数据，status=响应的网络状态码，headers=想通过响应头再携带不部分信息给前端)

1. 属性：response.data response.status_code response.status_text

2. 源码:Response类的____init____方法

       def __init__(self, data=None, status=None,
                    template_name=None, headers=None,
                    exception=False, content_type=None):
           """
           Alters the init arguments slightly.
           For example, drop 'template_name', and instead use 'data'.
   
           Setting 'renderer' and 'media_type' will typically be deferred,
           For example being set automatically by the `APIView`.
           """
           super().__init__(None, status=status)
   
           if isinstance(data, Serializer):
               msg = (
                   'You passed a Serializer instance as data, but '
                   'probably meant to pass serialized `.data` or '
                   '`.error`. representation.'
               )
               raise AssertionError(msg)
   
           self.data = data
           self.template_name = template_name
           self.exception = exception
           self.content_type = content_type
   
           if headers:
               for name, value in headers.items():
                   self[name] = value
   
   

   核心: 知道response对象可以产生哪些信息,response对象又是如何访问这些信息的(具体的 上面自定义错误信息代码中有使用)