Skip to content

9. Schichtenarchitektur und Datenzugriff

Die bisherigen Beispiele hielten ihre Daten im Speicher. Eine echte Anwendung speichert sie in einer Datenbank und ist in Schichten organisiert (siehe das Diagramm in der Einleitung):

  • die Web-Schicht (Views, Formulare, Templates): liest den Request, ruft die Geschäftsschicht auf, wählt das Template aus;
  • die Geschäftsschicht: die Geschäftsregeln;
  • die DAO-Schicht (Data Access Object): die Datenbankabfragen.

Jede Schicht kennt nur die darunterliegende Schicht und möglichst wenige Details über sie: Die Web-Schicht kennt die Abfragen nicht, und die Geschäftsschicht kennt das HTML nicht. Diese Trennung macht jede Schicht leichter verständlich, testbar und weiterentwickelbar. Beispiel 28 wendet das auf die Verwaltung einer Personenliste an: Es ist, in kleinerem Maßstab, die Verwaltung der Ärzte und Clients aus der Fallstudie.

In [Python] ist der Datenbankzugriff in mehreren Schichten organisiert:

  • Der Standard DB-API 2.0 (PEP 249) von [Python] definiert eine gemeinsame Schnittstelle für alle DBMS: eine Verbindung öffnen, einen Cursor erhalten, einen SQL-Befehl ausführen und Zeilen lesen. Jedes DBMS hat seinen eigenen Treiber: Für [MySQL] (und [MariaDB]) empfiehlt [Django] die Bibliothek [mysqlclient], die in C geschrieben ist und durch die Beispieldatei [requirements.txt] installiert wird;
  • Der ORM (Object-Relational Mapper) von [Django] bildet Klassen (Modelle) auf Datenbanktabellen ab und wandelt die gelesenen Zeilen in Objekte um. Er verwaltet Verbindungen und Transaktionen, erzeugt die SQL-Befehle selbst – angepasst an das jeweilige DBMS – und übersetzt die Fehler jedes Treibers in gemeinsame Exceptions (eine Verletzung einer Eindeutigkeitsbedingung wird unabhängig vom DBMS zu einer [IntegrityError]). Er folgt dem sogenannten Active-Record-Muster: Jedes Objekt weiß, wie es sich selbst speichert ([person.save()]) und löscht ([person.delete()]), und jede Klasse hat einen Manager ([Person.objects]), über den Abfragen gesendet werden. Das ist das Modell von [Eloquent], dem ORM von [Laravel]; [Doctrine], der ORM, der aus [Symfony] hervorgegangen ist, folgt dagegen dem Data-Mapper-Muster, bei dem ein separates Objekt die Entitäten liest und speichert.

