Le système de cache de Joomla

Le système de cache de Joomla permet de gérer différents niveaux de mise en cache. Par défaut celui-ci est désactivé et à chaque appel d’une page, elle est entièrement reconstruite. L’utilisation du cache permet d’éviter de reconstruire tout ou une partie de la page lorsqu’elle est appelée, ceci augmente la vitesse de restitution de la page, tout en allégeant la charge serveur.

La documentation officielle reste assez sommaire sur le sujet, et pour les développeurs, c’est à peine plus explicite. Je vais donc essayer de vous détailler le fonctionnement du cache et de vous présenter quelques points importants pour l’utilisation du cache lors des développements.

Le cache Joomla côté administration

Joomla permet de mettre en cache soit la page complète, soit les différents éléments de la page : le composant et les modules.

Cache de page

Il est basé sur le plugin Système – Cache. Il enregistre la page dans sa globalité et la lie à son url. Lors d’un nouvel appel de l’url, la page est alors restituée sans être recalculée. Pour l’activer, il faut se rendre dans l’administration, menu Extensions / Gestions des plugins .

Un seul paramètre est disponible et permet d’activer en plus le cache navigateur. Ceci permet de ne pas renvoyer une deuxième fois la page à un utilisateur qui aurait déjà consulté la page depuis sa mise en cache, si il retourne sur la page durant sa navigation.

La durée et la méthode de stockage de la page en cache sont configurables dans l’administration : menu Système / Configuration, onglet Système (cf. Cache de vues et de modules, ci après).

Il s’appuie sur l’url de la page pour le stockage (1 url => 1 page), cela sous entant que vous ne pourrez pas avoir de contenu différent pour une même url. Par exemple impossible d’afficher aléatoirement une image sur une page à chaque chargement. Toutefois le contenu dynamique généré en javascript reste visible puisque le javascript est ré-exécuté par le navigateur à chaque affichage.
Il existe quelques cas où les pages ne sont pas mises en cache :

Pour un utilisateur enregistré sur le site
Pour les formulaires, restez toutefois prudent suivant l’extension que vous utilisez et si vous utilisez des formulaires multi-pages, il peut toutefois y avoir des comportement non souhaités.

Cache de vue et modules

Il peut être activé dans l’administration, menu Système / Configuration, onglet Système.

On a le choix entre 2 types de cache dans Joomla :

Conservateur

Le plus bas niveau de cache, il conserve en cache le rendu de chaque module et vue (retour d’un composant) en fonction des paramètres d’entrée de ceux-ci et de l’url.
Dans le cadre des composants et modules natifs, les caches sont effacés lorsque l’on modifie quelque chose dans l’administration (Ajout d’un article).
Pour les extensions, il faut que les développeurs aient pris en compte ces possibilités pour que cela fonctionne.
Progressiste

Système de cache plus poussé notamment concernant les modules (pour les vues il n’y a aucun changement). Il n’est toutefois pas recommandé pour les très grands sites.
En fait, il prend une « image » de l’ensemble des modules présent sur une page pour chaque combinaison de modules affichés sur le site (typiquement chaque page), et restitue ces images suivant l’url demandée.
Attention : Avec ce type de cache, la mise en cache des modules n’est pas effacée automatiquement lors de modifications dans l’administration. Il faut donc effacer le cache manuellement ou attendre l’expiration du cache pour voir les modules se mettre à jour sur le site.

Noter que pour les modules, il est possible d’interdire la mise en cache d’un module en particulier dans les paramètres de celui-ci (si les développeurs on prévu le cas).

Les autres paramètres à configurer sont :

Le gestionnaire de cache. Nativement il s’agit du système de fichiers mais suivant la configuration du serveur, Joomla peut utiliser des systèmes de cache tel que APC, Eaccelerator, Memcached, etc
La durée de vie du cache (en minutes)

Purger le cache

Dans le cas du cache par page ou du cache progressiste (pour les modules), vous aurez peut-être besoin de purger manuellement le cache pour voir les modifications apportées se répercuter immédiatement en ligne. Pour cela il faut vous rendre dans l’administration, menu Système / Configuration / Purger le cache.

