本文主要是介绍python Django之django rest framework（二）版本、解析器、源码分析，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

文章目录

• 一、rest framework框架版本介绍
• • 1. rest framework框架版本源码分析
  • 2.rest framework框架版本的使用
  • 3.BaseVersioning类方法
  • • QueryParameterVersioning类使用
    • URLPathVersioning类使用
• 二、rest framework框架解析器介绍
• • 1.rest framework框架解析器源码分析
  • • JSONParser类
  • 2.rest framework框架解析器的使用

一、rest framework框架版本介绍

在上篇文章中，我们介绍了rest framework框架的3个认证函数，perform_authentication(身份验证)、permissions(许可验证)、throttles(节流认证、限制访问数量)，而该类方法，是通过APIView继承于View类方法，通过dispatch方法反射的操作，通过initialize_request方法封装了一个request(Request类)，之后在调用initial方法来执行认证函数，而在此之前initial方法还有赋值的操作，而是通过什么来赋值，作用是什么？让我们来通过源码来观察吧。

1. rest framework框架版本源码分析

initial函数方法如下：

    def initial(self, request, *args, **kwargs):
        self.format_kwarg = self.get_format_suffix(**kwargs)

        neg = self.perform_content_negotiation(request)
        request.accepted_renderer, request.accepted_media_type = neg

        version, scheme = self.determine_version(request, *args, **kwargs)
        request.version, request.versioning_scheme = version, scheme
        # 权限认证相关
        self.perform_authentication(request)
        self.check_permissions(request)
        self.check_throttles(request)

我们先从version开始看，能发现version的中文为版本，且通过调用self.determine_version方法，返回的参数由接收，最后再将接收到的参数赋值给request中的version、versioning_scheme对象中。

determine_version函数如下：

 def determine_version(self, request, *args, **kwargs):
        if self.versioning_class is None:
            return (None, None)
        scheme = self.versioning_class()
        return (scheme.determine_version(request, *args, **kwargs), scheme)

通过determine_version函数可以发现，参数需要传递request，且判断了self.versioning_class是否为空，而根据我们前面源码分析判断，可以推断出，该变量是APIView方法中默认的全局配置，所以我们在自定义版本的时候就可以加上versioning_class或配置在全局中。通过代码可以发现，该方法没有进行遍历，且后面通过scheme = self.versioning_class()调用了函数，也就是说我们在子类中定义的versioning_class不是列表，而是一个函数对象，通过scheme对象调用了determine_version方法，可以得知我们在自己定义类的时候必须传入determine_version函数。

最后return返回了2个参数，第一个则为根据determine_version函数发送来的请求来获取到版本号，而第二个返回参数则返回了versioning_class这个函数。

所以我们继续返回到initial函数中，发现返回的两个参数赋值给了version, scheme，而version, scheme又赋值给了request.version, request.versioning_scheme。由此得出当我们子类自定义函数时，若想获取版本信息，可以通过request.version获取版本，而想获取自定义类方法的对象时可以通过request.versioning_scheme获取(子类没有就从父类找)。

2.rest framework框架版本的使用

urls如下：

from django.conf.urls import url
from api import views

urlpatterns = [
    url(r'^api/v1/auth/$', views.AuthView.as_view()),
    url(r'^api/v1/order/$', views.OrderView.as_view()),
    url(r'^api/v1/users/$', views.UsersView.as_view()),
]

api/view如下：

from django.shortcuts import render, HttpResponse
from rest_framework.views import APIView
from django.http import JsonResponse

class ParamVersion(object):
    def determine_version(self, request, *args, **kwargs):
        version = request.query_params.get('version')
        return version
        
class UsersView(APIView):
    authentication_classes = []
    permission_classes = []
    throttle_classes = []
    versioning_class = ParamVersion

    def get(self, request, *args, **kwargs):
        print(request.version, request.versioning_scheme)
        return HttpResponse('ok')

此时访问http://127.0.0.1:8000/api/v1/users/?version=v1打印：

v1 <api.views.ParamVersion object at 0x000001CF29E7DD08>

可以发现通过request是可以获取到版本和ParamVersion函数的对象的，且在Reuqest类中定义了一个query_params函数，该函数的作用就是返回原生request中的GET请求的参数(具体还有很多返回请求的函数可以自行通过Request类中查看)。

3.BaseVersioning类方法

BaseVersioning类是django内置的version版本类，该方法作为多个类方法的父类(子类继承)，用于定义默认版本参数，以及版本的选择。

BaseVersioning源码如下：

