Skip to content

18. Praktische Übung – Version 8

Wir greifen die Beispielanwendung – Version 5 (und ihre durch die JSON-Datei konfigurierte Version 7) – wieder auf und machen daraus eine Client-Server-Anwendung. So können wir das, was wir im vorherigen Kapitel über Webdienste gelernt haben, in die Praxis umsetzen.

18.1. Einführung

Die Architektur von Version 5 sah wie folgt aus:

Image

  • Die Schicht namens [dao] (Data Access Objects) verwaltet die Interaktionen mit der MySQL-Datenbank und dem lokalen Dateisystem;
  • die Schicht namens [business] führt die Steuerberechnung durch;
  • Das Hauptskript fungiert als Orchestrator: Es instanziiert die Schichten [dao] und [business] und kommuniziert dann mit der Schicht [business] , um die erforderlichen Aufgaben auszuführen.

Wir werden diese Architektur auf die folgende Client-Server-Architektur migrieren:

Image

  • In [2] verwenden wir die Schicht [dao] von Version 5 wieder und entfernen die Methoden, die auf das lokale Dateisystem zugreifen. Diese Methoden werden in die Schicht [dao] des Clients [6, 7] migriert;
  • in [3] bleibt die Schicht [business] dieselbe wie in Version 5, abzüglich ihrer Methode [executeBatchTaxes], die in die Schichten [business] und [8] des Clients migriert wird;
  • In [4] muss das Serverskript geschrieben werden; es muss Folgendes leisten:
    • die Schichten [business], [dao] und [3, 2] erzeugen;
    • mit dem Client-Skript [5, 7] kommunizieren;
  • In [7] muss die Client-Schicht [dao] geschrieben werden:
    • sie ist ein HTTP-Client des Serverskripts [4, 5];
    • sie übernimmt die Methoden für den Zugriff auf das lokale Dateisystem aus der Schicht [dao] von Version 5;
  • In [8] stellt die Schicht [business] des Clients dieselben Methoden bereit wie die Schnittstelle [InterfaceBusiness] aus Version 5. Ihre Implementierung ist jedoch eine andere. In Version 5 führte die Schicht [business] die Steuerberechnung durch. Hier führt die Schicht [business] des Servers diese Berechnung durch. Die clientseitige Schicht [business] greift daher auf die Schichten [dao] und [7] zurück, um mit dem Server zu kommunizieren und ihn aufzufordern, die Steuer zu berechnen;
  • In [9] muss das Konsolenskript die Client-Schichten [dao, business] instanziieren und deren Ausführung starten.

Der Server ist ein Webskript: Es befindet sich im Ordner [scripts-web/tax/version-08] und wird vom Apache-Server in [Laragon] ausgeführt. Der Client ist ein Konsolenskript: Es befindet sich im Ordner [scripts-console/tax/version-08] und wird in einem Terminal ausgeführt.

18.2. Der Server

Wir konzentrieren uns auf die Serverseite der Anwendung.

Image

Diese Architektur wird durch die folgenden Dateien umgesetzt:

scripts-web/tax/version-08
├── Business
│   ├── InterfaceServerBusiness.php
│   └── ServerBusiness.php
├── Dao
│   ├── InterfaceServerDao.php
│   └── ServerDao.php
├── Data
│   ├── .htaccess
│   ├── config-server.json
│   ├── database-mysql.json
│   └── database-pgsql.json
├── Tests
│   ├── ServerBusinessTest.php
│   └── ServerDaoTest.php
└── tax-server.php

18.2.1. Zwischen den Schichten ausgetauschte Entitäten

Die zwischen den Schichten ausgetauschten Entitäten sind die aus Version 5: die Exception [TaxException], die Daten der Steuerverwaltung [TaxAdminData], und die Beschreibung der Datenbank [Database]. Der Server verwendet außerdem die Klasse [Utilities] aus Version 5, deren Methode [readJsonFile] von der Klasse [Database] verwendet wird. Im PHP-7-Kurs wurden diese Dateien in den Serverordner kopiert. Wir laden sie nun direkt aus dem Ordner [scripts-console/tax/version-05]: So existiert jede Klasse nur als eine einzige Instanz, und jede in Version 5 vorgenommene Korrektur kommt allen Versionen zugute, die sie verwenden.

18.2.2. Die [dao]-Schicht

Die Schicht [dao] implementiert die folgende Schnittstelle [InterfaceServerDao]:

<?php

declare(strict_types=1);

// Namespace
namespace Application;

// das Interface der [dao]-Schicht des Servers
interface InterfaceServerDao
{
    // Lesen der Daten der Steuerverwaltung
    // wirft im Fehlerfall eine Exception [TaxException]
    public function getTaxAdminData(): TaxAdminData;
}
  • Zeile 13: Die Methode [getTaxAdminData] ruft Daten aus der Datenbank der Steuerbehörde ab.

Die Schnittstelle [InterfaceServerDao] wird von der folgenden Klasse [ServerDao] implementiert:

<?php

declare(strict_types=1);

// Namespace
namespace Application;

// die [dao]-Schicht des Servers: sie findet die Daten der Steuerverwaltung in einer Datenbank
// es ist die Klasse [DaoTaxWithTaxAdminDataInDatabase] aus Version 5 ohne die Methoden,
// die mit den JSON-Dateien der Steuerzahler arbeiten
class ServerDao implements InterfaceServerDao
{
    // die Beschreibung der Datenbank
    private readonly Database $database;
    // das Objekt [TaxAdminData], das die Daten der Steuerverwaltung enthält
    // [protected]: abgeleitete Klassen können es initialisieren
    protected readonly TaxAdminData $taxAdminData;

    // der Konstruktor
    public function __construct(string $databaseFilename)
    {
        // die Beschreibung der Datenbank - kann eine [TaxException] werfen
        $this->database = Database::fromJsonFile($databaseFilename);
        $database = $this->database;
        try {
            // wir öffnen die Verbindung zur Datenbank
            // die gelesenen Zeilen werden als assoziative Arrays [Spalte => Wert] zurückgegeben
            $connection = \PDO::connect(
                $database->dsn,
                $database->id,
                $database->pwd,
                [\PDO::ATTR_DEFAULT_FETCH_MODE => \PDO::FETCH_ASSOC]
            );
            // wir starten eine Transaktion
            $connection->beginTransaction();
            // wir lesen die Tabelle der Steuerstufen
            $brackets = $this->getBrackets($connection);
            // wir lesen die Konstantentabelle
            $constants = $this->getConstants($connection);
            // wir beenden die Transaktion erfolgreich
            $connection->commit();
        } catch (\PDOException $ex) {
            // läuft eine Transaktion?
            if (isset($connection) && $connection->inTransaction()) {
                // wir beenden die Transaktion mit einem Misserfolg
                $connection->rollBack();
            }
            // wir reichen den Fehler als [TaxException] an den aufrufenden Code weiter
            throw new TaxException("Database access error ({$ex->getMessage()})", 30, $ex);
        }
        // Aufbau des Objekts [TaxAdminData]: die gelesenen Daten werden geprüft
        $this->taxAdminData = TaxAdminData::fromArray([...$brackets, ...$constants]);
    }

Dies ist der Code der Klasse [DaoTaxWithTaxAdminDataInDatabase] aus Version 5, die in Kapitel 13 vorgestellt wurde, ohne das Trait [TraitDao], das die Methoden zum Lesen und Schreiben der JSON-Dateien der Steuerzahler bereitstellte. Die folgenden privaten Methoden [getBrackets] und [getConstants] , die hier nicht wiedergegeben sind, bleiben unverändert. Es gibt nur einen Unterschied:

