Django Rest Framework源碼剖析(五)-----解析器

一、簡介

解析器顧名思義就是對請求體進行解析。為什么要有解析器？原因很簡單，當后台和前端進行交互的時候數據類型不一定都是表單數據或者json，當然也有其他類型的數據格式，比如xml，所以需要解析這類數據格式就需要用到解析器(也可以將請求體拿到，然后利用其他模塊進行解析)。

二、基本使用

1.json解析器

同樣以訂單視圖為例，添加json解析器，如下：

from rest_framework.versioning import URLPathVersioning
from rest_framework.parsers import JSONParser
class UserView(APIView):
    '''查看用戶信息'''
    parser_classes = [JSONParser,]
    versioning_class =URLPathVersioning

    def get(self,request,*args,**kwargs):
        res={"name":"wd","age":22}
        return JsonResponse(res,safe=True)
    
    
    def post(self,request,*args,**kwargs):
        print(request.data) #獲取解析后的請求結果
        return JsonResponse({"success":"ok"}, safe=True)

 

使用postman向http://127.0.0.1:8000/api/v1/user視圖發送json數據，注意請求頭必須是application/json,如下圖：

查看post結果（結果直接是json格式）：

 

2.form表單解析器

視圖

from rest_framework.versioning import URLPathVersioning
from rest_framework.parsers import JSONParser,FormParser
class UserView(APIView):
    '''查看用戶信息'''
    parser_classes = [JSONParser,FormParser]
    ##JSONParser,解析頭信息Content-Type:application/json,的json數據
    ##FormParser，解析頭信息Content-Type:x-www-form-urlencoded數據
    versioning_class =URLPathVersioning

    def get(self,request,*args,**kwargs):
        res={"name":"wd","age":22}
        return JsonResponse(res,safe=True)


    def post(self,request,*args,**kwargs):
        print(request.data) #獲取解析后的請求結果
        return JsonResponse({"success":"ok"}, safe=True)

使用postman發送form表單數據

后台接受，並且結果已經轉化為QueryDict類型了

 

三、源碼剖析

1.根據以上示例，梳理解析器解析數據流程

• 獲取用戶請求
• 獲取用戶請求體
• 根據用戶請求頭信息和parase_classes=[...],中的請求頭進行比較，匹配上請求頭就使用該解析器處理
• 解析器從請求體中拿數據進行處理，處理完成之后將結果返回給request.data

2.源碼剖析：

同樣和權限源碼流程一樣，請求進來，先執行APIView的dispatch方法，以下是源碼，分析請看注解

dispatch方法：

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
        #對原始request進行加工，豐富了一些功能
        #Request(
        #     request,
        #     parsers=self.get_parsers(),
        #     authenticators=self.get_authenticators(),
        #     negotiator=self.get_content_negotiator(),
        #     parser_context=parser_context
        # )
        #request(原始request,[BasicAuthentications對象，])
        #獲取原生request,request._request
        #獲取認證類的對象，request.authticators
        #1.封裝request
        request = self.initialize_request(request, *args, **kwargs)
        self.request = request
        self.headers = self.default_response_headers  # deprecate?

        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:
            response = self.handle_exception(exc)

        self.response = self.finalize_response(request, response, *args, **kwargs)
        return self.response

執行initialize_request()方法，在該方法中，get_parsers用於獲取解析器，並被封裝到request.parsers中。

    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(), #獲取所有的解析器，封裝到request.parsers中
            authenticators=self.get_authenticators(),
            negotiator=self.get_content_negotiator(),
            parser_context=parser_context
        )

get_parsers()源碼，和認證、權限一樣，解析器采用列表生成式返回解析器對象的列表，所以示例中定義解析器的變量是parser_classes：

  def get_parsers(self):
        """
        Instantiates and returns the list of parsers that this view can use.
        """
        return [parser() for parser in self.parser_classes] #列表生成式，返回解析器對象

self.praser_classes，默認（全局）配置