Notez que Joomla fonctionne en « groupes » de cache correspondant aux noms systèmes des différents composants et modules mis en cache . Ceci permet de choisir finement le type d’informations que l’on veut rafraichir.

Le cache côté Développement

Le système de cache de Joomla 3 s’appuie sur la classe JCache. Elle est utilisable et étendable directement, mais il est généralement suffisant et plus aisé d’utiliser les contrôleurs natifs à Joomla instanciant cette classe. Il y a notamment :

JCacheControllerPage, utilisé pour la mise en cache des pages. Vous n’aurez donc probablement pas besoin de vous en soucier.
JCacheControllerView, utilisé pour la mise en cache des vues des composants. Cette classe est notamment utilisée dans la méthode display du contrôleur de base de Joomla JControllerLegacy. Si dans vos développements vous étendez le système MVC de Joomla; son utilisation est donc implicite.
JCacheControllerCallback, utilisé pour mettre en cache le retour des fonctions suivant leurs paramètres d’entrées. Cette classe est très utile lors des développements. En effet même si le cache n’est pas activé dans l’administration de Joomla, vous pouvez l’utiliser pour mettre en cache des fonctions appelées fréquemment et/ou gourmandes en ressources serveur.

Cache de vue

Afin d’utiliser le cache de vue, il suffit d’étendre le système MVC natif de Joomla et d’utiliser les méthodes adéquates. Si vous choisissez de ne pas étendre les contrôleurs et modèles de Joomla lors de vos développements, il sera surement plus judicieux d’utiliser le cache de fonctions pour mettre en cache votre méthode d’affichage.

Du côté site, étendez le contrôleur natif de Joomla, et utilisez sa méthode display pour inclure la prise en compte du cache des vues.

[php]
class VotreComposantController extends JControllerLegacy {
function display() {
//votre traitement
…
parent::display( true ); // appel de la méthode display du parent
//true =>demande de mise en cache (si l’option est activée dans l’administration)
}
}
[/php]

Dans l’administration, le rafraichissement des caches liés au composant est obtenu grâce à la méthode cleanCache de la classe JModelLegacy. Notez que les actions (sauvegarder, réordonner,…) de la classe JModelAdmin incluent toutes une remise à zéro du cache du composant. Pensez donc à réutiliser la méthode parente lorsque vous surchargez une méthode.

[php]
class VotreComposantModelVotreobject extends JModelAdmin {
function save($data) {
//votre pré-traitement
…
return parent::save( $data ); // appel de la méthode save du parent
}
function votreaction($data) {
//vos tests et traitements
…
$this->cleanCache(); // effacement du cache du composant.
return true ;
}
}
[/php]

Cache de module

Le cache de module présente la particularité de pouvoir être géré module par module. Afin de prendre cela en compte lors du développement de modules, il suffit de rajouter dans le xml les champs adéquat. Notez que si vous ne rajoutez pas ces champs dans le xml, les valeurs par défaut sont utilisées lors de la mise en cache Joomla.

[xml]
<field
name="cache"
type="list"
default="1"
label="COM_MODULES_FIELD_CACHING_LABEL"
description="COM_MODULES_FIELD_CACHING_DESC">
<option
value="1">JGLOBAL_USE_GLOBAL</option>
<option
value="0">COM_MODULES_FIELD_VALUE_NOCACHING</option>
</field>

[/xml]

cache : « paramètres globaux » ou « désactivé », s’il n’est pas précisé, les paramètres globaux s’appliquent.
cache_time : durée de vie du cache en secondes, s’il n’est pas précisé, la durée de vie du cache paramétrée dans la configuration du site est utilisée.
cachemode : permet de définir à quels paramètres est rattaché une image mise en cache. Il peut prendre plusieurs valeurs :
- static : une seule image mise en cache quelque soit la page du site.
- itemid (valeur par défaut) : une image mise en cache par page du site.
- safeuri : une image mise en cache suivant l’itemid du site et les paramètres de l’url. Utile si l’affichage de votre module dépend de paramètres présents dans l’url.
- id : une image mise en cache suivant une clef spécifique définit par vos soins dans le fichier php du module. Cette liberté de réglage est rarement utile mais vous pouvez regarder le module mod_articles_category pour avoir un exemple

