Caching¶

Configuración de los Motores de Caché¶

static Cake\Cache\Cache::setConfig($clave, $configuracion = null)¶

Tu aplicación puede configurar cualquier número de “motores” durante su proceso de inicio. Las configuraciones del motor de caché se definen en config/app.php.

Para un rendimiento óptimo, CakePHP requiere que se definan dos motores de caché.

• _cake_core_ se utiliza para almacenar mapas de archivos y resultados analizados de archivos de Internationalization & Localization.

• _cake_model_ se utiliza para almacenar descripciones de esquemas para los modelos de tu aplicación.

Usar múltiples configuraciones de motores también te permite cambiar incrementalmente el almacenamiento según sea necesario. Por ejemplo, en tu config/app.php podrías poner lo siguiente:

// ...
'Cache' => [
    'short' => [
        'className' => 'File',
        'duration' => '+1 hours',
        'path' => CACHE,
        'prefix' => 'cake_short_',
    ],
    // Usando un nombre completamente calificado.
    'long' => [
        'className' => 'Cake\Cache\Engine\FileEngine',
        'duration' => '+1 week',
        'probability' => 100,
        'path' => CACHE . 'long' . DS,
    ],
]
// ...

Las opciones de configuración también se pueden proporcionar como una cadena DSN. Esto es útil cuando se trabaja con variables de entorno o proveedores de PaaS:

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

Cuando usas una cadena DSN, puedes definir cualquier parámetro/opción adicional como argumentos de cadena de consulta.

También puedes configurar los motores de caché en tiempo de ejecución:

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

// Usando un nombre completamente calificado.
Cache::setConfig('long', [
    'className' => 'Cake\Cache\Engine\FileEngine',
    'duration' => '+1 week',
    'probability' => 100,
    'path' => CACHE . 'long' . DS,
]);

// Usando un objeto construido.
$objeto = new FileEngine($configuracion);
Cache::setConfig('otro', $objeto);

Los nombres de estas configuraciones de motor (“short” y “long”) se utilizan como el parámetro $config para Cake\Cache\Cache::write() y Cake\Cache\Cache::read(). Al configurar los motores de caché, puedes referenciar el nombre de la clase utilizando las siguientes sintaxis:

// Nombre corto (en App\ o en los espacios de nombres de Cake)
Cache::setConfig('long', ['className' => 'File']);

// Nombre corto del plugin
Cache::setConfig('long', ['className' => 'MyPlugin.SuperCache']);

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

// Un objeto que implementa CacheEngineInterface
Cache::setConfig('long', ['className' => $miCache]);

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

Escritura en Caché¶

static Cake\Cache\Cache::write($clave, $valor, $configuracion = 'default')¶

Cache::write() escribirá un $valor en la caché. Puedes leer o eliminar este valor más tarde refiriéndote a él por $clave. Puedes especificar una configuración opcional para almacenar la caché también. Si no se especifica ninguna $configuración, se usará la predeterminada. Cache::write() puede almacenar cualquier tipo de objeto y es ideal para almacenar resultados de búsquedas de modelos:

$entradas = Cache::read('entradas');
if ($entradas === null) {
    $entradas = $servicio->obtenerTodasLasEntradas();
    Cache::write('entradas', $entradas);
}

Usar Cache::write() y Cache::read() para reducir el número de consultas realizadas a la base de datos para obtener las entradas.

$resultado = Cache::writeMany([
    'articulo-' . $slug => $articulo,
    'articulo-' . $slug . '-comentarios' => $comentarios
]);

// $resultado contendrá
['articulo-primer-post' => true, 'articulo-primer-post-comentarios' => true]

// Establecer una clave para actuar como bloqueo
$resultado = Cache::add($claveBloqueo, true);
if (!$resultado) {
    return;
}
// Realizar una acción donde solo puede haber un proceso activo a la vez.

// Eliminar la clave de bloqueo.
Cache::delete($claveBloqueo);

class ServicioDeAsunto
{
    public function todasLasTemas($repositorio)
    {
        return Cache::remember($repositorio . '-temas', function () use ($repositorio) {
            return $this->obtenerTodos($repositorio);
        });
    }
}

