serialize & unserialize

Teil des Abschnitts Objektorientierte Programmierung der PHP-Journey von Coddy. Lektion 49 von 91.

Wenn du ein Objekt zur Speicherung oder Übertragung in eine Zeichenkette umwandeln musst, verwendet PHP die Serialisierung. Die magischen Methoden __serialize() und __unserialize() geben dir Kontrolle darüber, welche Daten genau gespeichert werden und wie sie wiederhergestellt werden.

Die Methode __serialize() gibt ein Array mit zu serialisierenden Daten zurück, während __unserialize() dieses Array empfängt und das Objekt wiederherstellt:

<?php
class Session {
    public function __construct(
        private string $userId,
        private array $data,
        private int $createdAt
    ) {}
    
    public function __serialize(): array {
        return [
            'userId' => $this->userId,
            'data' => $this->data
        ];
    }
    
    public function __unserialize(array $data): void {
        $this->userId = $data['userId'];
        $this->data = $data['data'];
        $this->createdAt = time();
    }
    
    public function getCreatedAt(): int {
        return $this->createdAt;
    }
}

$session = new Session("user123", ["theme" => "dark"], time());
$serialized = serialize($session);

$restored = unserialize($serialized);
echo "Created at: " . $restored->getCreatedAt();

Beachte, dass createdAt von der Serialisierung ausgeschlossen wird und bei der Deserialisierung einen neuen Zeitstempel erhält. Dies ist nützlich, um vertrauliche Daten, temporäre Werte oder Ressourcen auszuschließen, die nicht serialisiert werden können, etwa Datenbankverbindungen.

Diese Methoden ersetzten in PHP 7.4 die älteren Methoden __sleep() und __wakeup() und bieten einen übersichtlicheren Ansatz, bei dem du direkt mit Daten-Arrays statt mit Eigenschaftsnamen arbeitest.

Aufgabe

Einfach

Lass uns ein Benutzerprofil-Caching-System erstellen, das veranschaulicht, wie __serialize() und __unserialize() dir Kontrolle darüber geben, welche Daten gespeichert und wie sie wiederhergestellt werden.

Du organisierst deinen Code über zwei Dateien:

UserProfile.php: Erstelle eine UserProfile-Klasse, die das Profil eines Benutzers mit Caching-Funktionen darstellt. Verwende Constructor Promotion, um private Eigenschaften für $userId (String), $username (String), $email (String) und $accessToken (String) zu definieren. Füge eine private Eigenschaft $cachedAt hinzu, die speichert, wann das Profil zwischengespeichert wurde (setze sie im Konstruktor zunächst auf "not cached"). Deine Klasse benötigt:
- __serialize(): Gibt ein Array zurück, das nur userId, username und email enthält. Der accessToken ist vertraulich und darf niemals serialisiert werden. Der Zeitstempel cachedAt wird bei der Wiederherstellung neu erzeugt.
- __unserialize(): Stellt userId, username und email aus dem Daten-Array wieder her. Setzt accessToken auf "expired" (da Token nicht dauerhaft gespeichert werden sollten).
- getInfo(): Gibt einen String im folgenden Format zurück: "[username] ([email]) - Token: [accessToken] - Cached: [cachedAt]"
main.php: Binde die UserProfile-Datei ein. Du erhältst vier Eingaben: eine Benutzer-ID, einen Benutzernamen, eine E-Mail-Adresse und ein Zugriffstoken. Erstelle mit diesen Werten eine UserProfile-Instanz. Gib drei Zeilen aus:
- Die Informationen des ursprünglichen Profils (vor der Serialisierung)
- Serialisiere das Profil mit serialize() und deserialisiere es anschließend mit unserialize(), um ein wiederhergestelltes Profil zu erstellen. Gib die Informationen des wiederhergestellten Profils aus.
- Gib "Token preserved: yes" oder "Token preserved: no" aus, je nachdem, ob das Token des wiederhergestellten Profils mit dem ursprünglichen übereinstimmt (Hinweis: Es sollte nicht übereinstimmen, da Token bei der Wiederherstellung ablaufen.)

Dieses Muster ist entscheidend, um Benutzerdaten sicher zwischenzuspeichern. Du möchtest die Profilinformationen speichern, aber vertrauliche Zugangsdaten wie Zugriffstoken niemals dauerhaft speichern. Wenn das Profil aus dem Cache wiederhergestellt wird, wird das Token als abgelaufen markiert, sodass die Anwendung ein neues Token anfordern muss.

Probier es selbst

<?php

require_once 'UserProfile.php';

// Eingaben lesen
$userId = trim(fgets(STDIN));
$username = trim(fgets(STDIN));
$email = trim(fgets(STDIN));
$accessToken = trim(fgets(STDIN));

// TODO: Erstelle eine UserProfile-Instanz mit den Eingabewerten

// TODO: Gib die Infos des ursprünglichen Profils aus (vor der Serialisierung)

// TODO: Serialisiere das Profil und deserialisiere es anschließend, um ein wiederhergestelltes Profil zu erstellen

// TODO: Gib die Infos des wiederhergestellten Profils aus

// TODO: Print "Token preserved: yes" or "Token preserved: no"
// je nachdem, ob das Token des wiederhergestellten Profils mit dem Original übereinstimmt

?>