Skip to content

20. Übungsanwendung – Version 10

Die vorherige Version hat gezeigt, dass die Steuerdaten, die von allen Benutzern der Anwendung gemeinsam genutzt werden, in einem Speicher mit dem Gültigkeitsbereich [application] abgelegt werden sollten. Dazu verwenden wir einen Redis-Server (https://redis.io).

20.1. Redis

Redis ist ein Server, der Daten im Arbeitsspeicher in Form von [key, value]-Paaren speichert. Er ist sehr schnell und wird von Webanwendungen häufig als Cache verwendet, also als Speicher für Daten, deren Beschaffung aufwendig ist. Der Speicher mit dem Gültigkeitsbereich [application] wird durch einen Redis-Server umgesetzt. Die PHP-Skripte, die diesen Anwendungsspeicher benötigen, sind Clients dieses Servers:

Image

  • In [1] sendet ein (PHP-)Skript einen Befehl an den Redis-Server, zum Beispiel um den zu einem Schlüssel gehörenden Wert abzufragen;
  • In [2] antwortet der Redis-Server.

Der Redis-Server arbeitet unabhängig von den PHP-Skripten: Die dort gespeicherten Daten bleiben von einer Anfrage zur nächsten und für alle Benutzer der Anwendung verfügbar.

20.2. Redis installieren

[Laragon] enthält einen Redis-Server, der standardmäßig deaktiviert ist. Sie können ihn in den Einstellungen von [Laragon] aktivieren (Menü [Preferences], Tab [Services & Ports]), indem Sie das Kontrollkästchen [Redis] aktivieren. Belassen Sie den Port [6379] unverändert, da dies der Standardport ist, den Redis-Clients verwenden. Der Redis-Server wird dann zusammen mit den anderen Diensten von [Laragon] (Apache, MySQL ...) gestartet, wenn Sie auf die Schaltfläche [Start All] klicken.

20.3. Der Redis-Client im Befehlsmodus

Der Redis-Server kann im Befehlsmodus abgefragt werden. Öffnen Sie ein Terminal von [Laragon] und geben Sie den Befehl [redis-cli] ein, der den Client des Redis-Servers im Befehlsmodus startet. Der Client zeigt dann den Prompt [127.0.0.1:6379>] an: Er ist mit dem Redis-Server auf dem lokalen Rechner (IP-Adresse 127.0.0.1) an Port 6379 verbunden. Hier ist eine Beispielsitzung:

> redis-cli
127.0.0.1:6379> command count
(integer) 240
127.0.0.1:6379> set title "PHP 8 by example"
OK
127.0.0.1:6379> get title
"PHP 8 by example"
127.0.0.1:6379> exists title
(integer) 1
127.0.0.1:6379> del title
(integer) 1
127.0.0.1:6379> get title
(nil)
127.0.0.1:6379> exists title
(integer) 0
127.0.0.1:6379> quit
  • Zeile 3: Der Redis-Client verfügt über mehr als 200 Befehle zur Kommunikation mit dem Server. Einer davon, [command count], zeigt die genaue Anzahl der Befehle an, die in der verwendeten Version verfügbar sind;
  • Zeilen 4–7: Wir behandeln nur die Befehle, die wir in unserer PHP-Anwendung benötigen. Wir verwenden Redis nur für eines: einem Schlüssel im Speicher von Redis einen Wert zuzuordnen. Dies geschieht mit dem Redis-Befehl [set key value]. Der Wert kann anschließend mit dem Befehl [get key] abgerufen werden. Mehr brauchen wir nicht;
  • Zeilen 8–9: Der Befehl [exists] prüft, ob ein Schlüssel existiert: Er gibt 1 zurück, wenn der Schlüssel existiert, andernfalls 0;
  • Zeilen 10–11: Der Befehl [del] löscht einen Schlüssel;
  • Zeilen 12–13: Wenn Sie den Wert eines nicht existierenden Schlüssels abfragen, erhalten Sie den Wert [nil], der anzeigt, dass der Schlüssel nicht gefunden wurde;
  • Zeile 16: Um den Redis-Client zu beenden, geben Sie den Befehl [quit] ein.

Es kann notwendig sein, den gesamten Redis-Speicher zu leeren. Das geschieht mit dem Befehl [flushdb].

20.4. Einen Redis-Client für PHP installieren

Wir benötigen nun einen Redis-Client für PHP. Es gibt zwei wichtige:

  • die PHP-Erweiterung [phpredis], in C geschrieben, die der PHP-Konfiguration hinzugefügt werden muss;
  • die Bibliothek [Predis] (https://github.com/predis/predis), in PHP geschrieben, die mit [Composer] installiert wird.

Wie im PHP-7-Kurs verwenden wir [Predis] in Version 3. Es ist in der Datei [composer.json] im Ordner [php8-oct-2026] eingetragen und wurde zusammen mit den anderen Bibliotheken des Kurses mit dem Befehl [composer install] installiert. Es befindet sich im Ordner [vendor/predis/predis]. Der Klassenlader von [Composer] unterstützt es: Anders als im PHP-7-Kurs muss keine Datei [predis/autoload.php] mehr eingebunden und keine Methode [Predis\Autoloader::register] mehr aufgerufen werden.

20.5. Servercode

Der Server von Version 10 besteht aus den folgenden Dateien:

1
2
3
4
5
6
scripts-web/tax/version-10
├── Data
│   ├── .htaccess
│   ├── config-server.json
│   └── logs.txt
└── tax-server.php

Die Konfigurationsdatei [config-server.json] ändert sich wie folgt:

{
    "databaseFilename": "../version-08/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",
        "../version-08/Dao/InterfaceServerDao.php",
        "../version-08/Dao/ServerDao.php",
        "../version-09/Dao/ServerDaoWithSession.php",
        "../version-08/Business/InterfaceServerBusiness.php",
        "../version-08/Business/ServerBusiness.php",
        "../version-09/Utilities/Logger.php",
        "../version-09/Utilities/SendAdminMail.php"
    ],
    "users": [
        {
            "login": "admin",
            "passwd": "admin"
        }
    ],
    "adminMail": {
        "smtp-server": "localhost",
        "smtp-port": 1025,
        "from": "guest@localhost",
        "to": "guest@localhost",
        "subject": "tax calculation server crash",
        "tls": false,
        "attachments": []
    },
    "logsFilename": "Data/logs.txt",
    "redis": {
        "scheme": "tcp",
        "host": "127.0.0.1",
        "port": 6379
    }
}

Anmerkungen

  • Zeilen 3–15: Version 10 bringt außer dem Skript [tax-server.php] keine Neuerungen. Sie verwendet Elemente aus den Versionen 5, 8 und 9;
  • Zeilen 32–37: Verbindungsparameter des Redis-Servers: das Protokoll (tcp), der Host und der Port. Dies sind die Standardwerte von [Predis], aber es ist besser, sie in der Konfiguration anzugeben: Wenn der Redis-Server auf einen anderen Host oder Port umzieht, muss nur die Konfiguration angepasst werden.

Der Code des Servers [tax-server.php] ändert sich 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;
use Symfony\Component\HttpFoundation\Session\Session;
// Abhängigkeiten von Predis
use Predis\Client as RedisClient;
use Predis\PredisException;
// Klassenalias: die [dao]-Schicht aus Version 9 wird mit Redis verwendet
use Application\ServerDaoWithSession as ServerDaoWithRedis;

// PHP-Fehler werden nicht an den Client gesendet (sie gehen in das Log des Webservers)
ini_set("display_errors", "0");

// 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";
}