  • Zeile 17: Das Attribut [taxAdminData] wird als [protected] statt als [private] deklariert. Version 9 leitet die Klasse [ServerDao] ab, und die abgeleitete Klasse muss dieses Attribut initialisieren können. Seit PHP 8.4 kann eine abgeleitete Klasse ein geerbtes [readonly]-Attribut initialisieren, sofern es nicht privat ist.

18.2.3. Die [business]-Schicht

Die Schicht [business] implementiert die folgende Schnittstelle [InterfaceServerBusiness]:

<?php

declare(strict_types=1);

// Namespace
namespace Application;

// das Interface der [business]-Schicht des Servers
interface InterfaceServerBusiness
{
    // Berechnung der Steuer eines Steuerzahlers
    // gibt das Array [tax, surcharge, discount, reduction, rate] zurück
    public function calculateTax(string $married, int $children, int $salary): array;
}

Die Schnittstelle [InterfaceServerBusiness] wird von der folgenden Klasse [ServerBusiness] implementiert:

<?php

declare(strict_types=1);

// Namespace
namespace Application;

// die [business]-Schicht des Servers: die Klasse [Business] aus Version 5 ohne die Methode [executeBatchTax]
class ServerBusiness implements InterfaceServerBusiness
{
    // Daten der Steuerverwaltung
    private readonly TaxAdminData $taxAdminData;

    // die Schicht [dao] wird vom Konstruktor injiziert
    public function __construct(private readonly InterfaceServerDao $dao)
    {
        // wir rufen die Daten zur Steuerberechnung ab
        // die Methode [getTaxAdminData] kann eine Exception [TaxException] werfen
        // wir lassen sie dann bis zum aufrufenden Code weitergeben
        $this->taxAdminData = $this->dao->getTaxAdminData();
    }

