Skip to content

7. El ciclo de vida de una solicitud

Entre la llegada de una solicitud y el envío de su respuesta, [Django] pasa por varios pasos, y la aplicación puede intervenir en cada uno. Ya hemos encontrado varios de estos puntos de intervención: los componentes de middleware y su método [__call__] (ejemplos 03, 12, 16, 23), sus métodos [process_exception] (ejemplos 08 y 12) y [process_view] (ejemplo 21), y los convertidores de rutas (ejemplo 12). Este capítulo los combina en un único ejemplo, que muestra un mensaje en la consola en cada paso para poder observar el orden:

    1. la señal [request_started]: la solicitud acaba de llegar. Una señal es una notificación, emitida por [Django] en un momento específico, que las funciones de la aplicación (los receptores) pueden recibir. No pueden actuar sobre la solicitud: simplemente son notificados;
    1. El método [__call__] de los componentes de middleware, antes de la llamada a [get_response]: los componentes de middleware se procesan en el orden especificado por la configuración [MIDDLEWARE]. El enrutamiento aún no ha tenido lugar: un componente de middleware todavía no sabe qué vista atenderá la solicitud. También puede responder por sí mismo, sin invocar el resto de la cadena: en ese caso, no se llama ni a los componentes de middleware siguientes ni a la vista;
    1. Enrutamiento: una vez procesados todos los componentes de middleware, [Django] busca la ruta que coincide con la ruta solicitada (ejemplo 02); en este momento se invoca a los convertidores de parámetros de ruta (ejemplo 12). Si ninguna ruta coincide, se lanza una excepción [Http404] (404);
  • 3 y 4. El método [process_view] de los componentes de middleware, en el orden especificado: la vista ha sido seleccionada pero aún no se ha llamado. Un componente de middleware conoce entonces la vista y sus parámetros; puede dejar que el proceso continúe (devolver [None]), responder en nombre de la vista o lanzar una excepción;
    1. la vista y la plantilla que genera;
  • x. El método de middleware [process_exception] , si la vista ha lanzado una excepción, en el orden inverso al de la configuración. El primero que proporcione una respuesta detiene la búsqueda. Si ninguno la proporciona, [Django] genera por sí mismo la respuesta de error: su página detallada en modo de depuración, o la página de error de la aplicación, proporcionada por las vistas [handler400], [handler403], [handler404], y [handler500] (véase más adelante). Una excepción lanzada en otro lugar (en el [__call__] o en el [process_view] de un componente de middleware, o en el enrutamiento) no pasa por [process_exception]: [Django] la convierte en una respuesta de error al salir del middleware correspondiente;
  • 6 y 7. El método [__call__] de los componentes de middleware, después de la llamada a [get_response], en el orden inverso al de la configuración: la respuesta está lista y cada componente de middleware puede modificarla (añadir un encabezado, una cookie);
    1. La señal [request_finished], enviada después de que la respuesta se envía al navegador. Los receptores ya no pueden modificar la respuesta: se usan para tareas de procesamiento que pueden esperar (como cerrar las conexiones a la base de datos, que es lo que hace [Django] mismo), sin hacer esperar al usuario.

Esto equivale a los filtros de [Java] y a los interceptores de [Spring MVC], a los filtros de acción de [ASP.NET Core MVC], a las funciones [before_request] / [after_request] y [Flask] , al middleware de [Laravel] y a los escuchas de eventos de [Symfony]. En comparación con estos, la diferencia está en la estructura: un componente de middleware encapsula el resto del procesamiento (llama a [get_response], y por lo tanto ve la solicitud antes y la respuesta después, dentro del mismo código, como las muñecas rusas del ejemplo 03), mientras que un escucha de eventos reacciona a un evento, y hay que escuchar dos eventos (uno antes y otro después de la acción) para intervenir. El orden de los componentes de middleware, por su parte, sigue la lista de la configuración [MIDDLEWARE], y no una secuencia numérica: esto es más fácil de leer, pero hay que conocer las restricciones de orden de los componentes de middleware en [Django] (la sesión antes de la autenticación, por ejemplo; según se especifica en la documentación de [Django]).