Lectura Desde la Caché¶

static Cake\Cache\Cache::read($clave, $configuracion = 'default')¶

Cache::read() se usa para leer el valor en caché almacenado bajo $clave desde la $configuración. Si $configuración es nulo, se usará la configuración predeterminada configuración. Cache::read() devolverá el valor en caché si es una caché válida o null si la caché ha caducado o no existe. Utiliza los operadores de comparación estricta === o !== para comprobar el éxito de la operación Cache::read().

Por ejemplo:

$nube = Cache::read('nube');
if ($nube !== null) {
    return $nube;
}

// Generar datos de la nube
// ...

// Almacenar datos en la caché
Cache::write('nube', $nube);

return $nube;

O si estás usando otra configuración de caché llamada corta, puedes especificarlo en las llamadas a Cache::read() y Cache::write() de la siguiente manera:

// Leer la clave "nube", pero de la configuración corta en lugar de la predeterminada
$nube = Cache::read('nube', 'corta');
if ($nube === null) {
    // Generar datos de la nube
    // ...

    // Almacenar datos en la caché, usando la configuración de caché corta en lugar de la predeterminada
    Cache::write('nube', $nube, 'corta');
}

return $nube;

$resultado = Cache::readMany([
    'articulo-' . $slug,
    'articulo-' . $slug . '-comentarios'
]);
// $resultado contendrá
['articulo-primer-post' => '...', 'articulo-primer-post-comentarios' => '...']

Eliminación de la Caché¶

static Cake\Cache\Cache::delete($clave, $configuracion = 'default')¶

Cache::delete() te permitirá eliminar completamente un objeto en caché del almacén:

// Eliminar una clave
Cache::delete('mi_clave');

A partir de la versión 4.4.0, el RedisEngine también proporciona un método deleteAsync() que utiliza la operación UNLINK para eliminar las claves de caché:

Cache::pool('redis')->deleteAsync('mi_clave');

$resultado = Cache::deleteMany([
    'articulo-' . $slug,
    'articulo-' . $slug . '-comentarios'
]);
// $resultado contendrá
['articulo-primer-post' => true, 'articulo-primer-post-comentarios' => true]

Limpieza de Datos en Caché¶

static Cake\Cache\Cache::clear($configuracion = 'default')¶

Elimina todos los valores en caché para una configuración de caché. En motores como: Apcu, Memcached, se utiliza el prefijo de la configuración de caché para eliminar entradas de caché. Asegúrate de que las diferentes configuraciones de caché tengan diferentes prefijos:

// Eliminará todas las claves.
Cache::clear();

A partir de la versión 4.4.0, el RedisEngine también proporciona un método clearBlocking() que utiliza la operación UNLINK para eliminar las claves de caché:

Cache::pool('redis')->clearBlocking();

Uso de Caché para Almacenar Contadores¶

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

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

Los contadores en tu aplicación son buenos candidatos para ser almacenados en caché. Por ejemplo, una contador de días para un evento puede ser guardado en la caché. La clase Cache expone formas de incrementar y decrementar los valores del contador. El hecho de que estas operaciones sean atómicas es importante para que se reduzca el riesgo de contención y la abilidad de que dos usuarios simultaneamente incrementen o decrementen el mismo valor.

Después de guardar un valor entero en la caché, puedes manipularlo usando increment() y decrement():

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

// Later on
Cache::decrement('initial_count');

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

Utilizando la Caché para Almacenar Resultados Comunes de Consultas¶

Puedes mejorar significativamente el rendimiento de tu aplicación almacenando en caché los resultados que rara vez cambian o que están sujetos a lecturas frecuentes. Un ejemplo perfecto de esto son los resultados de Cake\ORM\Table::find(). El objeto de consulta te permite almacenar en caché los resultados utilizando el método cache(). Consulta la sección Utilizando la Caché para Almacenar Resultados Comunes de Consultas para obtener más información.

Uso de Grupos¶