Der aus [Django] stammende ORM ist Teil von [Django] und eine seiner Schlüsselkomponenten: Die Administrationsoberfläche, die Authentifizierungsanwendung, die Datenbank-Sessions und die generischen Views stützen sich alle darauf. Er entspricht [JPA] und [Hibernate] in [Java], [Entity Framework Core] in [C#] oder [SQLAlchemy] (zusammen mit [Flask] verwendet) in [Python]. Beachten Sie eine Folge der Arbeitsweise von [Django]: Standardmäßig öffnet jeder Request seine eigene Verbindung zur Datenbank (bei seiner ersten SQL-Abfrage) und schließt sie am Ende (beim Signal [request_finished], Beispiel 24). Die Einstellung [CONN_MAX_AGE] erlaubt es, Verbindungen von einem Request zum nächsten offen zu halten (persistente Verbindungen), und [Django] 5.1 hat einen echten Verbindungspool für [PostgreSQL] hinzugefügt. Das Öffnen einer Verbindung zu [MySQL] auf demselben Rechner dauert nur wenige Millisekunden.

Dieses Beispiel setzt einen laufenden Server [MySQL] 8.4 oder höher voraus (oder [MariaDB] 10.11 oder höher; die Mindestversionen gelten für [Django] 6.1): Der Anhang erklärt, wie Sie mit [Laragon] einen installieren.

9.1. Beispiel 28: Eine dreischichtige Personalverwaltung

28-layers/
├── config/
│   ├── middleware.py
│   ├── rendering.py
│   ├── settings.py
│   ├── urls.py
│   └── ...
├── database/
│   └── dbpersons.sql
├── persons/
│   ├── __init__.py
│   ├── business.py
│   ├── dao.py
│   ├── forms.py
│   ├── models.py
│   ├── urls.py
│   └── views.py
├── static/
│   ├── css/
│   │   └── styles.css
│   └── js/
│       └── app.js
├── templates/
│   ├── forms/
│   │   └── field.html
│   ├── fragments/
│   │   └── confirmation.html
│   ├── persons/
│   │   ├── form.html
│   │   └── list.html
│   └── layout.html
└── manage.py

9.1.1. Die Datenbank

Die Datenbank [dbpersons] wird durch das SQL-Skript erstellt. Mit [Laragon] können Sie es beispielsweise im Werkzeug [HeidiSQL] ausführen (Menü Datei / SQL-Datei ausführen) oder über die Befehlszeile aus dem Beispielordner:

mysql -u root < database/dbpersons.sql

Die Datei [database/dbpersons.sql]:

-- Datenbank von Beispiel 28: eine einzige Tabelle, [persons]
-- das Skript ist in UTF-8 geschrieben
SET NAMES utf8mb4;
DROP DATABASE IF EXISTS dbpersons;
CREATE DATABASE dbpersons CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
USE dbpersons;

CREATE TABLE persons (
  id INT NOT NULL AUTO_INCREMENT,
  -- die Version der Zeile, bei jeder Änderung erhöht (siehe DAO-Schicht)
  version INT NOT NULL DEFAULT 0,
  first_name VARCHAR(30) NOT NULL,
  last_name VARCHAR(30) NOT NULL,
  age INT NOT NULL,
  PRIMARY KEY (id),
  -- zwei Personen können nicht denselben Vor- und Nachnamen haben
  CONSTRAINT unq_persons_first_name_last_name UNIQUE (first_name, last_name)
) ENGINE = InnoDB;

INSERT INTO persons (first_name, last_name, age) VALUES
  ('Marie', 'Pélissier', 42),
  ('Jacques', 'Bromard', 35),
  ('Philippe', 'Jandot', 58);
  • Zeile 3: Das Skript ist in [UTF-8] geschrieben; das wird dem Server mitgeteilt, damit die Akzente in den Daten ([Pélissier]) erhalten bleiben;
  • Zeile 5: Der Zeichensatz [utf8mb4] akzeptiert alle Zeichen (Akzente, Emojis usw.). Die Kollation [utf8mb4_unicode_ci] vergleicht Zeichenfolgen, ohne zwischen Groß- und Kleinbuchstaben oder Akzenten zu unterscheiden: Für [MySQL] sind [pelissier] und [Pélissier] gleich;
  • Zeile 11: eine Versionsnummer, die bei jeder Änderung der Zeile erhöht wird (siehe „optimistisches Sperren“ weiter unten);
  • Zeile 17: eine benannte Eindeutigkeitsbedingung: Die Datenbank erlaubt keine zwei Personen mit demselben Vor- und Nachnamen.

[Django] kann die Tabellen auch selbst anhand der Modelle mithilfe von Migrationen erstellen: [Python]-Dateien, die Schritt für Schritt die Erstellung und die Änderungen jeder Tabelle beschreiben. Der Befehl [python manage.py makemigrations] schreibt diese Dateien, indem er die Modelle mit dem von den früheren Migrationen beschriebenen Zustand vergleicht; [python manage.py migrate] wendet sie auf die Datenbank an. Das ist die übliche Arbeitsweise mit [Django]. Wir pflegen ein SQL-Skript, das allen Versionen der Fallstudie gemeinsam ist und genau zeigt, was die Datenbank enthält. Umgekehrt schreibt der Befehl [python manage.py inspectdb] die Modelle für eine bestehende Datenbank: ein guter Ausgangspunkt, den man aber durchsehen sollte.

9.1.2. Die Konfiguration: config/settings.py

# config/settings.py: die Konfiguration von Beispiel 28

from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent
DEBUG = True
SECRET_KEY = "django-insecure--7xp)7k(l6nl(owyoe0r99a@hufm3z2t@a(@w+va%5uw^%fbbm"
ALLOWED_HOSTS = []
LANGUAGE_CODE = "en"
TIME_ZONE = "Europe/Paris"
ROOT_URLCONF = "config.urls"
WSGI_APPLICATION = "config.wsgi.application"

INSTALLED_APPS = [
    "django.contrib.staticfiles",
    "django.contrib.messages",
    "django.forms",
    "persons",
]

MIDDLEWARE = [
    "django.middleware.csrf.CsrfViewMiddleware",
    "django.contrib.messages.middleware.MessageMiddleware",
    # PUT und DELETE über das versteckte Feld _method (siehe Beispiel 21)
    "config.middleware.MethodOverride",
]

MESSAGE_STORAGE = "django.contrib.messages.storage.cookie.CookieStorage"

# die DATENBANK: das DBMS MySQL auf diesem Rechner (127.0.0.1), Port 3306, die
# Datenbank dbpersons, der Benutzer root ohne Passwort (Einstellungen von Laragon)
DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.mysql",
        "NAME": "dbpersons",
        "USER": "root",
        "PASSWORD": "",
        "HOST": "127.0.0.1",
        "PORT": "3306",
        "OPTIONS": {"charset": "utf8mb4"},
    },
}

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "DIRS": [BASE_DIR / "templates"],
        "APP_DIRS": True,
        "OPTIONS": {
            "context_processors": [
                "django.contrib.messages.context_processors.messages",
            ],
        },
    },
]

FORM_RENDERER = "config.rendering.BootstrapRenderer"

STATIC_URL = "static/"
STATICFILES_DIRS = [
    BASE_DIR / "static",
    BASE_DIR.parent / "common" / "static",
]

# das LOG (logging): Die an die Datenbank gesendeten SQL-Anweisungen werden in die Konsole geschrieben
# (der Logger django.db.backends gibt sie nur im Debug-Modus aus)
LOGGING = {
    "version": 1,
    "disable_existing_loggers": False,
    "handlers": {"console": {"class": "logging.StreamHandler"}},
    "loggers": {
        "django.db.backends": {"handlers": ["console"], "level": "DEBUG"},
    },
}
  • Zeilen 21–26: die Middleware aus Beispiel 21: Anti-CSRF-Schutz, Flash-Meldungen und die Simulation der Methoden PUT und DELETE (die Datei [config/middleware.py] ist die aus Beispiel 21);
  • Zeilen 32–42: Die Konfiguration [DATABASES] beschreibt die Datenbanken der Anwendung: hier nur eine, die Datenbank [default]. [ENGINE] bezeichnet die Engine von [Django] für [MySQL] (die den Treiber [mysqlclient] verwendet); es folgen der Datenbankname, der Benutzername und das Passwort (bei den Einstellungen von [Laragon] leer gelassen: Hat Ihr Server ein Passwort, tragen Sie es hier ein), der Hostname und der Port. [OPTIONS] übergibt dem Treiber den Zeichensatz für die Kommunikation mit dem Server – den Zeichensatz der Datenbank;
  • Zeilen 44–55: die Templates, mit [APP_DIRS] für die Formular-Templates (Beispiel 18) und den Kontextprozessor für Meldungen (Beispiel 20);
  • Zeilen 67–74: Die Einstellung [LOGGING] konfiguriert das Logging von [Python] (das Modul [logging]), das [Django] für seine Meldungen verwendet. Sie folgt dem Format des Moduls [logging.config]: Ziele ([handlers]: hier die Konsole über einen [StreamHandler], der in die Fehlerausgabe schreibt) und Logger ([loggers]), die über ihre Namen identifiziert werden. Der Logger [django.db.backends] erhält, nur im Debug-Modus, jeden an die Datenbank gesendeten SQL-Befehl samt seiner Dauer: Wir leiten ihn auf der Stufe [DEBUG] (der detailliertesten) an die Konsole weiter. [disable_existing_loggers: False] behält die Logger bei, die [Django] selbst konfiguriert.