Notez que si votre module affiche des éléments gérés par un composant dans l’administration, il est possible de rafraichir automatiquement le cache lié à votre module lors de modification. Pour cela il faut surcharger la méthode cleanCache de JModelAdmin dans le modèle gérant les enregistrements.

[php]
class VotreComposantModelVotreobject extends JModelAdmin {
protected function cleanCache($group = null, $client_id = 0)
{
//appel la méthode parente pour effacer le cache de l’un de vos modules
parent::cleanCache(‘mod_votremod1’);
//appel la méthode parente pour effacer le cache d’un autre de vos modules
parent::cleanCache(‘mod_votremod2’);
//rappel le fonctionnement par défaut de la méthode
parent::cleanCache($group,$client_id);
}
}
[/php]

Si vous développez un module affichant des éléments d’un composant que vous ne développez pas, le moyen le plus propre que je connaisse est d’utiliser un plugin pour intercepter les actions effectuées (sauvegarde, changement d’ordre, …) et d’effacer les caches de votre module dans celui-ci. Si vous connaissez un autre moyen je suis preneur (n’hésitez à le partager dans les commentaires). Ça donnerait par exemple :

[php]
class PlgContentCache extends JPlugin
{
…
public function onContentAfterSave($context, $data, $isNew)
{
$allowed_contexts = array(‘com_content.category’, ‘com_content.article’, ‘com_content.featured’);

if (!in_array($context, $allowed_contexts))
{
return true;
}
$cache = JFactory::getCache(‘mod_votremodule’); //effacer le cache de l’un de vos modules
$cache->clean();
…
}

…
}
[/php]

Cache de fonction

Si vous voulez utiliser le cache plus finement que le cache de vue et de module (ou si vous voulez vous affranchir des classes MVC de Joomla), vous pouvez utiliser le cache de fonction de Joomla. Pour cela vous devez instancier un objet de contrôle de cache, et l’utiliser pour appeler une fonction.

[php]

// instancier la classe de cache
$cache = JFactory::getCache($group);
// $group contient le nom de votre composant ou de votre module

// appeler une fonction en vérifiant si le retour est en cache
// les variables à transmettre à la fonction sont passé en argument
$retour = $cache->call( ‘nomFonction’ [, $var1, $var2, …]);
// apriori la fonction "nomFonction" doit être définit dans le fichier d’appel

// appeler la méthode d’une classe
$retour = $cache->call( array( ‘NomClasse’, ‘nomMethode’ ) [, $var1, $var2, …]);
// attention dans ce cas la méthode est exécuter dans un contexte abstrait :
// la variable $this ne peut pas être utilisée dans la méthode

// appeler la méthode d’une classe déjà instanciée
$retour = $cache->call( array( $classe, ‘nomMethode’ ) [, $var1, $var2, …]);
// $classe est objet contenant la méthode ‘nomMethode’
// la variable $this peut être utilisée dans la méthode
[/php]

Le retour des fonctions est alors mise en cache et une image est générée par combinaison des valeurs des variables transmises à la fonction.

Le cache Joomla en résumé

Pour les sites que vous administrez, à mon avis, le meilleur compromis entre souplesse et performance est le cache de vue et de module conservateur.
En cas de fréquentation importante, le cache de page et le cache progressiste présentent de meilleures performances. Par contre, vu qu’ils ne se mettent pas à jour automatiquement, il faut que vos rédacteurs soient familiarisés avec le système de cache et sachent le purger au besoin.

Si votre site contient des fonctions particulières avec lesquels la mise en cache interfère, un système de cache plus pointu permettant de choisir les pages ou le cache s’applique est à envisager. Il existe par exemple le plugin CacheControl.

Pour le développement de composants, l’utilisation des classes MVC natives de Joomla permet d’inclure le fonctionnement du cache. Il faut toutefois penser à bien réinitialiser les caches lors des différentes actions dans l’administration.
La mise en cache de fonctions quand à elle, peut s’avérer très utile lorsque l’on veut gérer plus finement les éléments mis en cache.

Cet article a été rédigé par:

Alex | 15 ans d'experience

Lead développeur

Encadre tous les process de développement de l'agence