La mise en cache¶

Configuration de la classe Cache¶

La configuration de la classe Cache peut être effectuée n’importe où, mais généralement vous voudrez configurer le cache dans app/Config/bootstrap.php. Vous pouvez configurer autant de configurations de cache dont vous avez besoin, et vous pouvez utiliser tous les mélanges de moteurs de cache. CakePHP utilise deux configurations de cache en interne, qui sont configurés dans app/Config/core.php. Si vous utilisez APC ou Memcache vous devrez vous assurer de définir des clés uniques pour les caches du noyau. Ceci vous évitera qu’une application vienne réécrire les données cache d’une autre application.

L’utilisation de plusieurs configurations de cache peut aider à réduire le nombre de fois où vous aurez à utiliser Cache::set() et permettra aussi de centraliser tous vos paramètres de cache. L’utilisation de plusieurs configurations vous permet également de changer le stockage comme vous l’entendez.

Exemple:

Cache::config('short', array(
    'engine' => 'File',
    'duration' => '+1 hours',
    'path' => CACHE,
    'prefix' => 'cake_short_'
));

// long
Cache::config('long', array(
    'engine' => 'File',
    'duration' => '+1 week',
    'probability' => 100,
    'path' => CACHE . 'long' . DS,
));

En insérant le code ci-dessus dans votre app/Config/bootstrap.php vous aurez deux configurations de cache supplémentaires. Le nom de ces configurations “short” ou “long” est utilisé comme paramètre $config pour Cache::write() et Cache::read().

Création d’un moteur de stockage pour le Cache¶

Vous pouvez fournir vos propre adaptateurs Cache dans app/Lib ou dans un plugin en utilisant $plugin/Lib. Les moteurs de cache App/plugin peuvent aussi remplacer les moteurs du coeur. Les adaptateurs de cache doivent être dans un répertoire cache. Si vous avez un moteur de cache nommé MonMoteurDeCachePerso il devra être placé soit dans app/Lib/Cache/Engine/MonMoteurDeCachePerso.php comme une app/librairie ou dans $plugin/Lib/Cache/Engine/MonMoteurDeCachePerso.php faisant parti d’un plugin. Les configurations de cache venant d’un plugin doivent utiliser la notation par points de plugin.

Cache::config('custom', array(
    'engine' => 'CachePack.MyCustomCache',
    // ...
));

Les moteurs de cache personnalisés doivent étendre CacheEngine qui définit un certain nombre de méthodes d’abstraction ainsi que quelques méthodes d’initialisation.

L’API requise pour CacheEngine est

class CacheEngine¶

La classe de base pour tous les moteurs de cache utilisée avec le Cache.

CacheEngine::write($key, $value, $config = 'default')¶

Retourne:

un booléen en cas de succès.

Écrit la valeur d’une clé dans le cache, la chaîne optionnelle $config spécifie le nom de la configuration à écrire.

CacheEngine::read($key, $config = 'default')¶

Retourne:

La valeur mise en cache ou false en cas d’échec.

Lit une clé depuis le cache. Retourne false pour indiquer que l’entrée a expiré ou n’existe pas.

CacheEngine::delete($key, $config = 'default')¶

Retourne:

Un booléen true en cas de succès.

Efface une clé depuis le cache. Retourne false pour indiquer que l’entrée n’existe pas ou ne peut être effacée.

CacheEngine::clear($check)¶

Retourne:

Un Booléen true en cas de succès.

Efface toutes les clés depuis le cache. Si $check est à true, vous devez valider que chacune des valeurs a réellement expirée.

CacheEngine::clearGroup($group)¶

Renvoie:

Boolean true en cas de succès.

Supprime toutes les clés à partir du cache appartenant au même groupe.

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

Retourne:

La valeur décrémentée en en cas de succès, false sinon.

Décrémente un nombre dans la clé et retourne la valeur décrémentée

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

Retourne:

La valeur incrémentée en en cas de succès, false sinon.

Incrémente un nombre dans la clé et retourne la valeur incrémentée

CacheEngine::gc()¶

Non requise, mais utilisée pour faire du nettoyage quand les ressources expirent. Le moteur FileEngine utilise cela pour effacer les fichiers qui contiennent des contenus expirés.

CacheEngine::add($key, $value)¶

Définit une valeur dans le cache si elle n’existe pas déjà. Devrait utiliser une vérification et une définition atomique quand cela est possible.

Nouveau dans la version 2.8: La méthode add a été ajoutée dans 2.8.0.

