Skip to content

9. Schichtenarchitektur und Datenzugriff

Die bisherigen Beispiele speicherten ihre Daten im Arbeitsspeicher oder im Cache. Eine echte Anwendung speichert sie in einer Datenbank und ist in Schichten (siehe das Diagramm in der Einleitung) gegliedert:

  • die Web-Schicht (Controller, Formulare, Views): liest die Anfrage, ruft die Geschäftsschicht auf und wählt die View aus;
  • die Geschäftsschicht: Geschäftsregeln;
  • die DAO-Schicht (Data Access Object): Datenbankabfragen.

Jede Schicht kennt nur die darunterliegende Schicht und von dieser so wenige Details wie möglich: Die Web-Schicht kennt kein SQL, und die Geschäftsschicht kennt kein HTML. Diese Trennung macht jede Schicht leichter verständlich, testbar und weiterentwickelbar. Beispiel 28 wendet dies auf die Verwaltung einer Personenliste an: Es ist, in kleinerem Maßstab, die Verwaltung der Ärzte und Klienten aus der Fallstudie.

In [PHP] ist der Datenbankzugriff in mehrere Schichten gegliedert:

  • Die Erweiterung PDO (PHP Data Objects) von [PHP] definiert eine gemeinsame Schnittstelle für alle DBMS-Erweiterungen: eine Verbindung öffnen, einen SQL-Befehl ausführen und Zeilen lesen. Jedes DBMS hat seinen eigenen Treiber: [pdo_mysql] für [MySQL] (und [MariaDB]), der mit [PHP] ausgeliefert wird;
  • Das Framework DBAL (Database Abstraction Layer) ergänzt die Verwaltung von Verbindungen und Transaktionen, einen Query Builder und die Typkonvertierung und übersetzt die Fehler der einzelnen DBMS in gemeinsame Exceptions (eine Verletzung einer Eindeutigkeitsbedingung wird unabhängig vom DBMS zu einer [UniqueConstraintViolationException]);
  • Doctrine ORM (Object-Relational Mapper) bildet Klassen (Entitäten) auf Datenbanktabellen ab und wandelt die abgerufenen Zeilen in Objekte um. Es folgt dem sogenannten Data-Mapper-Modell: Entitäten sind gewöhnliche Objekte, die nichts von der Datenbank wissen; ein separates Objekt, der Entity Manager, liest und speichert sie. Dies ist der Unterschied zu [Eloquent] , dem ORM (das aus [Laravel] stammt), welches dem Active-Record-Modell folgt (jedes Objekt weiß, wie es sich selbst liest und speichert, [$person->save()]).