A veces querrás marcar varias entradas en caché para que pertenezcan a cierto grupo o espacio de nombres. Esta es una necesidad común para invalidar masivamente claves cada vez que cambia alguna información que se comparte entre todas las entradas en el mismo grupo. Esto es posible declarando los grupos en la configuración de la caché:

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

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

Digamos que quieres almacenar en caché el HTML generado para tu página de inicio, pero también quieres invalidar automáticamente esta caché cada vez que se agrega un comentario o una publicación a tu base de datos. Al agregar los grupos comment y article, hemos etiquetado efectivamente cualquier clave almacenada en esta configuración de caché con ambos nombres de grupo.

Por ejemplo, cada vez que se añade una nueva publicación, podríamos decirle al motor de caché que elimine todas las entradas asociadas al 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() se puede utilizar para recuperar la asignación entre el grupo y las configuraciones, es decir, tener el mismo grupo:

// src/Model/Table/ArticlesTable.php

/**
 * Una variación del ejemplo anterior que limpia todas las configuraciones de caché
 * que tienen el mismo grupo
 */
public function afterSave($event, $entity, $options = [])
{
    if ($entity->isNew()) {
        $configs = Cache::groupConfigs('article');
        foreach ($configs['article'] as $config) {
            Cache::clearGroup('article', $config);
        }
    }
}

Los grupos se comparten en todas las configuraciones de caché que utilizan el mismo motor y el mismo prefijo. Si estás usando grupos y quieres aprovechar la eliminación de grupos, elige un prefijo común para todas tus configuraciones.

Habilitar o Deshabilitar Globalmente la Caché¶

static Cake\Cache\Cache::disable¶

Puede que necesites deshabilitar todas las lecturas y escrituras en la caché cuando intentas resolver problemas relacionados con la expiración de la caché. Puedes hacerlo usando enable() y disable():

// Deshabilitar todas las lecturas y escrituras en la caché.
Cache::disable();

Una vez deshabilitada, todas las lecturas y escrituras devolverán null.

static Cake\Cache\Cache::enable¶

Una vez deshabilitada, puedes usar enable() para habilitar nuevamente la caché:

// Habilitar nuevamente todas las lecturas y escrituras en la caché.
Cache::enable();

static Cake\Cache\Cache::enabled¶

Si necesitas verificar el estado de la caché, puedes usar enabled().

Creación de un Motor de Caché¶

Puedes proporcionar motores de Cache personalizados en App\Cache\Engine, así como en plugins usando $plugin\Cache\Engine. Los motores de caché deben estar en un directorio de caché. Si tuvieras un motor de caché llamado MyCustomCacheEngine, se colocaría en src/Cache/Engine/MyCustomCacheEngine.php. O en plugins/MyPlugin/src/Cache/Engine/MyCustomCacheEngine.php como parte de un plugin. Las configuraciones de caché de los plugins deben utilizar la sintaxis de puntos del plugin:

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

Los motores de caché personalizados deben extender Cake\Cache\CacheEngine, que define varios métodos abstractos y también proporciona algunos métodos de inicialización.

La API requerida para un CacheEngine es

class Cake\Cache\CacheEngine¶

La clase base para todos los motores de caché utilizados con Cache.

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

Devuelve:

booleano para indicar el éxito.

Escribe el valor de una clave en la caché, devuelve true si los datos se almacenaron correctamente, false en caso de fallo.

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

Devuelve:

El valor en caché o null en caso de fallo.

Lee una clave de la caché. Devuelve null para indicar que la entrada ha caducado o no existe.

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

Devuelve:

Booleano true en caso de éxito.

Elimina una clave de la caché. Devuelve false para indicar que la entrada no existía o no se pudo eliminar.

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

Devuelve:

Booleano true en caso de éxito.

Elimina todas las claves de la caché. Si $check es true, debes validar que cada valor realmente ha caducado.

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

Devuelve:

Booleano true en caso de éxito.

Elimina todas las claves de la caché pertenecientes al mismo grupo.

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

Devuelve:

Booleano true en caso de éxito.

Decrementa un número bajo la clave y devuelve el valor decrecido.

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

Devuelve:

Booleano true en caso de éxito.

Incrementa un número bajo la clave y devuelve el valor incrementado.