class APIView(View):

    # The following policies may be set at either globally, or per-view.
    renderer_classes = api_settings.DEFAULT_RENDERER_CLASSES
    parser_classes = api_settings.DEFAULT_PARSER_CLASSES #解析器全局配置
    authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES
    throttle_classes = api_settings.DEFAULT_THROTTLE_CLASSES
    permission_classes = api_settings.DEFAULT_PERMISSION_CLASSES
    content_negotiation_class = api_settings.DEFAULT_CONTENT_NEGOTIATION_CLASS
    metadata_class = api_settings.DEFAULT_METADATA_CLASS
    versioning_class = api_settings.DEFAULT_VERSIONING_CLASS

當調用request.data獲取請求數據時候將使用解析器，下面是request.data源碼：

 @property
    def data(self):
        if not _hasattr(self, '_full_data'):
            self._load_data_and_files()   #執行_load_data_and_files()，獲取請求體數據獲取文件數據
        return self._full_data

執行self._load_data_and_files()，獲取請求數據或者文件數據，self._load_data_and_files()源碼：

    def _load_data_and_files(self):
        """
        Parses the request content into `self.data`.
        """
        if not _hasattr(self, '_data'):
            self._data, self._files = self._parse()  #執行self_parse(),獲取解析器，並對content_type進行解析，選擇解析器，返回數據
            if self._files:　　　　　　　　　　　　　　　　#判斷文件流數據，存在則加入到self._full_data（也就是我們的request.data）中
                self._full_data = self._data.copy()    ，
                self._full_data.update(self._files)
            else:
                self._full_data = self._data           #不存在將無文件流的解析完成的數據賦值到self._full_data(request.data) # if a form media type, copy data & files refs to the underlying
            # http request so that closable objects are handled appropriately.
            if is_form_media_type(self.content_type):
                self._request._post = self.POST
                self._request._files = self.FILES

執行self._prase()方法，獲取解析器，並對請求的Content-Type進行解析，選擇解析器，返回解析后的數據，以下是self._prase源碼：

    def _parse(self):
        """
        Parse the request content, returning a two-tuple of (data, files)

        May raise an `UnsupportedMediaType`, or `ParseError` exception.
        """
        media_type = self.content_type   #獲取請求體中的Content-Type try:
            stream = self.stream             #如果是文件數據，則獲取文件流數據 except RawPostDataException:
            if not hasattr(self._request, '_post'):
                raise
            # If request.POST has been accessed in middleware, and a method='POST'
            # request was made with 'multipart/form-data', then the request stream
            # will already have been exhausted.
            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) #執行解析器的parse方法（從這里可以看出每個解析器都必須有該方法），對請求數據進行解析 except Exception:
            # If we get an exception during parsing, fill in empty data and
            # re-raise.  Ensures we don't simply repeat the error when
            # attempting to render the browsable renderer response, or when
            # logging the request or similar.
            self._data = QueryDict('', encoding=self._request._encoding)
            self._files = MultiValueDict()
            self._full_data = self._data
            raise

        # Parser classes may return the raw data, or a
        # DataAndFiles object.  Unpack the result as required.
        try:
            return (parsed.data, parsed.files)     #返回解析結果，元祖，解析后的數據在parsed.data（在load_data_and_files中使用self._data和self._files進行接受）,
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　文件數據在parsed.files中 except AttributeError:
            empty_files = MultiValueDict()
            return (parsed, empty_files)

以上就是整個django rest framework 解析器源碼，下面我們來看看示例中json解析器的源碼，說明請看注解：

class JSONParser(BaseParser):
    """
    Parses JSON-serialized data.
    """
    media_type = 'application/json'   #解析的Content-Type類型
    renderer_class = renderers.JSONRenderer
    strict = api_settings.STRICT_JSON

    def parse(self, stream, media_type=None, parser_context=None):  #在源碼中解讀過，該方法用於解析請求體 """
        Parses the incoming bytestream as JSON and returns the resulting data.
        """
        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)  #本質使用json類進行解析 except ValueError as exc:
            raise ParseError('JSON parse error - %s' % six.text_type(exc))

四、總結

1.解析器本質：

django rest framework解析本質是根據請求頭中的Content-Type來實現，不同的類型使用不同的解析器，一個視圖可有多個解析器。

2.使用：

#全局使用
REST_FRAMEWORK = {
   
    #解析器
    "DEFAULT_PARSER_CLASSES":["rest_framework.parsers.JSONParser","rest_framework.parsers.FormParser"]
}

#單一視圖使用
parser_classes = [JSONParser,FormParser]