serialize e unserialize

Parte da seção Programação Orientada a Objetos do Journey de PHP da Coddy — lição 49 de 91.

Quando você precisa converter um objeto em uma string para armazenamento ou transmissão, o PHP usa serialização. Os métodos mágicos __serialize() e __unserialize() dão a você controle sobre exatamente quais dados são salvos e como eles são restaurados.

O método __serialize() retorna um array de dados a serem serializados, enquanto __unserialize() recebe esse array e reconstrói o objeto:

<?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 "User: " . $restored->getCreatedAt();

Observe como createdAt é excluído da serialização e recebe um novo timestamp quando desserializado. Isso é útil para excluir dados sensíveis, valores temporários ou recursos que não podem ser serializados, como conexões de banco de dados.

Estes métodos substituíram os antigos métodos __sleep() e __wakeup() no PHP 7.4, oferecendo uma abordagem mais limpa onde você trabalha diretamente com arrays de dados em vez de nomes de propriedades.

Desafio

Fácil

Vamos construir um sistema de cache de perfil de usuário que demonstra como __serialize() e __unserialize() oferecem controle sobre quais dados são salvos e como são restaurados.

Você organizará seu código em dois arquivos:

UserProfile.php — Crie uma classe UserProfile que represente o perfil de um usuário com recursos de cache. Use a promoção de construtor para definir propriedades privadas para $userId (string), $username (string), $email (string) e $accessToken (string). Adicione uma propriedade privada $cachedAt que armazena quando o perfil foi colocado em cache (defina-a como "not cached" inicialmente no construtor). Sua classe precisa de:
- __serialize() — Retorna um array contendo apenas o userId, username e email. O accessToken é sensível e nunca deve ser serializado. O timestamp cachedAt será regenerado na restauração.
- __unserialize() — Restaura o userId, username e email a partir do array de dados. Define accessToken como "expired" (já que os tokens não devem persistir).
- getInfo() — Retorna uma string no formato: "[username] ([email]) - Token: [accessToken] - Cached: [cachedAt]"
main.php — Inclua o arquivo UserProfile. Você receberá quatro entradas: um ID de usuário, um nome de usuário, um e-mail e um token de acesso. Crie uma instância de UserProfile com esses valores. Imprima três linhas:
- As informações do perfil original (antes da serialização)
- Serialize o perfil usando serialize(), depois desserialize-o usando unserialize() para criar um perfil restaurado. Imprima as informações do perfil restaurado.
- Imprima "Token preserved: yes" ou "Token preserved: no" dependendo se o token do perfil restaurado corresponde ao original (dica: não deve corresponder, pois os tokens expiram na restauração)

Este padrão é essencial para armazenar dados de usuário em cache com segurança — você deseja armazenar as informações do perfil, mas nunca persistir credenciais sensíveis como tokens de acesso. Quando o perfil é restaurado do cache, o token é marcado como expirado, forçando o aplicativo a obter um novo.

Folha de consulta

Os métodos mágicos __serialize() e __unserialize() controlam quais dados são salvos durante a serialização e como os objetos são restaurados.

__serialize() retorna um array de dados a serem serializados:

<?php
public function __serialize(): array {
    return [
        'userId' => $this->userId,
        'data' => $this->data
    ];
}

__unserialize() recebe o array e reconstrói o objeto:

<?php
public function __unserialize(array $data): void {
    $this->userId = $data['userId'];
    $this->data = $data['data'];
    $this->createdAt = time();
}

Use serialize() para converter um objeto em uma string e unserialize() para restaurá-lo:

<?php
$serialized = serialize($session);
$restored = unserialize($serialized);

Esses métodos são úteis para excluir dados sensíveis, valores temporários ou recursos que não podem ser serializados (como conexões de banco de dados). As propriedades podem ser regeneradas com valores novos durante a desserialização.

Experimente você mesmo

<?php

require_once 'UserProfile.php';

// Ler entradas
$userId = trim(fgets(STDIN));
$username = trim(fgets(STDIN));
$email = trim(fgets(STDIN));
$accessToken = trim(fgets(STDIN));

// TODO: Criar uma instância de UserProfile com os valores de entrada

// TODO: Imprimir as informações do perfil original (antes da serialização)

// TODO: Serializar o perfil e, em seguida, desserializá-lo para criar um perfil restaurado

// TODO: Imprimir as informações do perfil restaurado

// TODO: Imprimir "Token preserved: yes" ou "Token preserved: no"
// dependendo se o token do perfil restaurado corresponde ao original

?>