Одиночка

<?php
/**
* Класс Одиночка предоставляет метод `GetInstance`, который ведёт себя как
* альтернативный конструктор и позволяет клиентам получать один и тот же
* экземпляр класса при каждом вызове.
*/

class Singleton
{
    /**
    * Объект одиночки храниться в статичном поле класса. Это поле — массив, так
    * как мы позволим нашему Одиночке иметь подклассы. Все элементы этого
    * массива будут экземплярами кокретных подклассов Одиночки. Не волнуйтесь,
    * мы вот-вот познакомимся с тем, как это работает.
    */
    private static $instances = [];

    /**
    * Конструктор Одиночки всегда должен быть скрытым, чтобы предотвратить
    * создание объекта через оператор new.
    */
    protected function __construct() { }

    /**
    * Одиночки не должны быть клонируемыми.
    */
    protected function __clone() { }

    /**
    * Одиночки не должны быть восстанавливаемыми из строк.
    */
    public function __wakeup()
    {
        throw new \Exception("Cannot unserialize a singleton.");
    }

    /**
    * Это статический метод, управляющий доступом к экземпляру одиночки. При
    * первом запуске, он создаёт экземпляр одиночки и помещает его в
    * статическое поле. При последующих запусках, он возвращает клиенту объект,
    * хранящийся в статическом поле.
    *
    * Эта реализация позволяет вам расширять класс Одиночки, сохраняя повсюду
    * только один экземпляр каждого подкласса.
    */
    public static function getInstance(): Singleton
    {
        $cls = static::class;
        if (!isset(self::$instances[$cls])) {
            self::$instances[$cls] = new static();
        }
        return self::$instances[$cls];
    }

    /**
    * Наконец, любой одиночка должен содержать некоторую бизнес-логику, которая
    * может быть выполнена на его экземпляре.
    */
    public function someBusinessLogic()
    {
        // ...
    }
}

/**
* Клиентский код.
*/
function clientCode()
{
    $s1 = Singleton::getInstance();
    $s2 = Singleton::getInstance();
    if ($s1 === $s2) {
        echo "Singleton works, both variables contain the same instance.";
    } else {
        echo "Singleton failed, variables contain different instances.";
    }
}

clientCode();

<?php
/**
* Если вам необходимо поддерживать в приложении несколько типов Одиночек, вы
* можете определить основные функции Одиночки в базовом классе, тогда как
* фактическую бизнес-логику (например, ведение журнала) перенести в подклассы.
*/

class Singleton
{
    /**
    * Реальный экземпляр одиночки почти всегда находится внутри статического
    * поля. В этом случае статическое поле является массивом, где каждый
    * подкласс Одиночки хранит свой собственный экземпляр.
    */
    private static $instances = [];

    /**
    * Конструктор Одиночки не должен быть публичным. Однако он не может быть
    * приватным, если мы хотим разрешить создание подклассов.
    */
    protected function __construct() { }

    /**
    * Клонирование и десериализация не разрешены для одиночек.
    */
    protected function __clone() { }

    public function __wakeup()
    {
        throw new \Exception("Cannot unserialize singleton");
    }

    /**
    * Метод, используемый для получения экземпляра Одиночки.
    */
    public static function getInstance()
    {
        $subclass = static::class;
        if (!isset(self::$instances[$subclass])) {
        // Обратите внимание, что здесь мы используем ключевое слово
        // "static"  вместо фактического имени класса. В этом контексте
        // ключевое слово "static" означает «имя текущего класса». Эта
        // особенность важна, потому что, когда метод вызывается в
        // подклассе, мы хотим, чтобы экземпляр этого подкласса был создан
        // здесь.
            self::$instances[$subclass] = new static();
        }
        return self::$instances[$subclass];
    }
}

/**
* Класс ведения журнала является наиболее известным и похвальным использованием
* паттерна Одиночка.
*/

class Logger extends Singleton
{
    /**
    * Ресурс указателя файла файла журнала.
    */
    private $fileHandle;

    /**
    * Поскольку конструктор Одиночки вызывается только один раз, постоянно
    * открыт всего лишь один файловый ресурс.
    *
    * Обратите внимание, что для простоты мы открываем здесь консольный поток
    * вместо фактического файла.
    */
    protected function __construct()
    {
        $this->fileHandle = fopen('php://stdout', 'w');
    }

    /**
    * Пишем запись в журнале в открытый файловый ресурс.
    */
    public function writeLog(string $message): void
    {
        $date = date('Y-m-d');
        fwrite($this->fileHandle, "$date: $message\n");
    }

    /**
    * Просто удобный ярлык для уменьшения объёма кода, необходимого для
    * регистрации сообщений из клиентского кода.
    */
    public static function log(string $message): void
    {
        $logger = static::getInstance();
        $logger->writeLog($message);
    }
}

/**
* Применение паттерна Одиночка в хранилище настроек – тоже обычная практика.
* Часто требуется получить доступ к настройкам приложений из самых разных мест
* программы. Одиночка предоставляет это удобство.
*/

class Config extends Singleton
{
    private $hashmap = [];

    public function getValue(string $key): string
    {
        return $this->hashmap[$key];
    }