7.1. Ejemplo 24: los pasos del procesamiento de una solicitud

24-lifecycle/
├── calc/
│   ├── __init__.py
│   ├── apps.py
│   ├── converters.py
│   ├── errors.py
│   ├── logger.py
│   ├── middleware.py
│   ├── signals.py
│   ├── timer.py
│   └── views.py
├── config/
│   ├── settings.py
│   ├── urls.py
│   └── ...
├── templates/
│   ├── calc/
│   │   └── result.html
│   ├── error.html
│   └── layout.html
└── manage.py

La aplicación tiene una sola vista, que calcula el cuadrado de un entero: [/square/7]. Según la URL, tiene éxito o falla de diversas maneras. Los mensajes se escriben en la consola del servidor mediante una pequeña función:

1
2
3
4
5
6
7
8
# calc/logger.py: un mensaje en la consola del servidor de desarrollo

import sys


def log(message):
    # stderr: la salida de error, mostrada por la consola como los mensajes de Django
    print(message, file=sys.stderr)

De forma predeterminada, [print] escribe en la salida estándar; el parámetro [file=sys.stderr] la envía a la salida de error, mientras que [Django] escribe sus propios mensajes: así, ambos se mostrarán en el orden en que se generan. (Una aplicación real usaría el módulo [logging] de [Python], que [Django] configura mediante su ajuste [LOGGING]: el caso de estudio lo hace.)

7.1.1. La configuración: config/settings.py

# config/settings.py: la configuración del ejemplo 24

from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent
DEBUG = True
SECRET_KEY = "django-insecure-1lvp12eazqudzob^%kot4e29)o)jyuph+fvt_dse*lus--6^s^"
# los nombres de host aceptados: esenciales en cuanto DEBUG es False
ALLOWED_HOSTS = ["localhost", "127.0.0.1"]
LANGUAGE_CODE = "en"
TIME_ZONE = "Europe/Paris"
ROOT_URLCONF = "config.urls"
WSGI_APPLICATION = "config.wsgi.application"

INSTALLED_APPS = [
    "django.contrib.staticfiles",
    # la aplicación calc: su configuración (calc/apps.py) conecta nuestros
    # receptores de señales al inicio
    "calc",
]

# el orden de los middlewares: cada uno ENVUELVE a los siguientes
MIDDLEWARE = [
    "calc.middleware.Logger",
    "calc.middleware.Block",
    "calc.middleware.Timer",
    "calc.middleware.ErrorPage",
]

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "DIRS": [BASE_DIR / "templates"],
    },
]

STATIC_URL = "static/"
STATICFILES_DIRS = [
    BASE_DIR.parent / "common" / "static",
]
  • línea 9: [ALLOWED_HOSTS] se completa para que el ejemplo pueda desplegarse en producción ([DEBUG = False]) y puedan verse las páginas de error de la aplicación (véase más adelante);
  • líneas 23–28: cuatro componentes de middleware, en el orden en que la solicitud pasa por ellos.

7.1.2. Antes y después de todo lo demás: las señales

# calc/signals.py: dos SEÑALES de Django, emitidas al inicio y al final de cada solicitud

from django.core.signals import request_finished, request_started
from django.dispatch import receiver

from . import timer
from .logger import log


# @receiver: la función se llama en cada emisión de la señal request_started,
# antes de todos los middlewares
@receiver(request_started)
def start(sender, environ, **kwargs):
    log(f"--- {environ['REQUEST_METHOD']} {environ['PATH_INFO']}")
    log("0. signal request_started")


# request_finished: al final de todo, DESPUÉS de que la respuesta se envía al navegador; ya no
# podemos cambiar la respuesta
@receiver(request_finished)
def finish(sender, **kwargs):
    duration = timer.stop()
    # la medición no ha comenzado si no se llegó a la vista
    if duration is not None:
        log(f"8. signal request_finished (end, {duration} ms)")
  • línea 3: las dos señales de [Django] que enmarcan cada solicitud;
  • líneas 12–15: el decorador [@receiver] engancha la función [start] a la señal [request_started]: se llamará cada vez que se emita la señal. Un receptor recibe el emisor de la señal ([sender]), seguido de parámetros con nombre propios de cada señal; [**kwargs] recoge los que no se nombran, como exige la documentación de [Django] (una señal puede recibir nuevos parámetros en una versión futura). [request_started] proporciona [environ], el diccionario WSGI de la consulta (ejemplo 01): el objeto [HttpRequest] aún no existe. El receptor muestra el método y la ruta, seguidos del mensaje n.º 0;
  • líneas 20–25: el mensaje n.º 8, cuando todo ha terminado, con la duración medida por el temporizador (véase más adelante), si la medición se ha iniciado.

