Django-rest Framework(三)

时间:2019-11-19
本文章向大家介绍Django-rest Framework(三)，主要包括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对象又是如何访问这些信息的(具体的 上面自定义错误信息代码中有使用)

原文地址：https://www.cnblogs.com/kuck/p/11891924.html

随机文章
Javascript知识点必读
最近更新