Redis

webman/redis est basé sur illuminate/redis et ajoute des fonctionnalités de pool de connexions, supportant les environnements de coroutines et non-coroutines, avec une utilisation similaire à Laravel.

Avant d'utiliser illuminate/redis, il est nécessaire d'installer l'extension redis pour php-cli.

Attention
Ce manuel est pour la version v2 de webman. Si vous utilisez la version v1 de webman, veuillez consulter le manuel de la version v1.
Ce composant nécessite l'installation de l'extension redis. Utilisez la commande php -m | grep redis pour vérifier si php-cli a l'extension redis installée.

Installation

composer require -W webman/redis illuminate/events

Après l'installation, il est nécessaire de redémarrer (reload n'est pas effectif).

Configuration

Le fichier de configuration redis se trouve dans config/redis.php

return [
    'default' => [
        'host'     => '127.0.0.1',
        'password' => null,
        'port'     => 6379,
        'database' => 0,
        'pool' => [ // Configuration du pool de connexions
            'max_connections' => 10,     // Nombre maximum de connexions dans le pool
            'min_connections' => 1,      // Nombre minimum de connexions dans le pool
            'wait_timeout' => 3,         // Temps maximum d'attente pour obtenir une connexion du pool
            'idle_timeout' => 50,        // Temps d'inactivité maximum d'une connexion dans le pool avant qu'elle ne soit fermée, jusqu'à ce que le nombre de connexions soit égal à min_connections
            'heartbeat_interval' => 50,  // Intervalle de vérification de l'activité, ne pas dépasser 60 secondes
        ],
    ]
];

À propos du pool de connexions

Chaque processus a son propre pool de connexions, les pools de connexions ne sont pas partagés entre les processus.
Lorsqu'aucune coroutine n'est activée, les tâches s'exécutent dans le processus en attente, sans création de concurrence, donc le pool de connexions ne dispose que d'une seule connexion au maximum.
Lorsqu'une coroutine est activée, les tâches s'exécutent de manière concurrente dans le processus, le pool de connexions ajuste dynamiquement le nombre de connexions selon les besoins, sans dépasser max_connections et sans descendre en dessous de min_connections.
Étant donné que le nombre maximum de connexions dans le pool est max_connections, lorsque le nombre de coroutines effectuant des opérations Redis est supérieur à max_connections, certaines coroutines seront mises en attente et ne pourront pas dépasser le temps d'attente wait_timeout, au-delà duquel une exception sera déclenchée.
Dans des situations inactives (y compris dans des environnements de coroutines et non-coroutines), les connexions seront récupérées après le délai idle_timeout, jusqu'à ce que le nombre de connexions soit égal à min_connections (min_connections peut être 0).

Exemple

<?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));
    }
}

Interface Redis

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)

équivaut à

$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)
...

Attention
Utilisez avec précaution l'interface Redis::select($db), car webman est un framework à mémoire résidente, si une requête utilise Redis::select($db) pour changer de base de données, cela affectera les requêtes suivantes. Pour plusieurs bases de données, il est conseillé de configurer différents $db en tant que différentes configurations de connexion Redis.

Utilisation de plusieurs connexions Redis

Par exemple, le fichier de configuration 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,
    ],

]

La connexion utilisée par défaut est celle configurée sous default, vous pouvez choisir quelle connexion redis utiliser avec la méthode Redis::connection().

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

Configuration de cluster

Si votre application utilise un cluster de serveurs Redis, vous devez utiliser la clé clusters dans le fichier de configuration Redis pour définir ces clusters :

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

];

Par défaut, les clusters peuvent réaliser un partitionnement client sur les nœuds, vous permettant de créer un pool de nœuds et de créer une grande quantité de mémoire disponible. Il est important de noter que le partage client ne gérera pas les situations de défaillance ; par conséquent, cette fonctionnalité est principalement conçue pour les données mises en cache obtenues à partir d'une autre base de données principale. Pour utiliser le cluster natif Redis, vous devez spécifier ce qui suit dans la clé options du fichier de configuration :

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

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

Commandes en pipeline

Lorsque vous devez envoyer de nombreuses commandes au serveur en une seule opération, il est recommandé d'utiliser des commandes en pipeline. La méthode pipeline accepte une fermeture d'une instance Redis. Vous pouvez envoyer toutes les commandes à l'instance Redis, elles seront toutes exécutées en une seule opération :

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