Descrizione

A partire dalla versione 4.x, Workerman ha migliorato il supporto per i servizi HTTP. Sono state introdotte le classi di richiesta, risposta, sessione e SSE. Se desideri utilizzare il servizio HTTP di Workerman, si consiglia vivamente di utilizzare la versione 4.x di Workerman o versioni successive.

Nota: quanto segue si riferisce all'uso della versione 4.x di Workerman ed è incompatibile con la versione 3.x di Workerman.

Modifica del motore di archiviazione delle sessioni

Workerman fornisce un motore di archiviazione delle sessioni basato su file e un motore di archiviazione delle sessioni Redis. Per impostazione predefinita, viene utilizzato il motore di archiviazione basato su file. Se desideri modificarlo in un motore di archiviazione delle sessioni Redis, consulta il codice seguente.

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

// Configurazione redis
$config = [
    'host'     => '127.0.0.1', // parametro obbligatorio
    'port'     => 6379,        // parametro obbligatorio
    'timeout'  => 2,           // parametro facoltativo
    'auth'     => '******',    // parametro facoltativo
    'database' => 1,           // parametro facoltativo
    'prefix'   => 'session_'   // parametro facoltativo
];
// Usa il metodo Workerman\Protocols\Http\Session::handlerClass per cambiare la classe del driver delle sessioni di base
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();

Impostare la posizione di archiviazione delle sessioni

Quando si utilizza il motore di archiviazione predefinito, i dati delle sessioni vengono archiviati su disco nella posizione restituita da session_save_path().
Puoi usare il seguente metodo per cambiare la posizione di archiviazione.

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

// Imposta la posizione di archiviazione dei file di sessione
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'));
};

// Esegui il worker
Worker::runAll();

Pulizia dei file di sessione

Quando si utilizza il motore di archiviazione delle sessioni predefinito, ci saranno diversi file di sessione su disco,
workerman pulirà i file di sessione scaduti in base alle impostazioni di session.gc_probability, session.gc_divisor e session.gc_maxlifetime in php.ini. Per una spiegazione di queste tre opzioni, fai riferimento alla documentazione PHP.

Modifica del driver di archiviazione

Oltre ai motori di archiviazione delle sessioni basati su file e Redis, Workerman ti consente di aggiungere nuovi motori di archiviazione delle sessioni tramite l'interfaccia standard SessionHandlerInterface, come un motore di archiviazione delle sessioni MangoDB o un motore di archiviazione delle sessioni MySQL.

Processo di aggiunta di un nuovo motore di archiviazione delle sessioni

  1. Implementa l'interfaccia SessionHandlerInterface
  2. Utilizza il metodo Workerman\Protocols\Http\Session::handlerClass($class_name, $config) per sostituire l'interfaccia SessionHandler di base.

Implementazione dell'interfaccia SessionHandlerInterface

Un driver di archiviazione delle sessioni personalizzato deve implementare l'interfaccia SessionHandlerInterface. Questa interfaccia include i seguenti metodi:

SessionHandlerInterface {
    /* Metodi */
    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
}

Descrizione di SessionHandlerInterface

  • Il metodo read viene utilizzato per leggere tutti i dati delle sessioni corrispondenti a session_id dall'archiviazione. Non eseguire operazioni di deserializzazione sui dati, il framework lo farà automaticamente.
  • Il metodo write viene utilizzato per scrivere i dati delle sessioni corrispondenti a session_id nell'archiviazione. Non eseguire operazioni di serializzazione sui dati, il framework lo ha già fatto automaticamente.
  • Il metodo destroy viene utilizzato per distruggere i dati delle sessioni corrispondenti a session_id.
  • Il metodo gc viene utilizzato per eliminare i dati delle sessioni scaduti; l'archiviazione dovrebbe eseguire l'operazione di eliminazione per tutte le sessioni il cui tempo di modifica è maggiore di maxlifetime.
  • Il metodo close non richiede alcuna operazione, restituisci semplicemente true.
  • Il metodo open non richiede alcuna operazione, restituisci semplicemente true.

Sostituzione del driver di base

Una volta implementata l'interfaccia SessionHandlerInterface, usa il seguente metodo per cambiare il driver di base della sessione.

Workerman\Protocols\Http\Session::handlerClass($class_name, $config);
  • $class_name è il nome della classe SessionHandler che implementa l'interfaccia SessionHandlerInterface. Se ci sono spazi dei nomi, includi il nome completo dello spazio dei nomi.
  • $config sono i parametri del costruttore della classe SessionHandler.

Implementazione specifica

Nota: questa classe MySessionHandler è solo a scopo dimostrativo per illustrare il processo di cambiamento del driver di base della sessione; MySessionHandler non è adatta per l'ambiente di produzione.

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

//  Supponiamo che la nuova classe SessionHandler implementata richieda alcune configurazioni
$config = ['host' => 'localhost'];
//  Usa Workerman\Protocols\Http\Session::handlerClass($class_name, $config) per cambiare la classe del driver di base della sessione
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();