Mehr ist nicht zu konfigurieren: Die Module der drei Schichten importieren einander (die Web-Schicht importiert die Geschäftsschicht, die wiederum die DAO-Schicht importiert), und die ORM-Schicht baut die Verbindung zur Datenbank selbst auf, wenn sie sie braucht.

9.1.3. Das Modell Person: persons/models.py

# persons/models.py: eine Zeile der Tabelle [persons], ein Django-MODELL

from django.db import models


# ein Django-Modell: eine Klasse, die von models.Model erbt; jedes Klassenattribut,
# das ein FELD ist (models.XxxField), entspricht einer Spalte der Tabelle
class Person(models.Model):
    # der Primärschlüssel, von der Datenbank erzeugt (AUTO_INCREMENT)
    id = models.AutoField(primary_key=True)
    # die VERSION der Zeile, bei jeder Änderung erhöht (siehe DAO-Schicht)
    version = models.IntegerField(default=0)
    # die Spalten VARCHAR(30) und INT
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)
    age = models.IntegerField()

    # Meta: die Informationen über das Modell selbst
    class Meta:
        # der Name der Tabelle (standardmäßig: persons_person, application_model)
        db_table = "persons"
        # die Tabelle existiert bereits (Skript database/dbpersons.sql): Django legt sie nicht an
        managed = False
        # die Reihenfolge der Zeilen, wenn die Abfrage keine angibt
        ordering = ["last_name", "first_name"]

    # der Text, der das Objekt darstellt (in der Konsole, den Meldungen ...)
    def __str__(self):
        return f"{self.first_name} {self.last_name}"

Die Datei heißt [models.py]: Dort sucht [Django] nach den Modellen einer in [INSTALLED_APPS] deklarierten Anwendung.

  • Zeile 8: Ein Modell ist eine Klasse, die von [models.Model] erbt;
  • Zeile 10: der Primärschlüssel, der von der Datenbank erzeugt wird ([AutoField]: das [AUTO_INCREMENT] von [MySQL]). [Django] würde ihn automatisch hinzufügen, wenn er nicht deklariert wäre (ein Feld [id] des Typs, der durch die Einstellung [DEFAULT_AUTO_FIELD] gewählt wird); wir nehmen ihn hier der Deutlichkeit halber auf. Er ist gleich [None] , solange das Objekt nicht eingefügt wurde;
  • Zeile 12: die Versionsnummer der Zeile. Der ORM von [Django] hat kein eingebautes optimistisches Sperren: Es wird von der DAO-Schicht umgesetzt (siehe unten);
  • Zeilen 14–16: die Spalten. Jedes Klassenattribut, das ein Feld des Modells ist ([models.XxxField]), entspricht der gleichnamigen Spalte; der Spaltentyp wird aus dem Feldtyp abgeleitet ([CharField]: [VARCHAR] der Länge [max_length]; [IntegerField]: [INT]). Wie in einem Formular (Beispiel 08) werden die Felder als Attribute der Klasse deklariert, es sind aber nicht dieselben Felder: Die aus [django.db.models] beschreiben Spalten, die aus [django.forms] beschreiben Formularfelder;
  • Zeilen 19–25: Die innere Klasse [Meta] liefert Informationen über das Modell selbst. [db_table]: der Tabellenname (andernfalls würde [Django] den Namen der Anwendung gefolgt vom Namen des Modells nehmen, [persons_person]). [managed = False]: Die Tabelle existiert bereits, und [Django] verwaltet sie nicht: [makemigrations] erzeugt dafür keine Migrationen zur Erstellung oder Änderung. [ordering]: die Reihenfolge der Zeilen, wenn eine Abfrage keine angibt;
  • Zeilen 28–29: Die Methode [__str__] (Beispiel 12) liefert den Text, der das Objekt darstellt: [str(p)] oder [{p}] in einem f-String liefert [Marie Pélissier].

Ein Modell ist eine gewöhnliche Klasse, der man Methoden und Properties hinzufügen kann. Der ORM befüllt dagegen die Attribute anhand der gelesenen Zeilen und erzeugt die SQL-Befehle aus den Attributen.

9.1.4. Die DAO-Schicht: persons/dao.py

# persons/dao.py: die DAO-Schicht, Abfragen, keine Geschäftsregel

from django.db.models import F

from .models import Person


# SELECT ... FROM persons ORDER BY last_name, first_name. objects: der MANAGER des Modells,
# von dem alle Abfragen ausgehen; all() liefert ein QuerySet, eine Abfrage, die erst
# ausgeführt wird, wenn ihre Ergebnisse gelesen werden (hier durch list)
def list_all() -> list[Person]:
    return list(Person.objects.all())


# SELECT ... FROM persons WHERE id = ?; None, wenn die Person nicht existiert
def read(id: int) -> Person | None:
    return Person.objects.filter(id=id).first()


# eine Person mit demselben Vor- und Nachnamen, außer [except_id]. filter: die WHERE-
# Bedingungen; exclude: die WHERE-NOT-Bedingungen
def namesake(first_name: str, last_name: str, except_id: int = 0) -> Person | None:
    return Person.objects.filter(first_name=first_name, last_name=last_name).exclude(id=except_id).first()


# INSERT INTO persons ...: create baut das Objekt und speichert es
def insert(first_name: str, last_name: str, age: int) -> Person:
    return Person.objects.create(first_name=first_name, last_name=last_name, age=age)


