2. Vistas, enrutamiento, respuestas
Este capítulo examina el camino que sigue una solicitud, desde el navegador hasta la vista que la procesa, y la respuesta que esa vista devuelve. Las plantillas no se introducirán hasta el capítulo 3: aquí, las vistas devuelven texto o JSON directamente.
2.1. Ejemplo 01: la estructura de una aplicación Django
El primer ejemplo es la aplicación [Django] más pequeña posible. Un proyecto creado con [django-admin startproject] contiene seis archivos, y una aplicación creada con [python manage.py startapp] contiene siete más (véase la introducción); aquí conservamos solo aquellos sin los cuales la aplicación no puede funcionar:
- [manage.py]: la herramienta de línea de comandos del proyecto. Sirve para iniciar el servidor de desarrollo y ejecutar muchos otros comandos;
- [config]: un paquete [Python], es decir, una carpeta que contiene módulos [Python] (archivos [.py]) y un archivo [__init__.py]. Para importar un módulo de un paquete, se escribe [config.settings] (el archivo [config/settings.py]);
- [config/settings.py]: la configuración de la aplicación;
- [config/urls.py]: las rutas de la aplicación y, en este primer ejemplo, su única vista;
- [config/wsgi.py]: el punto de entrada de la aplicación para un servidor web;
- [config/__init__.py]: el archivo que convierte la carpeta [config] en un paquete. A menudo está vacío; el nuestro contiene solo un comentario.
2.1.1. El punto de entrada: config/wsgi.py
[Python] tiene un estándar para las aplicaciones web: WSGI (Web Server Gateway Interface, que se pronuncia “whiskey”). Define cómo un servidor web transmite una solicitud a una aplicación [Python] y cómo recibe la respuesta. Todos los servidores web [Python] ([gunicorn], [waitress], [uWSGI], el servidor de desarrollo de [Django]...) saben llamar a una aplicación WSGI, y todos los frameworks web de [Python] ([Django], [Flask]...) generan una. El archivo [config/wsgi.py] genera la de nuestro proyecto:
- Línea 1: un comentario, desde [#] hasta el final de la línea. Todos los archivos de los ejemplos comienzan con un comentario que indica su nombre y su propósito;
- línea 3: la instrucción [import] importa un módulo: en este caso, [os], un módulo de la biblioteca estándar de [Python], que da acceso al sistema operativo y, en particular, a las variables de entorno del proceso ([os.environ]);
- línea 5: [from ... import ...] importa un nombre de un módulo: la función [get_wsgi_application] del módulo [django.core.wsgi]. El nombre completo de un módulo indica su ubicación: [django.core.wsgi] es el archivo [wsgi.py] de la carpeta [core] del paquete [django], instalado en el entorno virtual (véase la introducción). Después de esta importación, se puede nombrar simplemente [get_wsgi_application];
- línea 8: [Django] obtiene su configuración mediante la variable de entorno [DJANGO_SETTINGS_MODULE], que contiene el nombre del módulo de configuración: [config.settings]. [os.environ] se comporta como un diccionario; su método [setdefault] le asigna un valor, salvo que ya tenga uno: una variable de entorno real, definida antes de iniciar el servidor, tiene prioridad;
- línea 11: [get_wsgi_application()] prepara [Django]: lee la configuración, configura el registro de eventos, carga las aplicaciones del proyecto (ejemplo 02) y luego devuelve la aplicación WSGI, almacenada en la variable [application]. Es esta variable la que el servidor web busca en el archivo. En [Python], una variable no se declara: se crea en su primera asignación y puede contener valores de cualquier tipo.
La aplicación WSGI es un objeto que el servidor llama, por cada solicitud que recibe, con los detalles de la solicitud; el objeto devuelve la respuesta. Toda la aplicación es, por lo tanto, una función que transforma una solicitud en una respuesta. En el medio, [Django] crea un objeto de solicitud ([HttpRequest]), encuentra la vista encargada de procesarla (enrutamiento), la llama y recupera el objeto de respuesta ([HttpResponse]) que esta produce, el cual transmite luego al servidor.
Este archivo se ejecuta una sola vez, cuando se inicia el servidor. Es la diferencia clave con [PHP], que los lectores del curso de [Symfony] han visto en acción: en [PHP], la aplicación se reconstruye en cada solicitud y luego se descarta; en [Python], se construye una sola vez, al iniciar, y luego permanece en memoria para procesar todas las solicitudes posteriores. La configuración, la tabla de enrutamiento, los módulos importados y los objetos almacenados en variables de módulo, todo esto se construye una vez y es compartido por todas las solicitudes. Esto es rápido, pero exige cautela: los datos modificados por una solicitud son visibles para las solicitudes siguientes y, si el servidor procesa varias solicitudes a la vez (el servidor de desarrollo lo hace, con un hilo por solicitud), dos solicitudes pueden modificar los mismos datos simultáneamente. Volveremos sobre esto en el ejemplo 06 y, sobre todo, en el capítulo sobre los ámbitos de datos.
[Python] tiene un segundo estándar, más reciente: ASGI (Asynchronous Server Gateway Interface), para aplicaciones asíncronas (como WebSockets, por ejemplo). [Django] puede generar ambas; el archivo [asgi.py] creado por [django-admin startproject] genera la aplicación ASGI. Nos quedaremos con WSGI.
2.1.2. La configuración: config/settings.py
Los parámetros de configuración de [Django] son variables del módulo [config.settings], escritas en mayúsculas. Es un archivo [Python] estándar: en él se pueden calcular valores, leer variables de entorno e importar otros módulos. [Django] solo exige unos pocos parámetros; todos los demás tienen un valor predeterminado, definido en el módulo [django.conf.global_settings] de [Django] (más de 150 parámetros). El comando [python manage.py diffsettings] muestra los parámetros que difieren de sus valores predeterminados:
- línea 3: [pathlib] es el módulo de la biblioteca estándar que maneja las rutas de archivos. Un objeto [Path] representa una ruta; se escribe igual en [Windows] y en los demás sistemas;
- línea 6: la carpeta del proyecto. [__file__] es la ruta del archivo actual ([config/settings.py]); [resolve()] la convierte en absoluta; [.parent] designa la carpeta que lo contiene ([config]), y [.parent.parent] designa la carpeta superior: la carpeta [01-structure]. Este parámetro, [BASE_DIR], no es un parámetro de [Django]: es una comodidad que otros parámetros utilizarán para referirse a las carpetas del proyecto ([BASE_DIR / "templates"], ejemplo 13: el operador [/] combina dos segmentos de ruta);
- línea 10: modo de depuración. Si se establece en [True], una excepción no controlada muestra una página de error detallada (ejemplo 03), y el servidor de desarrollo sirve él mismo los archivos estáticos (ejemplo 15). Este modo está pensado para el desarrollo, y solo para el desarrollo: la página de error revela el código fuente y la configuración de la aplicación;
- línea 13: la clave secreta de la aplicación: una cadena aleatoria que [Django] usa para firmar ciertos datos (cookies firmadas, tokens anti-CSRF, enlaces de restablecimiento de contraseña, etc.). Este parámetro es obligatorio: sin él, [Django] se negará a iniciar. Cada ejemplo tiene la suya. El prefijo [django-insecure-] es el que utiliza [django-admin startproject]: sirve como recordatorio de que esta clave, escrita directamente en el código fuente, no debe usarse en producción, donde la clave se suministra mediante una variable de entorno (caso de estudio);
- línea 17: los nombres de host que la aplicación está configurada para atender (el encabezado [Host] de la solicitud). Es una salvaguarda contra solicitudes que identifican falsamente el sitio de destino. En modo de depuración, una lista vacía equivale a [localhost], [127.0.0.1] y [::1]; fuera del modo de depuración, debe completarse; de lo contrario, [python manage.py runserver] se negará a iniciar. En [Python], [[a, b]] es una lista;
- líneas 20–21: el idioma de la aplicación ([en]: las fechas, los números y los mensajes de [Django] están en inglés; véase el ejemplo 06) y su zona horaria. Las cadenas pueden delimitarse con comillas dobles o simples; los ejemplos usan comillas dobles;
- línea 24: el módulo que contiene las rutas de la aplicación: [config.urls], es decir, el archivo [config/urls.py];
- línea 27: la aplicación WSGI, indicada por su ruta completa: la variable [application] del módulo [config.wsgi]. Es la que inicia el servidor de desarrollo.
2.1.3. Rutas y vista: config/urls.py
- líneas 3–4: importación de la clase [HttpResponse], la respuesta HTTP, y de la función [path], que declara una ruta;
- líneas 9–11: una vista, es decir, una función que recibe la solicitud y devuelve la respuesta. [def] define una función; su cuerpo es el bloque con sangría que sigue a los dos puntos. En [Python], la sangría no es solo una cuestión de formato: es lo que delimita los bloques (mientras que [PHP] y [Java] usan llaves). El parámetro [request] recibe la solicitud, un objeto [HttpRequest] que [Django] siempre pasa en primer lugar a una vista (ejemplo 05); es una convención de [Django] llamarlo [request];
- línea 11: la vista devuelve un objeto [HttpResponse], cuyo primer parámetro es el cuerpo de la respuesta. En [Python], un objeto se crea llamando a su clase como una función, sin la palabra clave [new]. Esta es la regla de [Django]: una vista siempre devuelve un objeto [HttpResponse] (ejemplo 03);
- líneas 15–17: la tabla de enrutamiento. [Django] busca en el módulo [ROOT_URLCONF] una variable llamada [urlpatterns]: una lista de rutas. La ruta [path("", home)] asocia la ruta vacía (la raíz del sitio, [/]) con la vista [home]. Observe que la ruta de una ruta se escribe sin la barra inicial: [Django] la elimina de la ruta solicitada antes de compararla con las rutas. Observe también que se pasa a la función misma ([home], sin paréntesis) [path], y no su resultado: en [Python], una función es un objeto como cualquier otro, que se puede almacenar en una variable o pasar a otra función. [Django] la llamará más tarde, en cada solicitud a [/]. Se permite una coma después del último elemento de la lista, y es una práctica habitual cuando los elementos se escriben uno por línea.
En un proyecto real, las vistas nunca se escriben en el archivo de rutas: van en los archivos [views.py] de la aplicación (ejemplo 02). Aquí lo hicimos así para mantener el ejemplo sencillo.
2.1.4. La herramienta manage.py
El archivo [manage.py] es un script [Python] que prepara [Django], igual que [config/wsgi.py], pero para ejecutar un comando en lugar de procesar solicitudes:
- línea 1: en [Linux] y [macOS], esta línea permite ejecutar el archivo directamente ([./manage.py]); en [Windows], siempre se escribe [python manage.py];
- línea 10: el módulo de configuración, como en [config/wsgi.py];
- líneas 12–13: una importación también puede realizarse dentro de una función. [execute_from_command_line] ejecuta el comando solicitado: [sys.argv] es la lista de parámetros de la línea de comandos ([["manage.py", "runserver"]]);
- líneas 16–17: [__name__] es igual a ["__main__"] cuando el archivo se ejecuta directamente ([python manage.py]), y al nombre del módulo cuando se importa. Esta condición, presente en muchos scripts de [Python], llama a la función [main] solo en el primer caso.
[python manage.py help] muestra la lista de comandos disponibles: veinticinco en este ejemplo, y más cuando se agregan funcionalidades de [Django] (archivos estáticos, sesiones, autenticación, etc.). Usaremos varios de ellos: [runserver], [check] (verificación del proyecto), [shell] (una consola de [Python] en la que [Django] está listo para usarse), [makemessages] y [compilemessages] (traducciones, ejemplo 22), [collectstatic] (archivos estáticos, caso de estudio; la aplicación [django.contrib.staticfiles] lo agrega). [django-admin] (véanse los apéndices) es la misma herramienta, pero no sabe dónde se encuentra la configuración del proyecto.
2.1.5. Ejecución
En una ventana de terminal abierta en la carpeta [01-structure], donde se ha activado el entorno virtual de los ejemplos (véase la introducción), escriba [python manage.py runserver]. [Django] muestra:
El comando [runserver] inicia el servidor de desarrollo integrado en [Django]. Primero realiza verificaciones del sistema en el proyecto: los parámetros ausentes o incoherentes, o las rutas mal escritas, producirán aquí errores o advertencias, antes de que se haga cualquier solicitud. Luego escucha en el puerto 8000 de la propia máquina ([127.0.0.1], [localhost]): solo acepta solicitudes de esta máquina, lo cual es adecuado para el desarrollo ([python manage.py runserver 0.0.0.0:8000] lo abriría a otras máquinas de la red). Se detiene con [Ctrl-C]. Este servidor está pensado para el desarrollo, como indica su advertencia: en producción será un servidor WSGI, como [gunicorn] o [waitress] (véase el caso de estudio).
La primera línea indica que el servidor supervisa los archivos del proyecto ([StatReloader]: compara periódicamente sus fechas de modificación). Como la aplicación permanece en memoria, un cambio en un archivo [Python] no sería detectado por la aplicación en ejecución; por eso, el servidor de desarrollo se reinicia automáticamente en cuanto un archivo cambia. No es necesario reiniciarlo manualmente, salvo después de agregar un archivo nuevo que nadie ha importado todavía.
Accedamos a la URL [http://localhost:8000/] con un navegador:

y luego con [curl]. La opción [-i] también muestra los encabezados HTTP de la respuesta:
La primera línea de la respuesta contiene la versión del protocolo, el código de estado (200) y su etiqueta ([OK]). Luego vienen los encabezados: la fecha, el servidor (el servidor WSGI de la biblioteca estándar de [Python], sobre el que se construye el servidor de desarrollo), el tipo de contenido y [Connection: close] (el servidor de desarrollo cierra la conexión después de cada respuesta). Una línea en blanco separa los encabezados del cuerpo de la respuesta. En el resto de este documento ya no incluiremos los encabezados [Date], [Server] y [Connection], pues no varían.
El encabezado [Content-Type: text/html; charset=utf-8] indica que la respuesta es HTML, con los caracteres codificados en UTF-8. Es la elección de [Django] para una respuesta cuya vista no especificó el tipo: el navegador interpreta entonces la cadena como HTML (aquí, al no haber etiquetas, se muestra tal cual). El ejemplo 03 mostrará cómo especificar un tipo distinto. La respuesta es mínima: no hay encabezado [Content-Length], ni cookies, ni encabezados de seguridad. Estos los agrega el middleware de [Django] (ejemplo 03), y nuestra aplicación no tiene ninguno.
Por cada solicitud, la consola del servidor muestra una entrada de registro: la fecha, los detalles de la solicitud (método, ruta, protocolo), el código de respuesta y el tamaño del cuerpo de la respuesta en bytes:
Modifiquemos el texto de la línea 11 de [config/urls.py] y guardemos el archivo: la consola muestra [.../01-structure/config/urls.py changed, reloading.], seguido de las líneas de inicio. La siguiente solicitud recibe el nuevo texto.
2.2. Ejemplo 02: enrutamiento
El enrutamiento asocia una URL con una vista. Escribir todas las vistas directamente en el archivo de enrutamiento pronto sería ilegible; en cambio, se organizan en aplicaciones. Una aplicación [Django] es un paquete [Python] que agrupa todo lo relacionado con un único dominio: sus vistas, sus rutas y, más adelante, sus plantillas, formularios y modelos. Un proyecto es un conjunto de aplicaciones. El ejemplo 02 tiene dos:
Los archivos [manage.py], [config/__init__.py], y [config/wsgi.py] son los del ejemplo 01: no volveremos a mencionarlos. El archivo [config/settings.py] siempre comienza con los mismos parámetros (solo cambian el nombre del ejemplo y la clave secreta); comentaremos únicamente los parámetros que agrega cada ejemplo. Esta es la lista de aplicaciones:
- líneas 17–20: el parámetro [INSTALLED_APPS] enumera las aplicaciones del proyecto, identificadas por los nombres de sus paquetes. [Django] las carga al iniciar, en este orden. Para nuestro ejemplo, la declaración no es esencial: las vistas de [home] y [first] se encuentran mediante importaciones desde los archivos de rutas. Se volverá esencial en cuanto las aplicaciones incluyan plantillas (ejemplo 13), etiquetas de plantilla (ejemplo 16), traducciones (ejemplo 22) o modelos del ORM (ejemplo 28), que [Django] busca únicamente en las aplicaciones declaradas. [Django] mismo proporciona varias aplicaciones ([django.contrib.sessions], [django.contrib.messages], [django.contrib.staticfiles], [django.contrib.admin]...), que se declaran de la misma manera.
2.2.1. La vista de la aplicación home
- línea 4: importación de un decorador de [Django];
- líneas 9–10: un decorador es una función que envuelve a otra función para modificar su comportamiento. Se escribe como [@name] encima de la definición de la función: [@require_GET] encima de [def index] equivale a escribir [index = require_GET(index)] después de la definición. La función [index] se reemplaza por una función que primero verifica el método HTTP de la solicitud: si no es GET, responde ella misma con un error 405, sin llamar a [index]. Sin decorador, una vista acepta todos los métodos. El módulo [django.views.decorators.http] también contiene [require_POST], [require_safe] (GET y HEAD) y [require_http_methods(["GET", "POST"])]. Observe que [require_GET] rechaza incluso las solicitudes con el método HEAD (la misma solicitud que GET, sin el cuerpo de la respuesta): [require_safe] es necesario para aceptarlas. Por convención, el nombre de una función o variable en [Python] se escribe en minúsculas, con las palabras separadas por guiones bajos ([require_GET] es una excepción), mientras que el nombre de una clase lleva una letra mayúscula al comienzo de cada palabra ([HttpResponse]);
- líneas 11–22: una cadena de varias líneas, delimitada por tres comillas (["""]). La vista devuelve HTML, enviado con el tipo [text/html] (véase el ejemplo 01).
La vista [index] devuelve así una página HTML que contiene enlaces a vistas de la otra aplicación:

2.2.2. Las vistas de la aplicación first
- líneas 9–11: una vista como función, igual que en el ejemplo 01;
- líneas 16–21: una vista también puede ser una clase que hereda de la clase [View] de [Django]. En [Python], la herencia se escribe colocando la clase padre entre paréntesis después del nombre de la clase. La clase tiene un método por cada método HTTP que implementa, con el nombre del método HTTP en minúsculas: [get] para GET, [post] para POST. [Django] llama al método que corresponde a la solicitud; un método HTTP que no es manejado por ningún método de la clase produce un error 405. Un método de [Python] siempre recibe, como primer parámetro, el objeto sobre el que se lo llama (llamado convencionalmente [self]), seguido de la solicitud. Es la forma más clara de manejar varios métodos HTTP en la misma URL (una función tendría que evaluar [request.method] por sí misma; véase el ejemplo 11). [Django] también ofrece vistas genéricas, clases listas para usar para necesidades comunes ([TemplateView], [ListView], [FormView]...), que este documento no utiliza: ocultan justamente lo que queremos mostrar;
- líneas 26–28: una vista que recibe un parámetro de ruta, [id], después de la solicitud. El valor ya está convertido en entero (véase más adelante). La cadena [f"Product no. {id}"] es una f-string: las expresiones escritas entre llaves se reemplazan por sus valores;
- líneas 32–34: dos parámetros de ruta. [Django] los pasa a la vista por nombre (parámetros con nombre): el orden de los parámetros de la vista no importa. Aquí, [number] se escribe antes que [id];
- líneas 38–40: un parámetro de ruta que contiene barras.
2.2.3. Las rutas: config/urls.py y first/urls.py
Falta todavía asociar las URL con las vistas. La tabla de enrutamiento principal, para el parámetro [ROOT_URLCONF]:
- línea 5: importa el módulo [views] de la aplicación [home] con otro nombre: [as home_views]. Dos aplicaciones pueden tener cada una un módulo llamado [views]; cambiarle el nombre evita confusiones;
- línea 9: la ruta de la raíz del sitio. El tercer parámetro, [name], da un nombre a la ruta: este nombre se usará para generar su URL (ejemplo 04) sin escribirla directamente en el código. [Python] acepta parámetros por posición o por nombre ([name="home"]): los parámetros con nombre hacen la llamada más legible;
- línea 12: [include] delega una parte de las URL a otra tabla de enrutamiento: todas las URL que comienzan con [first/] se asignan a las rutas del módulo [first.urls], al que [Django] solo le pasa el final de la ruta. Cada aplicación conserva así sus rutas en su propio archivo [urls.py], y el proyecto solo decide bajo qué prefijo se montan. El prefijo termina con una barra diagonal: es la convención que usa [Django], donde las rutas de las aplicaciones nunca comienzan con una barra diagonal.
- línea 10: [app_name] proporciona un espacio de nombres para las rutas del archivo: para el resto del proyecto, la ruta llamada [product] se denomina [first:product]. Así, dos aplicaciones pueden tener cada una una ruta llamada [index] sin conflicto;
- línea 14: la ruta [""] designa el propio prefijo: la URL [/first/];
- línea 17: la vista escrita como clase. [as_view()] es un método de la clase [View] que crea la función que [Django] llamará en cada solicitud: esta función crea un objeto [Action01] y luego llama a su método [get] o [post] , según el método HTTP de la solicitud. Se crea un objeto nuevo en cada solicitud;
- línea 20: [<int:id>] es un parámetro de ruta: este segmento de la URL puede tomar varios valores. [id] es el nombre del parámetro, que se pasará a la vista; [int] es un convertidor que solo acepta dígitos y pasa un entero a la vista: para la URL [/first/products/17], el parámetro [id] de la vista es el entero 17. Si el segmento no está formado por dígitos, la ruta no coincide. Esto es el enlace de datos (data binding), que el siguiente capítulo examinará en detalle;
- línea 22: dos parámetros de ruta;
- línea 25: el convertidor [path] acepta cualquier final de ruta, incluidas las barras. [Django] tiene cinco convertidores: [str] (el convertidor predeterminado: [<name>] equivale a [<str:name>]; cualquier texto no vacío sin barra), [int] (números), [slug] (letras, números, guiones y guiones bajos, como en [my-article-01]), [uuid] (un identificador UUID) y [path]. El ejemplo 12 mostrará cómo escribir un convertidor “personalizado”, y el ejemplo 22 mostrará la función [re_path], que describe una ruta mediante una expresión regular.
Para cada solicitud, [Django] recorre las rutas en orden y se detiene en la primera que coincide con la ruta solicitada: el orden de las rutas importa cuando dos rutas pueden coincidir con la misma ruta solicitada.
2.2.4. Ejecución
Estas son las respuestas a algunas solicitudes:
Para enviar una solicitud POST, use la opción [-X POST] de [curl]:
La solicitud POST se acepta tal cual. Esto dejará de ser así cuando la aplicación tenga el middleware de protección anti-CSRF de [Django] (ejemplo 18), que rechaza cualquier solicitud POST que no demuestre provenir de un formulario de la aplicación. Un método HTTP que la vista no maneja produce un error 405 ([Method Not Allowed]). El encabezado [Allow] especifica los métodos aceptados:
La respuesta no tiene cuerpo. La clase [View] acepta, además de los métodos de la clase, el método HEAD (manejado por el método [get]) y el método OPTIONS (que devuelve la lista de métodos aceptados). La consola del servidor informa del rechazo:
El decorador [@require_GET] produce el mismo error:
Una URL que ninguna ruta maneja produce un error 404. Lo mismo ocurre con un identificador que no es un número: el convertidor [int] impide que la ruta coincida con [/first/products/abc].
En un navegador, en modo de depuración:

La página de error de [Django] explica que ninguna ruta coincide con la ruta solicitada y enumera, en orden, todas las rutas de la aplicación junto con sus nombres: es una buena manera de comprobar las rutas ([Django] no tiene un comando que las enumere). Observe que las rutas de la aplicación [first] han sido efectivamente prefijadas con [first/], y que la ruta se comparó sin su barra inicial. El capítulo 6 mostrará cómo reemplazar esta página por una página personalizada para la aplicación. Observe también que [Django] distingue entre [/first/] y [/first]: la segunda, URL, no tiene ruta y devuelve un error 404. Un componente de middleware de [Django], [CommonMiddleware] (caso de estudio), resuelve este problema: cuando una ruta sin barra final no tiene ruta asociada, pero la misma ruta con barra final sí la tiene, redirige el navegador (ejemplo 04) a esa segunda ruta (esta es la configuración [APPEND_SLASH], habilitada de forma predeterminada).
2.3. Ejemplo 03: respuestas de una vista
Lo que devuelve una vista determina la respuesta HTTP. El ejemplo 03 revisa los casos principales:
La aplicación enruta [responses], montada bajo el prefijo [responses/] mediante el archivo [config/urls.py], asocia cada URL [/responses/xxx] con una vista:
Comentemos este código:
- línea 5: las clases de respuesta y de excepción del módulo [django.http];
- línea 8: importación de una clase desde un módulo de la misma aplicación. El punto en [.viewmodels] se refiere al paquete del archivo actual ([responses]): es una importación relativa;
- líneas 12–14: [HttpResponse] acepta parámetros con nombre: [content_type] especifica aquí texto plano ([text/plain]); el navegador no interpretará las etiquetas. [status] (el código de estado, 200 de forma predeterminada) y [headers] (un diccionario de encabezados) son los demás;
- líneas 18–20: la misma cadena, sin un tipo declarado: [Django] la envía con el tipo [text/html], y el navegador la interpreta;
- líneas 26–28: [JsonResponse] es una clase hija de [HttpResponse]: convierte su primer parámetro a JSON y declara el tipo [application/json]. La conversión la realiza el módulo [json] de la biblioteca estándar, que reconoce solo los tipos básicos de [Python]: diccionarios, listas, cadenas, números, booleanos y [None]. Por lo tanto, un objeto debe convertirse primero en un diccionario: esto es lo que hace la función [asdict] (línea 3) con una clase de datos, como [Person], que se muestra más abajo. La vista se llama [as_json]: si se llamara [json], ocultaría el módulo [json] en este archivo si este se importara;
- líneas 32–34: un diccionario llamado [Python], encerrado entre llaves, se convierte en un objeto llamado JSON;
- líneas 39–41: una lista se convierte en un arreglo JSON. De forma predeterminada, [JsonResponse] acepta solo un diccionario: es una antigua medida de protección contra una vulnerabilidad de navegadores antiguos que permitía a un sitio de terceros leer un arreglo JSON. El parámetro [safe=False] elimina esta restricción;
- líneas 45–49: una lista calculada. El método [sort] ordena la lista (modifica la propia lista). [[n * 10 for n in numbers]] es una comprensión de listas: la lista de valores [n * 10], para cada elemento [n] de la lista [numbers];
- líneas 53–55: el parámetro [status]: 201 ([Created]) reemplaza a 200;
- líneas 59–61: el código 204 ([No Content]) significa “nada que mostrar”: la respuesta no tiene cuerpo;
- líneas 65–67: un error “esperado”: una respuesta 404 ([Not Found]), con un cuerpo (JSON) elegido por la vista;
- líneas 71–73: el mismo error, causado por una excepción. [Http404] es una excepción de [Django]; la instrucción [raise] la lanza, lo que termina la vista. [Django] la convierte en una respuesta de error 404. Esta es la forma más común de terminar una vista por un error, incluso en lo profundo de una función llamada por la vista. El módulo [django.shortcuts] ofrece dos atajos que la lanzan: [get_object_or_404] y [get_list_or_404] (para los modelos del ORM, capítulo 7). [django.core.exceptions] define las excepciones que generan los demás códigos de error: [PermissionDenied] (403), [BadRequest] (400), [SuspiciousOperation] (400);
- líneas 77–79: un error “inesperado” (una excepción que nadie maneja) produce una respuesta 500 ([Internal Server Error]). [RuntimeError] es una clase de excepción de la biblioteca estándar de [Python], disponible sin necesidad de importarla;
- líneas 84–86: el error que se debe evitar. Una vista de [Django] debe devolver un objeto [HttpResponse]; esta vista genera la respuesta correctamente, pero no la devuelve. Una función de [Python] sin [return] devuelve el valor [None], que [Django] rechaza (veremos la respuesta más adelante). Esto difiere de otros frameworks, como [Flask], que convierten por sí mismos un diccionario o una cadena en una respuesta: [Django] exige que la vista especifique explícitamente qué respuesta devuelve.
La clase [Person]:
- línea 3: el módulo [dataclasses] de la biblioteca estándar;
- líneas 9–13: una clase de datos. Las líneas [last_name: str] declaran atributos, junto con sus tipos (anotaciones de tipo, que [Python] no impone en tiempo de ejecución, pero que el editor de código verifica). El decorador [@dataclass] usa estos atributos para generar el constructor de la clase (el método [__init__], llamado por [Person("Martin", "Jean", 42)]), su método de comparación ([==]) y su representación de texto ([Person(last_name='Martin', first_name='Jean', age=42)]). Con [frozen=True], los atributos ya no se pueden modificar después de la construcción: un objeto [Person] es inmutable. No es obligatorio colocar esta clase en un módulo [viewmodels.py]: es una decisión tomada en este documento, que reserva el nombre [models.py] para los modelos del ORM de [Django] (capítulo 7).
Queda el archivo [config/middleware.py]:
De forma predeterminada, una respuesta [JsonResponse] contiene un JSON compacto de una sola línea, en el que los caracteres que no son ASCII se escriben como secuencias de escape: [é] se convierte en [\u00e9], lo cual es JSON válido, pero poco legible. Para los ejemplos de este curso, queremos un JSON legible. En lugar de solicitarlo en cada vista (el parámetro [json_dumps_params] de [JsonResponse] lo permitiría), modificamos todas las respuestas JSON de la aplicación mediante un mecanismo central de [Django]: el middleware.
Un middleware es un eslabón de la cadena que lleva de la solicitud a la vista, y luego de la vista a la respuesta. [Django] encadena los componentes de middleware de la configuración [MIDDLEWARE] como muñecas rusas: el primero recibe la solicitud y se la pasa al siguiente, que se la pasa al siguiente, y así hasta llegar a la vista; la respuesta de la vista recorre entonces la cadena en sentido inverso. Cada componente de middleware puede examinar o modificar la solicitud a la entrada y la respuesta a la salida, e incluso puede responder por sí mismo sin llamar al siguiente componente. Así está construido [Django] mismo: la sesión, la protección anti-CSRF, los mensajes y el idioma son todos componentes de middleware.
- líneas 11–13: un middleware es una clase. [Django] crea una única instancia de ella al iniciarse la aplicación, pasando la función [get_response] (el resto de la cadena: los componentes de middleware siguientes, seguidos de la vista) a su constructor ([__init__]). El constructor la almacena en un atributo del objeto, [self.get_response];
- líneas 15–24: el método [__call__] hace que el objeto sea invocable como una función: [Django] lo llama en cada solicitud, junto con la solicitud. El código que precede a la llamada a [self.get_response(request)] se ejecuta antes de la vista; el código que la sigue se ejecuta después de la vista: aquí, el middleware no hace nada antes de la vista;
- líneas 19–23: si la respuesta es una respuesta JSON (la función [isinstance] verifica la clase de un objeto), el middleware vuelve a leer su cuerpo ([response.content], bytes), lo decodifica ([json.loads]) y luego lo codifica de nuevo ([json.dumps]) con dos opciones: [ensure_ascii=False] (los caracteres que no son ASCII se escriben tal cual) e [indent=4] (un formato con sangría, en varias líneas). La asignación a [response.content] reemplaza el cuerpo de la respuesta;
- línea 24: el middleware devuelve la respuesta, que continúa su propagación ascendente.
Todavía falta declarar el middleware en el archivo [config/settings.py]:
- líneas 20–22: la configuración [MIDDLEWARE] enumera los componentes de middleware de la aplicación en el orden en que la solicitud pasa por ellos, indicados mediante la ruta completa de su clase. Veremos cómo se va completando a medida que avancemos por los ejemplos. Los ejemplos 05 a 12 reutilizan este middleware.
En un navegador, la diferencia entre [text/plain] y [text/html] es visible:


Estas son las respuestas de las demás vistas:
El objeto se convirtió en un objeto JSON, con un campo por atributo. La vista [/responses/dictionary] produce exactamente la misma respuesta.
La respuesta de la excepción es la página de error de [Django], la del ejemplo 02, con nuestro mensaje en lugar de la lista de rutas. Incluso cuando el cliente solicita una respuesta JSON mediante el encabezado [Accept: application/json] (opción [-H] de [curl]: [curl -i -H "Accept: application/json" http://localhost:8000/responses/abort]), la respuesta sigue siendo la página HTML: [Django] no adapta sus respuestas de error al tipo solicitado. Una aplicación que quiera errores en formato JSON los genera por sí misma mediante un middleware (ejemplo 08). La consola informa del error:
Queda la excepción no manejada. En modo de depuración, el navegador muestra la página de error de [Django]: el tipo y el mensaje de la excepción, la vista actual, el archivo y la línea donde se lanzó, seguidos de la pila de llamadas (traceback) y la lista de funciones que se estaban ejecutando en el momento del error, de la más antigua a la más reciente:

Más abajo en la página, la última función de la pila es nuestra vista, [error], en la línea 79 del archivo [responses/views.py]; por encima están las funciones de [Django] que la llamaron. Para cada función, el enlace “Local vars” muestra los valores de sus variables locales; el resto de la página muestra la solicitud (sus parámetros, cookies y encabezados) y todos los ajustes de la aplicación (aquellos cuyos nombres sugieren información sensible, como [SECRET_KEY], se enmascaran con asteriscos). Por todas estas razones, el modo de depuración nunca debe habilitarse en un servidor accesible para otras personas. El error también se escribe en el registro de la aplicación (en este caso, la consola del servidor), junto con la pila de llamadas:
Sin el modo de depuración ([DEBUG = False] en el archivo [config/settings.py], junto con [ALLOWED_HOSTS = ["localhost"]], ya que la lista ya no puede estar vacía), la misma solicitud produce una página de error breve que no revela nada sobre el código:
y el error 404 para [/responses/abort] también se convierte en una página corta ([Not Found]: “The requested resource was not found on this server.”), sin nuestro mensaje. Fuera del modo de depuración, [Django] tampoco escribe ya la pila de llamadas en la consola: la envía por correo electrónico a los administradores del sitio, si se han especificado (configuración [ADMINS]). El caso de estudio mostrará cómo configurar el registro. El capítulo 6 mostrará cómo mostrar una página de error específica de la aplicación.
Por último, la vista que olvida devolver su respuesta:
La consola muestra el mensaje de la excepción:
El mensaje es claro: “The view did not return an object HttpResponse; it returned None.” Es un error común entre los principiantes: en una vista con varias ramas ([if] / [else]), en una de ellas se olvida el [return].
2.4. Ejemplo 04: redirecciones
Una redirección es una respuesta que indica al navegador que obtenga otra URL: un código 3xx, junto con el encabezado [Location], que contiene la nueva dirección. El navegador envía de inmediato una segunda solicitud a esa dirección. Las rutas del ejemplo:
El archivo [config/urls.py] monta las rutas de la aplicación [redirects] en la raíz del sitio (prefijo vacío). El archivo [redirects/urls.py] no contiene una línea para [app_name]: sus rutas no tienen espacio de nombres y se llaman simplemente [page], [new]... Las vistas:
- Línea 4: el módulo [django.shortcuts] contiene atajos y funciones que condensan en una sola línea las operaciones más comunes: [redirect], [render] (el capítulo sobre las plantillas), [get_object_or_404]...;
- Líneas 9–11: [redirect] genera una respuesta de redirección (un objeto [HttpResponsePermanentRedirect] o [HttpResponseRedirect] , dos subclases de [HttpResponse]) hacia la dirección especificada. Con [permanent=True], el código es 301 ([Moved Permanently]): la página cambió su dirección de forma permanente, y el navegador (y los motores de búsqueda) pueden recordar la nueva;
- Líneas 21–23: sin [permanent=True], [redirect] produce una redirección temporal con el código de estado 302 ([Found]). La dirección se calcula concatenando fragmentos de texto (el operador [+] concatena dos cadenas), lo que plantea un problema, como veremos;
- líneas 28–30: [redirect] también acepta el nombre de una ruta (['page']), seguido de sus parámetros ([name=destination]): entonces genera la dirección por sí mismo mediante la función [reverse] de [Django], que realiza el proceso de enrutamiento inverso (de un nombre de ruta y sus parámetros a una URL) y codifica correctamente los parámetros para una URL. Si alguna vez se cambia la ruta de la ruta [page], las redirecciones hacia ella se actualizarán automáticamente. Para una ruta de una aplicación que tiene un espacio de nombres, el nombre se escribe como [first:product] (ejemplo 02);
- líneas 40–41: una redirección a otro sitio: la dirección se toma tal cual. [redirect] primero verifica si la cadena es el nombre de una ruta; si no se encuentra ninguna, una cadena que contenga una barra o un punto se trata como una dirección (de lo contrario, es un error).
Las respuestas, usando [curl] (que, sin opciones, no sigue las redirecciones):
El encabezado [Location] contiene la dirección tal como la proporcionó la vista, relativa al sitio: el navegador la completa con el protocolo, el host y el puerto de la página actual. La respuesta no tiene cuerpo. La opción [-L] de [curl] sigue la redirección, tal como lo haría un navegador:
Ahora comparemos las dos redirecciones calculadas, con un destino que contiene un signo de interrogación, codificado como [%3F] en la URL (un [?] sin codificar iniciaría los parámetros de la URL):
[Django] decodificó el parámetro de la ruta antes de pasarlo a la vista: [destination] es igual a [a?b]. La primera vista lo inserta de nuevo en la URL tal cual: [/page/a?b], que el navegador interpreta como la ruta [/page/a] seguida del parámetro [b]. La segunda sigue la ruta con nombre, cuyo parámetro se vuelve a codificar así: [/page/a%3Fb]. Al seguir las redirecciones:
Solo la segunda lleva a la página correcta. De ahí la regla: una dirección que contiene un valor variable se construye a partir del nombre de su ruta ([redirect("page", name=...)], [reverse("page", kwargs={"name": ...})] y, en las plantillas, la etiqueta [{% url %}]), nunca concatenando cadenas. En el navegador, solo se ve la página final; la barra de direcciones muestra la nueva URL:

Existen otros dos códigos de redirección: 303 ([See Other]) y 307 ([Temporary Redirect]), que se obtienen generando la respuesta uno mismo: [HttpResponseRedirect(url, status=303)]. Después de una solicitud POST, los códigos 302 y 303 hacen que el navegador envíe una solicitud GET a la nueva dirección, mientras que 307 (y 308, la versión permanente) hacen que repita la solicitud POST. El ejemplo 20 usará una redirección después de un POST.
2.5. Ejemplo 05: los objetos de solicitud y de respuesta
Hasta ahora, las vistas solo han usado parámetros de ruta y han devuelto una respuesta de una línea. Una vista también puede acceder a la solicitud actual y construir su respuesta pieza por pieza. La aplicación se llama [http_app] (y no [http], como en el curso de [Symfony]: [http] ya es el nombre de un paquete de la biblioteca estándar de [Python], que la nuestra sobrescribiría); sus rutas se montan bajo el prefijo [http/]:
- líneas 11–20: el parámetro [request] de la vista, que aún no habíamos usado, es el objeto [HttpRequest] de la solicitud actual. Sus atributos y métodos proporcionan toda la información que contiene: su método HTTP ([method]), su ruta ([path]), su URL completa ([build_absolute_uri()], que agrega el protocolo, la máquina y el puerto) y sus encabezados ([headers], un diccionario cuyas claves no distinguen entre mayúsculas y minúsculas: [headers.get("user-agent")] produciría el mismo resultado). El atributo [META] es un diccionario que contiene todas las variables que transmitió el servidor WSGI: los encabezados (bajo nombres como [HTTP_USER_AGENT]), los parámetros sin procesar (la parte de la URL que sigue a [?], [QUERY_STRING]), la dirección IP del cliente ([REMOTE_ADDR])... El método [get] de un diccionario devuelve el valor de una clave, o [None] si la clave no existe, mientras que [d["key"]] lanzaría una excepción [KeyError]. Los parámetros, uno por uno, se tratarán en el próximo capítulo;
- líneas 24–28: la respuesta se crea primero y luego se rellena: un objeto [HttpResponse] se maneja como un diccionario de encabezados. [response["X-Example"] = ...] agrega el encabezado [X-Example] (por convención, los encabezados específicos de una aplicación suelen comenzar con [X-]); [response.headers] también da acceso a estos encabezados;
- líneas 32–35: la respuesta construida de una sola vez: el cuerpo, el código de estado y los encabezados. Una llamada a una función puede abarcar varias líneas; dentro de paréntesis, [Python] ignora los saltos de línea;
- líneas 40–49: una respuesta enviada por fragmentos (streaming). Un objeto [StreamingHttpResponse] recibe, en lugar de una cadena, un iterador: un objeto que produce fragmentos, uno tras otro. Aquí, es el resultado de una función generadora: una función que contiene la instrucción [yield]. Llamar a [chunks()] no ejecuta la función: devuelve un generador, que ejecutará la función paso a paso, de un [yield] al siguiente, cada vez que se solicite un fragmento. La función está definida dentro de la vista: esto está permitido en [Python]. El servidor envía el código y los encabezados, y luego cada segmento tan pronto como se genera. La longitud de la respuesta no se conoce de antemano. Esto es útil para una respuesta muy larga generada poco a poco (por ejemplo, un archivo CSV grande). Pero una vez enviado el primer fragmento, el código de estado ya no puede cambiar: aquí, la función lanza una excepción después del primer fragmento. Este es el error que se debe evitar: una respuesta que ya comenzó no puede convertirse en una respuesta de error.
El middleware [ReadableJson] es el del ejemplo 03. Las respuestas:
Las comillas alrededor de la URL evitan que el terminal interprete el carácter [&]. En un navegador, el encabezado [User-Agent] es el del navegador.
Después de un segundo, [curl] se detiene: el servidor cerró la conexión. El cliente recibió un código de estado 200 y un cuerpo simplemente truncado, sin ninguna forma de saber que ocurrió un error. [Django] no pudo hacer nada: cuando se lanza la excepción, su vista ya terminó hace mucho su trabajo (devolvió la respuesta y su generador), y es el servidor, al solicitar el siguiente fragmento, quien recibe la excepción. Solo la consola del servidor lo indica, con una pila de llamadas que parte del servidor WSGI de [Python], y no de [Django]:
2.6. Ejemplo 06: servicios compartidos
Una vista no debe contener por sí misma la lógica de la aplicación; delega esta lógica en servicios: objetos que realizan tareas específicas (como leer los datos de un producto o calcular el total de un carrito de compras). Varias vistas suelen usar el mismo servicio. [Symfony], como [Spring] o [ASP.NET Core], tiene para ello un contenedor de servicios, que crea los servicios y los proporciona automáticamente a quienes los necesitan: esto es la inyección de dependencias. [Django] no tiene nada parecido. En [Python], un módulo se ejecuta una sola vez, en su primera importación, y todos los que lo importan después reciben el mismo módulo: por lo tanto, un objeto almacenado en una variable de módulo ya está compartido en toda la aplicación. Los módulos actúan como contenedores. El siguiente paso es organizar las cosas para que las vistas dependan de un contrato, no de una implementación. El ejemplo 06 organiza su código por dominio (productos, clientes), es decir, en [Django], por aplicación:
2.6.1. El producto: products/viewmodels.py
- Línea 7: una clase de datos inmutable (véase el ejemplo 03). Un objeto inmutable se puede compartir de forma segura entre varias partes del código y entre varias solicitudes;
- Líneas 9–12: los atributos, junto con sus tipos. El precio es un entero: el precio en centavos (150 para 1,50 €). Un número de punto flotante, de tipo [float], se representa en binario y no puede representar exactamente 0.1 ni 3.2 (en binario, estos números tienen una cantidad infinita de dígitos): una suma de precios en [float] puede dar 5.500000000000001. En cambio, una suma de enteros siempre es exacta. [Python] también ofrece el tipo [Decimal] (módulo [decimal]), que realiza cálculos exactos en base 10: es el que usa el ORM de [Django] para las columnas decimales de una base de datos.
2.6.2. El contrato del servicio y su implementación: products/services.py
- Líneas 3, 10: el contrato del servicio: lo que puede hacer, sin especificar cómo. [Java] o [C#] lo definirían mediante una interfaz; [Python] lo define mediante una clase abstracta que hereda de la clase [ABC] (Abstract Base Class) del módulo [abc]. No se puede crear un objeto a partir de una clase abstracta;
- Líneas 11–18: los métodos del contrato, marcados con [@abstractmethod]: una clase hija debe implementarlos todos; de lo contrario, tampoco se podrá crear un objeto de esa clase hija. Su cuerpo, [...] (el objeto [Ellipsis]), no hace nada: está ahí porque una función de [Python] debe tener un cuerpo. Las anotaciones de tipo describen el contrato: [find_all] devuelve una lista de productos ([list[Product]]); [find_by_id] recibe un entero y devuelve un producto, o [None] si no existe ([Product | None]);
- línea 22: la implementación hereda el contrato;
- líneas 23–30: el constructor. [self._products] es un atributo del objeto; el guion bajo inicial es una convención en [Python] para indicar “privado”: nada impide que otro módulo lo use, pero sabe que no debería. La línea 25 muestra un mensaje en la consola para que podamos ver cuándo se crea el servicio;
- líneas 32–34: el método devuelve una copia de la lista de productos ([list(...)] crea una lista nueva): quien llama puede modificarla sin afectar los datos del servicio (los objetos [Product] en sí no se copian, pero son inmutables);
- líneas 36–38: [(p for p in self._products if p.id == id)] es una expresión generadora, similar a la comprensión de listas del ejemplo 03: produce, uno por uno, los productos cuyo identificador es [id]. La función [next] devuelve el primer elemento generado, o el valor de su segundo parámetro ([None]) si no hay ninguno.
2.6.3. El proveedor del servicio: products/provider.py
Las vistas no crean el servicio por sí mismas: lo solicitan a una función, el proveedor, que decide qué implementación crear y se asegura de que solo se cree una:
- Línea 5: [django.conf.settings] da acceso a la configuración de la aplicación, que es la del archivo [config/settings.py] complementada con los valores predeterminados: [settings.DEBUG], [settings.LANGUAGE_CODE]... Así es como cada módulo de la aplicación lee su configuración;
- línea 6: [import_string] importa un objeto indicado por su ruta completa, como cadena: así es como [Django] encuentra el middleware de la configuración [MIDDLEWARE];
- Líneas 14–18: la función proveedora. Lee el nombre de la clase seleccionada en la configuración [PRODUCTS_SERVICE], la carga, crea un objeto de esa clase ([cls()]) y lo devuelve. El decorador [@cache], del módulo [functools] de la biblioteca estándar, almacena en caché el resultado de la primera llamada: las llamadas posteriores devuelven el mismo objeto sin ejecutar la función. Por lo tanto, el servicio se crea una sola vez, en la primera llamada, y luego lo comparten todas las vistas y todas las solicitudes mientras el servidor esté en ejecución. Esto es lo que en otros lugares se conoce como singleton. También es diferido: mientras ninguna vista lo haya solicitado, no se crea. La anotación
***[-> ProductsService]*** especifica el tipo de retorno: el contrato, no la implementación.
Solo queda elegir la implementación, en el archivo [config/settings.py]:
- línea 25: una configuración específica de la aplicación. [Django] acepta, en el archivo de configuración, cualquier variable escrita en mayúsculas y la pone a disposición mediante [django.conf.settings]. Es aquí, y solo aquí, donde se elige la implementación del servicio. Para cambiar a una implementación que lea de una base de datos, bastaría con modificar esta línea: las vistas, que solo conocen el contrato, permanecerían sin cambios. Este es el beneficio de la inyección de dependencias, logrado aquí sin un contenedor: cada parte de la aplicación depende de contratos, y un único lugar determina las implementaciones. El paquete [products] también se llama [products] en la configuración [INSTALLED_APPS] (línea 15): [Django] lo importa al iniciarse.
2.6.4. Vistas de productos y de clientes
- Línea 8: la vista importa el proveedor, no la clase [InMemoryProductsService]; no sabe que los productos están en memoria;
- Líneas 12–16: la vista delega el trabajo en el servicio. La lista de productos se convierte en una lista de diccionarios, que se convierte en un arreglo de tipo JSON (ejemplo 03);
- Líneas 20–24: un producto desconocido devuelve una respuesta 404, con un mensaje en JSON. El conversor [<int:id>] de la ruta (archivo [products/urls.py]) garantiza que [id] sea un entero.
- líneas 7, 12: esta segunda aplicación usa el mismo servicio que la de los productos, importándolo desde el paquete [products]. El proveedor le devuelve el mismo objeto;
- línea 14: [sum] suma los elementos producidos por la expresión generadora;
- líneas 15–18: [len] devuelve el número de elementos de una lista. El total se devuelve en centavos y se formatea en euros: [number_format], del módulo [django.utils.formats], escribe un número con dos decimales según las convenciones del idioma de la aplicación: un punto como separador decimal para el inglés. La división [total / 100] produce un [float], pero solo para fines de visualización: los cálculos reales se realizaron con enteros. El ejemplo 16 mostrará una forma mucho mejor de dar formato a los importes.
Por último, unas palabras sobre el ciclo de vida de este servicio compartido. Como vimos en el ejemplo 01: en [Python], la aplicación permanece en memoria de una solicitud a la siguiente. Por lo tanto, el servicio es único para toda la aplicación: la siguiente solicitud recibirá el mismo objeto que la anterior, y cualquier dato modificado por una solicitud sería visible para todas las solicitudes posteriores. Para un servicio que solo lee datos estáticos, como este, esto es ideal: se crea una sola vez. Para un servicio cuyos datos cambian (la lista de tareas del ejemplo 20), esto es cómodo (los datos sobreviven entre solicitudes, sin archivo ni base de datos), pero hay que tomar dos precauciones: dos solicitudes simultáneas pueden modificar los datos al mismo tiempo, por lo que deben protegerse con un bloqueo; y los datos desaparecen cuando el servidor se apaga (o se reinicia, después de un cambio en el código). Esto es exactamente lo opuesto a [PHP], donde cada solicitud tiene sus propios servicios, recreados cada vez.
2.6.5. Ejecución
La consola del servidor muestra el mensaje del constructor en la primera solicitud que llama al servicio, y solo en esa solicitud:
La consola del servidor:
El servicio se creó una sola vez, para las tres solicitudes y las dos aplicaciones. Si se modifica un archivo del proyecto, el servidor se reinicia y el mensaje reaparece en la siguiente solicitud.