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].