// Session: sie enthält jetzt nur noch die Kennung des authentifizierten Benutzers
$session = new Session();
$session->start();

// Erstellen der Logdatei
try {
    $logger = new Logger(ROOT_DIRECTORY . "/" . $config["logsFilename"]);
} catch (TaxException $ex) {
    // Fehler 500 ohne Logs - die Meldung darf den Dateibaum des Servers nicht preisgeben
    $message = "Failed to create the log file [{$config["logsFilename"]}]";
    doInternalServerError($message, $config["adminMail"]);
    // erledigt
    exit;
}

// 1. Log
$logger->write("---new request");

// wir rufen die aktuelle Anfrage ab
$request = Request::createFromGlobals();
// Authentifizierung nur beim 1. Mal
if (!$session->has("user")) {
    // Log
    $logger->write("Authentication in progress…");
    // 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
        sendResponse(
            ["error" => "Authentication failed [$requestUser]"],
            Response::HTTP_UNAUTHORIZED,
            ["WWW-Authenticate" => 'Basic realm="Tax calculation server"'],
            $logger
        );
        // erledigt
        exit;
    }
    // wir vermerken in der Session, dass der Benutzer authentifiziert wurde
    $session->set("user", $requestUser);
    // Log
    $logger->write("Authentication successful [$requestUser]");
} else {
    // Log
    $logger->write("Authentication taken from the session…");
}

