Skip to content

12. Conclusión

Este documento describió el desarrollo de una aplicación web MVC con el framework [Django]: una aplicación cuyas páginas HTML genera el servidor mediante plantillas de [Django], sin un framework [JavaScript] en el navegador. Siguió paso a paso el curso de [Symfony], que a su vez se basa en los cursos de [Laravel], [Flask], [Spring MVC], [ASP.NET Core MVC] y [NestJS]: vistas y enrutamiento hacia las plantillas, formularios, internacionalización, seguridad y acceso a datos, seguidos de un caso de estudio completo.

Los mismos 28 ejemplos y la misma aplicación se escribieron así con siete frameworks: en [TypeScript], en [C#], en [Java], dos veces en [PHP] y dos veces en [Python]. Los conceptos son los mismos; solo cambian los nombres y los mecanismos. Las correspondencias entre [Symfony] y [Django]:

[Symfony]
[Django]
núcleo ([src/Kernel.php]), bundles, contenedor de servicios, inyección de dependencias
configuración ([config/settings.py]), aplicaciones ([INSTALLED_APPS]), módulos importados, proveedores ([functools.cache])
[composer.json], carpeta [vendor], [php bin/console]
[requirements.txt], entorno virtual ([.venv]), [python manage.py]
archivo [.env], carpeta [config/packages] (archivos YAML), [%env(...)%]
archivo [config/settings.py] (en [Python]), variables de entorno ([os.environ]), archivo [.env] leído por nosotros
[#[Route]] atributos de los controladores
listas [urlpatterns] ([path], [re_path], [include]), rutas con nombre, [app_name]
[render], [redirectToRoute], [generateUrl]; [path] en las vistas
[render], [redirect], [reverse]; [{% url %}] en las plantillas
objeto [Request], [requirements] ([{id<\d+>}]), resolvedores de argumentos, [#[MapQueryString]]
objeto [HttpRequest] ([GET], [POST], [headers], [COOKIES]), conversores ([<int:id>]), formularios como validadores
componente Validator (restricciones por atributos), componente Form (tipos, [handleRequest], [isValid])
[django.forms] formularios (campos, validadores, [clean], [error_messages], [is_valid], [cleaned_data])
tema de formularios [Bootstrap] 5
motor de renderizado ([FORM_RENDERER]), plantilla de campo, [as_field_group]
vistas [Twig], [{{ }}], [{% for %}], [{% if %}]
Plantillas de DTL, [{{ }}], [{% for %}] ... [{% empty %}], [{% if %}]
[{% extends %}] y bloques, [{% include %}], macros
[{% extends %}] y bloques, [{% include %}], fragmentos con nombre ([{% partialdef %}])
variables globales, extensiones [Twig] (funciones, filtros)
procesadores de contexto, bibliotecas de etiquetas ([templatetags]: filtros, etiquetas simples, etiquetas de inclusión)
mensajes flash ([addFlash], [app.flashes]), sesiones basadas en archivos
[messages] aplicación (cookie firmada), sesiones (archivos, cookie firmada, base de datos...)
escuchadores de eventos del kernel ([kernel.request], [kernel.controller], [kernel.response]...)
middleware ([__call__], [process_view], [process_exception]), señales ([request_started], [request_finished])
auriculares: [kernel.exception], [HttpException], [createNotFoundException]
[Http404], [PermissionDenied], [BadRequest], vistas [handler404]..., [process_exception]
firewalls, autenticadores, [access_control], [#[IsGranted]], voters
middleware de autenticación y control de acceso escrito por nosotros, decoradores; o la [django.contrib.auth] (aplicación)
token anti-CSRF para el componente Form, [csrf_token()], [isCsrfTokenValid]
[CsrfViewMiddleware] middleware, [{% csrf_token %}] etiqueta, [CSRF_FAILURE_VIEW] (respuesta 403, o 419 en nuestra aplicación)
componente [RateLimiter]
un limitador escrito sobre la caché
Archivo [translations] (YAML, ICU), filtro [trans], [TranslatorInterface]
archivo [locale] ([gettext]: [.po], [.mo]), [gettext], [gettext_lazy], [ngettext], [{% translate %}], [{% blocktranslate %}]
[intl] extensión: [IntlDateFormatter], [NumberFormatter]
Formato según el idioma activo (filtro [date], [floatformat]), [Babel]
Componente Cache (PSR-6 y contratos), componente Lock
caché de [Django] ([LocMemCache], [FileBasedCache]...), [get_or_set]
[Doctrine]: entidades Data Mapper, administrador de entidades, DQL y QueryBuilder
ORM de [Django]: modelos Active Record, administradores ([objects]), [QuerySet], [select_related], [F()]
[wrapInTransaction(...)], [flush]
[transaction.atomic()], [select_for_update()]
[#[ORM\Version]], administrado por [Doctrine] ([OptimisticLockException])
[update()], dependiente de la versión ([filter(version=...)]), escrito en la capa DAO
[php -S localhost:8000 -t public], o [symfony server:start]
[python manage.py runserver]

En cuanto a [Symfony], los puntos clave que conviene recordar son:

  • la aplicación [Django] se carga una sola vez, cuando arranca el servidor, y luego permanece en memoria y procesa todas las solicitudes (ejemplo 01): los objetos creados al arrancar (configuración, rutas, middleware, servicios) son compartidos por todas las solicitudes. Es simple y rápido, pero obliga a distinguir entre lo que pertenece a la aplicación (compartido y, por lo tanto, sin estado propio de una solicitud) y lo que pertenece a una solicitud (el objeto [request], las variables locales de las vistas), y a recordar que un servidor de producción ejecuta varios procesos, que comparten solo lo que se almacena fuera de ellos (la base de datos, la caché de archivos);
  • sin contenedor de servicios: los servicios son módulos de [Python] que se importan, y funciones proveedoras que crean un objeto único en la primera solicitud. Las dependencias de un módulo son visibles en sus [import] archivos; reemplazarlas con fines de prueba se hace mediante un ajuste de configuración (ejemplo 06);
  • La configuración es un archivo [Python] o [config/settings.py] : una secuencia de asignaciones que se pueden calcular, comentar o dividir. El comando [python manage.py diffsettings] muestra lo que difiere de los valores predeterminados;
  • El procesamiento de una solicitud pasa por una lista de componentes de middleware en el orden especificado en la lista [MIDDLEWARE] y luego en orden inverso para la respuesta: aquí se gestionan los ajustes de idioma, la protección anti-CSRF, la autenticación, el control de acceso y las páginas de error. El mecanismo es más simple que los eventos del kernel de [Symfony]: el orden de la lista es el orden de ejecución;
  • Las vistas son funciones simples que reciben una solicitud y devuelven una respuesta; los decoradores ([@require_POST], [@registration_pass_required]) las envuelven para agregar control. Hemos escrito varias de ellas, e incluso una clase cuyos métodos son vistas ([PersonManagement]), sin exigir nada específico a [Django];
  • Los formularios son objetos descritos mediante clases: campos, conversión de valores, validadores, reapertura de la entrada y mensajes de error. Se renderizan mediante plantillas que pueden reemplazarse (un motor de renderizado, una plantilla de campo): los campos de toda la aplicación se muestran de la misma manera, con las clases de [Bootstrap] y atributos de accesibilidad;
  • [Django] viene “listo para usar”: sesiones, mensajes, traducciones, caché, protección anti-CSRF, archivos estáticos, ORM; todo está incluido, documentado en un solo lugar y no requiere instalación adicional. Solo agregamos tres bibliotecas: el controlador de [MySQL], [PyJWT], y [bcrypt]. Se dejó de lado la completísima aplicación de autenticación [django.contrib.auth]: la base de datos del caso de estudio tiene sus propios usuarios, y queríamos tokens JWT, como en las demás versiones de la aplicación. Escribir el código de autenticación desde cero, en unas cien líneas, mostró exactamente lo que hace;
  • el ORM de [Django] sigue el patrón Active Record: un modelo es una clase vinculada a una tabla, donde cada objeto sabe cómo guardarse a sí mismo. Más directo que el Data Mapper de [Doctrine], también funciona muy bien con una base de datos existente ([managed = False], donde los nombres de tablas y columnas están predefinidos). Sus [QuerySet] diferidos, [select_related], las expresiones [F()] y las instrucciones [update()] condicionales permiten escribir consultas eficientes y seguras, y la consola del modo de desarrollo muestra cada comando SQL enviado a la base de datos;
  • Las plantillas DTL usan un lenguaje deliberadamente limitado: sin aritmética ni llamadas a funciones con parámetros. Una plantilla solo puede mostrar los datos que se le proporcionan: esto es a la vez una restricción y una garantía que lleva la lógica hacia las vistas y los modelos de vista. Cualquier información faltante se agrega mediante filtros y etiquetas escritos en [Python]. Las plantillas escapan automáticamente todo lo que muestran.

El caso de estudio muestra que una aplicación HTML clásica, sin [JavaScript] indispensable, sigue siendo una solución simple y robusta: cada página es una URL, el botón “Atrás” del navegador funciona y el servidor controla todo. El uso mínimo de [JavaScript] (ventanas de confirmación) mejora la experiencia del usuario sin ser necesario para la funcionalidad. [Django] también puede dar soporte a aplicaciones más interactivas sin alejarse de sus plantillas (con la biblioteca [htmx], por ejemplo, los fragmentos con nombre de [Django] 6 funcionan muy bien) o con un framework [JavaScript] del lado del navegador, al que ofrece una API JSON ([Django REST framework], [Django Ninja]): esto se tratará en otros documentos.

Para mayor información, consulte la documentación de [Django] (docs.djangoproject.com, traducida al francés), en particular las páginas dedicadas a vistas y URL, formularios, plantillas, middleware, internacionalización, ORM y seguridad, su tutorial (que cubre la interfaz de administración y las migraciones, que no se tratan aquí), el tutorial de [Python] (docs.python.org/fr), y compare esta aplicación con sus aplicaciones hermanas [Symfony], [Laravel], [Flask], [Spring MVC], [ASP.NET Core MVC] y [NestJS].