Utilisation du Cache pour stocker le résultat des requêtes les plus courantes¶

Vous pouvez considérablement améliorer les performances de vos applications en plaçant les résultats qui ne changent que peu fréquemment ou qui peuvent être sujets à de nombreuses lectures dans le cache. Un exemple parfait de ceci pourrait être les résultats d’un find Model::find(). Une méthode qui utilise la mise en Cache pour stocker les résultats pourrait ressembler à cela:

class Post extends AppModel {

    public function newest() {
        $result = Cache::read('newest_posts', 'longterm');
        if ($result === false) {
            $result = $this->find('all', array('order' => 'Post.updated DESC', 'limit' => 10));
            Cache::write('newest_posts', $result, 'longterm');
        }
        return $result;
    }
}

Vous pouvez améliorer le code ci-dessus en déplaçant la lecture du cache dans un comportement, qui lit depuis le cache, ou qui exécute les méthodes de model. C’est un exercice que vous pouvez faire.

Depuis 2.5, vous pouvez accomplir ce qui est au-dessus de façon bien plus simple en utilisant Cache::remember(). Utiliser la nouvelle méthode ci-dessous ressemblerait à ceci:

class Post extends AppModel {

    public function newest() {
        $model = $this;
        return Cache::remember('newest_posts', function() use ($model){
            return $model->find('all', array(
                'order' => 'Post.updated DESC',
                'limit' => 10
            ));
        }, 'longterm');
    }
}

Utilisation du Cache pour stocker les compteurs¶

L’utilisation de compteurs dans le cache peut être une chose intéressante. Par exemple un simple compte à rebours pour retenir les “slots” restants d’un concours pourrait être stocké en Cache. La classe Cache propose des moyens atomiques pour incrémenter/décrémenter des valeurs de compteur facilement. Les opérations atomiques sont importantes pour ces valeurs parce que cela réduit le risque de contention et la capacité de deux utilisateurs à simultanément en abaisser la valeur et de se retrouver avec une valeur incorrecte.

Après avoir défini une valeur entière vous pouvez la manipuler en utilisant Cache::increment() et Cache::decrement():

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

// Plus tard sur
Cache::decrement('compteur_initial');

//ou
Cache::increment('compteur_initial');

Utilisation des groupes¶

Parfois vous voudrez marquer plusieurs entrées de cache comme appartenant à un même groupe ou un namespace. C’est une exigence courante pour invalider des grosses quantités de clés alors que quelques changements d’informations sont partagés pour toutes les entrées dans un même groupe. Cela est possible en déclarant les groupes dans la configuration de cache:

Cache::config('site_home', array(
    'engine' => 'Redis',
    'duration' => '+999 days',
    'groups' => array('comment', 'post')
));

Disons que vous voulez stocker le HTML généré pour votre page d’accueil dans le cache, mais vous voulez aussi invalider automatiquement ce cache à chaque fois qu’un commentaire ou un post est ajouté à votre base de données. En ajoutant les groupes comment et post, nous avons effectivement taggés les clés stockées dans la configuration du cache avec les noms des deux groupes.

Par exemple, dès qu’un post est ajouté, nous pouvons dire au moteur de Cache de retirer toutes les entrées associées au groupe post:

// Model/Post.php

public function afterSave($created, $options = array()) {
    if ($created) {
        Cache::clearGroup('post', 'site_home');
    }
}

Cache::groupConfigs() peut être utilisée pour récupérer les correspondances entre le groupe et les configurations, par ex: en ayant le même groupe:

// Model/Post.php

/**
 * Une variation de l\'exemple précédent qui nettoie toutes les
 * configurations de Cache ayant le même groupe
 */
public function afterSave($created, $options = array()) {
    if ($created) {
        $configs = Cache::groupConfigs('post');
        foreach ($configs['post'] as $config) {
            Cache::clearGroup('post', $config);
        }
    }
}

Les groupes sont partagés à travers toutes les configs de cache en utilisant le même moteur et le même préfixe. Si vous utilisez les groupes et voulez tirer profit de la suppression de groupe, choisissez un préfixe commun pour toutes vos configs.

l’API de Cache¶

class Cache¶

La classe Cache dans CakePHP fournit un frontend générique pour plusieurs systèmes de cache backend. Différentes configurations de Cache et de moteurs peuvent être configurés dans votre app/Config/core.php

static Cache::config($name = null, $settings = array())¶

Cache::config() est utilisée pour créer des configurations de cache supplémentaires. Ces configurations supplémentaires peuvent avoir différentes durées, moteurs, chemins, ou préfixes par rapport à la configuration par défaut du cache.

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