// 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
    sendResponse(["errors" => $errors], Response::HTTP_BAD_REQUEST, [], $logger);
    // erledigt
    exit;
}
// Log
[$children, $salary] = [$values["children"], $values["salary"]];
$logger->write("valid parameters ['married'=>$married, 'children'=>$children, 'salary'=>$salary]");

// wir haben alles, was wir zum Arbeiten brauchen
// der Speicher mit [application]-Scope: ein Redis-Server
try {
    // der Redis-Client
    $redis = new RedisClient($config["redis"]);
    // wir verbinden uns sofort mit dem Server, um herauszufinden, ob er da ist
    $redis->connect();
} catch (PredisException $ex) {
    // Fehler 500
    doInternalServerError("[redis], {$ex->getMessage()}", $config["adminMail"], $logger);
    // erledigt
    exit;
}
// Erstellen der [dao]-Schicht
$json = $redis->get("taxAdminData");
if ($json === null) {
    // die Steuerdaten stammen aus der Datenbank
    $logger->write("tax data taken from the database");
    try {
        // Aufbau der [dao]-Schicht
        $dao = new ServerDaoWithRedis(ROOT_DIRECTORY . "/" . $config["databaseFilename"]);
        // wir legen den JSON-String der Steuerdaten in den Speicher mit [application]-Scope
        $redis->set("taxAdminData", (string) $dao->getTaxAdminData());
    } catch (TaxException $ex) {
        // Fehler 500
        doInternalServerError("[dao], {$ex->getMessage()}", $config["adminMail"], $logger, $redis);
        // erledigt
        exit;
    }
} else {
    // die Steuerdaten stammen aus dem Speicher mit [application]-Scope
    $taxAdminData = TaxAdminData::fromArray(json_decode($json, true, flags: JSON_THROW_ON_ERROR));
    // Instanziieren der [dao]-Schicht
    $dao = new ServerDaoWithRedis($taxAdminData);
    // Log
    $logger->write("tax data taken from Redis");
}
// Erstellen der [business]-Schicht
$business = new ServerBusiness($dao);
// Steuerberechnung
$result = $business->calculateTax($married, $children, $salary);
// wir geben die Antwort zurück
sendResponse($result, Response::HTTP_OK, [], $logger, $redis);
// Ende
exit;

// --------------------------------------------------------------------------
// schwerwiegender Fehler: eine E-Mail an den Administrator und eine 500-Antwort an den Client
function doInternalServerError(
    string $message,
    array $adminMail,
    ?Logger $logger = null,
    ?RedisClient $redis = null
): void {
    // die Fehlermeldung eines DBMS-Treibers ist möglicherweise nicht UTF-8-codiert (unter Windows Windows-1252)
    if (!mb_check_encoding($message, "UTF-8")) {
        $message = mb_convert_encoding($message, "UTF-8", "Windows-1252");
    }
    // wir senden eine E-Mail an den Administrator
    // [SendAdminMail] fängt alle Exceptions ab und protokolliert sie selbst
    (new SendAdminMail($adminMail, $logger))->send($message);
    // wir senden den Fehlercode 500 an den Client
    sendResponse(["error" => $message], Response::HTTP_INTERNAL_SERVER_ERROR, [], $logger, $redis);
}

// Senden der HTTP-Antwort an den Client
// $result: das zu sendende Array in der Form ["response" => $result]
// $statusCode: der HTTP-Status der Antwort
// $headers: der Antwort hinzuzufügende HTTP-Header
// $logger: das Log der Anwendung (null, wenn es nicht erstellt werden konnte)
// $redis: der Redis-Client (null, wenn er noch nicht erstellt wurde)
function sendResponse(
    array $result,
    int $statusCode,
    array $headers = [],
    ?Logger $logger = null,
    ?RedisClient $redis = null
): void {
    // die JSON-Antwort
    $response = new JsonResponse(null, $statusCode, $headers);
    $response->setEncodingOptions(JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_PRESERVE_ZERO_FRACTION);
    $response->setData(["response" => $result]);
    // Senden
    $response->send();
    // Log
    $logger?->write($response->getContent());
    // Schließen der Verbindung zum Redis-Server
    $redis?->disconnect();
}