[Django] envía otras señales: antes y después de guardar un modelo desde el ORM ([pre_save], [post_save]), cuando un usuario inicia sesión ([user_logged_in])... y la aplicación puede definir las suyas. Un receptor debe registrarse cuando se inicia la aplicación, antes de la primera solicitud. El lugar designado para ello es la configuración de la aplicación:

# calc/apps.py: la CONFIGURACIÓN de la aplicación calc

from django.apps import AppConfig


class CalcConfig(AppConfig):
    name = "calc"

    # ready: Django lo llama una vez, al inicio, cuando todas las aplicaciones
    # están cargadas. Aquí es donde se conectan los receptores de señales
    def ready(self):
        from . import signals  # noqa: F401 (la importación basta para conectarlos)
  • líneas 6–7: la configuración de una aplicación es una clase que hereda de [AppConfig], ubicada por convención en el módulo [apps.py] de la aplicación, y que [Django] localiza por sí mismo. [name] es el nombre del paquete de la aplicación. Aquí también se le daría a la aplicación un nombre legible ([verbose_name]);
  • líneas 11–12: [Django] llama al método [ready] una sola vez, al inicio, cuando todas las aplicaciones están cargadas. Basta con importar allí el módulo [signals]: sus decoradores [@receiver] conectan los receptores al ejecutarse. La importación se hace dentro del método, y no al principio del archivo, porque un módulo que usa los modelos del ORM no puede importarse hasta que se hayan cargado las aplicaciones. El comentario [# noqa: F401] indica a las herramientas de verificación de código que no señalen una importación “no utilizada”.

7.1.3. Antes y después de la vista: el middleware Logger

# calc/middleware.py: los middlewares del ejemplo 24, en el orden del ajuste MIDDLEWARE

from django.core.exceptions import BadRequest, PermissionDenied
from django.http import Http404
from django.shortcuts import render

from . import timer
from .errors import DomainError
from .logger import log


# el PRIMER middleware: ve pasar cada solicitud antes que los demás (y antes del
# enrutamiento), y la respuesta DESPUÉS de todos los demás
class Logger:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        log("1. Logger, before (before the routing)")
        response = self.get_response(request)
        log(f"7. Logger, after (code {response.status_code})")
        return response


# process_view: DESPUÉS del enrutamiento: el middleware conoce la ruta elegida
class Block:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        return self.get_response(request)

    def process_view(self, request, view_func, view_args, view_kwargs):
        # resolver_match: el resultado del enrutamiento (la vista, el nombre de la ruta...)
        log(f"3. Block, process_view (route: {request.resolver_match.url_name})")
        if "block" in request.GET:
            # una excepción: el resto (Timer, la vista) no se ejecuta
            raise PermissionDenied("access blocked")
        return None


# un middleware que solo actúa para las vistas marcadas con el decorador @timed:
# ANTES de la vista (process_view), DESPUÉS de ella; el fin de la medición se confía a la
# señal request_finished (véase calc/signals.py)
class Timer:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        response = self.get_response(request)
        if getattr(request, "timed", False):
            log(f"6. Timer, after the view (code {response.status_code})")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        # getattr(object, name, default): el atributo del objeto, o el valor predeterminado si no existe
        if getattr(view_func, "timed", False):
            log("4. Timer, process_view (before the view)")
            request.timed = True
            timer.start()
        return None


# process_exception: una excepción salió de la vista; este middleware la reemplaza
# con nuestra página de error
class ErrorPage:
    CODES = {BadRequest: 400, PermissionDenied: 403, Http404: 404}

    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        return self.get_response(request)

    def process_exception(self, request, exception):
        for cls, code in self.CODES.items():
            if isinstance(exception, cls):
                log(f"x. ErrorPage, process_exception (HTTP {code})")
                break
        else:
            # el else de un bucle for: se ejecuta si el bucle no fue interrumpido por break
            if not isinstance(exception, DomainError):
                return None    # los demás: la página de error de Django
            log(f"x. ErrorPage, process_exception (DomainError: {exception})")
            code = 500
        # la respuesta reemplaza a la excepción; luego vuelve a pasar por los middlewares
        # (Timer, luego Logger), como una respuesta ordinaria
        return render(request, "error.html", {"code": code}, status=code)
  • Líneas 14–22: el primer middleware de la configuración: procesa la solicitud antes que todos los demás (mensaje n.º 1) y la respuesta después de todos los demás (mensaje n.º 7), junto con su código ([status_code]). No conoce la ruta, ya que el enrutamiento aún no ha tenido lugar. Se usa para el procesamiento que se aplica a todas las solicitudes: registro, manejo de un proxy (el caso de estudio lo menciona en relación con la dirección IP de los clientes)...

7.1.4. Enrutamiento: calc/converters.py

# calc/converters.py: un conversor de ruta (véase el ejemplo 12): el segmento
# convertido en un entero, o en None si no es un entero (entonces es la
# vista la que decide)

from .logger import log


class IntegerConverter:
    # cualquier segmento, sin barra diagonal
    regex = r"[^/]+"

    def to_python(self, value):
        log(f'2. IntegerConverter, the routing (received value: "{value}")')
        try:
            return int(value)
        except ValueError:
            return None

    def to_url(self, value):
        return str(value)

Un convertidor de rutas (ejemplo 12), que escribe el mensaje n.º 2. Acepta cualquier segmento (la expresión [[^/]+]: uno o más caracteres que no son barras) y lo convierte en un número entero, o en [None] si no lo es: a diferencia del convertidor [int] (ejemplo 02), que devolvería una página 404 para [/square/abc]; aquí, la vista determinará el resultado. El archivo [config/urls.py] lo registra como [integer]:

# config/urls.py: la tabla de enrutamiento principal

from django.urls import path, register_converter

from calc import errors, views
from calc.converters import IntegerConverter

# el conversor "integer" (véase calc/converters.py)
register_converter(IntegerConverter, "integer")

urlpatterns = [
    path("square/<integer:n>", views.square, name="square"),
]

# las vistas de las páginas de error de la aplicación: Django las usa para los errores
# 400, 403, 404 y 500 (excepto, en modo de depuración, para 400, 404 y 500, que reemplaza
# con sus páginas detalladas)
handler400 = errors.page_400
handler403 = errors.page_403
handler404 = errors.page_404
handler500 = errors.page_500
  • Líneas 18–21: las vistas de las páginas de error, descritas más adelante.

7.1.5. Después del enrutamiento: el middleware "Block"

Volvamos al archivo [calc/middleware.py]:

  • Líneas 26–39: el segundo middleware solo actúa dentro de su método ***[process\_view], después del enrutamiento. [request.resolver_match] describe el resultado del enrutamiento (ejemplo 16): el nombre de la ruta ([url_name]***), la vista y sus parámetros. Mensaje n.º 3;
  • Líneas 36–38: el parámetro [?block] de la URL provoca un error 403 (Forbidden, acceso denegado): la excepción [PermissionDenied] interrumpe el procesamiento; los [process_view]s posteriores y la vista no se llaman.

7.1.6. Antes de la vista: el middleware Timer y el decorador @timed

Queremos medir el tiempo solo de ciertas vistas: las que lo soliciten. Basta con marcarlas con un decorador de nuestra autoría:

# calc/timer.py: un cronómetro por hilo de ejecución, y el decorador @timed

import threading
import time

# threading.local: un objeto cuyos atributos son PROPIOS de cada hilo de ejecución
# (thread); el servidor maneja cada solicitud en su propio hilo
_local = threading.local()


def start():
    # perf_counter_ns: un reloj preciso, en nanosegundos
    _local.start = time.perf_counter_ns()


# el tiempo transcurrido en milisegundos, o None si el cronómetro no ha comenzado
def stop():
    start = getattr(_local, "start", None)
    _local.start = None
    if start is None:
        return None
    return round((time.perf_counter_ns() - start) / 1e6)


# un DECORADOR que no cambia la vista: la MARCA, con un atributo que el
# middleware Timer puede leer
def timed(view):
    view.timed = True
    return view
  • líneas 27–29: un decorador que no reemplaza la vista; le añade un atributo, [timed], y la devuelve. En [Python], una función es un objeto al que se le pueden añadir atributos. Así es como [Django] mismo marca ciertas vistas: [@csrf_exempt] (ejemplo 18) añade el atributo [csrf_exempt], que [CsrfViewMiddleware] lee en su método [process_view];
  • Línea 8: la marca de tiempo debe pasarse de [process_view] a la señal [request_finished]. Sin embargo, el servidor procesa varias solicitudes simultáneamente: una variable de módulo normal sería compartida por todas ellas. Un objeto [threading.local] tiene atributos propios de cada hilo: cada solicitud, procesada en su propio hilo, tiene su propia hora de inicio;
  • líneas 11–22: inicio y detención del temporizador. [time.perf_counter_ns()] es un reloj preciso, en nanosegundos, diseñado para medir duraciones. [getattr(object, name, default)] devuelve un atributo de un objeto, o el valor predeterminado si no existe: es posible que el temporizador no se haya iniciado en este hilo. La duración se devuelve en milisegundos.

El middleware que lee la marca, en el archivo [calc/middleware.py]:

  • líneas 55–61: en [process_view], si la vista contiene la marca, se envía el mensaje n.º 4 y se inicia el temporizador. La marca también se guarda en la solicitud para su uso posterior. El decorador [@require_GET], aplicado sobre [@timed] (archivo [calc/views.py]), no borra la marca: [functools.wraps] (ejemplo 08) copia los atributos de la función que envuelve;
  • líneas 49–53: en [__call__], después de la vista, el mensaje n.º 6, con el código de respuesta, si se midió el tiempo de la vista.

7.1.7. La vista: calc/views.py

# calc/views.py: una vista cronometrada

from django.core.exceptions import BadRequest
from django.shortcuts import render
from django.views.decorators.http import require_GET

from .errors import DomainError
from .logger import log
from .timer import timed


# n: el parámetro de ruta, proporcionado por nuestro conversor IntegerConverter;
# @timed: el middleware Timer mide la duración de esta vista
@require_GET
@timed
def square(request, n):
    log(f"5. view square({n})")
    if n is None:
        raise BadRequest("not an integer")    # error 400: ver ErrorPage
    if n == 13:
        raise DomainError("13 brings bad luck")    # un error "inesperado"
    return render(request, "calc/result.html", {"n": n, "square": n * n})
  • línea 15: la vista se marca con nuestro decorador [@timed];
  • línea 16: el parámetro [n] lo proporciona nuestro convertidor;
  • líneas 18–19: un parámetro que no es un entero: error 400 (Bad Request), provocado por la excepción [BadRequest] (ejemplo 07);
  • líneas 20–21: el número 13 provoca un error «inesperado», una excepción [DomainError] de la aplicación;
  • línea 22: el caso normal. La plantilla [calc/result.html] simplemente muestra el resultado.

7.1.8. Gestión de errores: el middleware ErrorPage y las vistas de error

El último middleware del archivo [calc/middleware.py] reemplaza las páginas de error de [Django] por las nuestras, para las excepciones que escapan de la vista:

  • línea 67: un diccionario cuyas claves son clases de excepción y cuyos valores son los códigos HTTP correspondientes;
  • líneas 76–79: [isinstance] (ejemplo 03) comprueba si la excepción es de una de estas clases (o de una clase hija). Si es así, se muestra el mensaje n.º x, junto con el código, y [break] termina el bucle;
  • líneas 80–85: el [else] de un bucle [for] se ejecuta si el bucle terminó sin un [break]: ninguna de las tres clases es adecuada. Una excepción [DomainError] es un error «inesperado», convertido en una página de error «personalizada» con el código de estado 500 (Internal Server Error). El mensaje de la excepción se muestra en la consola, pero no en la página: puede contener detalles internos que no son relevantes para el usuario. Las demás excepciones las gestiona [Django] ([return None]);
  • línea 88: la respuesta, que reemplaza a la excepción. Luego pasa por los componentes de middleware anteriores ([Timer] y después [Logger]), igual que una respuesta normal.

Este middleware solo gestiona las excepciones lanzadas por la vista. En los demás casos (la excepción [PermissionDenied] del middleware [Block], el error 404 de una URL sin ruta), [Django] usa las vistas de error de la aplicación, declaradas en el archivo [config/urls.py] mediante las variables [handler400], [handler403], [handler404] y [handler500] (líneas 18–21), y escritas en el archivo [calc/errors.py]:

# calc/errors.py: una excepción de la aplicación y las vistas de las páginas de error

from django.shortcuts import render

from .logger import log


# una excepción de la aplicación: un error "inesperado" de un tipo dado
class DomainError(Exception):
    pass


# las vistas de las páginas de error (véase config/urls.py): exception es la excepción que
# causó el error
def page_400(request, exception):
    return page(request, 400)


def page_403(request, exception):
    return page(request, 403)


def page_404(request, exception):
    return page(request, 404)


# la página 500 no recibe la excepción
def page_500(request):
    return page(request, 500)


def page(request, code):
    log(f"x. view of the error page {code}")
    return render(request, "error.html", {"code": code}, status=code)
  • líneas 9–10: la excepción de la aplicación: una clase que hereda de [Exception], sin añadirle nada ([pass] es la instrucción que no hace nada: un bloque no puede estar vacío);
  • líneas 15–29: las vistas de error reciben la solicitud y la excepción (salvo la vista 500, que solo recibe la solicitud);
  • líneas 32–34: la misma página de error para todas, con el código de error (mensaje n.º x).

Hay una sutileza: en modo de depuración, [Django] conserva sus páginas detalladas para los errores 400, 404 y 500, y usa estas vistas solo para el error 403. Esto es intencional: durante el desarrollo, la página detallada es más útil. Fuera del modo de depuración, se usan las cuatro vistas. Sin estas vistas, [Django] usaría, fuera del modo de depuración, sus páginas simples (ejemplo 03), o las plantillas de la aplicación llamadas [400.html], [403.html], [404.html], y [500.html] si existen: esta es otra forma, aún más sencilla, de reemplazar las páginas de error. La página de error de la aplicación:

{% extends "layout.html" %}

{# la página de error; su modelo: el código de error #}
{% block content %}
  <div class="alert alert-danger">
    <h1 class="h4">Error {{ code }}</h1>
    <p class="mb-0">
      {% if code == 400 %}Bad request.{% elif code == 403 %}Access denied.{% elif code == 404 %}Page not found.{% else %}Internal server error.{% endif %}
    </p>
  </div>
{% endblock %}
  • línea 8: DTL no tiene un diccionario definido en la plantilla; el mensaje se selecciona mediante una secuencia de [{% elif %}].

7.1.9. Ejecución

El caso normal, [/square/7]:

Image

La consola del servidor muestra los pasos, en orden:

--- GET /square/7
0. signal request_started
1. Logger, before (before the routing)
2. IntegerConverter, the routing (received value: "7")
3. Block, process_view (route: square)
4. Timer, process_view (before the view)
5. view square(7)
6. Timer, after the view (code 200)
7. Logger, after (code 200)
[27/Sep/2026 19:38:41] "GET /square/7 HTTP/1.1" 200 359
8. signal request_finished (end, 5 ms)

La línea entre corchetes es el registro del servidor de desarrollo, escrito después de enviar la respuesta, justo antes de la señal [request_finished]. Un acceso bloqueado, [/square/7?block]:

Image

--- GET /square/7
0. signal request_started
1. Logger, before (before the routing)
2. IntegerConverter, the routing (received value: "7")
3. Block, process_view (route: square)
x. view of the error page 403
Forbidden (Permission denied): /square/7
Traceback (most recent call last):
  ...
  File "/home/claude/django-sept-2026/examples/24-lifecycle/calc/middleware.py", line 38, in process_view
    raise PermissionDenied("access blocked")
django.core.exceptions.PermissionDenied: access blocked
7. Logger, after (code 403)
[27/Sep/2026 19:38:42] "GET /square/7?block HTTP/1.1" 403 443

El middleware [Block] lanzó una excepción en [process_view]: no se llamó ni al [process_view] de [Timer] ni a la vista. La excepción no pasó por [process_exception] (no se originó en la vista): [Django] la convirtió en una respuesta mediante la vista [handler403] y luego la escribió en el registro, junto con su pila de llamadas (una excepción [PermissionDenied] es un error del cliente, que [Django] registra de este modo de todos modos, en el nivel «warning»). La respuesta pasó por la segunda mitad del middleware [Logger]. La señal [request_finished] se emitió pero no mostró nada, ya que la medición no había comenzado. Un parámetro que no es un entero, [/square/abc]:

Image

--- GET /square/abc
0. signal request_started
1. Logger, before (before the routing)
2. IntegerConverter, the routing (received value: "abc")
3. Block, process_view (route: square)
4. Timer, process_view (before the view)
5. view square(None)
x. ErrorPage, process_exception (HTTP 400)
6. Timer, after the view (code 400)
7. Logger, after (code 400)
Bad Request: /square/abc
[27/Sep/2026 19:38:42] "GET /square/abc HTTP/1.1" 400 441
8. signal request_finished (end, 1 ms)

Esta vez se llamó a la vista —[None]— y fue ella la que lanzó el error 400; [process_exception] lo convirtió en una página. [Django] registró de todos modos la respuesta 400 en su registro ([Bad Request: /square/abc]). Un error «inesperado», [/square/13]:

Image

--- GET /square/13
0. signal request_started
1. Logger, before (before the routing)
2. IntegerConverter, the routing (received value: "13")
3. Block, process_view (route: square)
4. Timer, process_view (before the view)
5. view square(13)
x. ErrorPage, process_exception (DomainError: 13 brings bad luck)
6. Timer, after the view (code 500)
7. Logger, after (code 500)
Internal Server Error: /square/13
[27/Sep/2026 19:38:42] "GET /square/13 HTTP/1.1" 500 451
8. signal request_finished (end, 1 ms)

Nuestro middleware gestionó la excepción: el usuario ve la página de error «personalizada», no la página detallada, aunque el modo de depuración esté activado. Por último, una URL que no corresponde a ninguna ruta, [/unknown]:

1
2
3
4
5
6
--- GET /unknown
0. signal request_started
1. Logger, before (before the routing)
7. Logger, after (code 404)
Not Found: /unknown
[27/Sep/2026 19:38:43] "GET /unknown HTTP/1.1" 404 2282

El enrutamiento falló: ningún [process_view], ninguna vista. En modo de depuración, la página 404 es la página de detalle de [Django] (ejemplo 02). Pasemos el ejemplo al modo de producción ([DEBUG = False] en el archivo [config/settings.py]); entonces debemos iniciar el servidor con [python manage.py runserver --insecure] para que siga sirviendo los archivos estáticos (ejemplo 15):

curl http://localhost:8000/unknown
...
<body>
  <div class="container py-3">

  <div class="alert alert-danger">
    <h1 class="h4">Error 404</h1>
    <p class="mb-0">
      Page not found.
    </p>
  </div>

  </div>
</body>
...

La página 404 ahora es la nuestra, generada por la vista [handler404] (la consola muestra [x. view of the error page 404]).

Resumamos los puntos clave. El middleware es el lugar adecuado para las verificaciones comunes a muchas vistas (¿el usuario inició sesión? ¿Tiene permiso para acceder a esta vista?), y los decoradores son para las verificaciones que se aplican solo a unas pocas vistas: la autenticación se apoyará en ellos, como veremos en el próximo capítulo. [process_exception] y las vistas de error garantizan que el usuario nunca vea una página técnica, sea cual sea el error: el caso de estudio aprovecha esto.