Sessões¶

Configuração da Sessão¶

A configuração da sessão é geralmente definida em /config/app.php. As opções disponíveis são:

• Session.timeout - O número de minutos antes que o manipulador de sessões do CakePHP expire a sessão

• Session.defaults - Permite usar as configurações de sessão padrão incorporadas como base para sua configuração de sessão. Veja abaixo os padrões internos.

• Session.handler - Permite definir um manipulador de sessão personalizado. O banco de dados principal e os manipuladores de sessão de cache usam isso. Veja abaixo informações adicionais sobre manipuladores de sessão.

• Session.ini - Permite definir configurações adicionais de sessão ini para sua configuração. Isso combinado com Session.handler substitui os recursos de manipulação de sessão personalizados das versões anteriores

• Session.cookie - O nome do cookie em uso, o padrão é “CAKEPHP”.

• Session.cookiePath - O caminho da URL para o qual o cookie de sessão está definido. Mapeia para a configuração php.ini session.cookie_path. O padrão é o caminho base do aplicativo.

O padrão do CakePHP session.cookie_secure é true, quando seu aplicativo está em um protocolo SSL. Se seu aplicativo atender a partir de protocolos SSL e não SSL, você poderá ter problemas com a perda de sessões. Se você precisar acessar a sessão nos domínios SSL e não SSL, desabilite isso:

Configure::write('Session', [
    'defaults' => 'php',
    'ini' => [
        'session.cookie_secure' => false
    ]
]);

O caminho do cookie da sessão é padronizado como o caminho base do aplicativo. Para mudar isso, você pode usar o valor ini session.cookie_path. Por exemplo, se você deseja que sua sessão persista em todos os subdomínios, você pode:

Configure::write('Session', [
    'defaults' => 'php',
    'ini' => [
        'session.cookie_path' => '/',
        'session.cookie_domain' => '.yourdomain.com'
    ]
]);

Por padrão, o PHP define o cookie da sessão para expirar assim que o navegador é fechado, independentemente do valor configurado Session.timeout. O tempo limite do cookie é controlado pelo valor ini session.cookie_lifetime e pode ser configurado usando:

Configure::write('Session', [
    'defaults' => 'php',
    'ini' => [
        // Invalide o cookie após 30 minutos sem visitar
        // qualquer página do site.
        'session.cookie_lifetime' => 1800
    ]
]);

A diferença entre Session.timeout e o valor session.cookie_lifetime é que este último depende do cliente dizer a verdade sobre o cookie. Se você precisar de uma verificação de tempo limite mais rigorosa, sem depender do que o cliente relata, use Session.timeout.

Observe que Session.timeout corresponde ao tempo total de inatividade para um usuário (ou seja, o tempo sem visitar nenhuma página em que a sessão é usada) e não limita a quantidade total de minutos que um usuário pode permanecer no site.

Manipuladores de sessão e configuração incorporados¶

O CakePHP vem com várias configurações de sessão embutidas. Você pode usá-los como base para a configuração da sessão ou criar uma solução totalmente personalizada. Para usar padrões, basta definir a chave “defaults” como o nome do padrão que você deseja usar. Você pode substituir qualquer subconjunto declarando-o na sua configuração de sessão:

Configure::write('Session', [
    'defaults' => 'php'
]);

O exemplo acima irá usar a configuração de sessão “php” embutida. Você pode aumentar parte ou a totalidade fazendo o seguinte:

Configure::write('Session', [
    'defaults' => 'php',
    'cookie' => 'my_app',
    'timeout' => 4320 // 3 dias
]);

O texto acima substitui o tempo limite e o nome do cookie para a configuração da sessão “php”. As configurações internas são:

• php - Salva sessões com as configurações padrão no seu arquivo php.ini.

• cake - Salva sessões como arquivos dentro de tmp/sessions. Essa é uma boa opção quando em hosts que não permitem que você escreva fora de seu próprio diretório.

• database - Use as sessões de banco de dados internas. Veja abaixo para mais informações.

• cache - Use as sessões de cache internas. Veja abaixo para mais informações.

'Session' => [
    'handler' => [
        'engine' => 'DatabaseSession',
        'model' => 'CustomSessions'
    ]
]

'Session' => [
    'defaults' => 'database'
]