Anmerkungen

  • Zeilen 15–16: die Klassen von [Predis] , die wir verwenden. Die Klasse [Predis\Client] ist der Redis-Client. Wir geben ihr den Alias [RedisClient], der in unserem Code aussagekräftiger ist. [PredisException] ist die Elternklasse aller von [Predis] ausgelösten Ausnahmen;
  • Zeile 18: Wir geben der Klasse [ServerDaoWithSession] aus Version 9 den Alias [ServerDaoWithRedis] , um die geänderte Implementierung des Serverskripts widerzuspiegeln. Die Klasse [ServerDaoWithSession] kann die Schicht [dao] aus bereits abgerufenen Steuerdaten aufbauen: Es spielt keine Rolle, ob die Daten aus einer Session oder von einem Redis-Server stammen;
  • Zeilen 38–39: Die Session bleibt erhalten. Hier sind zwei Informationen zu beachten:
    • die Tatsache, dass sich der Benutzer erfolgreich authentifiziert hat. Diese Information hat den Gültigkeitsbereich [session]: Sie ist an einen bestimmten Benutzer gebunden und gilt nicht für andere Benutzer. Sie bleibt in der Session;
    • die Daten der Steuerverwaltung. Diese Information hat den Gültigkeitsbereich [application]: Sie ist nicht an einen bestimmten Benutzer gebunden, sondern gilt für alle Benutzer. Sie wird auf dem Redis-Server gespeichert;
  • Zeilen 135–145: Erstellung des Clients [Predis], der mit den Verbindungsparametern aus der Konfigurationsdatei mit dem Redis-Server kommuniziert:
    • Zeile 140: Der Client wird sofort mit dem Server verbunden, um zu prüfen, ob dieser antwortet;
    • Schlägt die Verbindung zum Redis-Server fehl, wird eine Fehlerantwort an den Client gesendet und eine E-Mail an den Administrator der Anwendung geschickt. Der Fehlermeldung wird [[redis]] vorangestellt, um die Quelle des Fehlers anzugeben;
  • Zeile 148: Der Redis-Server wird nach dem Wert des Schlüssels [taxAdminData] gefragt. Der Client [Predis] stellt für jeden Redis-Befehl eine Methode bereit: Die Methode [get] sendet den Befehl [get taxAdminData]. Sie gibt den Wert des Schlüssels zurück oder [null] , falls er nicht existiert;
  • Zeile 149: Wird der Schlüssel nicht gefunden, werden die Steuerdaten aus der Datenbank abgerufen;
  • Zeile 156: Der Schlüssel [taxAdminData] wird im Redis-Speicher abgelegt, verknüpft mit dem JSON-String des Objekts [TaxAdminData] , das von der Schicht [dao] geliefert wurde. Die Methode [set] erwartet als Wert des Schlüssels einen String. Die Umwandlung mit [(string)] ruft die Methode [__toString] der Klasse [TaxAdminData] auf, die den JSON-String des Objekts zurückgibt. Das PHP-7-Skript überließ diese Umwandlung implizit PHP; mit [declare(strict_types=1)] ist es besser, sie auszuschreiben;
  • Zeile 159: Schlägt das Lesen aus der Datenbank fehl, wird ein 500-Fehler zurückgegeben und eine E-Mail an den Administrator gesendet; der Meldung wird [[dao]] vorangestellt;
  • Zeilen 164–169: Der Schlüssel [taxAdminData] befindet sich im Redis-Speicher. Wir wissen, dass sein Wert der JSON-String eines Objekts [TaxAdminData] ist:
    • Zeile 165: Der JSON-String wird in ein assoziatives Array dekodiert; anschließend erzeugt die statische Methode [TaxAdminData::fromArray] aus Version 5 aus diesem Array das Objekt [TaxAdminData] und prüft dabei dessen Daten;
    • Zeile 167: Die Schicht [dao] wird mit diesen Daten instanziiert;
  • Zeilen 182–187: Die Funktion [doInternalServerError] hat einen zusätzlichen Parameter, den Redis-Client, den sie an die Funktion [sendResponse] weiterreicht. Hat eine Funktion viele Parameter, werden sie je einer pro Zeile geschrieben;
  • Zeile 221: Die Funktion [sendResponse] schließt die Verbindung zum Redis-Server, sofern sie geöffnet wurde.