    public function setValue(string $key, string $value): void
    {
        $this->hashmap[$key] = $value;
    }
}

/**
* Клиентский код.
*/
Logger::log("Started!");

// Сравниваем значения одиночки-Логгера.
$l1 = Logger::getInstance();
$l2 = Logger::getInstance();
if ($l1 === $l2) {
    Logger::log("Logger has a single instance.");
} else {
    Logger::log("Loggers are different.");
}

// Проверяем, как одиночка-Конфигурация сохраняет данные...
$config1 = Config::getInstance();
$login = "test_login";
$password = "test_password";
$config1->setValue("login", $login);
$config1->setValue("password", $password);
// ...и восстанавливает их.
$config2 = Config::getInstance();
if ($login == $config2->getValue("login") &&
    $password == $config2->getValue("password")
) {
    Logger::log("Config singleton also works fine.");
}

Logger::log("Finished!");

<?php
// Без паттерна — конфигурация создаётся в каждом модуле заново
class AppConfig {
    private array $settings;

    public function __construct(array $settings) {
        $this->settings = $settings;
    }

    public function get(string $key, mixed $default = null): mixed {
        return $this->settings[$key] ?? $default;
    }

    public function set(string $key, mixed $value): void {
        $this->settings[$key] = $value;
    }
}

// Проблема: в разных модулях создаются разные экземпляры
$configInModuleA = new AppConfig(['debug' => false, 'db_host' => 'localhost']);
$configInModuleB = new AppConfig(['debug' => false, 'db_host' => 'localhost']);

$configInModuleA->set('debug', true);

// module_b не видит изменения module_a — это разные объекты!
var_dump($configInModuleB->get('debug')); // false, а должно быть true

// TODO: переделать AppConfig в Одиночку так, чтобы:
// - AppConfig::getInstance() всегда возвращал один объект
// - настройки инициализировались только один раз
// - изменения были видны из любого места программы

<?php
class DatabaseConnection {
    private static int $counter = 0;
    public readonly int $id;
    public bool $inUse = false;

    public function __construct() {
        $this->id = ++self::$counter;
    }

    public function execute(string $query): string {
        return "[Conn #{$this->id}] Результат: {$query}";
    }

    public function __toString(): string {
        return "Connection #{$this->id}";
    }
}

// TODO: реализовать Одиночку ConnectionPool:
// - getInstance(maxSize = 5) — всегда возвращает один объект
// - acquire() -> DatabaseConnection — возвращает свободное соединение
//   или бросает RuntimeException если все заняты
// - release(DatabaseConnection conn) — возвращает соединение в пул
// - getActiveCount() -> int — количество соединений в использовании

// Ожидаемый клиентский код:
// $pool  = ConnectionPool::getInstance(maxSize: 3);
// $pool2 = ConnectionPool::getInstance(maxSize: 10); // тот же объект
// assert($pool === $pool2);
//
// $conn1 = $pool->acquire();
// $conn2 = $pool->acquire();
// echo $conn1->execute("SELECT * FROM users") . "\n";
// $pool->release($conn1);
// echo "Активных соединений: " . $pool->getActiveCount() . "\n";

<?php
// TODO: реализовать Одиночку EventCounter с методами:
// - increment(event: string, amount: int = 1): void
// - decrement(event: string, amount: int = 1): void
// - get(event: string): int
// - reset(event: string): void
// - all(): array  — все счётчики

// Ожидаемый клиентский код:
// --- модуль аутентификации ---
// $counter = EventCounter::getInstance();
// $counter->increment('login_success');
// $counter->increment('login_success');
// $counter->increment('login_fail');

// --- модуль API ---
// $counter2 = EventCounter::getInstance(); // тот же объект
// $counter2->increment('api_request', 5);
// $counter2->increment('login_success');   // теперь 3

// --- мониторинг ---
// $counter3 = EventCounter::getInstance();
// print_r($counter3->all());
// ['login_success' => 3, 'login_fail' => 1, 'api_request' => 5]

// assert($counter === $counter2 && $counter2 === $counter3);

<?php
// TODO: реализовать Одиночку MemoryCache с методами:
// - set(key: string, value: mixed, ttl: float = 60.0): void
//   сохраняет значение с временем жизни в секундах
// - get(key: string): mixed
//   возвращает значение или null, если истекло / не существует
// - delete(key: string): void
// - flush(): void  — очищает весь кэш
// - getSize(): int  — количество живых записей

// Ожидаемый клиентский код:
// $cache  = MemoryCache::getInstance();
// $cache2 = MemoryCache::getInstance();
// assert($cache === $cache2);

// $cache->set('user:1', ['name' => 'Анна', 'role' => 'admin'], ttl: 2.0);
// $cache->set('user:2', ['name' => 'Иван', 'role' => 'user'],  ttl: 60.0);

// var_dump($cache->get('user:1'));   // ['name' => 'Анна', ...]
// var_dump($cache2->get('user:2'));  // ['name' => 'Иван', ...]

// sleep(3);
// var_dump($cache->get('user:1'));   // NULL — TTL истёк
// echo $cache->getSize();            // 1 — только user:2 живой