# UPDATE persons SET ..., version = version + 1 WHERE id = ? AND version = ?: Die
# Zeile wird nur geändert, wenn sich ihre Version seit dem Lesen nicht geändert hat (OPTIMISTISCHES
# SPERREN). F("version") bezeichnet die Spalte selbst in der SQL-Anweisung. update
# liefert die Anzahl der geänderten Zeilen: 0, wenn sich die Version geändert hat
def update(id: int, version: int, first_name: str, last_name: str, age: int) -> bool:
    rows = Person.objects.filter(id=id, version=version).update(
        first_name=first_name, last_name=last_name, age=age, version=F("version") + 1)
    return rows == 1


# DELETE FROM persons WHERE id = ?
def delete(person: Person) -> None:
    person.delete()

Die DAO-Schicht enthält nur Abfragen, keine Geschäftsregeln. Jede Funktion beginnt mit [Person.objects], dem Manager des Modells, von dem alle Abfragen ausgehen.

  • Zeilen 11–12: [all()] liefert ein [QuerySet]: ein Objekt, das eine Abfrage beschreibt, ohne sie auszuführen. Die Abfrage wird erst dann an die Datenbank gesendet, wenn ihre Ergebnisse benötigt werden (hier, wenn [list] sie durchläuft): Man sagt, ein [QuerySet] sei lazy. Es lässt sich daher vor der Ausführung weiter verfeinern ([filter], [exclude], [order_by] ...), wobei jede Methode ein neues [QuerySet] liefert. Die Reihenfolge ist die von [Meta.ordering];
  • Zeilen 16–17: [filter(id=id)] fügt die Bedingung [WHERE id = ...] hinzu; [first()] führt die Abfrage aus, begrenzt auf eine Zeile ([LIMIT 1]), und liefert das erste Objekt oder [None]. ([Person.objects.get(id=id)] würde das Objekt liefern, aber die Exception [Person.DoesNotExist] auslösen, wenn es nicht existierte, und die Abkürzung [get_object_or_404], Beispiel 03, würde einen 404-Fehler liefern);
  • Zeilen 22–23: Mehrere Bedingungen in [filter] werden durch [AND] verknüpft; [exclude] fügt eine Bedingung [NOT] hinzu. Die benannten Parameter beziehen sich auf die Felder ([first_name=...]); Suffixe legen den Vergleich fest: [age__gte=18] ([>=]), [last_name__startswith="P"], [last_name__iexact=...] (ohne Beachtung der Groß- und Kleinschreibung) ... Die Werte werden getrennt an die Datenbank übermittelt und niemals in den Text des SQL-Befehls kopiert, was eine SQL-Injection unmöglich macht;
  • Zeilen 27–28: [create] erstellt das Objekt und speichert es ([INSERT]); nach dem Einfügen legt der ORM die von der Datenbank erzeugte ID im Objekt ab. Das ist gleichbedeutend mit [p = Person(first_name=..., ...)] gefolgt von [p.save()];
  • Zeilen 35–38: die Aktualisierung, mit ihrem optimistischen Sperren. [update] aktualisiert alle vom [QuerySet] bezeichneten Zeilen in einer einzigen Operation mit einem einzigen [UPDATE]-Befehl und liefert die Anzahl der aktualisierten Zeilen. Der Filter hat zwei Bedingungen: die ID und die gelesene Version. Hat in der Zwischenzeit ein anderer Request die Zeile geändert – sodass sich ihre Version geändert hat –, ändert [UPDATE] keine Zeile, und die Funktion liefert [False]. Das ist das Prinzip des optimistischen Sperrens: Nichts wird gesperrt, aber gleichzeitige Änderungen werden erkannt. Der Ausdruck [F("version") + 1] bezieht sich auf die Spalte selbst, im SQL-Befehl ([version = version + 1]): Die Berechnung wird von der Datenbank durchgeführt, nicht in [Python] auf Grundlage eines zuvor gelesenen Werts;
  • Zeilen 42–43: das Löschen: [delete()] sendet den Befehl [DELETE] für die Zeile des Objekts.

Anders als [Doctrine] besitzt der ORM von [Django] keinen Manager, der jedes gelesene Objekt mit seinem ursprünglichen Zustand vergleicht, um nur die geänderten Spalten zu speichern: [save()] schreibt alle Spalten des Objekts neu (oder die seines Parameters [update_fields]). Das ist einfacher und besser vorhersagbar; [update] erlaubt es, genau den gewünschten SQL-Befehl zu schreiben.

9.1.5. Die Geschäftsschicht: persons/business.py

# persons/business.py: die GESCHÄFTSSCHICHT, die Geschäftsregeln und nur sie.
# Jede schreibende Operation ist eine TRANSAKTION: bestätigt (COMMIT), wenn die Funktion
# normal endet, verworfen (ROLLBACK), wenn eine Exception sie verlässt

from dataclasses import dataclass

from django.db import IntegrityError, transaction

from . import dao
from .models import Person

NAMESAKE = "A person already has these first and last names."
MODIFIED = "This record has been modified meanwhile: reload it."
UNKNOWN = "This person does not exist (anymore)."


# eine Geschäftsregel lehnt die Operation ab; die Meldung ist für den Benutzer bestimmt
class BusinessError(Exception):
    pass


# die Daten einer Person, wie die Web-Schicht sie übergibt
@dataclass(frozen=True)
class PersonData:
    first_name: str
    last_name: str
    age: int


def list_all() -> list[Person]:
    return dao.list_all()


def read(id: int) -> Person:
    person = dao.read(id)
    if person is None:
        raise BusinessError(UNKNOWN)
    return person