20.6. Clientcode

Version 10 des Clients ist mit Version 9 identisch. Die einzige Änderung betrifft die Konfigurationsdatei [config-client.json]:

{
    "urlServer": "http://localhost/php8-oct-2026/scripts-web/tax/version-10/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",
        "../version-08/Dao/InterfaceClientDao.php",
        "../version-09/Dao/ClientDao.php",
        "../version-08/Business/InterfaceClientBusiness.php",
        "../version-08/Business/ClientBusiness.php"
    ]
}
  • Zeile 2: die URL des Servers von Version 10;
  • Zeile 20: Die Schicht [dao] des Clients ist die aus Version 9.

Der Ordner [scripts-console/tax/version-10] enthält daher nur den Ordner [Data], das Hauptskript [Main/MainTaxClient.php] (das von Version 8) und das Testskript [Tests/ClientBusinessTest.php].

Bevor wir den Client ausführen, löschen wir den Schlüssel [taxAdminData] mit dem Befehl [del taxAdminData] von [redis-cli] aus dem Speicher des Redis-Servers. Führen wir dann den Client aus:

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

Die Ergebnisse entsprechen denen von Version 9. Die Logs des Servers sehen wie folgt aus:

01/10/26 18:10:12.890 : ---new request
01/10/26 18:10:12.891 : Authentication in progress…
01/10/26 18:10:12.891 : Authentication successful [admin]
01/10/26 18:10:12.891 : valid parameters ['married'=>yes, 'children'=>2, 'salary'=>55555]
01/10/26 18:10:12.907 : tax data taken from the database
01/10/26 18:10:12.909 : {"response":{"tax":2814,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}}
01/10/26 18:10:12.912 : ---new request
01/10/26 18:10:12.912 : Authentication taken from the session…
01/10/26 18:10:12.912 : valid parameters ['married'=>yes, 'children'=>2, 'salary'=>50000]
01/10/26 18:10:12.913 : tax data taken from Redis
01/10/26 18:10:12.913 : {"response":{"tax":1384,"surcharge":0,"discount":384,"reduction":347,"rate":0.14}}
01/10/26 18:10:12.916 : ---new request
…
  • Zeile 5: Bei der ersten Anfrage werden die Steuerdaten aus der Datenbank abgerufen;
  • Zeile 10: Bei der nächsten Anfrage werden die Daten aus Redis abgerufen.

Testen wir nun ein neues Fehlerszenario: Der Redis-Server ist nicht verfügbar. Wir könnten den Redis-Server in [Laragon] beenden. Stattdessen setzen wir in der Konfiguration des Servers ([redis]) den Port 6380, auf dem kein Server lauscht. Das Ergebnis in der Konsole sieht wie folgt aus:

1
2
3
> php MainTaxClient.php
Error no. 42: {"HTTP status":500,"error":"[redis], Connection refused [tcp://127.0.0.1:6380]"}
Done

Die Logs des Servers zeigen, dass der Administrator per E-Mail benachrichtigt wurde:

