Skip to content

12. Fazit

Dieses Dokument hat die Entwicklung einer MVC-Webanwendung mit dem Framework [Django] beschrieben: eine Anwendung, deren HTML-Seiten vom Server mithilfe von Templates von [Django] erzeugt werden, ohne ein browserseitiges [JavaScript]-Framework. Es folgte Schritt für Schritt dem Kurs zu [Symfony], der seinerseits auf den Kursen zu [Laravel], [Flask], [Spring MVC], [ASP.NET Core MVC] und [NestJS] aufbaut: von Views und Routing über Templates, Formulare, Internationalisierung und Sicherheit bis zum Datenzugriff, gefolgt von einer umfassenden Fallstudie.

Dieselben 28 Beispiele und dieselbe Anwendung wurden somit mit sieben Frameworks geschrieben: in [TypeScript], in [C#], in [Java], zweimal in [PHP] und zweimal in [Python]. Die Konzepte sind dieselben; nur die Namen und Mechanismen unterscheiden sich. Die Entsprechungen zwischen [Symfony] und [Django]:

[Symfony]
[Django]
Kernel ([src/Kernel.php]), Bundles, Service-Container, Dependency Injection
Einstellungen ([config/settings.py]), Anwendungen ([INSTALLED_APPS]), importierte Module, Provider ([functools.cache])
[composer.json], Ordner [vendor], [php bin/console]
[requirements.txt], virtuelle Umgebung ([.venv]), [python manage.py]
Datei [.env], Ordner [config/packages] (YAML-Dateien), [%env(...)%]
Datei [config/settings.py] (in [Python]), Umgebungsvariablen ([os.environ]), Datei [.env] von uns gelesen
[#[Route]]-Attribute der Controller
Listen [urlpatterns] ([path], [re_path], [include]), benannte Routen, [app_name]
[render], [redirectToRoute], [generateUrl]; [path] in den Views
[render], [redirect], [reverse]; [{% url %}] in den Templates
Objekt [Request], [requirements] ([{id<\d+>}]), Argument-Resolver, [#[MapQueryString]]
Objekt [HttpRequest] ([GET], [POST], [headers], [COOKIES]), Konverter ([<int:id>]), Formulare als Validatoren
Validator-Komponente (Attribut-Constraints), Form-Komponente (Typen, [handleRequest], [isValid])
[django.forms]-Formulare (Felder, Validatoren, [clean], [error_messages], [is_valid], [cleaned_data])
Formular-Theme [Bootstrap] 5
Rendering-Engine ([FORM_RENDERER]), Feld-Template, [as_field_group]
Views [Twig], [{{ }}], [{% for %}], [{% if %}]
Templates der DTL, [{{ }}], [{% for %}] ... [{% empty %}], [{% if %}]
[{% extends %}] und Blöcke, [{% include %}], Makros
[{% extends %}] und Blöcke, [{% include %}], benannte Fragmente ([{% partialdef %}])
globale Variablen, Erweiterungen [Twig] (Funktionen, Filter)
Context-Prozessoren, Tag-Bibliotheken ([templatetags]: Filter, einfache Tags, Inclusion-Tags)
Flash-Meldungen ([addFlash], [app.flashes]), dateibasierte Sitzungen
[messages]-Anwendung (signiertes Cookie), Sitzungen (Dateien, signiertes Cookie, Datenbank ...)
Kernel-Event-Listener ([kernel.request], [kernel.controller], [kernel.response] ...)
Middleware ([__call__], [process_view], [process_exception]), Signale ([request_started], [request_finished])
Listener: [kernel.exception], [HttpException], [createNotFoundException]
[Http404], [PermissionDenied], [BadRequest], Views [handler404] ..., [process_exception]
Firewalls, Authenticators, [access_control], [#[IsGranted]], Voter
von uns geschriebene Middleware für Authentifizierung und Zugriffskontrolle, Dekoratoren; oder die Anwendung [django.contrib.auth]
Anti-CSRF-Token für die Form-Komponente, [csrf_token()], [isCsrfTokenValid]
[CsrfViewMiddleware]-Middleware, [{% csrf_token %}]-Tag, [CSRF_FAILURE_VIEW] (403-Antwort oder 419 in unserer Anwendung)
Komponente [RateLimiter]
ein im Cache implementierter Begrenzer
Ordner [translations] (YAML, ICU), Filter [trans], [TranslatorInterface]
Ordner [locale] ([gettext]: [.po], [.mo]), [gettext], [gettext_lazy], [ngettext], [{% translate %}], [{% blocktranslate %}]
[intl]-Erweiterung: [IntlDateFormatter], [NumberFormatter]
Formatierung anhand der aktiven Sprache (Filter [date], [floatformat]), [Babel]
Cache-Komponente (PSR-6 und Contracts), Lock-Komponente
Cache von [Django] ([LocMemCache], [FileBasedCache] ...), [get_or_set]
[Doctrine]: Data-Mapper-Entitäten, Entity Manager, DQL und QueryBuilder
ORM von [Django]: Active-Record-Modelle, Manager ([objects]), [QuerySet], [select_related], [F()]
[wrapInTransaction(...)], [flush]
[transaction.atomic()], [select_for_update()]
[#[ORM\Version]], verwaltet von [Doctrine] ([OptimisticLockException])
[update()], versionsabhängig ([filter(version=...)]), in der DAO-Schicht geschrieben
[php -S localhost:8000 -t public] oder [symfony server:start]
[python manage.py runserver]

Bei [Symfony] sind folgende Kernpunkte zu beachten:

  • Die Anwendung [Django] wird einmal beim Start des Servers geladen, bleibt dann im Speicher und verarbeitet alle Anfragen (Beispiel 01): Die beim Start erzeugten Objekte (Einstellungen, Routen, Middleware, Services) werden von allen Anfragen gemeinsam genutzt. Das ist einfach und schnell, erfordert aber, zwischen dem, was zur Anwendung gehört (geteilt und daher ohne anfragespezifischen Zustand), und dem, was zu einer Anfrage gehört (das Objekt [request], die lokalen Variablen der Views), zu unterscheiden und daran zu denken, dass ein Produktionsserver mehrere Prozesse ausführt, die nur das gemeinsam nutzen, was außerhalb von ihnen gespeichert ist (die Datenbank, der Datei-Cache);
  • kein Service-Container: Services sind [Python]-Module, die importiert werden, und Provider-Funktionen, die bei der ersten Anfrage ein einziges Objekt erzeugen. Die Abhängigkeiten eines Moduls sind in seinen [import]-Anweisungen sichtbar; sie für Tests zu ersetzen, geschieht über eine Einstellung (Beispiel 06);
  • Die Konfiguration ist eine [Python]-Datei [config/settings.py] : eine Folge von Zuweisungen, die berechnet, kommentiert oder aufgeteilt werden können. Der Befehl [python manage.py diffsettings] zeigt an, was von den Standardwerten abweicht;
  • Die Verarbeitung einer Anfrage durchläuft eine Liste von Middleware-Komponenten in der in der Liste [MIDDLEWARE] angegebenen Reihenfolge, für die Antwort anschließend in umgekehrter Reihenfolge: Hier werden Spracheinstellungen, Anti-CSRF-Schutz, Authentifizierung, Zugriffskontrolle und Fehlerseiten behandelt. Der Mechanismus ist einfacher als die Kernel-Ereignisse von [Symfony]: Die Reihenfolge der Liste ist die Ausführungsreihenfolge;
  • Views sind einfache Funktionen, die eine Anfrage erhalten und eine Antwort zurückgeben; Dekoratoren ([@require_POST], [@registration_pass_required]) umhüllen sie, um zusätzliche Kontrolle einzubauen. Wir haben mehrere davon geschrieben, sogar eine Klasse, deren Methoden Views sind ([PersonManagement]), ohne dass dafür etwas Besonderes von [Django] verlangt wird;
  • Formulare sind Objekte, die durch Klassen beschrieben werden: Felder, Wertkonvertierung, Validatoren, erneute Anzeige der Eingaben und Fehlermeldungen. Sie werden über austauschbare Templates gerendert (eine Rendering-Engine, ein Feld-Template): Die Felder der gesamten Anwendung werden einheitlich dargestellt, mit den Klassen von [Bootstrap] und mit Barrierefreiheitsattributen;
  • [Django] wird „einsatzbereit“ geliefert: Sitzungen, Nachrichten, Übersetzungen, Cache, Anti-CSRF-Schutz, statische Dateien, ORM – alles ist enthalten, an einer Stelle dokumentiert und erfordert keine zusätzliche Installation. Wir haben lediglich drei Bibliotheken hinzugefügt: den [MySQL]-Treiber, [PyJWT], und [bcrypt]. Die sehr umfangreiche Authentifizierungsanwendung [django.contrib.auth] haben wir weggelassen: Die Datenbank der Fallstudie hat ihre eigenen Benutzer, und wir wollten JWT-Token, genau wie in den anderen Versionen der Anwendung. Den Authentifizierungscode in etwa hundert Zeilen selbst zu schreiben, hat genau gezeigt, was er leistet;
  • das ORM von [Django] folgt dem Active-Record-Muster: Ein Modell ist eine mit einer Tabelle verknüpfte Klasse, in der jedes Objekt weiß, wie es sich selbst speichert. Es ist unkomplizierter als der Data Mapper von [Doctrine] und funktioniert auch mit einer bestehenden Datenbank sehr gut ([managed = False], bei der Tabellen- und Spaltennamen vorgegeben sind). Das träge [QuerySet], [select_related], die [F()]-Ausdrücke und die bedingten [update()]-Anweisungen ermöglichen es, effiziente und sichere Abfragen zu schreiben, und die Konsole im Entwicklungsmodus zeigt jeden an die Datenbank gesendeten SQL-Befehl an;
  • DTL-Templates verwenden eine bewusst eingeschränkte Sprache: keine Arithmetik, keine Funktionsaufrufe mit Parametern. Ein Template kann nur die Daten anzeigen, die ihm übergeben werden: Das ist zugleich eine Einschränkung und eine Garantie dafür, dass die Logik in die Views und View-Modelle wandert. Fehlende Informationen werden über Filter und Tags ergänzt, die in [Python] geschrieben sind. Templates maskieren alles, was sie anzeigen, automatisch.

Die Fallstudie zeigt, dass eine klassische HTML-Anwendung ohne unverzichtbares [JavaScript] eine einfache und robuste Lösung bleibt: Jede Seite ist eine URL, die Schaltfläche „Zurück“ des Browsers funktioniert, und der Server kontrolliert alles. Der minimale Einsatz von [JavaScript] (Bestätigungsfenster) verbessert die Benutzererfahrung, ohne für die Funktionalität nötig zu sein. [Django] kann auch interaktivere Anwendungen unterstützen, ohne die Templates zu verlassen (mit der Bibliothek [htmx] zum Beispiel funktionieren die benannten Fragmente von [Django] 6 sehr gut) oder mit einem browserseitigen [JavaScript]-Framework, dem es eine JSON-API bereitstellt ([Django REST framework], [Django Ninja]): Das wird in anderen Dokumenten behandelt.

Weitere Informationen finden Sie in der Dokumentation von [Django] (docs.djangoproject.com, ins Französische übersetzt), insbesondere auf den Seiten zu Views und URLs, Formularen, Templates, Middleware, Internationalisierung, ORM und Sicherheit, im zugehörigen Tutorial (das die Administrationsoberfläche und die Migrationen behandelt, die hier nicht behandelt werden), im [Python]-Tutorial (docs.python.org/fr) und können diese Anwendung mit ihren Schwesteranwendungen vergleichen: [Symfony], [Laravel], [Flask], [Spring MVC], [ASP.NET Core MVC] und [NestJS].