gerenciamento de sessão do webman

Exemplo

<?php
namespace app\controller;

use support\Request;

class UserController
{
    public function hello(Request $request)
    {
        $name = $request->get('name');
        $session = $request->session();
        $session->set('name', $name);
        return response('hello ' . $session->get('name'));
    }
}

Através de $request->session(); você obtém uma instância de Workerman\Protocols\Http\Session, e pode usar os métodos da instância para adicionar, modificar ou deletar dados da sessão.

Nota: O objeto de sessão salvará automaticamente os dados da sessão quando for destruído, portanto, não armazene o objeto retornado por $request->session() em um array global ou em membros de classe, pois isso poderá impedir o salvamento da sessão.

Obtendo todos os dados da sessão

$session = $request->session();
$all = $session->all();

Retorna um array. Se não houver dados de sessão, retorna um array vazio.

Obtendo um valor específico da sessão

$session = $request->session();
$name = $session->get('name');

Se o dado não existir, retorna null.

Você também pode passar um valor padrão como segundo parâmetro para o método get; se o valor correspondente não for encontrado no array de sessão, retornará o valor padrão. Por exemplo:

$session = $request->session();
$name = $session->get('name', 'tom');

Armazenando sessão

Para armazenar um dado, use o método set.

$session = $request->session();
$session->set('name', 'tom');

set não retorna valor; os dados da sessão serão salvos automaticamente quando o objeto de sessão for destruído.

Ao armazenar vários valores, use o método put.

$session = $request->session();
$session->put(['name' => 'tom', 'age' => 12]);

Da mesma forma, put também não retorna valor.

Deletando dados da sessão

Para deletar um ou mais dados da sessão, use o método forget.

$session = $request->session();
// Deletar um item
$session->forget('name');
// Deletar múltiplos itens
$session->forget(['name', 'age']);

Além disso, o sistema fornece o método delete, que tem a diferença de que o delete pode remover apenas um item.

$session = $request->session();
// Equivalente a $session->forget('name');
$session->delete('name');

Obtendo e deletando um valor da sessão

$session = $request->session();
$name = $session->pull('name');

O efeito é o mesmo que o código a seguir

$session = $request->session();
$value = $session->get($name);
$session->delete($name);

Se o valor correspondente da sessão não existir, retornará null.

Deletando todos os dados da sessão

$request->session()->flush();

Não retorna valor; os dados da sessão serão automaticamente removidos do armazenamento quando o objeto de sessão for destruído.

Verificando se um dado da sessão existe

$session = $request->session();
$has = $session->has('name');

O código acima retornará false se o dado correspondente da sessão não existir ou se o valor for null; caso contrário, retornará true.

$session = $request->session();
$has = $session->exists('name');

O código acima também é usado para verificar a existência de dados da sessão; a diferença é que quando o valor correspondente da sessão é null, também retornará true.

Função auxiliar session()

O webman fornece a função auxiliar session() para realizar a mesma funcionalidade.

// Obtendo a instância da sessão
$session = session();
// Equivalente a
$session = $request->session();

// Obtendo um valor
$value = session('key', 'default');
// Equivalente a
$value = session()->get('key', 'default');
// Equivalente a
$value = $request->session()->get('key', 'default');

// Atribuindo valores à sessão
session(['key1'=>'value1', 'key2' => 'value2']);
// Equivalente a
session()->put(['key1'=>'value1', 'key2' => 'value2']);
// Equivalente a
$request->session()->put(['key1'=>'value1', 'key2' => 'value2']);

Arquivo de configuração

O arquivo de configuração da sessão está em config/session.php, com um conteúdo semelhante ao seguinte:

use Webman\Session\FileSessionHandler;
use Webman\Session\RedisSessionHandler;
use Webman\Session\RedisClusterSessionHandler;

return [
    // FileSessionHandler::class ou RedisSessionHandler::class ou RedisClusterSessionHandler::class 
    'handler' => FileSessionHandler::class,

    // Quando o handler é FileSessionHandler::class o valor é file,
    // quando o handler é RedisSessionHandler::class o valor é redis
    // quando o handler é RedisClusterSessionHandler::class o valor é redis_cluster, ou seja, cluster redis
    'type'    => 'file',

    // Diferentes handlers usam configurações diferentes
    'config' => [
        // Configuração para type=file
        'file' => [
            'save_path' => runtime_path() . '/sessions',
        ],
        // Configuração para type=redis
        'redis' => [
            'host'      => '127.0.0.1',
            'port'      => 6379,
            'auth'      => '',
            'timeout'   => 2,
            'database'  => '',
            'prefix'    => 'redis_session_',
        ],
        'redis_cluster' => [
            'host'    => ['127.0.0.1:7000', '127.0.0.1:7001', '127.0.0.1:7001'],
            'timeout' => 2,
            'auth'    => '',
            'prefix'  => 'redis_session_',
        ]

    ],

    'session_name' => 'PHPSID', // Nome do cookie que armazena o session_id
    'auto_update_timestamp' => false,  // Se atualizar automaticamente a sessão, padrão é desligado
    'lifetime' => 7*24*60*60,          // Tempo de expiração da sessão
    'cookie_lifetime' => 365*24*60*60, // Tempo de expiração do cookie que armazena o session_id
    'cookie_path' => '/',              // Caminho do cookie que armazena o session_id
    'domain' => '',                    // Domínio do cookie que armazena o session_id
    'http_only' => true,               // Se habilitar httpOnly, padrão é habilitado
    'secure' => false,                 // Habilitar sessão apenas em https, padrão é desligado
    'same_site' => '',                 // Para prevenir ataques CSRF e rastreamento de usuários, valores opcionais: strict/lax/none
    'gc_probability' => [1, 1000],     // Probabilidade de coletar a sessão
];

Segurança

Ao usar sessões, não é recomendado armazenar instâncias de classes diretamente, especialmente instâncias de classes cuja origem não pode ser controlada, pois a desserialização pode causar riscos potenciais.