[Doctrine] gehört nicht zu [Symfony]: Es ist ein eigenständiges Projekt, aber sein ORM ist das von [Symfony] empfohlene, und DoctrineBundle integriert es in die Anwendung. Es entspricht [JDBC], [JPA] und [Hibernate] in [Java] (woran sich [Doctrine] orientiert hat), [Entity Framework Core] in [C#] oder [SQLAlchemy] in [Python]. Beachten Sie eine Konsequenz der Funktionsweise von [PHP]: Da nichts über die Anfrage hinaus bestehen bleibt, öffnet jede Anfrage ihre eigene Verbindung zur Datenbank (bei ihrer ersten SQL-Abfrage) und schließt sie am Ende wieder. Es gibt keinen Verbindungspool wie in [Java] oder [Python]; das Öffnen einer Verbindung zu [MySQL] auf demselben Rechner dauert nur den Bruchteil einer Millisekunde.

Das Beispiel benötigt einen laufenden [MySQL] -Server (oder [MariaDB]): Der Anhang erklärt, wie man mit [Laragon] einen installiert.

9.1. Beispiel 28: Eine dreischichtige Personalverwaltung

28-layers/
├── .env
├── config/
│   ├── bundles.php
│   └── packages/
│       ├── doctrine.yaml
│       ├── framework.yaml
│       └── twig.yaml
├── database/
│   └── dbpersons.sql
├── public/
│   ├── css/
│   │   └── styles.css
│   └── js/
│       └── app.js
├── src/
│   ├── Controller/
│   │   └── PersonsController.php
│   ├── Dao/
│   │   └── PersonsDao.php
│   ├── Entity/
│   │   └── Person.php
│   ├── Form/
│   │   ├── PersonInput.php
│   │   └── PersonType.php
│   └── Business/
│       ├── PersonData.php
│       ├── BusinessException.php
│       └── PersonsBusiness.php
├── templates/
│   ├── fragments/
│   │   └── confirmation.html.twig
│   ├── layout.html.twig
│   └── persons/
│       ├── form.html.twig
│       └── list.html.twig
└── ...

9.1.1. Die Datenbank

Die Datenbank [dbpersons] wird durch das SQL-Skript erstellt. Mit [Laragon] können Sie es zum Beispiel im Tool [HeidiSQL] ausführen (Menü Datei / SQL-Datei ausführen) oder über die Befehlszeile im 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 dürfen 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; dies 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 Zeichenketten ohne Rücksicht auf Groß- und Kleinschreibung und Akzente: Für [MySQL] sind [pelissier] und [Pélissier] gleich;
  • Zeile 11: eine Versionsnummer, die bei jeder Änderung der Zeile erhöht wird (siehe „optimistische Sperre“ weiter unten);
  • Zeile 17: eine benannte Eindeutigkeitsbedingung: Die Datenbank lässt nicht zwei Personen mit demselben Vor- und Nachnamen zu.

[Doctrine] kann die Tabellen auch selbst anhand der Entitäten erstellen (Befehl [bin/console doctrine:schema:create]) oder über Migrationen: [PHP]-Klassen, die Schritt für Schritt die Erstellung und Änderung jeder Tabelle beschreiben (Bibliothek [DoctrineMigrationsBundle], Befehl [bin/console doctrine:migrations:migrate]). Wir pflegen ein SQL-Skript, das allen Versionen der Fallstudie gemeinsam ist und genau zeigt, was die Datenbank enthält.

9.1.2. Konfiguration

DoctrineBundle wird zur Liste der Bundles hinzugefügt:

1
2
3
4
5
6
7
8
<?php
// config/bundles.php: die Bundles der Anwendung; das DoctrineBundle integriert
// Doctrine (DBAL und ORM), die Bibliothek für den Datenbankzugriff
return [
    Symfony\Bundle\FrameworkBundle\FrameworkBundle::class => ['all' => true],
    Symfony\Bundle\TwigBundle\TwigBundle::class => ['all' => true],
    Doctrine\Bundle\DoctrineBundle\DoctrineBundle::class => ['all' => true],
];

Die Verbindung zur Datenbank wird in der Datei [.env] durch eine URL beschrieben:

1
2
3
4
5
6
# .env: die Konfiguration von Beispiel 28 (siehe Beispiel 01)
APP_ENV=dev
APP_SECRET=fe7d5dd3bafdb5b7ffcab097dd4e1c0c
# die Datenbankverbindung: das DBMS MySQL auf diesem Rechner (127.0.0.1), Port 3306,
# die Datenbank dbpersons, der Benutzer root ohne Passwort (Einstellungen von Laragon)
DATABASE_URL="mysql://root:@127.0.0.1:3306/dbpersons?serverVersion=8.0.32&charset=utf8mb4"

Die URL [DATABASE_URL] fasst alle Verbindungsparameter zusammen: das DBMS ([mysql]), den Benutzernamen und das Passwort ([root], wobei nach [:] nichts folgt), den Host und den Port und schließlich den Namen der Datenbank. Wenn Ihr Server ein Passwort hat, tragen Sie es nach [:] ein ([root:secret@...]). Nach [?] folgen zwei Parameter: [serverVersion], die Version des Servers ([Doctrine] passt das von ihm erzeugte SQL an jede Version an; für [MariaDB] würde man zum Beispiel [serverVersion=10.11.2-MariaDB] schreiben), und [charset], der für die Kommunikation mit dem Server verwendete Zeichensatz, der dem Zeichensatz der Datenbank entspricht. Die Konfiguration von DoctrineBundle:

# config/packages/doctrine.yaml: die Konfiguration des DoctrineBundle
doctrine:
    # DBAL: die Datenbankverbindung, beschrieben durch eine URL (Datei .env)
    dbal:
        url: '%env(resolve:DATABASE_URL)%'
        # Die SQL-Anweisungen werden im Debug-Modus ins Log (die Konsole) geschrieben
        logging: '%kernel.debug%'
    # ORM: Die ENTITÄTEN, die den Tabellen zugeordneten Klassen, sind die Klassen des
    # Ordners src/Entity; ihr Mapping auf die Tabellen wird durch PHP-Attribute beschrieben
    orm:
        mappings:
            App:
                type: attribute
                dir: '%kernel.project_dir%/src/Entity'
                prefix: 'App\Entity'
  • Zeile 5: die Verbindung. Das Präfix [resolve:] ersetzt gegebenenfalls alle Verweise auf andere Parameter ([%...%]) im Wert der Variablen;
  • Zeile 7: Im Debug-Modus wird jeder SQL-Befehl ins Log geschrieben, das wir in der Konsole ansehen können (Beispiel 24). Dies ist auch die Standardeinstellung;
  • Zeilen 10–15: Die Entitäten sind die Klassen im Ordner [src/Entity], deren Namespace mit [App\Entity] beginnt; ihre Abbildung auf die Tabellen wird durch [PHP]-Attribute beschrieben.

Die übrigen Konfigurationsdateien stammen aus Beispiel 21: die Session, der Anti-CSRF-Schutz und die Methoden PUT und DELETE ([framework.yaml]) sowie das Formular-Theme [Bootstrap] ([twig.yaml]). Es ist nichts weiter zu konfigurieren: Die Klassen der drei Schichten werden vom [Symfony]-Container erzeugt, der in jede die darunterliegende Schicht injiziert (der Controller erhält die Geschäftsschicht, die Geschäftsschicht erhält die DAO-Schicht), und DoctrineBundle registriert den Entity Manager ([EntityManagerInterface]) im Container.

9.1.3. Die Entität Person

<?php
// src/Entity/Person.php: eine Zeile der Tabelle [persons], eine Doctrine-ENTITÄT

namespace App\Entity;

use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;

// #[ORM\Entity]: Die Klasse ist eine Entität; #[ORM\Table]: ihre Tabelle
#[ORM\Entity]
#[ORM\Table(name: 'persons')]
class Person
{
    // der Primärschlüssel, von der Datenbank erzeugt (AUTO_INCREMENT); null vor dem Einfügen
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    // die VERSION der Zeile: Doctrine erhöht sie bei jeder Änderung und ändert die Zeile nur,
    // wenn ihre Version seit dem Lesen unverändert ist (optimistisches
    // Sperren); der Typ der Spalte muss explizit angegeben werden
    #[ORM\Version]
    #[ORM\Column(type: Types::INTEGER)]
    private int $version = 0;

    // die Spalten: Ihr SQL-Typ wird aus dem PHP-Typ abgeleitet (string: VARCHAR)
    #[ORM\Column(name: 'first_name', length: 30)]
    private string $firstName;

    #[ORM\Column(name: 'last_name', length: 30)]
    private string $lastName;

    #[ORM\Column]
    private int $age;

    public function __construct(string $firstName, string $lastName, int $age)
    {
        $this->edit($firstName, $lastName, $age);
    }

    public function edit(string $firstName, string $lastName, int $age): void
    {
        $this->firstName = $firstName;
        $this->lastName = $lastName;
        $this->age = $age;
    }

    public function getId(): ?int
    {
        return $this->id;
    }

    public function getVersion(): int
    {
        return $this->version;
    }

    public function getFirstName(): string
    {
        return $this->firstName;
    }

    public function getLastName(): string
    {
        return $this->lastName;
    }

    public function getAge(): int
    {
        return $this->age;
    }
}
  • Zeilen 10–11: Das Attribut [#[ORM\Entity]] kennzeichnet die Klasse als Entität; [#[ORM\Table]] gibt den Namen ihrer Tabelle an (andernfalls würde [Doctrine] den Namen der Klasse verwenden, [person]). [ORM] ist ein Alias für den Namespace [Doctrine\ORM\Mapping] (Zeile 7): [use ... as ORM] erlaubt es, Attribute in Kurzform zu schreiben;
  • Zeilen 15–18: Der Primärschlüssel ([#[ORM\Id]]) wird von der Datenbank erzeugt ([#[ORM\GeneratedValue]]: abgeleitet von [AUTO_INCREMENT], das aus [MySQL] stammt). Er ist [null] , bis die Entität eingefügt wurde;
  • Zeilen 23–25: die Version der Zeile. Das Attribut [#[ORM\Version]] verschafft [Doctrine] die optimistische Sperre, die weiter unten beschrieben wird;
  • Zeilen 28–35: die Spalten. Jede mit [#[ORM\Column]] markierte Eigenschaft entspricht der gleichnamigen Spalte; ihr SQL-Typ wird vom [PHP] -Typ abgeleitet ([string]: [VARCHAR] mit der Länge [length]; [int]: [INT]). Anders als bei [Eloquent] werden die Spalten deklariert: Die Klasse legt genau fest, was die Tabelle enthält;
  • Zeilen 37–72: Die Entität ist eine gewöhnliche Klasse: ein Konstruktor, eine Methode, die die Person ändert, und Accessoren. Die Eigenschaften sind privat: Eine Person kann nur über ihre Methoden geändert werden. [Doctrine] hingegen liest und schreibt die Eigenschaften direkt (per Reflection), ohne den Konstruktor oder die Methoden zu durchlaufen.

In einem Standardprojekt erzeugt der Befehl [bin/console make:entity] von [MakerBundle] die Entität und stellt dazu einige Fragen zu ihren Eigenschaften.

9.1.4. Die DAO-Schicht

<?php
// src/Dao/PersonsDao.php: die DAO-Schicht, Abfragen, keine Geschäftsregel

namespace App\Dao;

use App\Entity\Person;
use Doctrine\ORM\EntityManagerInterface;

class PersonsDao
{
    // der ENTITY MANAGER von Doctrine: Er liest und schreibt die Entitäten
    public function __construct(private EntityManagerInterface $em)
    {
    }

    // SELECT ... FROM persons ORDER BY last_name, first_name
    /** @return list<Person> */
    public function list(): array
    {
        return $this->em->getRepository(Person::class)->findBy([], ['lastName' => 'ASC', 'firstName' => 'ASC']);
    }

    // SELECT ... FROM persons WHERE id = ?; null, wenn die Person nicht existiert
    public function read(int $id): ?Person
    {
        return $this->em->find(Person::class, $id);
    }

    // eine Person mit demselben Vor- und Nachnamen, außer [$exceptId], geschrieben in DQL,
    // der Abfragesprache von Doctrine: Sie spricht von Entitäten und Eigenschaften, nicht
    // von Tabellen und Spalten
    public function namesake(string $firstName, string $lastName, int $exceptId = 0): ?Person
    {
        return $this->em->createQuery(
            'SELECT p FROM App\Entity\Person p WHERE p.firstName = :firstName AND p.lastName = :lastName AND p.id <> :id')
            ->setParameters(['firstName' => $firstName, 'lastName' => $lastName, 'id' => $exceptId])
            ->setMaxResults(1)
            ->getOneOrNullResult();
    }

    // INSERT (neue Entität) oder UPDATE (gelesene, dann geänderte Entität): persist übergibt
    // die Entität dem Manager, flush sendet die nötigen SQL-Anweisungen an die Datenbank
    public function save(Person $person): void
    {
        $this->em->persist($person);
        $this->em->flush();
    }

    // DELETE FROM persons WHERE id = ?
    public function delete(Person $person): void
    {
        $this->em->remove($person);
        $this->em->flush();
    }
}

Die DAO-Schicht enthält nur Abfragen, keine Geschäftslogik. Sie erhält den Entity Manager (Zeile 12), der die Verbindung der laufenden Anfrage verwendet und an der von der Geschäftsschicht gestarteten Transaktion teilnimmt – sofern es eine gibt.

  • Zeilen 18–21: Jede Entität hat ein Repository (repository), ein Objekt, das sie aus der Datenbank abruft: [getRepository]. Seine Methode [findBy(criteria, orderBy)] liefert die Liste der Entitäten, die den Kriterien entsprechen (hier keine: also alle), in der gewünschten Reihenfolge. (Ein Repository hat außerdem [findAll], [findOneBy], [count] ...; eine Anwendung kann eine eigene Repository-Klasse mit eigenen Abfragen schreiben: Genau das erzeugt [make:entity].);
  • Zeilen 24–27: [find]: Abruf über den Primärschlüssel oder [null];
  • Zeilen 32–39: eine in DQL (Doctrine Query Language) geschriebene Abfrage, der Abfragesprache von [Doctrine]. Sie ähnelt SQL, verweist aber auf Entitäten und Eigenschaften ([App\Entity\Person p], [p.firstName]), die [Doctrine] in Tabellen und Spalten übersetzt. Die Werte sind benannte Parameter ([:firstName]), die über [setParameters] bereitgestellt werden: Sie werden getrennt an die Datenbank übermittelt und niemals in den Text des SQL-Befehls kopiert, was SQL-Injection unmöglich macht. [setMaxResults(1)] begrenzt das Ergebnis auf eine Zeile ([LIMIT 1]); [getOneOrNullResult] liefert die gefundene Entität oder [null];
  • Zeilen 43–47: Das Speichern. [persist] übergibt dem Manager eine neue Entität (eine vom Manager gelesene Entität ist ihm bereits zugeordnet); [flush] sendet alle erforderlichen SQL-Befehle an die Datenbank: ein [INSERT] für eine neue Entität und ein [UPDATE] , das nur die geänderten Spalten enthält, für eine Entität, die gelesen und dann geändert wurde. Der Manager vergleicht jede von ihm gelesene Entität mit ihrem ursprünglichen Zustand: Dies ist das Change Tracking. Nach einem [INSERT] speichert [Doctrine] die von der Datenbank erzeugte ID in der Entität;
  • Zeilen 50–54: das Löschen: [remove], gefolgt von [flush], das [DELETE] auslöst.

9.1.5. Die Geschäftsschicht

<?php
// src/Business/PersonData.php: die Daten einer Person, so wie die Web-Schicht sie weitergibt

namespace App\Business;

readonly class PersonData
{
    public function __construct(
        public string $firstName,
        public string $lastName,
        public int $age,
    ) {
    }
}

Die Daten einer Person, wie sie von der Web-Schicht an die Geschäftsschicht übergeben werden: ein einfaches Objekt ohne Bezug zu [Symfony].

<?php
// src/Business/BusinessException.php: Eine Geschäftsregel lehnt die Operation ab; die
// Meldung ist für den Benutzer bestimmt

namespace App\Business;

use RuntimeException;

class BusinessException extends RuntimeException
{
}

Eine für die Geschäftsschicht spezifische Exception-Klasse: Eine Geschäftsregel lehnt die Operation ab, und die Meldung der Exception ist für den Benutzer bestimmt. Sie erbt von [RuntimeException] , ohne etwas hinzuzufügen – nur ihr Name zählt.

<?php
// src/Business/PersonsBusiness.php: die GESCHÄFTSSCHICHT, die Geschäftsregeln und nur
// sie. Jede schreibende Operation ist eine TRANSAKTION: bestätigt (COMMIT), wenn die
// Funktion normal endet, abgebrochen (ROLLBACK), wenn eine Exception aus ihr herauskommt

namespace App\Business;

use App\Dao\PersonsDao;
use App\Entity\Person;
use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\OptimisticLockException;

class PersonsBusiness
{
    private const NAMESAKE = 'A person already has these first and last names.';

    private const MODIFIED = 'This record has been modified meanwhile: reload it.';

    private const UNKNOWN = 'This person does not exist (anymore).';

    public function __construct(private PersonsDao $dao, private EntityManagerInterface $em)
    {
    }

    /** @return list<Person> */
    public function list(): array
    {
        return $this->dao->list();
    }

    public function read(int $id): Person
    {
        return $this->dao->read($id) ?? throw new BusinessException(self::UNKNOWN);
    }

    public function add(PersonData $data): Person
    {
        // wrapInTransaction: Die Funktion wird in einer Transaktion ausgeführt
        return $this->transaction(function () use ($data) {
            // Regel 1: keine zwei Personen mit demselben Vor- und Nachnamen
            if ($this->dao->namesake($data->firstName, $data->lastName)) {
                throw new BusinessException(self::NAMESAKE);
            }
            $person = new Person($data->firstName, $data->lastName, $data->age);
            $this->dao->save($person);
            return $person;
        });
    }

    public function edit(int $id, int $version, PersonData $data): Person
    {
        return $this->transaction(function () use ($id, $version, $data) {
            $person = $this->read($id);
            // Regel 2: Wir ändern keinen Datensatz, der inzwischen von jemand anderem geändert wurde
            if ($person->getVersion() !== $version) {
                throw new BusinessException(self::MODIFIED);
            }
            if ($this->dao->namesake($data->firstName, $data->lastName, $id)) {
                throw new BusinessException(self::NAMESAKE);
            }
            $person->edit($data->firstName, $data->lastName, $data->age);
            // Das UPDATE "WHERE id = ... AND version = ..." von Doctrine löst eine
            // OptimisticLockException aus, wenn es keine Zeile geändert hat (siehe Transaktion)
            $this->dao->save($person);
            return $person;
        });
    }

    public function delete(int $id): Person
    {
        return $this->transaction(function () use ($id) {
            $person = $this->read($id);
            $this->dao->delete($person);
            return $person;
        });
    }

    // die Funktion [$operation], in einer Transaktion ausgeführt. Zwei Fehler der
    // Datenbank sind Geschäftsfehler: die Eindeutigkeits-Constraint (zwei gleichzeitige Hinzufügungen)
    // und das optimistische Sperren (zwei gleichzeitige Bearbeitungen)
    private function transaction(callable $operation): Person
    {
        try {
            return $this->em->wrapInTransaction($operation);
        } catch (UniqueConstraintViolationException $e) {
            throw new BusinessException(self::NAMESAKE, previous: $e);
        } catch (OptimisticLockException $e) {
            throw new BusinessException(self::MODIFIED, previous: $e);
        }
    }
}
  • Zeilen 16–20: die Meldungen der Geschäftsregeln;
  • Zeilen 32–35: Eine nicht existierende Person ist ein Geschäftsfehler. Der Operator [??] akzeptiert auf der rechten Seite einen Ausdruck [throw]: Ist die Person [null], wird die Exception geworfen;
  • Zeilen 37–49: 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 eine Exception [BusinessException] wird geworfen, wenn sie nicht erfüllt ist. Diese Prüfung reicht jedoch nicht aus: Zwei gleichzeitige Anfragen könnten beide feststellen, dass es keine Namensvettern gibt, und dann beide den Datensatz einfügen. Die Eindeutigkeitsbedingung der Datenbank lehnt dann das zweite [INSERT] ab, und [Doctrine] löst eine [UniqueConstraintViolationException] aus, die die Methode [transaction] in dieselbe [BusinessException] umwandelt. Die Datenbank ist die letzte Verteidigungslinie;
  • Zeilen 51–68: Regel Nr. 2: Keinen Datensatz ändern, der zwischenzeitlich 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. Bleibt der Fall, dass die gleichzeitige Änderung zwischen dem Lesen in Zeile 54 und dem Speichern in Zeile 65 erfolgt: Sie wird durch die optimistische Sperre von [Doctrine] erkannt. Bei einer Entität mit Version prüft [UPDATE] zwei Bedingungen – die ID und die gelesene Version – und erhöht die Version um 1; hat eine andere Abfrage die Zeile in der Zwischenzeit geändert – ihre Version hat sich geändert –, ändert das [UPDATE] keine Zeilen, und [Doctrine] wirft eine [OptimisticLockException]. Das ist das Prinzip des optimistischen Sperrens: Nichts wird blockiert, aber gleichzeitige Änderungen werden erkannt. ([Doctrine] erledigt dies selbst, ebenso wie [Hibernate] und [SQLAlchemy]; in der [Laravel]-Version dieses Kurses musste die Bedingung von Hand geschrieben werden.);
  • Zeilen 70–77: Das Löschen markiert die Person für die Bestätigungsmeldung als gelöscht;
  • Zeilen 82–91: Jede Operation, die Daten schreibt, wird innerhalb einer Transaktion ausgeführt: [wrapInTransaction] öffnet die Transaktion, führt die Funktion aus, übermittelt die ausstehenden Änderungen ([flush]), schließt dann die Transaktion mit einem Commit ab ([COMMIT]) und liefert den Rückgabewert der Funktion zurück. Wird innerhalb der Funktion eine Exception geworfen, wird die Transaktion zurückgerollt ([ROLLBACK]): Keine der innerhalb der Funktion vorgenommenen Änderungen bleibt erhalten, und die Exception wird weitergegeben. Die Geschäftsschicht legt somit den Umfang der Transaktionen fest: eine Geschäftsoperation, eine Transaktion. Die beiden Datenbankfehler, die Geschäftsfehler sind, werden zu [BusinessException]; der Parameter mit dem Namen [previous] hängt die ursprüngliche Exception für das Log an die neue an. Jeder andere Fehler wird unverändert weitergereicht: Er ist kein Geschäftsfehler, sondern ein Programmierfehler (oder ein Systemausfall). Nach einer Exception [Doctrine] schließt den Entity Manager, dessen Zustand nicht mehr verlässlich ist: Er kann während der Anfrage nicht mehr verwendet werden, was hier kein Problem ist, da die Anfrage endet.

Der Parameter [callable] der Methode [transaction] bezeichnet eine beliebige Funktion; die anonymen Funktionen in den Zeilen 40, 53 und 72 erfassen die benötigten Variablen über [use].

9.1.6. Die Web-Schicht

Die Formulareingabe wird durch eine Klasse beschrieben, ihre Constraints durch Attribute (Beispiel 19):

<?php
// src/Form/PersonInput.php: die Felder des Formulars und ihre Constraints (siehe Beispiel 19)

namespace App\Form;

use App\Entity\Person;
use App\Business\PersonData;
use Symfony\Component\Validator\Constraints as Assert;

class PersonInput
{
    #[Assert\NotBlank(message: 'The first name is required.')]
    #[Assert\Length(max: 30, maxMessage: '30 characters at most.')]
    public ?string $firstName = null;

    #[Assert\NotBlank(message: 'The last name is required.')]
    #[Assert\Length(max: 30, maxMessage: '30 characters at most.')]
    public ?string $lastName = null;

    #[Assert\NotNull(message: 'The age is required.')]
    #[Assert\Range(notInRangeMessage: 'The age must be between 0 and 150.', min: 0, max: 150)]
    public ?int $age = null;

    // die Version des Datensatzes, getragen von einem versteckten Feld (nur beim Bearbeiten)
    public ?int $version = null;

    // die Eingabe, mit einer vorhandenen Person vorbelegt
    public static function from(Person $p): self
    {
        $input = new self();
        $input->firstName = $p->getFirstName();
        $input->lastName = $p->getLastName();
        $input->age = $p->getAge();
        $input->version = $p->getVersion();
        return $input;
    }

    // die validierten Daten für die Geschäftsschicht
    public function data(): PersonData
    {
        return new PersonData(trim($this->firstName), trim($this->lastName), $this->age);
    }
}
  • Zeilen 12–22: die Constraints, mit Meldungen auf Englisch;
  • Zeile 25: die Version des Datensatzes, übertragen in einem versteckten Feld (nur im Bearbeitungsmodus);
  • Zeilen 28–36: eine vorausgefüllte Eingabe mit einer vorhandenen Person, für das Änderungsformular;
  • Zeilen 39–42: die validierten Daten, im von der Geschäftsschicht erwarteten Format.

Wir hätten das Formular direkt mit der Entität [Person] verknüpfen (Option [data_class], Beispiel 19) und die Constraints darauf setzen können: Das ist bei [Symfony] üblich. Das Formular würde die Entität dann aber ändern, bevor die Geschäftsschicht ihre Regeln geprüft hat, und eine ungültige Entität würde an den Entity Manager übergeben. Eine separate Eingabeklasse hält die Schichten getrennt: Die Web-Schicht übermittelt nur validierte Daten an die Geschäftsschicht.

<?php
// src/Form/PersonType.php: das Formular einer Person (siehe Beispiel 18)

namespace App\Form;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\HiddenType;
use Symfony\Component\Form\Extension\Core\Type\IntegerType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class PersonType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
        $builder
            ->add('firstName', TextType::class, ['label' => 'First name', 'attr' => ['maxlength' => 30]])
            ->add('lastName', TextType::class, ['label' => 'Last name', 'attr' => ['maxlength' => 30]])
            ->add('age', IntegerType::class, ['label' => 'Age', 'attr' => ['min' => 0, 'max' => 150],
                'invalid_message' => 'The age must be an integer.']);
        // die Version: ein verstecktes Feld, nur im Bearbeitungsformular
        if ($options['edit']) {
            $builder->add('version', HiddenType::class);
        }
    }

    // die Optionen des Formulars: die Klasse der Daten und eine eigene Option
    public function configureOptions(OptionsResolver $resolver): void
    {
        $resolver->setDefaults(['data_class' => PersonInput::class, 'edit' => false]);
    }
}
  • Zeilen 20–21: ein Ganzzahlfeld; [invalid_message] ist die Meldung, die angezeigt wird, wenn die Eingabe nicht in eine Ganzzahl umgewandelt werden kann;
  • Zeilen 23–25: das versteckte Versionsfeld, nur im Änderungsformular, gemäß der Option [edit];
  • Zeilen 29–32: [configureOptions] deklariert die Optionen des Formulars und ihre Standardwerte: die Datenklasse und eine benutzerdefinierte Option, [edit].
<?php
// src/Controller/PersonsController.php: die WEB-Schicht; sie kennt nur die Geschäftsschicht

namespace App\Controller;

use App\Form\PersonInput;
use App\Form\PersonType;
use App\Business\BusinessException;
use App\Business\PersonsBusiness;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
use Symfony\Component\Routing\Attribute\Route;

// name: ein Präfix für den Namen aller Routen der Klasse (persons_list...)
#[Route(name: 'persons_')]
class PersonsController extends AbstractController
{
    public function __construct(private PersonsBusiness $business)
    {
    }

    #[Route('/', name: 'home', methods: ['GET'])]
    public function home(): Response
    {
        return $this->redirectToRoute('persons_list');
    }

    #[Route('/persons', name: 'list', methods: ['GET'])]
    public function list(): Response
    {
        return $this->render('persons/list.html.twig', ['persons' => $this->business->list()]);
    }

    // GET: das leere Formular; POST: das gesendete Formular
    #[Route('/persons/add', name: 'add', methods: ['GET', 'POST'])]
    public function add(Request $request): Response
    {
        $input = new PersonInput();
        $form = $this->createForm(PersonType::class, $input);
        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            try {
                $p = $this->business->add($input->data());
                $this->addFlash('success', "{$p->getFirstName()} {$p->getLastName()} has been added.");
                return $this->redirectToRoute('persons_list');
            } catch (BusinessException $e) {
                // Eine Geschäftsregel lehnt ab: Das Formular wird erneut angezeigt, mit der
                // Eingabe und der Meldung am Seitenende
                return $this->formPage('Add a person', $form, $e->getMessage());
            }
        }
        return $this->formPage('Add a person', $form);
    }

    // GET: das Bearbeitungsformular, vorbelegt
    #[Route('/persons/{id<\d+>}/edit', name: 'edit_form', methods: ['GET'])]
    public function editForm(int $id): Response
    {
        try {
            $p = $this->business->read($id);
        } catch (BusinessException $e) {
            $this->addFlash('error', $e->getMessage());
            return $this->redirectToRoute('persons_list');
        }
        return $this->formPage('Edit a person', $this->editFormFor($id, PersonInput::from($p)));
    }

    // PUT: das gesendete Bearbeitungsformular
    #[Route('/persons/{id<\d+>}', name: 'edit', methods: ['PUT'])]
    public function edit(Request $request, int $id): Response
    {
        $input = new PersonInput();
        $form = $this->editFormFor($id, $input);
        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            try {
                $p = $this->business->edit($id, (int) $input->version, $input->data());
                $this->addFlash('success', "{$p->getFirstName()} {$p->getLastName()} has been edited.");
                return $this->redirectToRoute('persons_list');
            } catch (BusinessException $e) {
                return $this->formPage('Edit a person', $form, $e->getMessage());
            }
        }
        return $this->formPage('Edit a person', $form);
    }

    #[Route('/persons/{id<\d+>}', name: 'delete', methods: ['DELETE'])]
    public function delete(Request $request, int $id): Response
    {
        if (! $this->isCsrfTokenValid("delete-person-$id", $request->request->getString('_token'))) {
            throw new AccessDeniedHttpException('invalid anti-CSRF token');
        }
        try {
            $p = $this->business->delete($id);
            $this->addFlash('success', "{$p->getFirstName()} {$p->getLastName()} has been deleted.");
        } catch (BusinessException $e) {
            // kein Formular, das erneut anzuzeigen wäre: Der Fehler wird auch als Flash-Meldung übermittelt
            $this->addFlash('error', $e->getMessage());
        }
        return $this->redirectToRoute('persons_list');
    }

    // das Bearbeitungsformular: mit der Methode PUT an die URL /persons/{id} gesendet
    private function editFormFor(int $id, PersonInput $input): FormInterface
    {
        return $this->createForm(PersonType::class, $input, ['edit' => true,
            'method' => 'PUT', 'action' => $this->generateUrl('persons_edit', ['id' => $id])]);
    }

    private function formPage(string $title, FormInterface $form, ?string $error = null): Response
    {
        // ein Geschäftsfehler: der Code 422, wie bei einem ungültigen Formular (siehe Beispiel 19)
        return $this->render('persons/form.html.twig',
            ['title' => $title, 'form' => $form, 'error' => $error],
            new Response(status: $error ? 422 : 200));
    }
}
  • Zeile 18: Das Klassenattribut [#[Route]] setzt hier nur den Namen der Routen ein Präfix voran: Die Route mit dem Namen [list] heißt tatsächlich [persons_list];
  • Zeile 21: die Geschäftsschicht, die einzige Schicht, die der Controller kennt;
  • Zeilen 38–56: der Ablauf in drei Schritten: Formularvalidierung (Eingabefehler, Beispiel 19); der Aufruf der Geschäftsschicht (Geschäftsregeln); dann das PRG-Schema mit einer Flash-Erfolgsmeldung (Beispiel 20). Eine [BusinessException] bewirkt, dass das Formular zusammen mit den eingegebenen Daten und der Meldung der Exception erneut angezeigt wird, die das Template am Seitenende ausgibt. Eingabefehler und Fehler der Geschäftslogik werden somit auf dieselbe Weise behandelt;
  • Zeilen 59–69: das Bearbeitungsformular, vorausgefüllt mit der abgerufenen Person. Existiert die Person nicht, wird der Benutzer mit einer Flash-Fehlermeldung zur Liste umgeleitet;
  • Zeilen 72–88: die Änderung, nach demselben Muster wie das Hinzufügen;
  • Zeilen 90–104: das Löschen, geschützt durch ein für jede Person eindeutiges CSRF-Token (Beispiel 21). Es gibt kein Formular, das erneut angezeigt werden müsste: Jeder Fehler wird ebenfalls in einer Flash-Meldung übermittelt, [error];
  • Zeilen 107–111: Das Bearbeitungsformular wird mit der Methode PUT gesendet (Option [method]: [form_start] fügt dann das versteckte Feld [_method] hinzu, Beispiel 21) an die URL [/persons/{id}] (Option [action]);
  • Zeilen 113–119: die Formularseite. Ein Geschäftsfehler wird mit dem Code 422 zurückgegeben, der ein ungültiges Formular anzeigt.

Die Web-Schicht enthält weder SQL noch irgendwelche Geschäftsregeln: Sie übersetzt die Anfrage in einen Aufruf der Geschäftsschicht und das Ergebnis in eine Seite.

Die Views:

<!doctype html>
<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="{{ path('bootstrap', {file: 'css/bootstrap.min.css'}) }}">
  <link rel="stylesheet" href="{{ asset('css/styles.css') }}">
</head>
<body>
  <div class="container py-3" style="max-width: 40rem">
    {# die Erfolgsmeldung ([success]-Flash-Nachricht): am Seitenanfang #}
    {% for message in app.flashes('success') %}
      <div class="alert alert-success" role="status">{{ message }}</div>
    {% endfor %}
    <main>
      {% block content %}{% endblock %}
    </main>
    {# die Fehler: am Seitenende; eine [error]-Flash-Nachricht oder die Variable [error] der View #}
    {% for message in app.flashes('error') %}
      <div class="error-area" role="alert">{{ message }}</div>
    {% endfor %}
    {% if error is defined and error %}
      <div class="error-area" role="alert">{{ error }}</div>
    {% endif %}
  </div>
  {% include 'fragments/confirmation.html.twig' %}
  <script src="{{ asset('js/app.js') }}"></script>
</body>
</html>
  • Zeilen 13–15: die Erfolgsmeldung am Seitenanfang (Beispiel 20);
  • Zeilen 20–25: Fehler; am Seitenende: eine Flash-Meldung (nach einer Umleitung) oder die View-Variable [error] (Formular erneut angezeigt). Der Test [is defined] verhindert einen Fehler auf Seiten, die diese Variable nicht haben.
{% extends 'layout.html.twig' %}

{% block content %}
  <h1 class="h3">Persons</h1>
  <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.firstName }}</td>
          <td>{{ p.lastName }}</td>
          <td>{{ p.age }}</td>
          <td class="text-end">
            <a class="btn btn-sm btn-outline-primary" href="{{ path('persons_edit_form', {id: p.id}) }}">Edit</a>
            <form method="post" class="d-inline" action="{{ path('persons_delete', {id: p.id}) }}"
                  data-confirmation="Delete {{ p.firstName }} {{ p.lastName }}?">
              <input type="hidden" name="_method" value="DELETE">
              <input type="hidden" name="_token" value="{{ csrf_token('delete-person-' ~ p.id) }}">
              <button class="btn btn-sm btn-outline-danger" type="submit">Delete</button>
            </form>
          </td>
        </tr>
      {% endfor %}
    </tbody>
  </table>
  <a class="btn btn-primary" href="{{ path('persons_add') }}">Add a person</a>
{% endblock %}

Die Liste enthält die Links und Schaltflächen aus Beispiel 21 samt ihrem Bestätigungsfenster (die Dateien [fragments/confirmation.html.twig] und [public/js/app.js] sind die aus Beispiel 21). Die Eigenschaften [p.firstName], [p.lastName] ... werden über die Accessoren [getFirstName()], [getLastName()] ... gelesen: [Twig] findet sie selbstständig (Beispiel 13).

{% extends 'layout.html.twig' %}

{% block content %}
  <h1 class="h3">{{ title }}</h1>
  {# novalidate: die Validierung erfolgt durch den Server (siehe Beispiel 19); form_start
     schreibt auch das versteckte Feld _method eines PUT-Formulars #}
  {{ form_start(form, {attr: {novalidate: 'novalidate'}}) }}
    {{ form_widget(form) }}
    <button class="btn btn-primary" type="submit">Save</button>
    <a class="btn btn-link" href="{{ path('persons_list') }}">Cancel</a>
  {{ form_end(form) }}
{% endblock %}

Eine View, die sowohl zum Hinzufügen als auch zum Ändern von Datensätzen dient. [form_widget] rendert alle Formularfelder, einschließlich des versteckten Versionsfelds und des Anti-CSRF-Tokens.

9.1.7. Ausführung

Die Liste der Personen:

Image

Ein fehlerhaft ausgefülltes Hinzufügen-Formular: 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ß-/Kleinschreibung und 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 (die Zeitangaben und Zeilen des Entwicklungsservers wurden entfernt). Die Anzeige des Änderungsformulars für Person Nr. 1:

1
2
3
[info] Connecting with parameters [array]
[debug] Executing statement: SELECT t0.id AS id_1, t0.version AS version_2, t0.first_name AS first_name_3, t0.last_name AS last_name_4, t0.age AS age_5 FROM persons t0 WHERE t0.id = ? (parameters: [array], types: [array])
[info] Disconnecting

Eine Verbindung, ein Lesezugriff über den Primärschlüssel (dessen Wert als Parameter übergeben wird – [?]), gefolgt von einem Verbindungsabbau am Ende der Anfrage. Es gibt keine Transaktion: Ein isolierter Lesezugriff erfordert keine. [Doctrine] vergibt für jede Tabelle ([t0]) und jede Spalte ([id_1]) einen Alias. Die Parameterwerte sind ein Array, das das minimale Log von [Symfony] nicht anzeigt ([[array]]); [Monolog] oder die Debug-Leiste von [Symfony] ([WebProfilerBundle], installiert mit [composer require --dev profiler]) würden sie anzeigen. Die Aktualisierung des Datensatzes mit einem neuen Alter:

1
2
3
4
5
6
7
8
[debug] Beginning transaction
[debug] Executing statement: SELECT t0.id AS id_1, t0.version AS version_2, t0.first_name AS first_name_3, t0.last_name AS last_name_4, t0.age AS age_5 FROM persons t0 WHERE t0.id = ? (parameters: [array], types: [array])
[debug] Executing statement: SELECT p0_.id AS id_0, p0_.version AS version_1, p0_.first_name AS first_name_2, p0_.last_name AS last_name_3, p0_.age AS age_4 FROM persons p0_ WHERE p0_.first_name = ? AND p0_.last_name = ? AND p0_.id <> ? LIMIT 1 (parameters: [array], types: [array])
[debug] Executing statement: SAVEPOINT DOCTRINE_2
[debug] Executing statement: UPDATE persons SET age = ?, version = version + 1 WHERE id = ? AND version = ? (parameters: [array], types: [array])
[debug] Executing statement: SELECT version FROM persons WHERE id = ? (parameters: [array], types: [array])
[debug] Executing statement: RELEASE SAVEPOINT DOCTRINE_2
[debug] Committing transaction

In einer einzigen Transaktion sehen wir: das Lesen des Datensatzes, die Suche nach einem Namensvetter (die DQL-Abfrage, in SQL übersetzt), gefolgt von [UPDATE]. Diese Transaktion ändert nur die Spalte, die sich geändert hat ([age]), erhöht die Versionsnummer und setzt die Bedingung der optimistischen Sperre ([AND version = ?]). [Doctrine] liest dann die neue Version erneut, um sie in der Entität zu speichern. [flush] öffnet selbst eine Transaktion; da bereits eine existiert – die Transaktion der Geschäftsschicht –, legt es lediglich einen Savepoint ([SAVEPOINT]) an, eine verschachtelte Transaktion, die am Ende von [RELEASE] bestätigt wird ([flush]). Senden wir nun dasselbe Formular ein zweites Mal ab, wiederum mit der alten Version:

1
2
3
[debug] Beginning transaction
[debug] Executing statement: SELECT t0.id AS id_1, t0.version AS version_2, t0.first_name AS first_name_3, t0.last_name AS last_name_4, t0.age AS age_5 FROM persons t0 WHERE t0.id = ? (parameters: [array], types: [array])
[debug] Rolling back transaction

Die gelesene Version ist nicht die aus dem Formular: Die Geschäftsschicht hat eine [BusinessException] ausgelöst, die die Transaktion zurückgerollt hat ([ROLLBACK]), und die Seite zeigt „Dieser Datensatz wurde inzwischen geändert: Laden Sie ihn neu.“ an. Ebenso endet das Hinzufügen eines Namensvetters nach der Suche nach dem Namensvetter, ohne [INSERT].