1
2
3
4
5
6
01/10/26 18:10:32.255 : ---new request
01/10/26 18:10:32.255 : Authentication in progress…
01/10/26 18:10:32.256 : Authentication successful [admin]
01/10/26 18:10:32.256 : valid parameters ['married'=>yes, 'children'=>2, 'salary'=>55555]
01/10/26 18:10:32.305 : Message [[redis], Connection refused [tcp://127.0.0.1:6380]] sent to guest@localhost
01/10/26 18:10:32.305 : {"response":{"error":"[redis], Connection refused [tcp://127.0.0.1:6380]"}}

Anschließend haben wir in der Konfiguration wieder den Port 6379 eingetragen.

20.7. Client-Tests mit [PHPUnit]

Die Testklasse [ClientBusinessTest] für Version 10 ist mit der von Version 9 identisch; die Testumgebung ist die des Clients von Version 10. Löschen Sie vor dem Start der Tests mit dem Client [redis-cli] den Schlüssel [taxAdminData] aus dem Speicher des Redis-Servers (Befehl [del taxAdminData]). Führen Sie nun den Test aus:

> php vendor/bin/phpunit scripts-console/tax/version-10/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.063, 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)

Sehen wir uns die Logs [logs.txt] des Servers an:

01/10/26 18:10:32.488 : ---new request
01/10/26 18:10:32.488 : Authentication in progress…
01/10/26 18:10:32.488 : Authentication successful [admin]
01/10/26 18:10:32.488 : valid parameters ['married'=>yes, 'children'=>2, 'salary'=>55555]
01/10/26 18:10:32.489 : tax data taken from the database
01/10/26 18:10:32.491 : {"response":{"tax":2814,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}}
01/10/26 18:10:32.495 : ---new request
01/10/26 18:10:32.495 : Authentication in progress…
01/10/26 18:10:32.495 : Authentication successful [admin]
01/10/26 18:10:32.495 : valid parameters ['married'=>yes, 'children'=>2, 'salary'=>50000]
01/10/26 18:10:32.496 : tax data taken from Redis
01/10/26 18:10:32.496 : {"response":{"tax":1384,"surcharge":0,"discount":384,"reduction":347,"rate":0.14}}
01/10/26 18:10:32.500 : ---new request
01/10/26 18:10:32.500 : Authentication in progress…
01/10/26 18:10:32.500 : Authentication successful [admin]
01/10/26 18:10:32.500 : valid parameters ['married'=>yes, 'children'=>3, 'salary'=>50000]
01/10/26 18:10:32.501 : tax data taken from Redis
01/10/26 18:10:32.501 : {"response":{"tax":0,"surcharge":0,"discount":720,"reduction":0,"rate":0.14}}
…

Wir haben bereits erwähnt, dass die Methode [setUp] der Testklasse vor jedem Test erneut ausgeführt wird, sodass die getestete Klasse [ClientDao] bei jedem Test mit einem nicht vorhandenen Session-Cookie instanziiert wird. Es ist also, als stünden die 11 Tests für 11 verschiedene Benutzer mit 11 verschiedenen Sessions:

  • Zeilen 2–3, 8–9, 14–15: Jeder Test authentifiziert sich selbst, weil er eine neue Session startet;
  • Zeile 5: Die Steuerdaten werden aus der Datenbank abgerufen;
  • Zeilen 11, 17: Die Steuerdaten werden aus dem Redis-Speicher abgerufen. Das zeigt deutlich, dass es einen Speicher mit dem Gültigkeitsbereich [application] gibt, der von allen Benutzern der Anwendung gemeinsam genutzt wird.

20.8. Den Inhalt des Redis-Servers anzeigen

Wir haben gesehen, dass der Redis-Server im Befehlsmodus verwaltet werden kann. Der Befehl [get taxAdminData] zeigt den Wert des Schlüssels [taxAdminData] an: Wir erkennen den JSON-String eines Objekts vom Typ [TaxAdminData]:

> redis-cli get taxAdminData
"{\"limits\":[9964,27519,73779,156244,0],\"coeffR\":[0,0.14,0.3,0.41,0.45],\"coeffN\":[0,1394.96,5798,13913.69,20163.45],\"halfShareQfCeiling\":1551,\"singleIncomeCeilingForReduction\":21037,\"coupleIncomeCeilingForReduction\":42074,\"halfShareReductionValue\":3797,\"singleDiscountCeiling\":1196,\"coupleDiscountCeiling\":1970,\"coupleTaxCeilingForDiscount\":2627,\"singleTaxCeilingForDiscount\":1595,\"tenPercentAllowanceMax\":12502,\"tenPercentAllowanceMin\":437}"

[redis-cli] zeigt den String in Anführungszeichen an und stellt jedem darin enthaltenen Anführungszeichen das Zeichen [\] voran.

Der Redis-Server lässt sich auch über eine grafische Oberfläche verwalten. Das offizielle Werkzeug ist [Redis Insight] (https://redis.io/insight), das kostenlos und für Windows verfügbar ist. Nach der Verbindung mit dem Server [127.0.0.1:6379] zeigt es die Liste der auf dem Server gespeicherten Schlüssel an. Mit einem Klick auf den Schlüssel [taxAdminData] sehen Sie seinen Wert, den das Werkzeug als JSON-Objekt darstellt. Außerdem können Sie einen Schlüssel löschen, einen neuen hinzufügen oder in einer integrierten Konsole [redis-cli]-Befehle ausführen.