Caching¶

Configurando Mecanismos de Cache¶

static Cake\Cache\Cache::setConfig($key, $config = null)¶

Seu aplicativo pode configurar qualquer número de “engines” durante o processo de inicialização. As configurações do mecanismo de cache são definidas em config/app.php.

Para um desempenho ideal, o CakePHP requer que dois mecanismos de cache sejam definidos.

• _cake_core_ é usado para armazenar mapas de arquivos e resultados analisados de arquivos Internacionalização e Localização.

• _cake_model_, é usado para armazenar descrições de esquema para seus modelos de aplicativos.

O uso de várias configurações de mecanismo também permite alterar gradualmente o armazenamento, conforme necessário. Por exemplo, em seu config/app.php, você pode colocar o seguinte:

// ...
'Cache' => [
    'short' => [
        'className' => 'File',
        'duration' => '+1 hours',
        'path' => CACHE,
        'prefix' => 'cake_short_'
    ],
    // Usando um namespace para nome completo.
    'long' => [
        'className' => 'Cake\Cache\Engine\FileEngine',
        'duration' => '+1 week',
        'probability' => 100,
        'path' => CACHE . 'long' . DS,
    ]
]
// ...

As opções de configuração também podem ser fornecidas como uma string DSN. Isso é útil ao trabalhar com variáveis de ambiente ou provedores de PaaS:

Cache::setConfig('short', [
    'url' => 'memcached://user:password@cache-host/?timeout=3600&prefix=myapp_',
]);

Ao usar uma sequência DSN, você pode definir parâmetros/opções adicionais como argumentos da sequência de consultas.

Você também pode configurar os mecanismos de cache em tempo de execução:

// Usando um nome abreviado
Cache::setConfig('short', [
    'className' => 'File',
    'duration' => '+1 hours',
    'path' => CACHE,
    'prefix' => 'cake_short_'
]);

// Usando um namespace para nome completo.
Cache::setConfig('long', [
    'className' => 'Cake\Cache\Engine\FileEngine',
    'duration' => '+1 week',
    'probability' => 100,
    'path' => CACHE . 'long' . DS,
]);

// Usando um construtor de objeto
$object = new FileEngine($config);
Cache::setConfig('other', $object);

O nome dessas configurações de mecanismo (“curto” e “longo”) é usado como o parâmetro $config para Cake\Cache\Cache::write() e Cake\Cache\Cache::read(). Ao configurar mecanismos de cache, você pode consultar o nome da classe usando as seguintes sintaxes:

// Nome curto (in App\ or Cake namespaces)
Cache::setConfig('long', ['className' => 'File']);

// Plugin com nome curto
Cache::setConfig('long', ['className' => 'MyPlugin.SuperCache']);

// Namespace completo
Cache::setConfig('long', ['className' => 'Cake\Cache\Engine\FileEngine']);

// Um objeto implementando CacheEngineInterface
Cache::setConfig('long', ['className' => $myCache]);

Cache::setConfig('redis', [
    'className' => 'Redis',
    'duration' => '+1 hours',
    'prefix' => 'cake_redis_',
    'host' => '127.0.0.1',
    'port' => 6379,
    'fallback' => 'default',
]);

Cache::setConfig('redis', [
    'className' => 'Redis',
    'duration' => '+1 hours',
    'prefix' => 'cake_redis_',
    'host' => '127.0.0.1',
    'port' => 6379,
    'fallback' => false
]);

Gravando em um Cache¶

static Cake\Cache\Cache::write($key, $value, $config = 'default')¶

Cache::write() gravará um $valor no cache. Você pode ler ou excluir esse valor posteriormente consultando-o com $key. Você pode especificar uma configuração opcional para armazenar o cache também. Se nenhum $config for especificado, o padrão será usado. Cache::write() pode armazenar qualquer tipo de objeto e é ideal para armazenar resultados de descobertas de modelos:

if (($posts = Cache::read('posts')) === false) {
    $posts = $someService->getAllPosts();
    Cache::write('posts', $posts);
}

Usando Cache::write() e Cache::read() irá reduzir o número de viagens feitas ao banco de dados para buscar postagens.

$result = Cache::writeMany([
    'article-' . $slug => $article,
    'article-' . $slug . '-comments' => $comments
]);

// $result poderá conter
['article-first-post' => true, 'article-first-post-comments' => true]

class IssueService
{
    public function allIssues($repo)
    {
        return Cache::remember($repo . '-issues', function () use ($repo) {
            return $this->fetchAll($repo);
        });
    }
}

