Django REST Framework (DRF) extends Django's capabilities for building Web APIs. It introduces specific components for handling requests, responses, parsing, and exceptions, all centered around the APIView class.

Key imports typically include:

from rest_framework.views import APIView
from rest_framework.request import Request
from rest_framework.response import Response
from rest_framework.exceptions import APIException
from rest_framework.parsers import JSONParser

To enable DRF, add rest_framework to INSTALLED_APPS in your Django settings.

Request Lifecycle

The core of DRF's functionality lies in the APIView class, which subclasses Django's generic View. It overrides key methods to manage the request-response cycle:

1. Entry Point (as_view): DRF's as_view method wraps the parent class's view but explicitly disables CSRF protection for the view function.
2. Dispatching (dispatch): This method orchestrates the entire lifecycle.
   • Initialization: The incoming Django request is wrapped into a DRF Request object.
   • Authentication/Authorization: The initial method performs authentication, permission checks, and throttling before the main logic runs.
   • Handler Execution: The appropriate HTTP method handler (e.g., get, post) is executed.
   • Exception Handling: Any exception triggered during the process is caught and processed by the exception module.
   • Response Finalization: The returned data is wrapped into a Response object and negotiated with content renderers.

Parsers Module

Parsers determine how the request body data is parsed. DRF supports JSON, Form data, and Multipart data by default.

Configuration Hierarchy

DRF follows a strict order when loading parser configurations:

1. Local Configuration: Attributes defined directly on the View class (e.g., parser_classes).
2. Global Configuration: Settings defined in the project's settings.py under REST_FRAMEWORK.
3. Default Configuration: DRF's built-in default settings.

Example: Local Parser Configuration

from rest_framework.parsers import JSONParser, MultiPartParser

class DocumentView(APIView):
    parser_classes = [JSONParser, MultiPartParser]

    def post(self, request):
        return Response({'status': 'received'})

Example: Global Parser Configuration

# settings.py
REST_FRAMEWORK = {
    'DEFAULT_PARSER_CLASSES': [
        'rest_framework.parsers.JSONParser',
        'rest_framework.parsers.FormParser',
        'rest_framework.parsers.MultiPartParser',
    ]
}

Request Module

DRF extends the standard Django HttpRequest into a Request object. This wrapper provides a consistent interface for accessing request data.

• Backward Compatibility: The original Django request is accessible via request._request.
• Query Parameters: Accessed via request.query_params, a more explicit naming convention than Django's request.GET.
• Request Body: Parsed body data is available via request.data. This property intelligently parses JSON, form data, or multipart files, removing the need to manually check content types.

Internal Mecahnism: The Request class uses Python's __getattr__ magic method to fall back to the underlying Django request for attributes not found on the DRF request object.

class Request:
    def __init__(self, request, parsers=None):
        self._request = request
        self.parsers = parsers

    @property
    def data(self):
        # Returns parsed data body
        return self._full_data

    def __getattr__(self, attr):
        # Proxy to the original HttpRequest
        return getattr(self._request, attr)

Response and Rendering Module

Unlike Django's JsonResponse, DRF's Response object can handle various data types and performs content negotiation based on the client's Accept header.

Response Object

from rest_framework.response import Response
from rest_framework import status

def get(self, request):
    payload = {'message': 'Success'}
    return Response(data=payload, status=status.HTTP_200_OK)

Renderers

Renderers format the response data. For example, JSONRenderer returns raw JSON, while BrowsableAPIRenderer provides a user-friendly HTML interface for browsers.

# settings.py
REST_FRAMEWORK = {
    'DEFAULT_RENDERER_CLASSES': [
        'rest_framework.renderers.JSONRenderer',
        'rest_framework.renderers.BrowsableAPIRenderer',
    ]
}

Exception Module

DRF centralizes exception handling through a customizable exception handler. By default, it handles API exceptions (like ParseError or NotAuthenticated) and returns standard error responses.

You can customize this globally to add logging or format error responses differently.

Custom Exception Handler Implementation

# utils/exceptions.py
from rest_framework.views import exception_handler
from rest_framework.response import Response

def custom_exception_handler(exc, context):
    # Call the default handler first
    response = exception_handler(exc, context)

    # Add custom logic, e.g., logging
    view = context.get('view')
    request = context.get('request')
    
    if response is not None:
        # Standardize error structure
        response.data['custom_code'] = response.status_code
    else:
        # Handle unhandled exceptions (500 error)
        return Response({'error': 'Server Error'}, status=500)
    
    return response

To activate the custom handler, configure it in settings.py:

REST_FRAMEWORK = {
    'EXCEPTION_HANDLER': 'utils.exceptions.custom_exception_handler'
}