class BaseVersioning:
    default_version = api_settings.DEFAULT_VERSION
    allowed_versions = api_settings.ALLOWED_VERSIONS
    version_param = api_settings.VERSION_PARAM

    def determine_version(self, request, *args, **kwargs):
        msg = '{cls}.determine_version() must be implemented.'
        raise NotImplementedError(msg.format(
            cls=self.__class__.__name__
        ))

    def reverse(self, viewname, args=None, kwargs=None, request=None, format=None, **extra):
        return _reverse(viewname, args, kwargs, request, format, **extra)

    def is_allowed_version(self, version):
        if not self.allowed_versions:
            return True
        return ((version is not None and version == self.default_version) or
                (version in self.allowed_versions))

看到api_settings我们知道了可以通过settings设置全局，所以我们就可以通过全局的设置来改变默认参数、允许的版本、传入的值通过什么来接收。

settings.py如下：

REST_FRAMEWORK = {
    "DEFAULT_VERSION": 'v1',
    "ALLOWED_VERSIONS": ['v1', 'v2'],
    "VERSION_PARAM": 'version'
}

BaseVersioning类还有个reverse方法，该方法就是通过获取路由后面传递参数的值，然后调用django的reverse方法将url返回给用户。

urls.py如下：

from django.conf.urls import url
from api import views

urlpatterns = [
    url(r'^api/v1/auth/$', views.AuthView.as_view()),
    url(r'^api/v1/order/$', views.OrderView.as_view()),
    url(r'^api/v1/users/$', views.UsersView.as_view(), name='uuu'),
]

api/views.py如下：

from django.shortcuts import render, HttpResponse
from rest_framework.views import APIView
from rest_framework.versioning import BaseVersioning


class ParamVersion(BaseVersioning):
    def determine_version(self, request, *args, **kwargs):
        version = request.query_params.get('version')
        return version
        
class UsersView(APIView):
    authentication_classes = []
    permission_classes = []
    throttle_classes = []
    versioning_class = ParamVersion

    def get(self, request, *args, **kwargs):
        u1 = request.versioning_scheme.reverse(viewname='uuu', request=request)
        print(request.version, request.versioning_scheme, u1)
        return HttpResponse('ok')

此时访问http://127.0.0.1:8000/api/v1/users/?version=v2打印：

v2 <api.views.ParamVersion object at 0x00000286D85413C8> http://127.0.0.1:8000/api/v1/users/

QueryParameterVersioning类使用

QueryParameterVersioning方法继承于BaseVersioning的类，该方法通过以GET请求的方式获取版本，且还可以通过内置的reverse类来获取URL。

QueryParameterVersioning源码如下：

class QueryParameterVersioning(BaseVersioning):
    invalid_version_message = _('Invalid version in query parameter.')

    def determine_version(self, request, *args, **kwargs):
        version = request.query_params.get(self.version_param, self.default_version)
        if not self.is_allowed_version(version):
            raise exceptions.NotFound(self.invalid_version_message)
        return version

    def reverse(self, viewname, args=None, kwargs=None, request=None, format=None, **extra):
        url = super().reverse(
            viewname, args, kwargs, request, format, **extra
        )
        if request.version is not None:
            return replace_query_param(url, self.version_param, request.version)
        return url

可以发现QueryParameterVersioning中的determine_version方法通过request.query_params.get获取GET请求中的参数，通过我们定义的全局配置属性，self.version_param获取键值，还有默认属性，之后通过is_allowed_version判断我们是否传了值，没传则显示默认值。
而reverse方法则是调用了父类BaseVersioning的reverse方法。

is_allowed_version函数如下：

    def is_allowed_version(self, version):
        if not self.allowed_versions:
            return True
        return ((version is not None and version == self.default_version) or
                (version in self.allowed_versions))

api/view如下：

from rest_framework.versioning import QueryParameterVersioning
from django.shortcuts import render, HttpResponse
class UsersView(APIView):
    authentication_classes = []
    permission_classes = []
    throttle_classes = []
    versioning_class = QueryParameterVersioning

    def get(self, request, *args, **kwargs):
        u1 = request.versioning_scheme.reverse(viewname='uuu', request=request)
        print(request.version, request.versioning_scheme, u1)
        return HttpResponse('ok')

此时打印的数据和之前一样的。

URLPathVersioning类使用

URLPathVersioning方法继承了BaseVersioning的类，该方法封装了版本、URL路径，可以使用版本放在路由中，通过调用父类的reverse方法来获取URL。

URLPathVersioning源码如下：

class URLPathVersioning(BaseVersioning):
	"""

    urlpatterns = [
        re_path(r'^(?P<version>[v1|v2]+)/users/$', users_list, name='users-list'),
        re_path(r'^(?P<version>[v1|v2]+)/users/(?P<pk>[0-9]+)/$', users_detail, name='users-detail')
    ]
    """
    invalid_version_message = _('Invalid version in URL path.')
    def determine_version(self, request, *args, **kwargs):
        version = kwargs.get(self.version_param, self.default_version)
        if version is None:
            version = self.default_version

        if not self.is_allowed_version(version):
            raise exceptions.NotFound(self.invalid_version_message)
        return version

    def reverse(self, viewname, args=None, kwargs=None, request=None, format=None, **extra):
        if request.version is not None:
            kwargs = {} if (kwargs is None) else kwargs
            kwargs[self.version_param] = request.version

        return super().reverse(
            viewname, args, kwargs, request, format, **extra
        )