# with transaction.atomic(): Der Block wird in einer Transaktion ausgeführt. Die Eindeutigkeits-
# einschränkung der Datenbank (zwei gleichzeitige Hinzufügungen) löst IntegrityError aus, was zu einem
# Geschäftsfehler wird
def add(data: PersonData) -> Person:
    try:
        with transaction.atomic():
            # Regel 1: keine zwei Personen mit demselben Vor- und Nachnamen
            if dao.namesake(data.first_name, data.last_name):
                raise BusinessError(NAMESAKE)
            return dao.insert(data.first_name, data.last_name, data.age)
    except IntegrityError as e:
        raise BusinessError(NAMESAKE) from e


def update(id: int, version: int, data: PersonData) -> Person:
    try:
        with transaction.atomic():
            person = read(id)
            # Regel 2: Ein zwischenzeitlich von jemand anderem geänderter Datensatz wird nicht geändert
            if person.version != version:
                raise BusinessError(MODIFIED)
            if dao.namesake(data.first_name, data.last_name, id):
                raise BusinessError(NAMESAKE)
            # das UPDATE ... WHERE version = ... ändert nichts, wenn eine andere Anfrage die Zeile
            # seit unserem Lesen geändert hat
            if not dao.update(id, version, data.first_name, data.last_name, data.age):
                raise BusinessError(MODIFIED)
            return read(id)
    except IntegrityError as e:
        raise BusinessError(NAMESAKE) from e


def delete(id: int) -> Person:
    with transaction.atomic():
        person = read(id)
        dao.delete(person)
        return person
  • Zeilen 12–14: Meldungen der Geschäftsregeln;
  • Zeilen 18–19: eine Exception-Klasse, die für die Geschäftsschicht spezifisch ist: Eine Geschäftsregel lehnt die Operation ab, und die Meldung der Exception ist für den Benutzer bestimmt. Sie erbt von [Exception] und fügt nichts hinzu; nur ihr Name zählt;
  • Zeilen 23–27: die Daten einer Person, wie sie von der Web-Schicht an die Geschäftsschicht übergeben werden: ein einfaches Objekt, unabhängig von [Django];
  • Zeilen 34–38: Eine nicht existierende Person ist ein Geschäftsfehler;
  • Zeilen 44–52: Regel Nr. 1: Keine zwei Personen dürfen denselben Vor- und Nachnamen haben. Die Regel wird vor dem Schreiben in die Datenbank geprüft, und bei Verstoß wird eine [BusinessError]-Exception ausgelöst. Diese Prüfung genügt aber nicht: Zwei gleichzeitige Requests könnten beide feststellen, dass es keinen Namensvetter gibt, und dann beide das Einfügen durchführen. Die Eindeutigkeitsbedingung der Datenbank weist dann das zweite [INSERT] ab, und der ORM löst eine [IntegrityError] aus, die in denselben [BusinessError] umgewandelt wird. Die Datenbank ist die letzte Verteidigungslinie. [raise ... from e] verknüpft die ursprüngliche Exception mit der neuen: Das Log zeigt beide;
  • Zeilen 55–70: Regel Nr. 2: Einen Datensatz nicht ändern, der in der Zwischenzeit von jemand anderem geändert wurde. Das Änderungsformular trägt die Version des gelesenen Datensatzes (in einem versteckten Feld); weicht sie von der aktuellen Version ab, hat sich der Datensatz seit seiner Anzeige geändert. Es bleibt der Fall, dass die gleichzeitige Änderung zwischen dem Lesen in Zeile 58 und dem Speichern in Zeile 66 erfolgt: Sie wird durch das optimistische Sperren in der DAO-Schicht erkannt. Die Funktion liest den Datensatz der Person dann erneut, um die neue Version zurückzugeben;
  • Zeilen 73–77: Das Löschen setzt die Person für die Bestätigungsmeldung auf „gelöscht“.

Jede Operation, die Daten schreibt, wird innerhalb einer Transaktion ausgeführt: [transaction.atomic()], verwendet mit [with] (einem Kontextmanager, Beispiel 20), öffnet zu Beginn des Blocks eine Transaktion ([BEGIN]); endet der Block normal (auch mit einem [return]), wird die Transaktion bestätigt ([COMMIT]); tritt innerhalb des Blocks eine Exception auf, wird die Transaktion zurückgerollt ([ROLLBACK]): Keine der im Block vorgenommenen Änderungen bleibt erhalten, und die Exception setzt ihren Weg fort. [transaction.atomic] kann auch als Dekorator für eine ganze Funktion verwendet werden ([@transaction.atomic]). Die Geschäftsschicht legt somit den Umfang der Transaktionen fest: Eine Geschäftsoperation entspricht einer Transaktion. Außerhalb eines [atomic]-Blocks arbeitet der ORM im „Autocommit“-Modus: Jeder SQL-Befehl wird sofort bestätigt. Eine [IntegrityError] wird außerhalb des [with]-Blocks abgefangen: Innerhalb des Blocks wäre die Transaktion nach dem Fehler nicht mehr verwendbar. Andere Exceptions (etwa ein Datenbankausfall oder ein Programmierfehler) sind keine Geschäftsfehler: Sie werden weitergereicht.

9.1.6. Die Web-Schicht

Die Dateneingabe wird durch ein Formular beschrieben (Beispiel 19):

# persons/forms.py: das Formular einer Person (siehe Beispiele 18 und 19)

from django import forms

from .business import PersonData