Lendo de um Cache¶

static Cake\Cache\Cache::read($key, $config = 'default')¶

Cache::read() é usado para ler o valor em cache armazenado em $key do $config. Se $config for nulo, a configuração padrão será usada. Cache::read() retornará o valor em cache se for um cache válido ou false se o cache expirou ou não existe. O conteúdo do cache pode ser avaliado como falso, portanto, use os operadores de comparação estritos: === ou !==.

Por exemplo:

$cloud = Cache::read('cloud');
if ($cloud !== false) {
    return $cloud;
}

// Gere dados na nuvem
// ...

// Armazenar dados no cache
Cache::write('cloud', $cloud);

return $cloud;

Ou, se você estiver usando outra configuração de cache chamada short, poderá especificá-la nas chamadas Cache::read() e Cache::write(), conforme abaixo:

// Leia a chave "cloud", mas a partir da configuração curta em vez do padrão

$cloud = Cache::read('cloud', 'short');
if ($cloud !== false) {
    return $cloud;
}

// Gere dados na nuvem
// ...

// Armazene dados no cache, usando a configuração de cache "short" em vez do padrão
Cache::write('cloud', $cloud, 'short');

return $cloud;

$result = Cache::readMany([
    'article-' . $slug,
    'article-' . $slug . '-comments'
]);
// $result poderá conter
['article-first-post' => '...', 'article-first-post-comments' => '...']

Exclusão de um Cache¶

static Cake\Cache\Cache::delete($key, $config = 'default')¶

Cache::delete() permitirá remover completamente um objeto em cache da loja:

// Remove uma chave
Cache::delete('my_key');

$result = Cache::deleteMany([
    'article-' . $slug,
    'article-' . $slug . '-comments'
]);
// $result conterá
['article-first-post' => true, 'article-first-post-comments' => true]

Limpando Dados em Cache¶

static Cake\Cache\Cache::clear($check, $config = 'default')¶

Destrua todos os valores em cache para uma configuração de cache. Em mecanismos como: Apcu, Memcached e Wincache, o prefixo da configuração do cache é usado para remover as entradas do cache. Verifique se diferentes configurações de cache têm prefixos diferentes:

// Limpa apenas as chaves expiradas.
Cache::clear(true);

// Limpará todas as chaves.
Cache::clear(false);

Usando Cache para Armazenar Contadores¶

static Cake\Cache\Cache::increment($key, $offset = 1, $config = 'default')¶

static Cake\Cache\Cache::decrement($key, $offset = 1, $config = 'default')¶

Os contadores no seu aplicativo são bons candidatos para armazenamento em cache. Como exemplo, uma contagem regressiva simples para os “slots” restantes em uma disputa pode ser armazenada no cache. A classe Cache expõe maneiras atômicas de aumentar/diminuir os valores dos contadores de maneira fácil. As operações atômicas são importantes para esses valores, pois reduzem o risco de contenção e a capacidade de dois usuários reduzirem simultaneamente o valor em um, resultando em um valor incorreto.

Depois de definir um valor inteiro, você pode manipulá-lo usando increment() e decrement():

Cache::write('initial_count', 10);

// Decrementa
Cache::decrement('initial_count');

// Ou
Cache::increment('initial_count');

Usando o Cache para Armazenar Resultados Comuns de Consulta¶

Você pode melhorar bastante o desempenho do seu aplicativo colocando resultados que raramente mudam ou estão sujeitos a leituras pesadas no cache. Um exemplo perfeito disso são os resultados de Cake\ORM\Table::find(). O objeto Query permite armazenar resultados em cache usando o método cache(). Veja a seção Cache de Resultados Carregados para mais informações.

Usando Grupos¶

Às vezes, você deseja marcar várias entradas de cache para pertencer a determinado grupo ou namespace. Esse é um requisito comum para chaves de invalidação em massa sempre que algumas informações são alteradas e são compartilhadas entre todas as entradas no mesmo grupo. Isso é possível declarando os grupos na configuração de cache:

Cache::setConfig('site_home', [
    'className' => 'Redis',
    'duration' => '+999 days',
    'groups' => ['comment', 'article']
]);

Cake\Cache\Cache::clearGroup($group, $config = 'default')¶