    // Steuerberechnung
    // --------------------------------------------------------------------------
    #[\Override]
    public function calculateTax(string $married, int $children, int $salary): array
  • Zeile 9: Die Klasse [ServerBusiness] ist die Klasse [Business] aus Version 5 ohne ihre Methode [executeBatchTaxes];
  • Zeile 15: Der Konstruktor erhält eine Referenz auf eine Schicht [dao] vom Typ [InterfaceServerDao];
  • Zeile 26: Die Methode [calculateTax] und die privaten Methoden, die sie verwendet, bleiben unverändert. Der Algorithmus wurde ab Version 1 besprochen und erklärt, und seine objektorientierte Fassung wird in Kapitel 13 behandelt.

18.2.4. Das Serverskript

Das Serverskript [tax-server.php] implementiert die Schichten [web] und [4] . Es wird durch die folgenden JSON-Dateien und [Data/config-server.json] konfiguriert:

{
    "databaseFilename": "Data/database-mysql.json",
    "dependencies": [
        "../../../scripts-console/tax/version-05/Entities/TaxException.php",
        "../../../scripts-console/tax/version-05/Entities/TaxAdminData.php",
        "../../../scripts-console/tax/version-05/Entities/Database.php",
        "../../../scripts-console/tax/version-05/Utilities/Utilities.php",
        "Dao/InterfaceServerDao.php",
        "Dao/ServerDao.php",
        "Business/InterfaceServerBusiness.php",
        "Business/ServerBusiness.php"
    ],
    "users": [
        {
            "login": "admin",
            "passwd": "admin"
        }
    ]
}
  • Zeile 2: die JSON-Konfigurationsdatei für die MySQL-Datenbank. Dies ist die Datei [database-mysql.json] aus Version 7. Der Ordner [Data] enthält außerdem die Datei [database-pgsql.json] für die PostgreSQL-Datenbank: Ändern Sie einfach diese Zeile, damit der Server mit PostgreSQL arbeitet;
  • Zeilen 3–12: die PHP-Dateien der Anwendung, deren Pfade relativ zum Ordner [version-08] auf dem Server angegeben sind. Die ersten vier stammen aus Version 5;
  • Zeilen 13–18: die Liste der Benutzer, die die Anwendung verwenden dürfen.

Wie in Version 7 gibt es den Schlüssel [rootDirectory] nicht mehr: Das Skript berechnet seinen eigenen Stammordner anhand der Konstante [__DIR__]. Auch den Schlüssel [absoluteDependencies] gibt es nicht mehr, der den absoluten Pfad zur Datei [vendor/autoload.php] von [Composer] lieferte: Er wird nun anhand von [__DIR__] bestimmt.

Die Datei [config-server.json] befindet sich im Ordner [Data] auf dem Server und damit innerhalb der Verzeichnisstruktur der Website: Ohne Vorkehrungen könnte jeder sie mit der URL [http://localhost/php8-oct-2026/scripts-web/tax/version-08/Data/config-server.json] herunterladen und die Zugangsdaten der Benutzer lesen. Dasselbe gilt für die Datei [database-mysql.json], die das Passwort der Datenbank enthält. Der Ordner [Data] enthält deshalb eine Datei namens [.htaccess]:

# der Ordner [Data] enthält Passwörter: Apache verweigert die Auslieferung seiner Dateien
Require all denied

Eine Datei namens [.htaccess] enthält Konfigurationsdirektiven des Apache-Servers, die für den Ordner, der sie enthält, und seine Unterordner gelten. Die Direktive [Require all denied] verweigert den Zugriff auf den Ordner: Apache antwortet mit [403 Forbidden] auf jede Anfrage nach einer Datei im Ordner [Data]. Das PHP-Skript hingegen liest diese Dateien direkt von der Festplatte, ohne Apache zu durchlaufen, und ist davon nicht betroffen.

Das Skript [tax-server.php] implementiert die Schicht [web] wie folgt:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter und -ergebnisse
declare(strict_types=1);

// Namespace
namespace Application;

// Abhängigkeiten von Symfony
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

// der Wurzelordner des Servers: die Pfade der Konfigurationsdatei sind relativ zu diesem Ordner
const ROOT_DIRECTORY = __DIR__;
// Pfad der Konfigurationsdatei
const CONFIG_FILENAME = ROOT_DIRECTORY . "/Data/config-server.json";

// wir rufen die Konfiguration ab
$config = json_decode(file_get_contents(CONFIG_FILENAME), true, flags: JSON_THROW_ON_ERROR);

// wir binden die vom Skript benötigten Abhängigkeiten ein
require_once ROOT_DIRECTORY . "/../../../vendor/autoload.php";
foreach ($config["dependencies"] as $dependency) {
    require_once ROOT_DIRECTORY . "/$dependency";
}

// Vorbereiten der JSON-Antwort des Servers
$response = new JsonResponse();
// Umlaute und / werden nicht maskiert, Gleitkommazahlen werden immer mit Dezimalpunkt geschrieben (0.0)
$response->setEncodingOptions(JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_PRESERVE_ZERO_FRACTION);

// wir rufen die aktuelle Anfrage ab
$request = Request::createFromGlobals();
// Authentifizierung: die vom Client gesendeten Zugangsdaten (null, wenn er keine gesendet hat)
$requestUser = $request->getUser();
$requestPassword = $request->getPassword();
// ist der Benutzer einer der autorisierten Benutzer?
$found = $requestUser !== null && $requestPassword !== null
    && array_any(
        $config["users"],
        fn(array $user): bool => $user["login"] === $requestUser && hash_equals($user["passwd"], $requestPassword)
    );
if (!$found) {
    // nicht gefunden - Code 401
    $response->setStatusCode(Response::HTTP_UNAUTHORIZED);
    $response->headers->set("WWW-Authenticate", 'Basic realm="Tax calculation server"');
    // Fehlermeldung
    $response->setData(["response" => ["error" => "Authentication failed [$requestUser]"]]);
    $response->send();
    // Ende
    exit;
}

// wir haben einen gültigen Benutzer - wir prüfen die empfangenen Parameter
$errors = [];
// wir müssen eine GET-Anfrage mit drei Parametern haben
if ($request->getMethod() !== "GET" || $request->query->count() !== 3) {
    $errors[] = "GET method required with only the parameters [married, children, salary]";
}
// der Familienstand
if (!$request->query->has("married")) {
    $errors[] = "missing married parameter";
} else {
    $married = strtolower(trim($request->query->getString("married")));
    if (!in_array($married, ["yes", "no"], true)) {
        $errors[] = "invalid married parameter [$married]";
    }
}
// die Anzahl der Kinder und das Gehalt: ganze Zahlen >= 0
$values = [];
foreach (["children", "salary"] as $parameter) {
    if (!$request->query->has($parameter)) {
        $errors[] = "missing $parameter parameter";
        continue;
    }
    $value = trim($request->query->getString($parameter));
    if (preg_match('/^\d+$/', $value) !== 1) {
        $errors[] = "invalid $parameter parameter [$value]";
    } else {
        $values[$parameter] = (int) $value;
    }
}
// weitere Parameter in der Anfrage?
foreach (array_diff(array_keys($request->query->all()), ["married", "children", "salary"]) as $parameter) {
    $errors[] = "invalid parameter [$parameter]";
}
// Fehler?
if ($errors !== []) {
    // wir senden den Fehlercode 400 an den Client
    $response->setStatusCode(Response::HTTP_BAD_REQUEST);
    $response->setData(["response" => ["errors" => $errors]]);
    $response->send();
    exit;
}

// wir haben alles, was wir zum Arbeiten brauchen
// Aufbau der Architektur des Servers
try {
    // Erstellen der [dao]-Schicht
    $dao = new ServerDao(ROOT_DIRECTORY . "/" . $config["databaseFilename"]);
    // Erstellen der [business]-Schicht
    $business = new ServerBusiness($dao);
} catch (TaxException $ex) {
    // die Fehlermeldung eines DBMS-Treibers ist möglicherweise nicht UTF-8-codiert (unter Windows Windows-1252)
    $message = $ex->getMessage();
    if (!mb_check_encoding($message, "UTF-8")) {
        $message = mb_convert_encoding($message, "UTF-8", "Windows-1252");
    }
    // wir senden den Fehlercode 500 an den Client
    $response->setStatusCode(Response::HTTP_INTERNAL_SERVER_ERROR);
    $response->setData(["response" => ["error" => $message]]);
    $response->send();
    exit;
}
// Steuerberechnung
$result = $business->calculateTax($married, $values["children"], $values["salary"]);
// wir geben die Antwort zurück
$response->setData(["response" => $result]);
$response->send();

Kommentare

  • Zeilen 10–12: Die Klassen der Bibliothek [HttpFoundation], die verwendet werden, werden deklariert;
  • Zeile 15: Das Stammverzeichnis des Servers ist das Verzeichnis des Skripts;
  • Zeile 20: Die Konfigurationsdatei wird geladen;
  • Zeilen 23–26: Wir laden den Class Loader von [Composer] und dann alle Dateien der Anwendung;
  • Zeile 29: Wir bereiten eine JSON-Antwort vor. Die Klasse [JsonResponse] ist eine Unterklasse von [Response]: Ihre Methode [setData] codiert das übergebene Array in JSON und verwendet es als Antwortrumpf. Sie setzt außerdem den HTTP-Header [Content-Type: application/json];
  • Zeile 31: Die Optionen der Funktion [json_encode], die von [setData] verwendet wird. Mit [JSON_UNESCAPED_UNICODE] werden Zeichen mit Akzent nicht als [\uXXXX] codiert. Mit [JSON_PRESERVE_ZERO_FRACTION] wird der tatsächliche Steuersatz [0.0] als [0.0] und nicht als [0] geschrieben: Der Client decodiert ihn dann als Gleitkommazahl (float) und nicht als ganze Zahl;
  • Zeilen 36–37: Wir rufen die vom Client gesendeten Zugangsdaten ab, wie im vorherigen Kapitel;
  • Zeilen 39–43: Wir prüfen, ob der Benutzer tatsächlich zu den autorisierten Benutzern gehört. Die Funktion [array_any] (PHP 8.4) liefert [true] , wenn mindestens ein Element des Arrays [$config["users"]] die Bedingung erfüllt, die durch die übergebene Arrow-Funktion ausgedrückt wird. Sie ersetzt die [while]-Schleife des PHP-7-Skripts. Passwörter werden mit [hash_equals] verglichen;
  • Zeilen 44–52: Ist dies nicht der Fall, wird der HTTP-Code [401 Unauthorized] gesendet, der anzeigt, dass der Zugriff verweigert wurde. Beim Empfang dieses Codes und des HTTP-Headers [WWW-Authenticate: Basic realm=…] zeigen Browser ein Authentifizierungsfenster an, das den Benutzer zur Authentifizierung auffordert;
  • Zeile 49: Die JSON-Antwort des Servers erklärt die Ursache des Fehlers. Alle Serverantworten sind der JSON-String eines Arrays [["response" => something]]. Das PHP-7-Skript gab den abgelehnten Benutzernamen und das Passwort an den Client zurück. Ein Passwort darf niemals zurückgegeben oder in Logs geschrieben werden: Wir geben nur den Benutzernamen zurück;
  • Zeilen 56–88: Wir prüfen die Gültigkeit der Anfrage:
    • eine GET-Anfrage mit genau drei Parametern;
    • ein Parameter [married] , dessen Wert [yes] oder [no] sein muss;
    • ein Parameter [children], dessen Wert eine ganze Zahl >= 0 sein muss;
    • ein Parameter [salary], dessen Wert eine ganze Zahl größer oder gleich 0 sein muss;
    • keine weiteren Parameter;
  • Zeile 59: Jedes Mal, wenn ein Fehler erkannt wird, wird dem Array [$errors] eine Fehlermeldung hinzugefügt;
  • Zeile 65: Die Methode [getString] des Objekts [$request->query] liefert den Parameterwert als Zeichenkette;
  • Zeile 72: Für die Parameter [children] und [salary] gilt dieselbe Regel: Sie werden in derselben Schleife geprüft. Ihre in ganze Zahlen umgewandelten Werte werden im Array [$values] abgelegt;
  • Zeile 85: Die Funktion [array_diff] liefert die Namen der empfangenen Parameter, die nicht in der Liste [married, children, salary] stehen;
  • Zeile 89: Tritt ein Fehler auf, wird der HTTP-Code [400 Bad Request] an den Client gesendet. Die JSON-Antwort enthält die Liste der Fehler;
  • Zeilen 99–104: Ab diesem Punkt ist die Anfrage validiert. Die Schichten [dao, business] können nun instanziiert werden. Diese Instanziierung verursacht Kosten (Lesen der Datenbank) und sollte nur erfolgen, wenn Sie sicher sind, dass die Anfrage gültig ist. Die Konstruktion der Schicht [dao] kann eine Exception vom Typ [TaxException] auslösen;
  • Zeilen 106–108: Die Fehlermeldung stammt häufig vom PDO-Treiber des DBMS. Unter Windows kann sie mitunter in Windows-1252 statt in UTF-8 codiert sein. Die Funktion [json_encode] akzeptiert jedoch nur UTF-8-Strings: [JsonResponse] würde dann eine Exception auslösen. Die Funktion [mb_check_encoding] prüft die Codierung des Strings, und die Funktion [mb_convert_encoding] konvertiert ihn bei Bedarf. Das PHP-7-Skript verwendete die Funktion [utf8_encode], die seit PHP 8.2 veraltet ist;
  • Zeile 111: Ist eine Exception aufgetreten, wird der HTTP-Code [500 Internal Server Error] an den Client gesendet. Dieser Code zeigt an, dass der Server eine gültige Anfrage nicht verarbeiten konnte. Die Antwort erklärt die Ursache des Fehlers;
  • Zeile 117: Die Steuerberechnung wird an die Schicht [business] delegiert;
  • Zeilen 119–120: Die Antwort wird mit dem Standardstatuscode [200 OK] gesendet.

Testen wir dieses Skript. Fordern Sie in einem Browser die URL [http://localhost/php8-oct-2026/scripts-web/tax/version-08/tax-server.php?married=yes&children=2&salary=55555] an. Der Browser zeigt sein Authentifizierungsfenster an, in das Sie [admin] und [admin] eingeben. Anschließend zeigt er die Antwort des Servers an: JSON. Lehnt der Server diese Zugangsdaten ab, lesen Sie den Abschnitt „Wenn der Server immer mit 401 antwortet“ im vorherigen Kapitel.

18.2.4.1. Warum [http] und nicht [https]?

Der Client sendet seine Zugangsdaten: Streng genommen müsste die URL gesichert sein ([https]), wie wir im vorherigen Kapitel gesehen haben. Moderne Browser ([Chrome], [Edge], [Firefox]) akzeptieren eine HTTPS-Seite jedoch nur, wenn das Serverzertifikat von einer Zertifizierungsstelle ausgestellt wurde, der sie vertrauen. Das Zertifikat, das [Laragon] für [localhost] erzeugt, ist selbstsigniert: Niemand bürgt dafür. Je nach Browserversion und Zustand seines Caches zeigt der Browser entweder eine Warnung mit einem Link ([Proceed to localhost (unsafe)]) an oder weigert sich, die Seite zu laden, ohne die Möglichkeit zum Fortfahren anzubieten. Das geschieht, wenn der Browser vermerkt hat, dass [localhost] stets mit einem gültigen Zertifikat ausgeliefert werden muss (HSTS-Mechanismus), oder wenn er das Zertifikat als nicht konform einstuft. Die im vorherigen Kapitel beschriebenen Lösungen (das Zertifikat von [Laragon] zum Zertifikatspeicher von [Windows] hinzuzufügen, die HSTS-Regel zu löschen) reichen nicht immer aus.

Wir verwenden daher im Browser die ungesicherte URL [http://localhost/...]. Das ist hier keine Sicherheitslücke: Eine Anfrage an [localhost] verlässt den Rechner nie (sie läuft über die interne Netzwerkschnittstelle, die als „Loopback“-Schnittstelle bekannt ist), und keine Spionagesoftware kann sie im Netzwerk abfangen. Webbrowser wissen das übrigens: Sie behandeln [http://localhost] als vertrauenswürdigen Ursprung. Sobald der Server jedoch über das Netzwerk erreichbar ist – und erst recht in einer Produktionsumgebung –, ist das HTTPS-Protokoll unverzichtbar, zusammen mit einem gültigen Zertifikat einer anerkannten Stelle (zum Beispiel kostenlos von [Let's Encrypt]).

Die Clients, die wir schreiben, sind jedoch keine Browser: Der Befehl [curl] (Option [-k]) und der Symfony-Client [HttpClient] (Optionen [verify_peer] bis [false]) können das selbstsignierte Zertifikat von [Laragon] akzeptieren. Dies setzt jedoch voraus, dass das HTTPS-Protokoll in [Laragon] aktiviert wurde (Menü [Apache / SSL / Enabled]), was standardmäßig nicht der Fall ist, und dass dieses Zertifikat auf dem Rechner verwendbar ist. Damit die Beispiele bei jeder Installation von [Laragon] funktionieren, verwenden wir in diesem und in den folgenden Kapiteln daher durchgehend URLs [http://localhost/...]: im Browser, in den Befehlen [curl] und in den Konfigurationsdateien der Clients (Schlüssel [urlServer]). Um auf HTTPS umzustellen, ersetzen Sie einfach [http] durch [https] in diesen URLs und fügen Sie die Option [-k] zu den [curl]-Befehlen hinzu: Die Konfigurationsdateien der Clients enthalten bereits die notwendigen Optionen [verify_peer] und [verify_host], die bei Verwendung von [http] keine Wirkung haben. Die Ergebnisse sind bei beiden Schemata dieselben.

Führen wir dieselbe Abfrage mit [curl] aus. Nicht-ASCII-Zeichen in einer URL müssen codiert werden: Das Zeichen [é] wird beispielsweise als [%C3%A9] codiert (seine beiden Bytes in UTF-8). Ein Browser nimmt diese Codierung selbst vor:

> curl -i -u admin:admin "http://localhost/php8-oct-2026/scripts-web/tax/version-08/tax-server.php?married=yes&children=2&salary=55555"
HTTP/1.0 200 OK
Date: Fri, 02 Oct 2026 12:29:49 GMT
Server: Apache/2.4.58 (Ubuntu)
X-Powered-By: PHP/8.5.11
Cache-Control: no-cache, private
Connection: close
Content-Type: application/json

{"response":{"tax":2814,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}}
  • Zeile 2: der Code [200 OK];
  • Zeile 8: der HTTP-Header [Content-Type: application/json] , definiert durch die Klasse [JsonResponse];
  • Zeile 10: Die JSON-Antwort des Servers.

Ohne Anmeldedaten (keine Option [-u]) wird der Code [401 Unauthorized] zurückgegeben:

> curl -i "http://localhost/php8-oct-2026/scripts-web/tax/version-08/tax-server.php?married=yes&children=2&salary=55555"
HTTP/1.0 401 Unauthorized
Date: Fri, 02 Oct 2026 12:29:49 GMT
Server: Apache/2.4.58 (Ubuntu)
X-Powered-By: PHP/8.5.11
Cache-Control: no-cache, private
WWW-Authenticate: Basic realm="Tax calculation server"
Connection: close
Content-Type: application/json

{"response":{"error":"Authentication failed []"}}

Führen wir einige Fehlertests durch. Wir rufen die URL [http://localhost/php8-oct-2026/scripts-web/tax/version-08/tax-server.php?married=x&children=x&salary=x&w=x] auf:

> curl -i -u admin:admin "http://localhost/php8-oct-2026/scripts-web/tax/version-08/tax-server.php?married=x&children=x&salary=x&w=x"
HTTP/1.0 400 Bad Request
Date: Fri, 02 Oct 2026 12:29:49 GMT
Server: Apache/2.4.58 (Ubuntu)
X-Powered-By: PHP/8.5.11
Cache-Control: no-cache, private
Connection: close
Content-Type: application/json

{"response":{"errors":["GET method required with only the parameters [married, children, salary]","invalid married parameter [x]","invalid children parameter [x]","invalid salary parameter [x]","invalid parameter [w]"]}}

Eine POST-Anfrage ohne Parameter (Option [-X POST] von [curl]):

> curl -i -u admin:admin -X POST "http://localhost/php8-oct-2026/scripts-web/tax/version-08/tax-server.php"
HTTP/1.0 400 Bad Request
Date: Fri, 02 Oct 2026 12:29:49 GMT
Server: Apache/2.4.58 (Ubuntu)
X-Powered-By: PHP/8.5.11
Cache-Control: no-cache, private
Connection: close
Content-Type: application/json

{"response":{"errors":["GET method required with only the parameters [married, children, salary]","missing married parameter","missing children parameter","missing salary parameter"]}}

Simulieren wir nun einen Ausfall des DBMS. Wir könnten MySQL im Fenster von [Laragon] beenden. Stattdessen haben wir den DSN-Eintrag in der Datei [database-mysql.json] auf [mysql:host=127.0.0.1;port=3307;dbname=dbtaxes-2019;charset=utf8mb4] geändert: Auf Port 3307 lauscht kein DBMS, und der Verbindungsaufbau wird abgelehnt, genau wie bei einem beendeten MySQL:

> curl -i -u admin:admin "http://localhost/php8-oct-2026/scripts-web/tax/version-08/tax-server.php?married=yes&children=3&salary=60000"
HTTP/1.0 500 Internal Server Error
Date: Fri, 02 Oct 2026 12:29:50 GMT
Server: Apache/2.4.58 (Ubuntu)
X-Powered-By: PHP/8.5.11
Cache-Control: no-cache, private
Connection: close
Content-Type: application/json

{"response":{"error":"Database access error (SQLSTATE[HY000] [2002] Connection refused)"}}
  • Zeile 2: der Code [500 Internal Server Error];
  • Zeile 10: die Ausnahmemeldung [TaxException] , ausgelöst von der Schicht [dao]. Unter Windows ist die Meldung des Treibers auf Französisch: [Aucune connexion n'a pu être établie car l'ordinateur cible l'a expressément refusée].

Stellen Sie anschließend den ursprünglichen DSN wieder her.

18.2.5. [PHPUnit]-Tests

Bei jeder neuen Version des Servers testen wir die Schichten [dao] und [business], wie schon seit Version 4. Diese Tests laufen nicht über den Webserver: Sie bauen die Schichten [dao] und [business] genauso auf wie das Serverskript und testen sie direkt. Sie befinden sich im Ordner [Tests] des Servers. Der PHP-7-Kurs verwendete das Test-Framework [Codeception]; wir verwenden [PHPUnit], wie in den vorherigen Kapiteln.

18.2.5.1. [dao]-Schicht: Tests

Der Test [Tests/ServerDaoTest.php] sieht wie folgt aus:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter und -ergebnisse
declare(strict_types=1);

// Namespace der Tests
namespace Application\Tests;

// die getestete Klasse
use Application\ServerDao;
// die PHPUnit-Klassen
use PHPUnit\Framework\TestCase;

final class ServerDaoTest extends TestCase
{
    // der Wurzelordner des Servers
    private const string ROOT_DIRECTORY = __DIR__ . "/..";
    // die Konfiguration des Servers
    private static array $config;

    // einmal vor dem ersten Test der Klasse ausgeführt
    #[\Override]
    public static function setUpBeforeClass(): void
    {
        // wir rufen die Konfiguration des Servers ab
        self::$config = json_decode(file_get_contents(self::ROOT_DIRECTORY . "/Data/config-server.json"), true, flags: JSON_THROW_ON_ERROR);
        // wir binden die Abhängigkeiten des Servers ein
        foreach (self::$config["dependencies"] as $dependency) {
            require_once self::ROOT_DIRECTORY . "/$dependency";
        }
    }

    // die aus der Datenbank gelesenen Daten der Steuerverwaltung
    public function testTaxAdminData(): void
    {
        // Erstellen der [dao]-Schicht wie im Serverskript
        $dao = new ServerDao(self::ROOT_DIRECTORY . "/" . self::$config["databaseFilename"]);
        $taxAdminData = $dao->getTaxAdminData();
        // Berechnungskonstanten
        $this->assertSame(1551.0, $taxAdminData->halfShareQfCeiling);
        $this->assertSame(21037.0, $taxAdminData->singleIncomeCeilingForReduction);

Anmerkungen

  • Zeilen 23–31: Wir richten dieselbe Arbeitsumgebung ein wie im Serverskript [tax-server.php]: Lesen der Konfigurationsdatei und Laden der Anwendungsdateien. Der Klassenlader von [Composer] muss nicht geladen werden: [PHPUnit] hat das bereits erledigt;
  • Zeile 37: Wir erzeugen eine Instanz der zu testenden Schicht [dao], genau wie im Serverskript;
  • Ab hier sind die Bedingungen dieselben wie im Serverskript: Der Rest der Methode [testTaxAdminData], der hier nicht wiedergegeben ist, entspricht dem Test [DaoTest] der Versionen 5 bis 7.

18.2.5.2. Tests der Schicht [business]

Der Test [Tests/ServerBusinessTest.php] sieht wie folgt aus:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter und -ergebnisse
declare(strict_types=1);

// Namespace der Tests
namespace Application\Tests;

// die getesteten Klassen
use Application\InterfaceServerBusiness;
use Application\ServerDao;
use Application\ServerBusiness;
// die PHPUnit-Klassen
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;

final class ServerBusinessTest extends TestCase
{
    // der Wurzelordner des Servers
    private const string ROOT_DIRECTORY = __DIR__ . "/..";
    // die Konfiguration des Servers
    private static array $config;
    // die getestete Schicht [business]
    private InterfaceServerBusiness $business;

    // einmal vor dem ersten Test der Klasse ausgeführt
    #[\Override]
    public static function setUpBeforeClass(): void
    {
        // wir rufen die Konfiguration des Servers ab
        self::$config = json_decode(file_get_contents(self::ROOT_DIRECTORY . "/Data/config-server.json"), true, flags: JSON_THROW_ON_ERROR);
        // wir binden die Abhängigkeiten des Servers ein
        foreach (self::$config["dependencies"] as $dependency) {
            require_once self::ROOT_DIRECTORY . "/$dependency";
        }
    }

    // wird vor jedem Test ausgeführt
    #[\Override]
    protected function setUp(): void
    {
        // Erstellen der [dao]- und der [business]-Schicht wie im Serverskript
        $dao = new ServerDao(self::ROOT_DIRECTORY . "/" . self::$config["databaseFilename"]);
        $this->business = new ServerBusiness($dao);
    }

    // die Steuerpflichtigen der Tabelle mit den offiziellen Zahlen
    public static function taxpayers(): array

Anmerkungen

  • Zeilen 28–36: Wir richten dieselbe Arbeitsumgebung ein wie im Serverskript;
  • Zeilen 40–44: Vor jedem Test wird eine Instanz der zu testenden Schicht [business] erzeugt, wie im Serverskript;
  • Der Rest des Tests, der hier nicht wiedergegeben ist, entspricht dem Test [BusinessTest] der Versionen 4 bis 7: ein Data Provider [taxpayers] mit den 11 Steuerpflichtigen aus der Tabelle der offiziellen Zahlen und die Methode [testCalculateTax].

Die Testergebnisse sehen wie folgt aus (das DBMS MySQL muss laufen):

> php vendor/bin/phpunit scripts-web/tax/version-08/Tests --testdox
PHPUnit 12.5.37 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.5.11
Configuration: .../php8-oct-2026/phpunit.xml

............                                                      12 / 12 (100%)

Time: 00:00.014, Memory: 16.00 MB

Server Business (Application\Tests\ServerBusiness)
 ✔ Calculate tax with data set "couple, 2 children, 55555"
 ✔ Calculate tax with data set "couple, 2 children, 50000"
 ✔ Calculate tax with data set "couple, 3 children, 50000"
 ✔ Calculate tax with data set "single, 2 children, 100000"
 ✔ Calculate tax with data set "single, 3 children, 100000"
 ✔ Calculate tax with data set "couple, 3 children, 100000"
 ✔ Calculate tax with data set "couple, 5 children, 100000"
 ✔ Calculate tax with data set "single, 0 children, 100000"
 ✔ Calculate tax with data set "couple, 2 children, 30000"
 ✔ Calculate tax with data set "single, 0 children, 200000"
 ✔ Calculate tax with data set "couple, 3 children, 200000"

Server Dao (Application\Tests\ServerDao)
 ✔ Tax admin data

OK (12 tests, 35 assertions)

18.3. Der Client

Wir konzentrieren uns auf die Client-Seite der Anwendung.

Image

Diese Architektur wird durch die folgenden Dateien umgesetzt:

scripts-console/tax/version-08
├── Business
│   ├── ClientBusiness.php
│   └── InterfaceClientBusiness.php
├── Dao
│   ├── ClientDao.php
│   └── InterfaceClientDao.php
├── Data
│   ├── config-client-ko.json
│   ├── config-client-unreachable.json
│   ├── config-client.json
│   ├── errors.json
│   ├── results.json
│   └── taxpayersdata.json
├── Main
│   └── MainTaxClient.php
└── Tests
    └── ClientBusinessTest.php

18.3.1. Zwischen den Schichten ausgetauschte Entitäten

Die Entitäten des Clients sind alle bereits beschrieben und werden schon in Version 5 verwendet:

  • die Ausnahme [TaxException];
  • die Daten des Steuerpflichtigen [TaxPayerData].

Wie der Server lädt der Client sie aus dem Ordner von Version 5, zusammen mit der Klasse [Utilities] und dem Trait [TraitDao].

18.3.2. Die [dao]-Schicht

Die Schicht [dao] implementiert die folgende Schnittstelle [InterfaceClientDao]:

<?php

declare(strict_types=1);

// Namespace
namespace Application;

// das Interface der [dao]-Schicht des Clients
// alle Methoden werfen im Fehlerfall eine Exception [TaxException]
interface InterfaceClientDao
{
    // Lesen der Daten der Steuerzahler
    // die fehlerhaften Daten werden in der JSON-Datei [$errorsFilename] gemeldet
    /** @return TaxPayerData[] */
    public function getTaxPayersData(string $taxPayersFilename, string $errorsFilename): array;

    // Berechnung der Steuer eines Steuerzahlers durch den Server
    // gibt das Array [tax, surcharge, discount, reduction, rate] zurück
    public function calculateTax(string $married, int $children, int $salary): array;

    // Speichern der Ergebnisse
    /** @param TaxPayerData[] $taxPayersData */
    public function saveResults(string $resultsFilename, array $taxPayersData): void;
}
  • Zeile 15: Die Methode [getTaxPayersData] lädt die Daten der Steuerpflichtigen aus der JSON-Datei [$taxPayersFilename] in den Speicher. Treten Fehler auf, werden sie in der JSON-Datei [$errorsFilename] protokolliert;
  • Zeile 19: Die Methode [calculateTax] berechnet die Steuer eines Steuerpflichtigen;
  • Zeile 23: Die Methode [saveResults] speichert die Daten des Arrays [$taxPayersData]—, das die Ergebnisse mehrerer Steuerberechnungen enthält, in der Datei [$resultsFilename].

Die Methoden [getTaxPayersData] und [saveResults] gehören in Version 5 zur Schnittstelle [InterfaceDao]. Die Schnittstelle [InterfaceClientDao] wird von der folgenden Klasse [ClientDao] implementiert:

<?php

declare(strict_types=1);

// Namespace
namespace Application;

// Abhängigkeiten von Symfony
use Symfony\Component\HttpClient\HttpClient;
use Symfony\Contracts\HttpClient\Exception\ExceptionInterface;
use Symfony\Contracts\HttpClient\HttpClientInterface;

// die [dao]-Schicht des Clients: ein HTTP-Client des Steuerberechnungsservers
class ClientDao implements InterfaceClientDao
{
    // der Trait aus Version 5 implementiert die Methoden [getTaxPayersData] und [saveResults] des Interfaces
    use TraitDao;

    // der HTTP-Client
    private readonly HttpClientInterface $httpClient;

    // Konstruktor
    // $urlServer: die URL des Steuerberechnungsservers
    // $user: der Benutzer, der die Anfragen stellt, Array [login, passwd]
    // $httpClientOptions: zusätzliche Optionen des HTTP-Clients (verify_peer, verify_host...)
    public function __construct(
        private readonly string $urlServer,
        #[\SensitiveParameter] array $user,
        array $httpClientOptions = [],
    ) {
        // der HTTP-Client: die Zugangsdaten des Benutzers werden mit jeder Anfrage gesendet
        $this->httpClient = HttpClient::create([
            ...$httpClientOptions,
            "auth_basic" => [$user["login"], $user["passwd"]],
        ]);
    }

    // Steuerberechnung durch den Server
    #[\Override]
    public function calculateTax(string $married, int $children, int $salary): array
    {
        try {
            // wir stellen die Anfrage an den Server
            $response = $this->httpClient->request("GET", $this->urlServer, [
                "query" => [
                    "married" => $married,
                    "children" => $children,
                    "salary" => $salary,
                ],
            ]);
            // der Status der Antwort
            $statusCode = $response->getStatusCode();
            // das JSON-Dokument der Antwort, auch wenn der Status ein Fehlercode ist (Parameter false)
            $json = $response->getContent(false);
        } catch (ExceptionInterface $ex) {
            // der Server war nicht erreichbar
            throw new TaxException("Error communicating with the server ({$ex->getMessage()})", 40, $ex);
        }
        // Logs
        // print "$json\n";
        // der Server sendet den JSON-String eines Arrays ["response" => etwas]
        try {
            $serverResponse = json_decode($json, true, flags: JSON_THROW_ON_ERROR)["response"] ?? null;
        } catch (\JsonException $ex) {
            $serverResponse = null;
        }
        if (!is_array($serverResponse)) {
            throw new TaxException("Invalid server response [$json]", 41);
        }
        // Fehler?
        if ($statusCode !== 200) {
            // wir werfen eine Exception, deren Nachricht die um ihren HTTP-Status ergänzte Antwort des Servers ist
            $message = json_encode(
                ["HTTP status" => $statusCode] + $serverResponse,
                JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR
            );
            throw new TaxException($message, 42);
        }
        // wir geben die Antwort zurück: das Array [tax, surcharge, discount, reduction, rate]
        return $serverResponse;
    }
}

Anmerkungen

  • Zeile 17: Wir binden den Trait [TraitDao] aus Version 5 ein, der die Methoden [getTaxPayersData] und [saveResults] implementiert. Damit bleibt nur noch die Methode [calculateTax] zu implementieren;
  • Zeile 20: der HTTP-Client von [Symfony] mit dem Schnittstellentyp [HttpClientInterface];
  • Zeilen 26–30: Der Konstruktor der Klasse [ClientDao] erwartet drei Parameter:
    • die URL [$urlServer] des Steuerberechnungsservers. Dies ist ein Parameter, der zu einem Attribut hochgestuft wird (Constructor Property Promotion);
    • das Array [$user] mit den Schlüsseln [login] und [passwd], das den Benutzer definiert, der die Anfragen stellt. Das Attribut [#[\SensitiveParameter]] (PHP 8.2) weist PHP an, den Wert dieses Parameters in den bei einem Fehler angezeigten Stack-Traces zu verbergen: Das Passwort erscheint dort nicht;
    • zusätzliche Optionen für den HTTP-Client;
  • Zeilen 32–35: Der HTTP-Client wird einmalig mit den erhaltenen Optionen erstellt, die um die Option [auth_basic] ergänzt werden: Die Anmeldedaten des Benutzers werden bei jeder Anfrage gesendet. Der Operator [...] kopiert die Elemente des Arrays [$httpClientOptions] in das Optionen-Array. Der PHP-7-Client erstellte für jede Anfrage einen neuen HTTP-Client;
  • Zeile 40: Die Methode [calculateTax] erhält die drei Parameter, die an den Steuerberechnungsserver gesendet werden sollen;
  • Zeilen 44–50: Der Server wird mit den drei Parametern abgefragt, die er erwartet. Die Option [query] hängt diese Parameter nach ihrer Codierung an die URL an;
  • Zeile 54: Die JSON-Antwort des Servers wird abgerufen. Wird der Parameter [false] nicht an die Methode [getContent] übergeben, löst der HTTP-Client eine Ausnahme aus, sobald versucht wird, den Inhalt der Antwort abzurufen, falls der Status der Serverantwort einen Fehler anzeigt (Codes 3xx–5xx). Hier wollen wir unabhängig vom HTTP-Status der Antwort auf deren Inhalt zugreifen, was die Angabe erklärt;
  • Zeilen 55–57: Wenn der Server nicht erreicht werden konnte, löst der HTTP-Client eine Ausnahme [ExceptionInterface] aus. Wir wandeln sie in eine Ausnahme [TaxException] um: So müssen die oberen Schichten des Clients nur einen Ausnahmetyp behandeln;
  • Zeile 60: Im Entwicklungsmodus kann die JSON-Antwort des Servers angezeigt werden;
  • Zeilen 63–68: Die Antwort des Servers ist der JSON-String eines Arrays [["response" => something]]. Wir rufen das [something] ab. Ist das empfangene Dokument kein JSON (zum Beispiel eine HTML-Fehlerseite von Apache), lösen wir eine Ausnahme [TaxException] aus;
  • Zeilen 71–77: Ist der HTTP-Statuscode nicht 200, ist beim Server ein Problem aufgetreten. Dann wird eine Ausnahme vom Typ [TaxException] ausgelöst, deren Meldung aus der JSON-Antwort des Servers besteht, ergänzt um den HTTP-Antwortcode. Der Operator [+] verbindet zwei assoziative Arrays;
  • Zeile 80: Das Ergebnis wird als assoziatives Array mit den Schlüsseln [tax, surcharge, discount, reduction, rate] zurückgegeben.

18.3.3. Die [business]-Schicht

Die Schicht [business] [8] implementiert die folgende Schnittstelle [InterfaceClientBusiness]:

<?php

declare(strict_types=1);

// Namespace
namespace Application;

// das Interface der [business]-Schicht des Clients
interface InterfaceClientBusiness
{
    // Berechnung der Steuer eines Steuerpflichtigen
    // gibt das Array [tax, surcharge, discount, reduction, rate] zurück
    public function calculateTax(string $married, int $children, int $salary): array;

    // Berechnung der Steuern im Batch-Modus
    // kann eine [TaxException] werfen, die aus der Schicht [dao] aufsteigt
    public function executeBatchTaxes(string $taxPayersFileName, string $resultsFileName, string $errorsFileName): void;
}
  • Zeile 13: Die Methode [calculateTax] berechnet die Steuer;
  • Zeile 17: Die Methode [executeBatchTaxes] berechnet die Steuer der Steuerpflichtigen, deren Daten in der Datei [$taxPayersFileName] stehen, schreibt die Ergebnisse in die Datei [$resultsFileName] und schreibt etwaige aufgetretene Fehler in die Datei [$errorsFileName].

Dies sind die beiden Methoden der Schnittstelle [InterfaceBusiness] aus Version 5. Die Schnittstelle [InterfaceClientBusiness] wird von der folgenden Klasse [ClientBusiness] implementiert:

<?php

declare(strict_types=1);

// Namespace
namespace Application;

// die [business]-Schicht des Clients: die Steuerberechnung erfolgt durch den Server
class ClientBusiness implements InterfaceClientBusiness
{
    // die Schicht [dao] wird vom Konstruktor injiziert
    public function __construct(private readonly InterfaceClientDao $clientDao)
    {
    }

    // Steuerberechnung: sie wird an die [dao]-Schicht delegiert, die den Server abfragt
    #[\Override]
    public function calculateTax(string $married, int $children, int $salary): array
    {
        return $this->clientDao->calculateTax($married, $children, $salary);
    }

    // Berechnung der Steuern im Batch-Modus
    #[\Override]
    public function executeBatchTaxes(string $taxPayersFileName, string $resultsFileName, string $errorsFileName): void
    {
        // wir lassen die Exceptions aus der Schicht [dao] aufsteigen
        // wir rufen die Steuerpflichtigendaten ab
        $taxPayersData = $this->clientDao->getTaxPayersData($taxPayersFileName, $errorsFileName);
        // wir berechnen die Steuer jedes Steuerpflichtigen
        $results = array_map(
            fn(TaxPayerData $taxPayerData): TaxPayerData => $taxPayerData->withResults(
                $this->calculateTax($taxPayerData->married, $taxPayerData->children, $taxPayerData->salary)
            ),
            $taxPayersData
        );
        // Speichern der Ergebnisse
        $this->clientDao->saveResults($resultsFileName, $results);
    }
}

Anmerkungen

  • Zeile 12: Der Konstruktor der Klasse [ClientBusiness] erhält als Parameter eine Referenz auf die Schicht [dao];
  • Zeilen 18–20: Die Steuerberechnung wird an die Schicht [dao] delegiert;
  • Zeilen 25–38: Die Methode [executeBatchTaxes] ist die der Klasse [Business] aus Version 5.

18.3.4. Das Hauptskript

Das Clientskript [Main/MainTaxClient.php] setzt die Schichten [console] und [9] um. Es wird durch die folgende JSON-Datei [Data/config-client.json] konfiguriert:

{
    "urlServer": "http://localhost/php8-oct-2026/scripts-web/tax/version-08/tax-server.php",
    "user": {
        "login": "admin",
        "passwd": "admin"
    },
    "httpClientOptions": {
        "verify_peer": false,
        "verify_host": false
    },
    "taxPayersDataFilename": "Data/taxpayersdata.json",
    "resultsFilename": "Data/results.json",
    "errorsFilename": "Data/errors.json",
    "dependencies": [
        "../version-05/Entities/TaxException.php",
        "../version-05/Entities/TaxPayerData.php",
        "../version-05/Utilities/Utilities.php",
        "../version-05/Dao/TraitDao.php",
        "Dao/InterfaceClientDao.php",
        "Dao/ClientDao.php",
        "Business/InterfaceClientBusiness.php",
        "Business/ClientBusiness.php"
    ]
}
  • Zeile 2: die URL des Steuerberechnungsservers. Sie verwendet das Schema [http]: Den Grund haben wir weiter oben gesehen;
  • Zeilen 3–6: der Benutzer, der die Anfragen an den Steuerberechnungsserver sendet;
  • Zeilen 7–9: die Optionen des HTTP-Clients. Sie werden nur bei einer URL mit [https] verwendet: Wie im vorherigen Kapitel weisen sie den Client an, das selbstsignierte Zertifikat des Servers nicht zu überprüfen. Bei einer URL mit [http] werden diese Optionen ignoriert;
  • Zeilen 11–13: die JSON-Dateien mit den Daten der Steuerpflichtigen, den Ergebnissen und den Fehlern;
  • Zeilen 14–23: die verschiedenen PHP-Dateien des Clients. Die ersten vier sind die aus Version 5.

Der Code des Skripts [MainTaxClient.php] lautet wie folgt:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter und -ergebnisse
declare(strict_types=1);

// Namespace
namespace Application;

// der Wurzelordner des Clients: die Pfade der Konfigurationsdatei sind relativ zu diesem Ordner
const ROOT_DIRECTORY = __DIR__ . "/..";
// die Konfigurationsdatei des Ordners [Data]: 1. Argument der Kommandozeile, falls vorhanden
$configFilename = ROOT_DIRECTORY . "/Data/" . ($argv[1] ?? "config-client.json");

// wir rufen die Konfiguration ab
$config = json_decode(file_get_contents($configFilename), true, flags: JSON_THROW_ON_ERROR);

// wir binden die vom Skript benötigten Abhängigkeiten ein: Bibliotheken von Drittanbietern (Symfony), dann Dateien der Anwendung
require_once ROOT_DIRECTORY . "/../../../vendor/autoload.php";
foreach ($config["dependencies"] as $dependency) {
    require_once ROOT_DIRECTORY . "/$dependency";
}

// die Pfade der Datendateien
$taxPayersDataFilename = ROOT_DIRECTORY . "/" . $config["taxPayersDataFilename"];
$resultsFilename = ROOT_DIRECTORY . "/" . $config["resultsFilename"];
$errorsFilename = ROOT_DIRECTORY . "/" . $config["errorsFilename"];

// Erzeugung der Schicht [dao]
$clientDao = new ClientDao($config["urlServer"], $config["user"], $config["httpClientOptions"]);
// Erzeugung der Schicht [business]
$clientBusiness = new ClientBusiness($clientDao);

// Steuerberechnung im Batch-Modus
try {
    $clientBusiness->executeBatchTaxes($taxPayersDataFilename, $resultsFilename, $errorsFilename);
    print "The results have been saved in the file [{$config["resultsFilename"]}]\n";
} catch (TaxException $ex) {
    // wir zeigen den Fehler an
    print "Error no. {$ex->getCode()}: {$ex->getMessage()}\n";
}
// Ende
print "Done\n";

Anmerkungen

  • Zeile 10: Das Stammverzeichnis des Clients ist das übergeordnete Verzeichnis des Ordners [Main];
  • Zeile 12: die Konfigurationsdatei im Ordner [Data]. Ihr Name kann dem Skript als Argument übergeben werden ([php MainTaxClient.php config-client-ko.json]). Andernfalls wird standardmäßig die Datei [config-client.json] verwendet. Diese Möglichkeit nutzen wir für die Fehlertests;
  • Zeilen 18–21: Laden der Abhängigkeiten: der Klassenlader von [Composer] für die Symfony-Bibliothek [HttpClient], gefolgt von den Dateien des Clients;
  • Zeile 29: Erstellung der Schicht [dao]. Wir übergeben ihr die Informationen, die der Konstruktor der Schicht erwartet:
    • die URL des Steuerberechnungsservers;
    • die Anmeldedaten des Benutzers, der die Anfragen stellt;
    • die Optionen für den HTTP-Client;
  • Zeile 31: Erstellung der Schicht [business]. Dem Konstruktor der Schicht wird eine Referenz auf die soeben erstellte Schicht [dao] übergeben;
  • Zeile 35: Die Schicht [business] wird angewiesen:
    • die Steuern aller Steuerpflichtigen in der Datei [taxpayersdata.json] zu berechnen;
    • die Ergebnisse in die Datei [results.json] zu schreiben;
    • die Fehler in die Datei [errors.json] zu schreiben;
  • Zeilen 37–39: Alle Fehler des Clients, einschließlich der Kommunikationsfehler mit dem Server, treten als Ausnahme [TaxException] auf, deren Code und Meldung angezeigt werden.

Bei laufendem Apache-Server und laufendem DBMS MySQL führen wir den Client in einem im Ordner [Main] geöffneten Terminal aus:

1
2
3
> php MainTaxClient.php
The results have been saved in the file [Data/results.json]
Done

Die Ausführung des Clients liefert dieselben Ergebnisse wie in den vorherigen Versionen. Prüfen Sie die folgenden Dateien:

  • [Data/taxpayersdata.json]: Daten der Steuerpflichtigen, für die der Steuerbetrag berechnet wird;
  • [Data/results.json]: Ergebnisse für die verschiedenen Steuerpflichtigen der Datei [Data/taxpayersdata.json]. Diese Datei ist identisch mit der Datei [results.json] aus Version 7;
  • [Data/errors.json]: Fehler, die bei der Verarbeitung der Datei [Data/taxpayersdata.json] aufgetreten sein können.

Betrachten wir die möglichen Fehlerszenarien. Zuerst ein nicht erreichbarer Server. Sie können den Apache-Server in [Laragon] beenden. Stattdessen haben wir die Konfigurationsdatei [config-client-unreachable.json] verwendet, die bis auf die URL mit der Datei [config-client.json] identisch ist: Diese gibt Port 4443 auf dem Rechner [localhost] an, auf dem kein Server auf Anfragen lauscht ([http://localhost:4443/php8-oct-2026/...]). Die Ergebnisse in der Konsole des Clients sehen dann wie folgt aus:

1
2
3
> php MainTaxClient.php config-client-unreachable.json
Error no. 40: Error communicating with the server (Failed to connect to localhost port 4443 after 0 ms: Couldn't connect to server for "http://localhost:4443/php8-oct-2026/scripts-web/tax/version-08/tax-server.php?married=yes&children=2&salary=55555".)
Done

Die vom HTTP-Client von Symfony ausgelöste Ausnahme wurde von der Schicht [dao] in eine Ausnahme [TaxException] mit dem Code 40 umgewandelt.

Simulieren wir nun einen Ausfall des DBMS MySQL, so wie wir es zuvor mit [curl] getan haben. Die Ergebnisse in der Konsole des Clients sehen wie folgt aus:

1
2
3
> php MainTaxClient.php
Error no. 42: {"HTTP status":500,"error":"Database access error (SQLSTATE[HY000] [2002] Connection refused)"}
Done

Stellen wir das DBMS wieder her und verwenden dann die Konfigurationsdatei [config-client-ko.json], in der der sich anmeldende Benutzer dem Server unbekannt ist:

1
2
3
4
    "user": {
        "login": "x",
        "passwd": "x"
    },

Die Ergebnisse in der Konsole des Clients sehen dann wie folgt aus:

1
2
3
> php MainTaxClient.php config-client-ko.json
Error no. 42: {"HTTP status":401,"error":"Authentication failed [x]"}
Done

18.3.5. [PHPUnit]-Tests

Wie bei den vorherigen Versionen schreiben wir einen Test mit [PHPUnit] für die Schicht [business] des Clients. Der Test [Tests/ClientBusinessTest.php] sieht wie folgt aus:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter und -ergebnisse
declare(strict_types=1);

// Namespace der Tests
namespace Application\Tests;

// die getesteten Klassen
use Application\ClientDao;
use Application\ClientBusiness;
use Application\InterfaceClientBusiness;
// die PHPUnit-Klassen
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;

// Test der [business]-Schicht des Clients: der Server muss laufen
final class ClientBusinessTest extends TestCase
{
    // der Wurzelordner des Clients
    private const string ROOT_DIRECTORY = __DIR__ . "/..";
    // die Konfiguration des Clients
    private static array $config;
    // die getestete Schicht [business]
    private InterfaceClientBusiness $business;

    // einmal vor dem ersten Test der Klasse ausgeführt
    #[\Override]
    public static function setUpBeforeClass(): void
    {
        // wir rufen die Konfiguration des Clients ab
        self::$config = json_decode(file_get_contents(self::ROOT_DIRECTORY . "/Data/config-client.json"), true, flags: JSON_THROW_ON_ERROR);
        // wir binden die Abhängigkeiten des Clients ein (der Composer-Autoloader wird bereits von PHPUnit geladen)
        foreach (self::$config["dependencies"] as $dependency) {
            require_once self::ROOT_DIRECTORY . "/$dependency";
        }
    }

    // wird vor jedem Test ausgeführt
    #[\Override]
    protected function setUp(): void
    {
        // Erstellen der [dao]- und der [business]-Schicht wie im Hauptskript
        $clientDao = new ClientDao(self::$config["urlServer"], self::$config["user"], self::$config["httpClientOptions"]);
        $this->business = new ClientBusiness($clientDao);
    }

Anmerkungen

  • Zeilen 29–37: Definition der Testumgebung. Wir verwenden dieselbe wie im Hauptskript [MainTaxClient.php];
  • Zeilen 41–45: Erstellung der Schichten [dao] und [business] vor jedem Test. Das Attribut [$this->business] referenziert die Schicht [business];
  • Der Rest des Tests, der hier nicht wiedergegeben ist, entspricht den vorherigen Versionen: die 11 Steuerpflichtigen aus der Tabelle der offiziellen Zahlen und die Methode [testCalculateTax]. Beachten Sie, dass die Prüfung mit [assertSame] verlangt, dass die vom Server zurückgegebenen Werte genau die erwarteten Typen haben: ganze Zahlen für Steuer, Zuschlag, Ermäßigung und Minderung; eine reelle Zahl für den Satz. Dies stellt die Option [JSON_PRESERVE_ZERO_FRACTION] des Servers sicher.

Dieser Test prüft den Client, aber auch den Server, denn der Apache-Server und das DBMS MySQL müssen laufen. Die Testergebnisse sehen wie folgt aus:

> php vendor/bin/phpunit scripts-console/tax/version-08/Tests --testdox
PHPUnit 12.5.37 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.5.11
Configuration: .../php8-oct-2026/phpunit.xml

...........                                                       11 / 11 (100%)

Time: 00:00.070, Memory: 16.00 MB

Client Business (Application\Tests\ClientBusiness)
 ✔ Calculate tax with data set "couple, 2 children, 55555"
 ✔ Calculate tax with data set "couple, 2 children, 50000"
 ✔ Calculate tax with data set "couple, 3 children, 50000"
 ✔ Calculate tax with data set "single, 2 children, 100000"
 ✔ Calculate tax with data set "single, 3 children, 100000"
 ✔ Calculate tax with data set "couple, 3 children, 100000"
 ✔ Calculate tax with data set "couple, 5 children, 100000"
 ✔ Calculate tax with data set "single, 0 children, 100000"
 ✔ Calculate tax with data set "couple, 2 children, 30000"
 ✔ Calculate tax with data set "single, 0 children, 200000"
 ✔ Calculate tax with data set "couple, 3 children, 200000"

OK (11 tests, 22 assertions)

Wir haben nun eine Client-Server-Anwendung. In der nächsten Version verbessern wir den Server: Er verwendet eine Session, protokolliert seine Vorgänge und benachrichtigt den Administrator bei einem Problem per E-Mail.