Django Class-Based Views: Understanding the Request Handling Mechanism

Consider the following code example demonstrating how to use the as_view() method in Django's views module:

# urls.py
from django.contrib import admin
from django.urls import path
import app.views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('app/', app.views.task.as_view()),
]

# views.py
class TaskView(View):
    def get(self, request, user_id):
        response_data = {'status_code': '200', 'message': "Query successful"}
        return JsonResponse(.dumps(response_data), safe=False)

This functionality returns a response dictionary when a GET request is sent to the 'app' endpoint. The question arises: how does the GET method precisely handle requests from the browser?

The answer lies in the as_view() method called during URL registration, which handles most of the routing logic for us.

Let's examine the as_view() source code:

class View:
    http_method_names = [
        "get",
        "post",
        "put",
        "patch",
        "delete",
        "head",
        "options",
        "trace",
    ]

    def __init__(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

    @classonlymethod
    def as_view(cls, **initkwargs):
        """Main entry point for a request-response process."""
        for key in initkwargs:
            if key in cls.http_method_names:
                raise TypeError(
                    "The method name %s is not accepted as a keyword argument "
                    "to %s()." % (key, cls.__name__)
                )
            if not hasattr(cls, key):
                raise TypeError(
                    "%s() received an invalid keyword %r. as_view "
                    "only accepts arguments that are already "
                    "attributes of the class." % (cls.__name__, key)
                )

        def view(request, *args, **kwargs):
            self = cls(**initkwargs)
            self.setup(request, *args, **kwargs)
            if not hasattr(self, "request"):
                raise AttributeError(
                    "%s instance has no 'request' attribute. Did you override "
                    "setup() and forget to call super()?" % cls.__name__
                )
            return self.dispatch(request, *args, **kwargs)

        view.view_class = cls
        view.view_initkwargs = initkwargs
        view.__doc__ = cls.__doc__
        view.__module__ = cls.__module__
        view.__annotations__ = cls.dispatch.__annotations__
        view.__dict__.update(cls.dispatch.__dict__)

        if cls.view_is_async:
            markcoroutinefunction(view)

        return view

The @classonlymethod decorator indicates this method can only be called on a class, not an instance. When TaskView inherits from View, it uses this as_view() method.

The key part of the method is the returned view function:

def view(request, *args, **kwargs):
    self = cls(**initkwargs)
    self.setup(request, *args, **kwargs)
    if not hasattr(self, "request"):
        raise AttributeError(
            "%s instance has no 'request' attribute. Did you override "
            "setup() and forget to call super()?" % cls.__name__
        )
    return self.dispatch(request, *args, **kwargs)

This function creates an instance of the view class, sets up the request, and calls the dispatch method. The dispatch method is responsible for routing the request to the appropriate handler method:

def dispatch(self, 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
    return handler(request, *args, **kwargs)

The http_method_names attribute contains a list of allowed HTTP methods:

http_method_names = [
    "get",
    "post",
    "put",
        "patch",
    "delete",
    "head",
    "options",
    "trace",
]

The dispatch method uses getattr() to dynamically retrieve the appropriate handler method based on the request method. For example, if the request method is GET, it looks for a get() method in the view instance.

Here's how getattr() works:

class TestClass:
    attribute = 1

instance = TestClass()
print(getattr(instance, 'attribute'))  # Returns 1
print(getattr(instance, 'nonexistent', 'default'))  # Returns 'default'
print(instance.attribute)  # Equivalent to the first getattr call, returns 1

So, to answer our original question: when a browser sends a GET request, the dispatch method looks for a get() method in the view instance. If it exists, that method is called; otherwise, the default http_method_not_allowed method is used.