Cache::read() est utilisée pour lire la valeur en cache stockée dans $key depuis le $config. Si $config est null la configuration par défaut sera utilisée. Cache::read() retournera la valeur en cache si c’est un cache valide ou false si le cache a expiré ou n’existe pas. Le contenu du cache pourrait être vu comme false, donc assurez-vous que vous utilisez les opérateurs de comparaison stricte === ou !==.

Par exemple:

$cloud = Cache::read('cloud');

if ($cloud !== false) {
    return $cloud;
}

// génération des données cloud
// ...

// stockage des donnée en cache
Cache::write('cloud', $cloud);
return $cloud;

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

Cache::write() va écrire $value dans le cache. Vous pouvez lire ou effacer cette valeur plus tard en vous y référant avec $key.. Vous pouvez spécifier une configuration optionnelle pour stocker le cache. Si il n’y a pas de $config spécifiée c’est la configuration par défaut qui sera appliquée. Cache::write() peut stocker n’importe quel type d’objet et elle est idéale pour stocker les résultats des finds de vos models.

if (($posts = Cache::read('posts')) === false) {
    $posts = $this->Post->find('all');
    Cache::write('posts', $posts);
}

Utiliser Cache::write() et Cache::read() pour facilement réduire le nombre de déplacement fait dans la base de données pour rechercher les posts.

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

Cache::delete() vous permet d’enlever complètement un objet mis en cache de son lieu de stockage de Cache.

static Cache::set($settings = array(), $value = null, $config = 'default')¶

Cache::set() vous permet de réécrire temporairement les paramètres de configs pour une opération (habituellement une lecture ou écriture). Si vous utilisez Cache::set() pour changer les paramètres pour une écriture, vous devez aussi utiliser Cache::set() avant de lire les données en retour. Si vous ne faites pas cela, les paramètres par défaut seront utilisés quand la clé de cache est lue.

Cache::set(array('duration' => '+30 days'));
Cache::write('results', $data);

// plus tard

Cache::set(array('duration' => '+30 days'));
$results = Cache::read('results');

Si vous trouvez que vous répétez l’appel à Cache::set() peut-être devriez-vous créer une nouvelle Cache::config(). Qui enlèvera les besoins d’appeler Cache::set().

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

Incrémente de manière atomique une valeur stockée dans le moteur de cache. Idéal pour modifier un compteur ou des valeurs de sémaphore.

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

Décrémente de manière atomique une valeur stockée dans le moteur de cache. Idéal pour modifier un compteur ou des valeurs de sémaphore.

static Cache::add($key, $value, $config = 'default')¶

Ajoute des données au cache, mais seulement si la clé n’existe pas déjà. Dans le cas où cette donnée existe, cette méthode va retourner false. Lorsque c’est possible, les données sont vérifiées et définies de façon atomique.

Nouveau dans la version 2.8: La méthode add a été ajoutée dans 2.8.0.

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

Détruit toutes les valeurs en cache pour une configuration de cache. Dans les moteurs comme Apc, Memcache et Wincache le préfixe de configuration de cache est utilisé pour enlever les entrées de cache. Assurez-vous que les différentes configurations de cache ont un préfixe différent.

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

Renvoie:

Boléen true en cas de succès.

Supprime toutes les clés du cache appartenant au même groupe.

static Cache::gc($config)¶

La Garbage (Poubelle) collecte les entrées dans la configuration du cache. Utilisée principalement par FileEngine. Elle doit être mise en œuvre par n’importe quel moteur de cache qui requiert des évictions manuelles de données de cache.

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

Renvoie:

Tableau de groupes et leurs noms de configuration liés.

Récupère les noms de groupe pour configurer la correspondance.

static Cache::remember($key, $callable, $config = 'default')¶

Fournit une manière facile pour faire la lecture à travers la mise en cache. Si la clé cache existe, elle sera retournée. Si la clé n’existe pas, la callable sera invoquée et les résultats stockés dans le cache au niveau de la clé fournie.

Par exemple, vous voulez souvent mettre en cache les résultats de requête. Vous pouvez utiliser remember() pour faciliter ceci. En supposant que vous utilisez PHP5.3 ou supérieur:

class Articles extends AppModel {
    function all() {
        $model = $this;
        return Cache::remember('all_articles', function() use ($model){
            return $model->find('all');
        });
    }
}

Nouveau dans la version 2.5: remember() a été ajoutée dans 2.5.