DRF

DRF

一、drf的安装与使用

​ 1、安装

pip install djangorestframework

​ 2、注册

# settings.py文件
app: INSTALLED_APPS = [
    ...
    'rest_framework'
]

​ 3、使用

​ urls：

from django.conf.urls import url, include
urlpatterns = [
    url(r'^api/',include('api.urls'))
]

​ api/urls：

from django.conf.urls import url

from . import views
urlpatterns = [
    url(r'^books/$', view.BookAPIView.as_view())
]

​ views：

from rest_framework.views import APIView
from rest_framework.response import Response

book_list = [{'id': 1, 'name': '百科'}, {'id': 2, 'name': '历史'}]

class Books(APIView):
    def get(self, request, *args, **kwargs):
        return Response({
            'status': 0,
            'msg': 'ok',
            'result': book_list
        })
    def post(self, request, *args, **kwargs):
        name = request.data.get('name')
        id = len(book_list) + 1
        book = {'id': id, 'name': name}
        book_list.append(book)
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': book
        })

二、drf的封装风格

​ drf的封装风格，通过代码一眼就可以看出：

from rest_framework import status
from rest_framework.views import APIView
from rest_framework.request import Request
from rest_framework.response import Response
from rest_framework.settings import APISettings
from rest_framework.filters import  SearchFilter
from rest_framework.exceptions import APIException
from rest_framework.permissions import IsAuthenticated
from rest_framework.throttling import SimpleRateThrottle
from rest_framework.pagination import PageNumberPagination
from rest_framework.authentication import BaseAuthentication

三、请求模块

3.1 使用

​ 1、drf的request是在wsgi的request基础上再次封装。

​ 2、wsgi的request作为drf的request一个属性：_request。

​ 3、新的request对旧的request做了完全兼容。

print(request._request.GET)
print(request.GET)
# 打印结果一致

​ 4、新的request对数据解析更规范化：所有的拼接参数都解析到query_params中，所有数据包数据都被解析到data中 ，query_params和data属于QueryDict类型，可以 .dict() 转化成原生dict类型。

print(request.query_params.dict())
print(request.data.dict())

3.2 源码分析

​ 1、drf的APIView类：重写了as_view()，但主体逻辑还是调用父类View的as_view()，局部禁用了csrf认证。

​ 注意！！！所有继承drf的基本视图类APIView的视图类，都不在做csrf认证校验。

​ rest_framework\views.py：

    def as_view(cls, **initkwargs):
        ...
        view = super().as_view(**initkwargs)
        view.cls = cls
        view.initkwargs = initkwargs
        return csrf_exempt(view)

​ 2、drf的APIView类：重写了dispatch()，在内部对request进行了二次封装：self.initialize_request(request, *args, **kwargs)。

​ rest_framework\views.py：

    def dispatch(self, request, *args, **kwargs):
        self.args = args
        self.kwargs = kwargs
        request = self.initialize_request(request, *args, **kwargs)
        self.request = request
        self.headers = self.default_response_headers 

​ 内部核心：走drf的Request初始化方法__init__：self._request = request；drf的Request的getter方法__getattr__：先从self._request反射取属性，没取到再冲drf的request中取。

​ rest_framework\request.py：

    def __init__(self, view, request, method):
        self.view = view
        self.request = request
        self.method = method
        self.action = getattr(view, 'action', None)
     ...
     def __getattr__(self, attr):
        try:
            return getattr(self._request, attr)
        except AttributeError:
            return self.__getattribute__(attr)

​ 核心：request除了可以访问原wsgi协议的request所有内容，还可以访问 query_params、data。

四、渲染模块

4.1 使用

​ 1、可以在项目的配置文件的drf配置中通过DEFAULT_RENDERER_CLASSES对该视图的数据响应渲染做配置 - 全局配置。

​ settings.py：

