Redis

webman/redis fügt auf der Basis von illuminate/redis die Funktionalität eines Verbindungs-Pools hinzu und unterstützt sowohl Koroutinen- als auch Nicht-Koroutinen-Umgebungen. Die Nutzung ist identisch zu Laravel.

Um illuminate/redis verwenden zu können, muss vorher die Redis-Erweiterung für php-cli installiert werden.

Hinweis
Dieses Handbuch bezieht sich auf die Version v2 von webman. Wenn Sie die Version v1 von webman verwenden, schauen Sie bitte in das v1-Handbuch.
Dieses Modul benötigt die Redis-Erweiterung. Verwenden Sie den Befehl php -m | grep redis, um zu überprüfen, ob die Redis-Erweiterung in php-cli installiert ist.

Installation

composer require -W webman/redis illuminate/events

Nach der Installation muss ein Neustart erfolgen (Reload ist nicht ausreichend).

Konfiguration

Die Redis-Konfigurationsdatei befindet sich in config/redis.php

return [
    'default' => [
        'host'     => '127.0.0.1',
        'password' => null,
        'port'     => 6379,
        'database' => 0,
        'pool' => [ // Konfiguration des Verbindungs-Pools
            'max_connections' => 10,     // Maximale Anzahl von Verbindungen im Pool
            'min_connections' => 1,      // Minimale Anzahl von Verbindungen im Pool
            'wait_timeout' => 3,         // Maximale Wartezeit beim Abrufen einer Verbindung aus dem Pool
            'idle_timeout' => 50,        // Zeitüberschreitung für inaktiven Verbindungen im Pool; Verbindungen, die länger inaktiv sind, werden geschlossen, bis die Anzahl der Verbindungen `min_connections` erreicht
            'heartbeat_interval' => 50,  // Intervall für die Herzschlagüberprüfung; sollte 60 Sekunden nicht überschreiten
        ],
    ]
];

Über Verbindungs-Pools

• Jeder Prozess hat seinen eigenen Verbindungs-Pool, dieser wird zwischen Prozessen nicht geteilt.
• Bei deaktivierten Koroutinen wird die Verarbeitung innerhalb des Prozesses sequenziell durchgeführt, wodurch keine Parallelität entsteht. Daher hat der Pool maximal 1 Verbindung.
• Mit aktivierten Koroutinen wird die Verarbeitung innerhalb des Prozesses parallel ausgeführt. Der Pool passt die Anzahl der Verbindungen dynamisch an, darf jedoch max_connections nicht überschreiten und mindestens min_connections haben.
• Da die maximale Anzahl der Verbindungen im Pool max_connections beträgt, warten Koroutinen bei einer Anzahl von Operationen an Redis, die größer ist als max_connections, maximal wait_timeout Sekunden. Wird diese Zeit überschritten, erfolgt eine Ausnahme.
• In einer inaktiven Situation (sowohl in Koroutinen- als auch in Nicht-Koroutinen-Umgebungen) werden Verbindungen nach idle_timeout zurückgegeben, bis die Anzahl der Verbindungen min_connections erreicht (min_connections kann 0 sein).

Beispiel

<?php
namespace app\controller;

use support\Request;
use support\Redis;

class UserController
{
    public function db(Request $request)
    {
        $key = 'test_key';
        Redis::set($key, rand());
        return response(Redis::get($key));
    }
}

Redis-Schnittstelle

Redis::append($key, $value)
Redis::bitCount($key)
Redis::decr($key, $value)
Redis::decrBy($key, $value)
Redis::get($key)
Redis::getBit($key, $offset)
Redis::getRange($key, $start, $end)
Redis::getSet($key, $value)
Redis::incr($key, $value)
Redis::incrBy($key, $value)
Redis::incrByFloat($key, $value)
Redis::mGet(array $keys)
Redis::getMultiple(array $keys)
Redis::mSet($pairs)
Redis::mSetNx($pairs)
Redis::set($key, $value, $expireResolution = null, $expireTTL = null, $flag = null)
Redis::setBit($key, $offset, $value)
Redis::setEx($key, $ttl, $value)
Redis::pSetEx($key, $ttl, $value)
Redis::setNx($key, $value)
Redis::setRange($key, $offset, $value)
Redis::strLen($key)
Redis::del(...$keys)
Redis::exists(...$keys)
Redis::expire($key, $ttl)
Redis::expireAt($key, $timestamp)
Redis::select($dbIndex)

entspricht

$redis = Redis::connection('default');
$redis->append($key, $value)
$redis->bitCount($key)
$redis->decr($key, $value)
$redis->decrBy($key, $value)
$redis->get($key)
$redis->getBit($key, $offset)
...

Hinweis
Verwenden Sie die Redis::select($db) Schnittstelle mit Vorsicht. Da webman ein Framework mit dauerhaftem Speicher ist, wird bei einem bestimmten Request, der Redis::select($db) verwendet, um die Datenbank zu wechseln, dies die nachfolgenden Requests beeinflussen. Es wird empfohlen, verschiedene $dbs als unterschiedliche Redis-Verbindungs-Konfigurationen zu verwenden.

Verwendung mehrerer Redis-Verbindungen

Beispiel für die Konfigurationsdatei config/redis.php

return [
    'default' => [
        'host'     => '127.0.0.1',
        'password' => null,
        'port'     => 6379,
        'database' => 0,
    ],

    'cache' => [
        'host'     => '127.0.0.1',
        'password' => null,
        'port'     => 6379,
        'database' => 1,
    ],

]

Standardmäßig wird die Verbindung unter default verwendet; Sie können die Methode Redis::connection() verwenden, um auszuwählen, welche Redis-Verbindung verwendet werden soll.

$redis = Redis::connection('cache');
$redis->get('test_key');

Cluster-Konfiguration

Wenn Ihre Anwendung einen Redis-Server-Cluster verwendet, sollten Sie im Redis-Konfigurationsdatei den Schlüssel clusters verwenden, um diese Cluster zu definieren:

return [
    'clusters' => [
        'default' => [
            [
                'host'     => 'localhost',
                'password' => null,
                'port'     => 6379,
                'database' => 0,
            ],
        ],
    ],

];

Standardmäßig kann der Cluster Client-seitiges Sharding auf Knoten implementieren, wodurch Sie Knotenpools und große Mengen an verfügbarem Speicher erstellen können. Beachten Sie hierbei, dass das Client-Sharing gescheiterte Verbindungen nicht behandelt; diese Funktion ist daher hauptsächlich für von einem anderen Master-Database abgerufene Cache-Daten geeignet. Wenn Sie Redis nativ im Cluster-Modus verwenden möchten, müssen Sie im options-Schlüssel in der Konfigurationsdatei die folgende Angabe machen:

return[
    'options' => [
        'cluster' => 'redis',
    ],

    'clusters' => [
        // ...
    ],
];

Pipeline-Befehle

Wenn Sie viele Befehle an den Server in einem einzigen Vorgang senden müssen, wird empfohlen, Pipeline-Befehle zu verwenden. Die pipeline-Methode akzeptiert ein Closure für eine Redis-Instanz. Sie können alle Befehle an die Redis-Instanz senden, die dann in einem einzigen Vorgang ausgeführt werden:

Redis::pipeline(function ($pipe) {
    for ($i = 0; $i < 1000; $i++) {
        $pipe->set("key:$i", $i);
    }
});