Django source code analysis request process

The Django project is a Python custom framework that originated from an online news Web site and was released as open source in 2005. This article will conduct source code analysis of django's request process.

1. What is the process from the browser issuing a request to returning the response content?

1. The browser parses the input url

2. Finds the IP address corresponding to the URL

3. Accesses our server through the IP address

　a . The request enters the wsgi server (I have omitted the possible proxy server here, such as nginx)

b. The wsgi server packages the request and passes it to the django application

c. The django application is based on The request path finds the corresponding processing function for processing

　d. After the processing is completed, the django application returns the response to the wsgi server

　e. The wsgi server packages the response returned by the django application and returns the response

4. The server returns the response content, and the browser renders the output

2. Processing entrance of the django application

The wsgi service communicates with the django application through the wsgi protocol. The wsgi service It is the server side, and the Django application is application. The server side calls the Djano application through the application_callable function provided by Django. After the application_callable function is processed, the response is returned to the server

#django The application_callable function is in the django.core.handlers.wsgi.py file. The server will call the WSGIHandler class when processing each request.

#wsgi.py文件
class WSGIHandler(base.BaseHandler):
    request_class = WSGIRequest
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.load_middleware()
    def __call__(self, environ, start_response):
        set_script_prefix(get_script_name(environ))
        signals.request_started.send(sender=self.__class__, environ=environ)
        request = self.request_class(environ)
        response = self.get_response(request)
        response._handler_class = self.__class__
        status = '%d %s' % (response.status_code, response.reason_phrase)
        response_headers = list(response.items())
        for c in response.cookies.values():
            response_headers.append(('Set-Cookie', c.output(header='')))
        start_response(status, response_headers)
        if getattr(response, 'file_to_stream', None) is not None and environ.get('wsgi.file_wrapper'):
            response = environ['wsgi.file_wrapper'](response.file_to_stream)
        return response

3. Django processing request process

The WSGIHandler class is in During initialization, first load the middleware, and encapsulate the requested function _get_response with middleware (middleware is equivalent to a decorator). When executed, the middleware will execute

# wsgi.py文件

# wsgi.py文件
def load_middleware(self):
　　...


    self._view_middleware = []
    self._template_response_middleware = []
    self._exception_middleware = []

    handler = convert_exception_to_response(self._get_response)
    for middleware_path in reversed(settings.MIDDLEWARE):
        middleware = import_string(middleware_path)
        try:
            mw_instance = middleware(handler)
        except MiddlewareNotUsed as exc:
　　　　　　　...

            

        handler = convert_exception_to_response(mw_instance)

    self._middleware_chain = handler

Next, the request is called WSGIHandler

1. Instantiate a request_class

2. Get the request through get_response, get_response will eventually call the function _get_response

def _get_response(self, request):
    response = None

    if hasattr(request, 'urlconf'):
        urlconf = request.urlconf
        set_urlconf(urlconf)
        resolver = get_resolver(urlconf)
    else:
        resolver = get_resolver()

    resolver_match = resolver.resolve(request.path_info)
    callback, callback_args, callback_kwargs = resolver_match
    request.resolver_match = resolver_match

    ...

    if response is None:
        wrapped_callback = self.make_view_atomic(callback)
        try:
            response = wrapped_callback(request, *callback_args, **callback_kwargs)
        except Exception as e:
            response = self.process_exception_by_middleware(e, request)

    ...

    return response

_get_response function encapsulated by the middleware, First, the view function to be called will be found based on the url resolver_match = resolver.resolve(request.path_info), and then the view function response = wrapped_callback(request, *callback_args, **callback_kwargs) Return the response (some middleware will also be called in _get_response)

At this point, the response is returned to the server, and the entire request process is completed

4. Summary

django For a request, the main process is to find the view function corresponding to the request, call the view function encapsulated by the middleware, and return the response.

[Recommended course: Django video tutorial]

The above is the detailed content of Django source code analysis request process. For more information, please follow other related articles on the PHP Chinese website!