Digamos que você deseja armazenar o HTML gerado para sua página inicial no cache, mas também deseja invalidá-lo automaticamente sempre que um comentário ou postagem for adicionado ao seu banco de dados. Adicionando os grupos comment e article, identificamos efetivamente qualquer chave armazenada nessa configuração de cache com os dois nomes de grupos.

Por exemplo, sempre que uma nova postagem é adicionada, poderíamos dizer ao mecanismo de cache para remover todas as entradas associadas ao grupo article:

// src/Model/Table/ArticlesTable.php
public function afterSave($event, $entity, $options = [])
{
    if ($entity->isNew()) {
        Cache::clearGroup('article', 'site_home');
    }
}

static Cake\Cache\Cache::groupConfigs($group = null)¶

groupConfigs() pode ser usado para recuperar o mapeamento entre o grupo e as configurações, ou seja: ter o mesmo grupo:

// src/Model/Table/ArticlesTable.php

/**
 * Uma variação do exemplo anterior que limpa todas as
 * configurações de cache com o mesmo grupo
 */
public function afterSave($event, $entity, $options = [])
{
    if ($entity->isNew()) {
        $configs = Cache::groupConfigs('article');
        foreach ($configs['article'] as $config) {
            Cache::clearGroup('article', $config);
        }
    }
}

Os grupos são compartilhados em todas as configurações de cache usando o mesmo mecanismo e o mesmo prefixo. Se você estiver usando grupos e quiser tirar proveito da exclusão do grupo, escolha um prefixo comum para todas as suas configurações.

Ativar ou Desativar Globalmente o Cache¶

static Cake\Cache\Cache::disable¶

Pode ser necessário desativar todas as leituras e gravações do cache ao tentar descobrir problemas relacionados à expiração do cache. Você pode fazer isso usando enable() e disable():

// Desative todas as leituras de cache e gravações de cache.
Cache::disable();

Uma vez desativado, todas as leituras e gravações retornarão null.

static Cake\Cache\Cache::enable¶

Uma vez desativado, você pode usar enable() para reativar o cache:

// Reative todas as leituras e gravações do cache.
Cache::enable();

static Cake\Cache\Cache::enabled¶

Se você precisar verificar o estado do cache, poderá usar enabled().

Criando um Mecanismo de Cache¶

Você pode fornecer mecanismos personalizados de Cache em App\Cache\Engine, bem como em plugins usando $plugin\Cache\Engine. Os mecanismos de cache devem estar em um diretório de cache. Se você tivesse um mecanismo de cache chamado MyCustomCacheEngine, ele seria colocado em src/Cache/Engine/MyCustomCacheEngine.php. Ou em plugins/MyPlugin/src/Cache/Engine/MyCustomCacheEngine.php como parte de um plug-in. As configurações de cache dos plugins precisam usar a sintaxe de pontos do plug-in:

Cache::setConfig('custom', [
    'className' => 'MyPlugin.MyCustomCache',
    // ...
]);

Os mecanismos de cache personalizado devem estender Cake\Cache\CacheEngine, que define vários métodos abstratos, além de fornecer alguns métodos de inicialização.

A API necessária para um CacheEngine é

class Cake\Cache\CacheEngine¶

A classe base para todos os mecanismos de cache usados com o Cache.

Cake\Cache\CacheEngine::write($key, $value)¶

Returns:

boolean para sucesso.

Escreva o valor de uma chave no cache, retorna true se os dados foram armazenados em cache com sucesso, false em caso de falha.

Cake\Cache\CacheEngine::read($key)¶

Returns:

O valor em cache ou false para falha.

Leia uma chave do cache. Retorne false para indicar que a entrada expirou ou não existe.

Cake\Cache\CacheEngine::delete($key)¶

Returns:

Booleano true para sucesso.

Exclua uma chave do cache. Retorne false para indicar que a entrada não existia ou não pôde ser excluída.

Cake\Cache\CacheEngine::clear($check)¶

Returns:

Booleano true para sucesso.

Exclua todas as chaves do cache. Se $check for true, você deve validar se cada valor realmente expirou.

Cake\Cache\CacheEngine::clearGroup($group)¶

Returns:

Booleano true para sucesso.

Exclua todas as chaves do cache pertencentes ao mesmo grupo.

Cake\Cache\CacheEngine::decrement($key, $offset = 1)¶

Returns:

Booleano true para sucesso.

Decrementar um número na chave e retorna o valor decrementado

Cake\Cache\CacheEngine::increment($key, $offset = 1)¶

Returns:

Booleano true para sucesso.

Incremente um número abaixo da chave e retorna valor incrementado