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:

- 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:
| 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:
| > 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:
| > 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:
| 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.