从源码注释来看可以知道，该类方法通过kwargs的get方法获取通过正则来获取路由上的数据，且定义路由时的方式可以为(?P[v1|v2]+)来定义版本，如果什么都没有就返回默认版本的信息。

而reverse方法则先判断request.version是不是存在，存在则赋值给kwargs，之后调用父类的BaseVersioning方法的reverse函数，所以我们可以知道，在URLPathVersioning中也只需要传入request即可，内部会进行赋值操作的。

urls.py如下：

from django.conf.urls import url
from api import views

urlpatterns = [
    url(r'^api/v1/auth/$', views.AuthView.as_view()),
    url(r'^api/v1/order/$', views.OrderView.as_view()),
    url(r'^api/(?P<version>[v1|v2]+)/users/$', views.UsersView.as_view(), name='uuu'),
]

app/views.py如下：

from rest_framework.versioning import URLPathVersioning
from django.shortcuts import render, HttpResponse

class UsersView(APIView):
    authentication_classes = []
    permission_classes = []
    throttle_classes = []
    versioning_class = URLPathVersioning

    def get(self, request, *args, **kwargs):
    	# reverse(viewname='uuu', request={'version':'v1'})
        u1 = request.versioning_scheme.reverse(viewname='uuu', request=request)
        print(request.version, request.versioning_scheme, u1)
        return HttpResponse('ok')

此时访问http://127.0.0.1:8000/api/v1/users/打印：

v1 <rest_framework.versioning.URLPathVersioning object at 0x000001ACD1710488> http://127.0.0.1:8000/api/v1/users/

一般我们定义版本的时候都是放在路由中，所以为了方便，我们可以通过配置versioning_class来使得全局使用上。

settings.py如下：

REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES": ['api.utils.auth.Authtication', ],
    "UNAUTHENTICATED_USER": None,
    "UNAUTHENTICATED_TOKEN": None,
    "DEFAULT_PERMISSION_CLASSES": ['api.utils.permissions.MyPermission', ],
    "DEFAULT_THROTTLE_CLASSES": ['api.utils.throttle.UserThrottle'],
    "DEFAULT_THROTTLE_RATES": {
        "scope": '3/m',
        "user": '5/m',
    },
    "DEFAULT_VERSION": 'v1',
    "ALLOWED_VERSIONS": ['v1', 'v2'],
    "VERSION_PARAM": 'version',
    "DEFAULT_VERSIONING_CLASS": "rest_framework.versioning.URLPathVersioning"
}

二、rest framework框架解析器介绍

当数据返回的时候，如果请求通过post请求返回，那么就需要遵循post请求数据的规范：

1. 请求头Content-type：application/x-www/form-urlencoded(request.post请求去request.body解析数据)
2. post请求数据格式要求：name=cyy&age=18&gender=女

1.rest framework框架解析器源码分析

一般对于封装类似请求的东西，APIView都会封装在Request类中，之后在把原生request打包好，之后就可以通过打包好的函数调用，而解析器其实就封装在Request类中的data函数中。

initialize_request函数如下：

    def initialize_request(self, request, *args, **kwargs):
        """
        Returns the initial request object.
        """
        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
        )

可以发现Request类中parsers这个对象调用了get_parsers()方法。get_parsers函数如下：

    def get_parsers(self):
        return [parser() for parser in self.parser_classes]

可以发现通过调用self.parser_classes对象遍历成每一个函数，所以从这里我们就可以知道，要想在子类定义解析器，需写上self.parser_classes这个列表。

Request/data函数如下：

   @property
    def data(self):
        if not _hasattr(self, '_full_data'):
            self._load_data_and_files()
        return self._full_data

可以看到在data函数中添加了@property装饰器，所以在使用request.data的时候是无需传括号的，且我们可以看到data函数中调用了_load_data_and_files函数。

_load_data_and_files函数源码如下：

    def _load_data_and_files(self):

        if not _hasattr(self, '_data'):
            self._data, self._files = self._parse()
            if self._files:
                self._full_data = self._data.copy()
                self._full_data.update(self._files)
            else:
                self._full_data = self._data

            if is_form_media_type(self.content_type):
                self._request._post = self.POST
                self._request._files = self.FILES

此时可以看到_load_data_and_files方法又调用了self._parse()，且返回的参数给self._data, self._files。