class PersonForm(forms.Form):
    first_name = forms.CharField(label="First name", max_length=30, error_messages={
        "required": "The first name is required.", "max_length": "30 characters at most."})
    last_name = forms.CharField(label="Last name", max_length=30, error_messages={
        "required": "The last name is required.", "max_length": "30 characters at most."})
    age = forms.IntegerField(label="Age", min_value=0, max_value=150, error_messages={
        "required": "The age is required.",
        "invalid": "The age must be an integer.",
        "min_value": "The age must be between 0 and 150.",
        "max_value": "The age must be between 0 and 150."})

    # edit=True: das Bearbeitungsformular, das ein Feld mehr hat
    def __init__(self, *args, edit=False, **kwargs):
        super().__init__(*args, **kwargs)
        for field in self.fields.values():
            field.widget.attrs["class"] = "form-control"
        # die Version: ein verstecktes Feld, nur im Bearbeitungsformular
        if edit:
            self.fields["version"] = forms.IntegerField(widget=forms.HiddenInput)

    # die validierten Daten für die Geschäftsschicht; CharField hat bereits die
    # Leerzeichen am Anfang und Ende der Eingabe entfernt (Option strip, standardmäßig true)
    def data_for_business(self) -> PersonData:
        d = self.cleaned_data
        return PersonData(d["first_name"], d["last_name"], d["age"])
  • Zeilen 9–17: die Felder und ihre Einschränkungen, mit Meldungen auf Englisch;
  • Zeilen 20–26: ein zusätzlicher Parameter für den Konstruktor, [edit], der namentlich angegeben wird ([PersonForm(request.POST, edit=True)]): Ein Parameter, der nach [*args] geschrieben wird, kann nur namentlich übergeben werden. Das Änderungsformular erhält ein zusätzliches Feld, „version“, in einem versteckten Feld: [self.fields] ist ein Dictionary, dem ein Feld hinzugefügt werden kann;
  • Zeilen 30–32: die validierten Daten, in dem Format, das die Geschäftsschicht erwartet.

[Django] kann ein Formular auch aus einem Modell erzeugen (die Klasse [forms.ModelForm]): Seine Felder und deren Einschränkungen werden aus den Spalten abgeleitet, und seine Methode [save()] speichert das Objekt. Das ist sehr verbreitet. Das Formular würde das Modell jedoch ändern, bevor die Geschäftsschicht ihre Regeln geprüft hat. Ein separates Formular hält die Schichten getrennt: Die Web-Schicht übergibt der Geschäftsschicht nur validierte Daten.

# persons/views.py: die WEB-Schicht; sie kennt nur die Geschäftsschicht

from django.contrib import messages
from django.shortcuts import redirect, render
from django.urls import reverse
from django.views.decorators.http import require_GET, require_http_methods

from . import business
from .business import BusinessError
from .forms import PersonForm


@require_GET
def home(request):
    return redirect("persons_list")


@require_GET
def list_persons(request):
    return render(request, "persons/list.html", {"persons": business.list_all()})


# GET: das leere Formular; POST: das gesendete Formular
@require_http_methods(["GET", "POST"])
def add(request):
    title = "Add a person"
    action = reverse("persons_add")
    if request.method == "GET":
        return form_page(request, title, PersonForm(), action)
    form = PersonForm(request.POST)
    if not form.is_valid():
        return form_page(request, title, form, action, status=422)
    try:
        p = business.add(form.data_for_business())
    except BusinessError as e:
        # eine Geschäftsregel lehnt ab: Das Formular wird erneut angezeigt, mit der Eingabe und
        # der Meldung am Seitenende
        return form_page(request, title, form, action, error=str(e))
    messages.success(request, f"{p} has been added.")
    return redirect("persons_list")


# GET: das Bearbeitungsformular, vorausgefüllt
@require_GET
def edit(request, id):
    try:
        p = business.read(id)
    except BusinessError as e:
        messages.error(request, str(e))
        return redirect("persons_list")
    form = PersonForm(edit=True, initial={
        "first_name": p.first_name, "last_name": p.last_name, "age": p.age, "version": p.version})
    return form_page(request, "Edit a person", form,
                     reverse("persons_person", args=[id]), method="PUT")


# PUT: das gesendete Bearbeitungsformular; DELETE: das Löschen
@require_http_methods(["PUT", "DELETE"])
def person(request, id):
    if request.method == "DELETE":
        try:
            p = business.delete(id)
            messages.success(request, f"{p} has been deleted.")
        except BusinessError as e:
            # kein Formular zum erneuten Anzeigen: Der Fehler wird auch als Flash-Meldung übermittelt
            messages.error(request, str(e))
        return redirect("persons_list")
    title = "Edit a person"
    action = reverse("persons_person", args=[id])
    form = PersonForm(request.POST, edit=True)
    if not form.is_valid():
        return form_page(request, title, form, action, method="PUT", status=422)
    try:
        p = business.update(id, form.cleaned_data["version"], form.data_for_business())
    except BusinessError as e:
        return form_page(request, title, form, action, method="PUT", error=str(e))
    messages.success(request, f"{p} has been edited.")
    return redirect("persons_list")


# die Seite des Formulars; ein Geschäftsfehler: der Code 422, wie bei einem ungültigen Formular
# (siehe Beispiel 19)
def form_page(request, title, form, action, method=None, error=None, status=200):
    return render(request, "persons/form.html", {
        "title": title, "form": form, "action": action, "method": method,
        "error": error}, status=422 if error else status)
  • Zeile 8: die Geschäftsschicht, die einzige Schicht, die die Web-Schicht kennt;
  • Zeilen 25–40: das Hinzufügen in drei Schritten: Validierung des Formulars (Eingabefehler, Beispiel 19); Aufruf der Geschäftsschicht (Geschäftsregeln); dann das PRG-Muster mit einer Flash-Erfolgsmeldung (Beispiel 20). Ein [BusinessError] zeigt das Formular erneut an, zusammen mit den eingegebenen Daten und der Meldung der Exception ([str(e)]), die das Template am Ende der Seite anzeigt. Eingabefehler und Fehler der Geschäftslogik werden so auf dieselbe Weise behandelt;
  • Zeilen 44–54: das Änderungsformular, vorausgefüllt mit der gelesenen Person (Parameter [initial], Beispiel 18). Existiert die Person nicht, leitet die View mit einer Flash-Fehlermeldung ([messages.error]) zur Liste um. Das Formular wird mit der Methode PUT (dem versteckten Feld [_method], Beispiel 21) an die URL [/persons/<id>] gesendet ([reverse], mit den Routenparametern in [args]);
  • Zeilen 58–78: die View von [/persons/<id>] für die Methoden PUT (Aktualisieren, nach demselben Muster wie das Hinzufügen) und DELETE (Löschen, geschützt durch das Anti-CSRF-Token, Beispiel 21). Beim Löschen gibt es kein Formular, das erneut anzuzeigen wäre: Jeder Fehler wird ebenfalls in einer Flash-Meldung übermittelt;
  • Zeilen 83–86: die Formularseite. Ein Geschäftsfehler wird wie bei einem ungültigen Formular mit dem Code 422 zurückgegeben.