CREATE TABLE `sessions` (
  `id` char(40) CHARACTER SET ascii COLLATE ascii_bin NOT NULL,
  `created` datetime DEFAULT CURRENT_TIMESTAMP, -- Optional
  `modified` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, -- Optional
  `data` blob DEFAULT NULL, -- for PostgreSQL use bytea instead of blob
  `expires` int(10) unsigned DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

'Session' => [
    'defaults' => 'database',
    'handler' => [
        'engine' => 'DatabaseSession',
        'model' => 'CustomSessions'
    ]
]

Configure::write('Session', [
    'defaults' => 'cache',
    'handler' => [
        'config' => 'session'
    ]
]);

Definindo diretivas ini¶

Os padrões internos tentam fornecer uma base comum para a configuração da sessão. Pode ser necessário ajustar também sinalizadores ini específicos. O CakePHP expõe a capacidade de personalizar as configurações ini para as configurações padrão e personalizadas. A chave ini nas configurações da sessão permite especificar valores de configuração individuais. Por exemplo, você pode usá-lo para controlar configurações como session.gc_divisor:

Configure::write('Session', [
    'defaults' => 'php',
    'ini' => [
        'session.cookie_name' => 'MyCookie',
        'session.cookie_lifetime' => 1800, // Valid for 30 minutes
        'session.gc_divisor' => 1000,
        'session.cookie_httponly' => true
    ]
]);

Criando um manipulador de sessão personalizado¶

Criar um manipulador de sessão personalizado é simples no CakePHP. Neste exemplo, criaremos um manipulador de sessão que armazena sessões no cache (APC) e no banco de dados. Isso nos dá o melhor das E/S rápidas da APC, sem a necessidade de se preocupar com a evaporação das sessões quando o cache ficar cheio.

Primeiro, precisamos criar nossa classe personalizada e colocá-la em src/Http/Session/ComboSession.php. A classe deve se parecer com:

namespace App\Http\Session;

use Cake\Cache\Cache;
use Cake\Core\Configure;
use Cake\Http\Session\DatabaseSession;

class ComboSession extends DatabaseSession
{
    public $cacheKey;

    public function __construct()
    {
        $this->cacheKey = Configure::read('Session.handler.cache');
        parent::__construct();
    }

    // Lê dados da sessão.
    public function read($id)
    {
        $result = Cache::read($id, $this->cacheKey);
        if ($result) {
            return $result;
        }

        return parent::read($id);
    }

    // Gravar dados na sessão.
    public function write($id, $data)
    {
        Cache::write($id, $data, $this->cacheKey);

        return parent::write($id, $data);
    }

    // Apaga uma sessão.
    public function destroy($id)
    {
        Cache::delete($id, $this->cacheKey);

        return parent::destroy($id);
    }

    // Remove sessões expiradas.
    public function gc($expires = null)
    {
        return Cache::gc($this->cacheKey) && parent::gc($expires);
    }
}

Nossa classe estende o DatabaseSession interno, para que não tenhamos que duplicar toda a sua lógica e comportamento. Envolvemos cada operação com uma operação Cake\Cache\Cache. Isso nos permite buscar sessões no cache rápido e não ter que nos preocupar com o que acontece quando o cache é preenchido. Usar este manipulador de sessões também é fácil. No seu app.php, faça com que o bloco de sessões esteja como o seguinte:

'Session' => [
    'defaults' => 'database',
    'handler' => [
        'engine' => 'ComboSession',
        'model' => 'Session',
        'cache' => 'apc'
    ]
],
// Certifique-se de adicionar uma configuração de cache apc
'Cache' => [
    'apc' => ['engine' => 'Apc']
]

Agora, nosso aplicativo começará a usar nosso manipulador de sessão personalizado para ler e gravar dados da sessão.

class Session¶

Acessando o Objeto de Sessão¶

Você pode acessar os dados da sessão em qualquer lugar em que tenha acesso a um objeto de solicitação. Isso significa que a sessão é acessível em:

• Controllers

• Views

• Helpers

• Cells

• Components

Além do objeto básico da sessão, você também pode usar o Cake\View\Helper\SessionHelper para interagir com a sessão nas suas visualizações. Um exemplo básico de uso da sessão seria:

// Antes da versão 3.6.0, use session()
$name = $this->getRequest()->getSession()->read('User.name');

// Se você estiver acessando a sessão várias vezes,
// provavelmente desejará uma variável local.
$session = $this->getRequest()->getSession();
$name = $session->read('User.name');

Leitura e gravação de dados da sessão¶

Session::read($key)¶

Você pode ler valores da sessão usando Hash::extract():

$session->read('Config.language');

Session::write($key, $value)¶

$key deve ser o caminho separado por pontos que você deseja escrever $value para:

$session->write(“Config.language”, “en”);

Você também pode especificar um ou vários hashes assim:

$session->write([
  'Config.theme' => 'blue',
  'Config.language' => 'en',
]);

Session::delete($key)¶

Quando você precisar excluir dados da sessão, poderá usar delete():

$session->delete('Some.value');

static Session::consume($key)¶

Quando você precisar ler e excluir dados da sessão, poderá usar consume():

$session->consume('Some.value');

Session::check($key)¶

Se você deseja ver se existem dados na sessão, você pode usar check():

if ($session->check('Config.language')) {
    // Config.language exists existe e não é nulo.
}

Destruindo a Sessão¶

Session::destroy()¶

Destruir a sessão é útil quando os usuários efetuam logout. Para destruir uma sessão, use o método destroy():

$session->destroy();

Destruir uma sessão removerá todos os dados do servidor na sessão, mas não removerá o cookie da sessão.

Identificadores de Sessão Rotativos¶

Session::renew()¶

Embora o AuthComponent renove automaticamente o ID da sessão quando os usuários se conectam e se desconectam, pode ser necessário girar os IDs da sessão manualmente. Para fazer isso, use o método renew():

$session->renew();

Mensagens em Flash¶

Flash messages are small messages displayed to end users once. They are often used to present error messages, or confirm that actions took place successfully.

To set and display flash messages you should use Flash and Flash

Mensagens em Flash são pequenas mensagens exibidas para os usuários finais uma vez. Eles são frequentemente usados para apresentar mensagens de erro ou confirmar que as ações foram realizadas com êxito.

Para definir e exibir mensagens em flash, você deve usar Flash e Flash.