self._parse()函数源码如下：

    def _parse(self):
        media_type = self.content_type
        try:
            stream = self.stream
        except RawPostDataException:
            if not hasattr(self._request, '_post'):
                raise
            if self._supports_form_parsing():
                return (self._request.POST, self._request.FILES)
            stream = None

        if stream is None or media_type is None:
            if media_type and is_form_media_type(media_type):
                empty_data = QueryDict('', encoding=self._request._encoding)
            else:
                empty_data = {}
            empty_files = MultiValueDict()
            return (empty_data, empty_files)

        parser = self.negotiator.select_parser(self, self.parsers)

        if not parser:
            raise exceptions.UnsupportedMediaType(media_type)

        try:
            parsed = parser.parse(stream, media_type, self.parser_context)
        except Exception:
            self._data = QueryDict('', encoding=self._request._encoding)
            self._files = MultiValueDict()
            self._full_data = self._data
            raise

        try:
            return (parsed.data, parsed.files)
        except AttributeError:
            empty_files = MultiValueDict()
            return (parsed, empty_files)

可以看到_parse函数获取到了self.content_type(即请求头content_type的参数)。
我们直接看 parser = self.negotiator.select_parser(self, self.parsers)这里传入了self.parsers(解析器)，通过self.negotiator对象的select_parser方法来解析，之后将值返还给parser。

DefaultContentNegotiation类/select_parser函数如下：

 def select_parser(self, request, parsers):
 
        for parser in parsers:
            if media_type_matches(parser.media_type, request.content_type):
                return parser
        return None

可以发现此时通过循环parsers来获取到该方法中的media_type请求头，根据支持的请求头，返回该请求头的解析器。

之后我们继续往下走到parsed = parser.parse(stream, media_type, self.parser_context)可以发现该方法是通过调用子类的parse函数执行的。

JSONParser类

rest_framework有内置给我们的解析器，且它们都继承BaseParser类，而该类有一个parse函数，继承BaseParser类的解析器有很多，不过每一个源码流程都相似，这里就通过JSONParser的源码来了解一下解析器的整个流程。

JSONParser/parse函数如下：

    def parse(self, stream, media_type=None, parser_context=None):
        parser_context = parser_context or {}
        encoding = parser_context.get('encoding', settings.DEFAULT_CHARSET)

        try:
            decoded_stream = codecs.getreader(encoding)(stream)
            parse_constant = json.strict_constant if self.strict else None
            return json.load(decoded_stream, parse_constant=parse_constant)
        except ValueError as exc:
            raise ParseError('JSON parse error - %s' % str(exc))

decoded_stream 接收到的就是request.body返回的参数，然后通过json.load的方式将json格式解析成了字典的形式。

2.rest framework框架解析器的使用

urls.py如下：

from django.conf.urls import url
from api import views

urlpatterns = [
    url(r'^api/v1/auth/$', views.AuthView.as_view()),
    url(r'^api/v1/order/$', views.OrderView.as_view()),
    url(r'^api/(?P<version>[v1|v2]+)/users/$', views.UsersView.as_view(), name='uuu'),
    url(r'^api/(?P<version>[v1|v2]+)/parser/$', views.ParserView.as_view(), name='ddd'),
]

api/views.py如下：

from rest_framework.parsers import JSONParser


class ParserView(APIView):
    authentication_classes = []
    permission_classes = []
    throttle_classes = []
    parser_classes = [JSONParser]

    def post(self, request, *args, **kwargs):
        print(request.data)

        return HttpResponse('ParserView')

此时访问http://127.0.0.1:8000/api/v1/parser/显示：

此时控制台打印：

{'name': 'sehun', 'age': 18, 'gender': '男'}

而要想每一个都能使用，我们继续将其放入全局配置中。

settings.py如下：

REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES": ['api.utils.auth.Authtication', ],
    "UNAUTHENTICATED_USER": None,
    "UNAUTHENTICATED_TOKEN": None,
    "DEFAULT_PERMISSION_CLASSES": ['api.utils.permissions.MyPermission', ],
    "DEFAULT_THROTTLE_CLASSES": ['api.utils.throttle.UserThrottle'],
    "DEFAULT_THROTTLE_RATES": {
        "scope": '3/m',
        "user": '5/m',
    },
    "DEFAULT_VERSION": 'v1',
    "ALLOWED_VERSIONS": ['v1', 'v2'],
    "VERSION_PARAM": 'version',
    "DEFAULT_VERSIONING_CLASS": "rest_framework.versioning.URLPathVersioning",
    "rest_framework": ["rest_framework.parsers.JSONParser", ["rest_framework.parsers.FormParser"]],
}

此时就会可以全局都配置上解析器了。

这篇关于python Django之django rest framework（二）版本、解析器、源码分析的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！