Die Web-Schicht enthält weder SQL noch Geschäftsregeln: Sie übersetzt den Request in einen Aufruf der Geschäftsschicht und das Ergebnis in eine Seite. Die Routen ([persons/urls.py]): [/persons] (die Liste), [/persons/add], [/persons/<id>/edit] und [/persons/<id>] (PUT und DELETE).

Die Templates:

<!doctype html>
{% load static %}
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Persons</title>
  <link rel="stylesheet" href="{% static 'bootstrap/css/bootstrap.min.css' %}">
  <link rel="stylesheet" href="{% static 'css/styles.css' %}">
</head>
<body>
  <div class="container py-3" style="max-width: 44rem">
    {# die Flash-Nachrichten; tags: ihre Stufe (success, error) #}
    {% for message in messages %}
      <div class="alert {% if message.tags == 'error' %}alert-danger{% else %}alert-success{% endif %}" role="status">{{ message }}</div>
    {% endfor %}
    <main>
      {% block content %}{% endblock %}
    </main>
    {% block page_bottom %}{% endblock %}
  </div>
  {% include "fragments/confirmation.html" %}
  <script src="{% static 'js/app.js' %}"></script>
</body>
</html>
  • Zeilen 14–16: die Flash-Meldungen am Seitenanfang (Beispiel 20). Ihr Label ([message.tags]: [success], [error]) bestimmt ihre Farbe;
  • Zeile 20: der Footer-Block, in dem die Seiten ihre Fehler anzeigen (Beispiel 19);
  • Zeilen 22–23: das Bestätigungsfenster und sein Skript (Beispiel 21).
{% extends "layout.html" %}

{% block content %}
  <div class="d-flex justify-content-between align-items-center mb-2">
    <h1 class="h3 mb-0">Persons</h1>
    <a class="btn btn-primary btn-sm" href="{% url 'persons_add' %}">Add</a>
  </div>
  <table class="table align-middle">
    <thead><tr><th>First name</th><th>Last name</th><th>Age</th><th></th></tr></thead>
    <tbody>
      {% for p in persons %}
        <tr>
          <td>{{ p.first_name }}</td>
          <td>{{ p.last_name }}</td>
          <td>{{ p.age }}</td>
          <td class="text-end">
            <a class="btn btn-sm btn-outline-primary" href="{% url 'persons_edit' p.id %}">Edit</a>
            <form method="post" class="d-inline" action="{% url 'persons_person' p.id %}"
                  data-confirmation="Delete {{ p.first_name }} {{ p.last_name }}?">
              {% csrf_token %}
              <input type="hidden" name="_method" value="DELETE">
              <button class="btn btn-sm btn-outline-danger" type="submit">Delete</button>
            </form>
          </td>
        </tr>
      {% empty %}
        <tr><td colspan="4">No persons.</td></tr>
      {% endfor %}
    </tbody>
  </table>
{% endblock %}

Die Liste enthält die Links und Schaltflächen aus Beispiel 21 samt ihrem Bestätigungsfenster (die Dateien [fragments/confirmation.html] und [static/js/app.js] sind die aus Beispiel 21). Die Attribute [p.first_name], [p.last_name] ... sind die der vom ORM gelesenen [Person]-Objekte. Der Block [{% empty %}] (Beispiel 14) behandelt die leere Liste.

{% extends "layout.html" %}

{% block content %}
  <h1 class="h3">{{ title }}</h1>
  <form method="post" action="{{ action }}" novalidate style="max-width: 24rem">
    {% csrf_token %}
    {# die Änderung wird mit der Methode PUT gesendet (siehe Beispiel 21) #}
    {% if method %}<input type="hidden" name="_method" value="{{ method }}">{% endif %}
    {{ form.first_name.as_field_group }}
    {{ form.last_name.as_field_group }}
    {{ form.age.as_field_group }}
    {# die Version: ein verstecktes Feld, nur im Bearbeitungsformular #}
    {% if form.version %}{{ form.version }}{% endif %}
    <div class="d-flex gap-2">
      <button class="btn btn-primary" type="submit">Save</button>
      <a class="btn btn-link" href="{% url 'persons_list' %}">Cancel</a>
    </div>
  </form>
{% endblock %}

{% block page_bottom %}
  {% if error %}
    <div class="error-area" role="alert">{{ error }}</div>
  {% endif %}
{% endblock %}

Ein Template, das sowohl für das Hinzufügen als auch für das Ändern gilt:

  • Zeile 8: das versteckte Feld [_method], nur für die Änderung;
  • Zeile 13: das versteckte Versionsfeld, falls es im Formular vorhanden ist;
  • Zeilen 21–25: der Geschäftsfehler am Ende der Seite.

9.1.7. Ausführung

Die Liste der Personen:

Image

Ein falsch ausgefülltes Formular zum Hinzufügen: Eingabefehler werden von der Web-Schicht erkannt.

Image

Ein Namensvetter: Die Eingabe ist korrekt, aber die Geschäftsschicht lehnt das Hinzufügen ab. Da der Vergleich von der Datenbank durchgeführt wird, ignoriert er Groß- und Kleinschreibung sowie Akzente: [marie pelissier] ist ein Namensvetter von [Marie Pélissier].

Image

Ein erfolgreiches Hinzufügen:

Image

Um Regel Nr. 2 zu testen, öffnen wir denselben Datensatz in zwei Tabs. Im ersten Tab ändern wir das Alter und speichern. Im zweiten Tab, der noch die alte Version anzeigt, ändern wir den Datensatz ebenfalls:

Image

Das Löschen mit seiner Bestätigung:

Image

Image

9.1.8. Die SQL-Befehle

Verfolgen wir die SQL-Befehle einer Änderung in der Konsole (der Server wurde neu gestartet und die Datenbank neu erstellt). Die Anzeige des Änderungsformulars für Person Nr. 1:

(0.000)
                SELECT VERSION(),
                       @@sql_mode,
                       @@default_storage_engine,
                       @@sql_auto_is_null,
                       @@lower_case_table_names,
                       CONVERT_TZ('2001-01-01 01:00:00', 'UTC', 'UTC') IS NOT NULL
            ; args=None; alias=default
(0.000) SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED; args=None; alias=default
(0.000) SELECT `persons`.`id`, `persons`.`version`, `persons`.`first_name`, `persons`.`last_name`, `persons`.`age` FROM `persons` WHERE `persons`.`id` = 1 ORDER BY `persons`.`last_name` ASC, `persons`.`first_name` ASC LIMIT 1; args=(1,); alias=default
[27/Sep/2026 19:45:19] "GET /persons/1/edit HTTP/1.1" 200 2460

Jede Zeile zeigt die Dauer des Befehls (in Sekunden), den SQL-Befehl, seine Parameter ([args]) und den Namen der Datenbank ([alias]). Die ersten beiden Befehle dienen dem Verbindungsaufbau: [Django] fragt den Server ab (seine Version, seine Einstellungen) und legt dann die Isolationsstufe der Transaktionen fest ([READ COMMITTED]: Eine Transaktion sieht die von anderen bestätigten Änderungen). Danach folgt das Lesen über den Primärschlüssel, mit seinem [ORDER BY] (entsprechend [Meta.ordering]) und seinem [LIMIT 1] (entsprechend [first()]). Im Log werden die Parameter der Reihe nach eingesetzt, damit sie lesbar sind; ursprünglich werden sie getrennt gesendet ([args]). Es gibt keine Transaktion: Ein einzelnes Lesen braucht keine. Der Datensatz wird mit einem neuen Alter gespeichert:

1
2
3
4
5
6
7
(0.000) BEGIN; args=None; alias=default
(0.001) SELECT `persons`.`id`, `persons`.`version`, `persons`.`first_name`, `persons`.`last_name`, `persons`.`age` FROM `persons` WHERE `persons`.`id` = 1 ORDER BY `persons`.`last_name` ASC, `persons`.`first_name` ASC LIMIT 1; args=(1,); alias=default
(0.001) SELECT `persons`.`id`, `persons`.`version`, `persons`.`first_name`, `persons`.`last_name`, `persons`.`age` FROM `persons` WHERE (`persons`.`first_name` = 'Marie' AND `persons`.`last_name` = 'Pélissier' AND NOT (`persons`.`id` = 1)) ORDER BY `persons`.`last_name` ASC, `persons`.`first_name` ASC LIMIT 1; args=('Marie', 'Pélissier', 1); alias=default
(0.000) UPDATE `persons` SET `first_name` = 'Marie', `last_name` = 'Pélissier', `age` = 43, `version` = (`persons`.`version` + 1) WHERE (`persons`.`id` = 1 AND `persons`.`version` = 0); args=('Marie', 'Pélissier', 43, 1, 1, 0); alias=default
(0.000) SELECT `persons`.`id`, `persons`.`version`, `persons`.`first_name`, `persons`.`last_name`, `persons`.`age` FROM `persons` WHERE `persons`.`id` = 1 ORDER BY `persons`.`last_name` ASC, `persons`.`first_name` ASC LIMIT 1; args=(1,); alias=default
(0.001) COMMIT; args=None; alias=default
[27/Sep/2026 19:45:19] "POST /persons/1 HTTP/1.1" 302 0

(Die Verbindung wurde wie beim vorherigen Request geöffnet.) Innerhalb einer einzigen Transaktion ([BEGIN] ... [COMMIT]) sehen wir: das Lesen des Datensatzes, die Suche nach einem Namensvetter, das [UPDATE] und dann das erneute Lesen des Datensatzes. Das [UPDATE] erhöht die Version ([version + 1]) und setzt die Bedingung des optimistischen Sperrens ([AND version = 0]). Der Entwicklungsserver protokolliert den Request als POST: So ist er eingetroffen, bevor die Middleware ihn in ein PUT umgewandelt hat. Senden wir nun dasselbe Formular ein zweites Mal ab, weiterhin mit der alten Version:

1
2
3
4
5
(0.000) BEGIN; args=None; alias=default
(0.000) SELECT `persons`.`id`, `persons`.`version`, `persons`.`first_name`, `persons`.`last_name`, `persons`.`age` FROM `persons` WHERE `persons`.`id` = 1 ORDER BY `persons`.`last_name` ASC, `persons`.`first_name` ASC LIMIT 1; args=(1,); alias=default
(0.000) ROLLBACK; args=None; alias=default
Unprocessable Content: /persons/1
[27/Sep/2026 19:45:19] "POST /persons/1 HTTP/1.1" 422 2562

Die gelesene Version ist nicht die des Formulars: Die Geschäftsschicht hat einen [BusinessError] ausgelöst, der die Transaktion zurückgerollt hat ([ROLLBACK]), und die Seite zeigt „This record has been modified meanwhile: reload it.“ an. Ebenso endet das Hinzufügen eines Namensvetters nach der Suche nach dem Namensvetter, ohne ein [INSERT].