REST_FRAMEWORK = {
    # 渲染模块的全局配置：开发一般只配置json
    'DEFAULT_RENDERER_CLASSES': [
        'rest_framework.renderers.JSONRenderer',
    ],

​ 2、可以在视图类中通过renderer_classes类属性对该视图的数据响应渲染做配置 - 局部配置。

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

​ views:

class Book(APIView):
    renderer_classes = [JSONRenderer, BrowsableAPIRenderer]
    # 局部禁用就是设置空列表
    # renderer_classes = []

4.2 源码分析

​ 1、二次处理响应对象：APIView的dispatch方法 。

​ rest_framework\views.py：

def dispatch(self, request, *args, **kwargs):
    ...
    self.response = self.finalize_response(request, response, *args, **kwargs)

​ 2、获取渲染类对象：

​ rest_framework\views.py：

def finalize_response(self, request, response, *args, **kwargs):
	if isinstance(response, Response):
		if not getattr(request, 'accepted_renderer', None):
            # 获取对象
			neg = self.perform_content_negotiation(request, force=True)

​ 3、从配置文件中得到渲染类对象：

perform_content_negotiation 
-> self.get_renderers() 
-> [renderer() for renderer in self.renderer_classes]

​ 核心：可以全局和局部配置视图类支持的结果渲染：默认可以json和页面渲染，学习该模块的目的是开发可以全局只配置json方式渲染。

五、解析模块

5.1 使用

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

# 解析模块的局部配置
parser_classes = [JSONParser, MultiPartParser, FormParser]
# 注意：
# JSONParser: json数据
# FormParser： urlencoded
# MultiPartParser：form-data

​ 2、可以在项目的配置文件的drf配置中通过DEFAULT_PARSER_CLASSES对该视图的数据包解析做配置 - 全局配置。

REST_FRAMEWORK = {
    # 解析模块的全局配置
    'DEFAULT_PARSER_CLASSES': [
        'rest_framework.parsers.JSONParser',
        'rest_framework.parsers.FormParser',
        'rest_framework.parsers.MultiPartParser'
    ],

5.2 源码分析

​ 1、APIView的dispatch方法：self.initialize_request(request, *args, **kwargs)内部还提供了数据解析。

​ rest_framework\views.py：

def dispatch(self, request, *args, **kwargs):
	self.args = args
    self.kwargs = kwargs
    request = self.initialize_request(request, *args, **kwargs)

def initialize_request(self, request, *args, **kwargs):
    parser_context = self.get_parser_context(request)
    return Request(
            request,
            parsers=self.get_parsers(),
            authenticators=self.get_authenticators(),
            negotiator=self.get_content_negotiator(),
            parser_context=parser_context
        )

​ 2、self.get_parser_context(request)提供要解析的数据，self.get_parsers()提供解析的类对象（内部从配置中找解析类）。

​ rest_framework\views.py：

def get_parser_context(self, http_request):
        return{
            'view': self,
            'args': getattr(self, 'args', ()),
            'kwargs': getattr(self, 'kwargs', {})
        }
def get_parsers(self):
        return [parser() for parser in self.parser_classes]

​ 核心：请求的数据包格式会有三种（json、urlencoded、form-data），drf默认支持三种数据的解析，可以全局或局部配置视图类具体支持的解析方式

六、异常模块

​ 重写异常模块目的是记录异常信息(项目上线)。

6.1 使用

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

​ settings:

REST_FRAMEWORK = {
    # 异常模块
    # 'EXCEPTION_HANDLER': 'rest_framework.views.exception_handler',
    'EXCEPTION_HANDLER': 'api.utils.exception_handler',
}

​ 2、drf出现异常了，都会回调exception_handler函数，携带 异常对象和异常相关信息内容，在exception_handler函数完成异常信息的返回以及异常信息的logging日志

​ utils:

# 低级版
from rest_framework.response import Response

def exception_hadler(exc, context):
    return Response('%s - %s' % (context['view'].__class__.__name__, exc))

# 中级版
from rest_framework.response import Response
from rest_framework.views import exception_handler as drf_exception_handler
def exception_handler(exc, context):
    response = drf_exception_handler(exc, context)

    if response is None: # drf没有处理的异常
        response = Response({'detail': '%s' % exc})
    return response

# 高级版
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')
    })

6.2 源码分析

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

​ rest_framework\views.py：

    def dispatch(self, request, *args, **kwargs):
       ...
        try:
            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

            response = handler(request, *args, **kwargs)

        except Exception as exc:
            response = self.handle_exception(exc)

	def handle_exception(self, exc):
        if isinstance(exc, (exceptions.NotAuthenticated,
                            exceptions.AuthenticationFailed)):
            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

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

    def get_exception_handler(self):
        return self.settings.EXCEPTION_HANDLER

​ 3、异常函数exception_handler(exc, context)处理异常，就会走自己的： 先交给系统处理(客户端的异常)，系统没处理(服务器异常)，再自己处理。

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

七、相应模块

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

7.1 使用

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

​ 2、属性：response.data 、response.status_code 、 response.status_text

7.2 源码分析

​ Response类的__init__方法

​ rest_framework\response.py：

class Response(SimpleTemplateResponse):
    def __init__(self, data=None, status=None,
                 template_name=None, headers=None,
                 exception=False, content_type=None):
        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对象又是如何访问这些信息的