Description

Workerman a renforcé son support pour les services HTTP à partir de la version 4.x. Il introduit des classes de requête, de réponse, de session et également le SSE. Si vous souhaitez utiliser les services HTTP de Workerman, il est fortement recommandé d'utiliser Workerman 4.x ou une version ultérieure.

Veuillez noter que ce qui suit est l'usage de Workerman 4.x, et n'est pas compatible avec Workerman 3.x.

Changer le moteur de stockage de session

Workerman fournit des moteurs de stockage de session basés sur des fichiers et Redis. Par défaut, le moteur de stockage de fichiers est utilisé. Si vous souhaitez passer au moteur de stockage Redis, veuillez vous référer au code suivant.

<?php
use Workerman\Worker;
use Workerman\Protocols\Http\Session;
use Workerman\Protocols\Http\Session\RedisSessionHandler;
use Workerman\Connection\TcpConnection;
use Workerman\Protocols\Http\Request;
require_once __DIR__ . '/vendor/autoload.php';

$worker = new Worker('http://0.0.0.0:8080');

// configuration redis
$config = [
    'host'     => '127.0.0.1', // paramètre requis
    'port'     => 6379,        // paramètre requis
    'timeout'  => 2,           // paramètre optionnel
    'auth'     => '******',    // paramètre optionnel
    'database' => 1,           // paramètre optionnel
    'prefix'   => 'session_'   // paramètre optionnel
];
// Utilisez la méthode Workerman\Protocols\Http\Session::handlerClass pour changer le moteur de session sous-jacent
Session::handlerClass(RedisSessionHandler::class, $config);

$worker->onMessage = function(TcpConnection $connection, Request $request)
{
    $session = $request->session();
    $session->set('somekey', rand());
    $connection->send($session->get('somekey'));
};

Worker::runAll();

Définir l'emplacement de stockage de la session

Lorsque vous utilisez le moteur de stockage par défaut, les données de session sont stockées par défaut sur le disque, à l'emplacement retourné par session_save_path().
Vous pouvez modifier cet emplacement de stockage en utilisant la méthode suivante.

use Workerman\Worker;
use \Workerman\Protocols\Http\Session\FileSessionHandler;
use Workerman\Connection\TcpConnection;
use Workerman\Protocols\Http\Request;
require_once __DIR__ . '/vendor/autoload.php';

// Définir l'emplacement du fichier de stockage de session
FileSessionHandler::sessionSavePath('/tmp/session');

$worker = new Worker('http://0.0.0.0:8080');

$worker->onMessage = function(TcpConnection $connection, Request $request)
{
    $session = $request->session();
    $session->set('name', 'tome');
    $connection->send($session->get('name'));
};

// Exécuter le worker
Worker::runAll();

Nettoyage des fichiers de session

Lorsque vous utilisez le moteur de stockage de session par défaut, il y aura plusieurs fichiers de session sur le disque.
Workerman Nettoiera les fichiers de session expirés en fonction des options session.gc_probability, session.gc_divisor et session.gc_maxlifetime définies dans php.ini. Pour des explications sur ces trois options, veuillez consulter le manuel PHP.

Changer le pilote de stockage

Outre le moteur de stockage de session basé sur des fichiers et Redis, Workerman vous permet d'ajouter de nouveaux moteurs de stockage de session via l'interface standard SessionHandlerInterface, comme un moteur de stockage de session MongoDB, un moteur de stockage de session MySQL, etc.

Processus pour ajouter un nouveau moteur de stockage de session

  1. Implémentez l'interface SessionHandlerInterface.
  2. Utilisez la méthode Workerman\Protocols\Http\Session::handlerClass($class_name, $config) pour remplacer l'interface SessionHandler sous-jacente.

Implémentation de l'interface SessionHandlerInterface

Un pilote de stockage de session personnalisé doit implémenter l'interface SessionHandlerInterface. Cette interface comprend les méthodes suivantes :

SessionHandlerInterface {
    /* Méthodes */
    abstract public read ( string $session_id ) : string
    abstract public write ( string $session_id , string $session_data ) : bool
    abstract public destroy ( string $session_id ) : bool
    abstract public gc ( int $maxlifetime ) : int
    abstract public close ( void ) : bool
    abstract public open ( string $save_path , string $session_name ) : bool
}

Explication de SessionHandlerInterface

  • La méthode read est utilisée pour lire toutes les données de session associées à session_id à partir du stockage. Ne désérialisez pas les données, le framework s'en occupera automatiquement.
  • La méthode write est utilisée pour écrire les données de session associées à session_id dans le stockage. Ne sérialisez pas les données, le framework s'en occupe déjà automatiquement.
  • La méthode destroy est utilisée pour détruire les données de session associées à session_id.
  • La méthode gc est utilisée pour supprimer les données de session expirées. Le stockage doit supprimer toutes les sessions dont la dernière date de modification est supérieure à maxlifetime.
  • La méthode close n'a besoin d'aucune opération, renvoyez simplement true.
  • La méthode open n'a besoin d'aucune opération, renvoyez simplement true.

Remplacer le pilote sous-jacent

Après avoir implémenté l'interface SessionHandlerInterface, vous pouvez changer le pilote de session sous-jacent en utilisant la méthode suivante.

Workerman\Protocols\Http\Session::handlerClass($class_name, $config);
  • $class_name est le nom de la classe SessionHandler qui implémente l'interface SessionHandlerInterface. Si une namespace est présente, elle doit être incluse.
  • $config contient les paramètres du constructeur de la classe SessionHandler.

Implémentation spécifique

Remarque : cette classe MySessionHandler est uniquement à des fins d'illustration pour expliquer le processus de changement du pilote de session sous-jacent, MySessionHandler ne peut pas être utilisée en production.

<?php
use Workerman\Worker;
use Workerman\Protocols\Http\Session;
use Workerman\Connection\TcpConnection;
use Workerman\Protocols\Http\Request;
require_once __DIR__ . '/vendor/autoload.php';

$worker = new Worker('http://0.0.0.0:8080');

class MySessionHandler implements SessionHandlerInterface
{
    protected static $store = [];

    public function __construct($config) {
        // ['host' => 'localhost']
        var_dump($config);
    }

    public function open($save_path, $name)
    {
        return true;
    }

    public function read($session_id)
    {
        return isset(static::$store[$session_id]) ? static::$store[$session_id]['content'] : '';
    }

    public function write($session_id, $session_data)
    {
        static::$store[$session_id] = ['content' => $session_data, 'timestamp' => time()];
    }

    public function close()
    {
        return true;
    }

    public function destroy($session_id)
    {
        unset(static::$store[$session_id]);
        return true;
    }

    public function gc($maxlifetime) {
        $time_now = time();
        foreach (static::$store as $session_id => $info) {
            if ($time_now - $info['timestamp'] > $maxlifetime) {
                unset(static::$store[$session_id]);
            }
        }
    }
}

// Supposons que la nouvelle classe SessionHandler implémentée nécessite une certaine configuration
$config = ['host' => 'localhost'];
// Utilisez Workerman\Protocols\Http\Session::handlerClass($class_name, $config) pour changer le pilote de session sous-jacent
Session::handlerClass(MySessionHandler::class, $config);

$worker->onMessage = function(TcpConnection $connection, Request $request)
{
    $session = $request->session();
    $session->set('somekey', rand());
    $connection->send($session->get('somekey'));
};

Worker::runAll();