[Plan du site]
Vous êtes ici ---
> Le Site du Zéro
> Les tutoriels
> Non-Officiels
> Site Web
> PHP
> Optimisation & Sécurité
> Système de cache de Dr Night
> Lecture du tutoriel
Système de cache de Dr Night
Vous vous apprêtez à lire un tutoriel rédigé par un membre de ce site. Malgré tout le soin que ce membre a pu apporter au tutoriel, nous ne pouvons pas garantir que les informations contenues sur cette page sont exactes à 100%. Merci de garder cela en tête lorsque vous lirez cette page ;o)
Qu'est-ce qu'un système de cache ?
Un système de cache est un ensemble de fonctions qui permettent de stocker des données à un endroit auquel on peut accéder plus rapidement et plus efficacement que si on les stockait dans une base de données.
Les données sont bel et bien
stockées dans une base, mais le système de cache permet de diminuer le nombre de demandes que ferait une requête SQL, par exemple, et donc de diminuer le temps de chargement de la page.
On dit qu'
on met des données en cache.
Il existe déjà un tutoriel expliquant comment mettre en place un système de cache simple, mais je vais ici vous exposer une autre façon de faire.
Le tutoriel écrit par
php5 : "
Un système de cache simple" propose un système qui met à jour le cache si ce dernier a été créé il y a plus d'une minute, même si les données qu'il contient n'ont pas été modifiées entre temps.
Les problèmes posés sont les suivants :
- les caches peuvent souvent être mis à jour inutilement
- le contenu du cache n'est pas mis à jour instantanément. Il peut être décalé au pire d'une minute.
Quelle différence ici ?
Le système de cache que je vous propose n'est pas basé sur une
mise à jour périodique (toutes les 60 secondes) mais sur une
mise à jour instantanée (mise à jour à chaque modification).
Il est en effet inutile de mettre à jour le cache quand il n'y a pas de modification : changer le cache à chaque modification permet d'avoir un affichage toujours à jour et ce, dans tous les cas.
Création du dossier cache
Pour fonctionner, le système de cache a besoin d'un dossier autorisé en lecture et en écriture pour stocker les données temporaires.
Ici, le dossier sera placé en racine du site et son nom sera
cache (ouais, on va pas spécialement chercher quelque chose d'original
).
Fonctionnement
Le système de cache a besoin d'effectuer
trois actions :
- créer un fichier de cache contenant des informations,
- lire les informations contenues dans un fichier de cache,
- détruire un fichier de cache.
On a seulement besoin de ces trois actions ?
Oui, le système est basé sur la création et la suppression de fichiers, et pas vraiment sur la modification.
Explications
Imaginons que nous voulons mettre en cache les messages d'un sujet de forum.
Au premier affichage, le script constate qu'il n'existe pas de fichier de cache contenant les messages voulus, il va alors récupérer dans la base de données les messages, puis créera un nouveau fichier de cache contenant ces messages.
Aux prochains affichages, le script verra que le fichier de cache existe et lira donc son contenu, sans passer par la base de données.
Lors d'une modification, c'est-à-dire quand un message sera posté, le fichier de cache sera effacé, et la base de données mise à jour pour qu'au prochain affichage, un nouveau fichier de cache soit créé !
Regardez bien, il n'y a que trois actions différentes à effectuer
. On peut maintenant commencer le concret !
Définition des fonctions
Comme je l'ai dit plus haut, le système de cache a besoin d'effectuer trois actions principales. Ces trois grandes actions vont être effectués par trois fonctions PHP (que nous allons créer) :
- create_cache(nom_cache,contenu)
- get_cache(nom_cache)
- destroy_cache(nom_cache)
Vous l'aurez peut-être compris,
create_cache() permet d'enregistrer
contenu dans le fichier de cache nommé
nom_cache,
get_cache() permet de récupérer
contenu et
destroy_cache() permet de détruire le cache
nom_cache.
Écriture des fonctions
Création d'un cache :
create_cache()
OK, c'est cool, mais maintenant on l'enregistre comment, le cache ? Comment elle fonctionne, la fonction create_cache() ?
L'idée est d'obtenir une fonction PHP qui, quand on l'appelle, restitue les données qu'on lui a fournies lors de sa création.
Pour stocker tout type de données, on va utiliser la fonction
serialize(), qui transforme n'importe quelle variable (ou presque) en une chaîne de caractères.
Le fichier créé contiendra le code permettant de récupérer la variable initiale en utilisant la fonction
unserialize().
Voilà la fonction que j'ai faite :
Code : PHP 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 | // met en cache une variable
function create_cache($nom_cache, $contenu)
{
// utilisation de serialize() pour transformer $content en chaine de caractères
$contenu = serialize($contenu);
// échappement les caractères spéciaux pour pouvoir mettre le tout entre quotes dans le futur fichier
$contenu = str_replace(array('', ''', "0"), array('\\', '\'', '0'), $contenu);
// création du code php à stocker dans le fichier
$contenu = '<?php' . "nn" . '$cache = unserialize('' . $contenu . '');' . "nn" . '?>';
// écriture du code dans le fichier
$fichier = fopen('./cache/donnees_' . $nom_cache . '.php', 'w');
$resultat = fwrite($fichier, $contenu);
fclose($fichier);
// renvoie true si l'écriture du fichier a réussi
return $resultat;
}
|
Note : $nom_cache est le nom sous lequel le cache est stocké et $contenu, la variable contenant les données à mettre en cache.
Lecture d'un cache :
get_cache()
Vous pouvez tester la fonction
create_cache(), par exemple en faisant
create_cache('test', 'Bonjour !').
Vous verrez ensuite qu'un fichier nommé
donnees_test.php aura été créé dans le dossier
cache/.
Si l'on regarde le contenu du fichier
donnees_test.php, on voit ceci :
Code : PHP1
2
3
4
5 | <?php
$cache = unserialize('s:9:"Bonjour !";');
?>
|
Le fichier contient les données
sérialisées. Lorsqu'il est exécuté, il recrée les données telles qu'elles étaient au moment de la création du cache avec
unserialize() et les enregistre dans la variable
$cache.
La fonction
get_cache() a donc juste à appeler le fichier créé en utilisant
include(), puis à retourner le contenu de
$cache.
Voici le code que je vous propose :
Code : PHP 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 | // récupère une variable mise en cache
function get_cache($nom_cache)
{
// vérifie que le fichier de cache existe
if ( is_file('./cache/donnees_' . $nom_cache . '.php') )
{
// le fichier existe, on l'exécute puis on retourne le contenu de $cache
include('./cache/donnees_' . $nom_cache . '.php');
return $cache;
}
else
{
// le fichier de cache n'existe pas, on retourne false
return false;
}
}
|
Il est important de retourner
false si le fichier de cache est inexistant. C'est en effet primordial pour le fonctionnement général du système. Cela permet de savoir si un cache existe ou non (vous comprendrez un peu plus bas, si ce n'est pas déjà fait
).
Destruction d'un cache :
destroy_cache()
Cette fonction est simple. Elle permet juste de supprimer un fichier de cache en utilisant la fonction
unlink() :
Code : PHP1
2
3
4
5 | // détruit un cache
function destroy_cache($nom_cache)
{
return @unlink('./cache/donnees_' . $nom_cache . '.php');
}
|
Le @ permet de ne pas afficher de message d'erreur dans le cas où unlink() tenterait d'effacer un fichier qui n'existe pas.
Voilà ! On a créé nos 3 fonctions. Il ne reste plus qu'à les utiliser !
Je vais donc, en reprenant l'exemple des messages d'un sujet de forum, vous montrer comment les fonctions s'emploient. Vous allez voir, ce n'est pas compliqué
!
Lecture des messages
Sans le système de cache
Voici un script d'exemple simplifié récupérant les messages du sujet :
Code : PHP 1
2
3
4
5
6
7
8
9
10
11
12
13 | <?php
// récupération des messages
$resultat = mysql_query('SELECT * FROM messages WHERE sujet = 42');
while ( $ligne = mysql_fetch_array($resultat) )
{
//
// on affiche les messages
//
}
?>
|
Avec le système de cache
Voici maintenant le même script, avec le système de cache.
Code : PHP 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25 | <?php
// on essaye de récupérer les données dans le cache
if ( !$donnees = get_cache('messages_sujet_42') )
{
// le cache n'existe pas, récupération des messages dans la base de données
$resultat = mysql_query('SELECT * FROM messages WHERE sujet = 42');
// stockage du résultat dans la variable $donnees
$donnees = array();
while ( $donnees[] = mysql_fetch_array($resultat) );
// mise en cache de $donnees
create_cache('messages_sujet_42', $donnees);
}
// lecture des messages
foreach ( $donnees as $ligne )
{
//
// on affiche les messages
//
}
?>
|
Qu'est-ce que fait le second script ?
Le second script, contrairement au premier, utilise un intérmédiaire : la variable
$donnees. Si le cache existe, on met le contenu du cache dans
$donnees, sinon on y met le contenu lu depuis la base de données, et on recrée le cache.
Ensuite, on lit les messages ligne par ligne à partir de
$donnees comme si on lisait les lignes obtenues à partir d'une requête SQL.
Ainsi, vous n'avez pas à modifier le code qui consiste à afficher les messages.
Mise à jour du cache lors d'une modification
Voici un code simplifié d'exemple lorsqu'un message est posté :
Code : PHP1
2
3
4
5
6 | <?php
// ajout d'un message
mysql_query('INSERT INTO messages(texte, sujet) VALUES ('blablablablabla', 42)');
?>
|
Ici, il n'y a qu'une chose à faire : supprimer le fichier de cache pour qu'à la prochaine lecture des messages, il soit remis à jour
:
Code : PHP1
2
3
4
5
6
7
8
9 | <?php
// ajout d'un message
mysql_query('INSERT INTO messages(texte, sujet) VALUES ('blablablablabla', 42)');
// suppression du cache
destroy_cache('messages_sujet_42');
?>
|
Voilà ! Ici, le système de cache a été mis en place assez facilement sans grande modification. Avec un système de ce type, on peut facilement ajouter le cache à ses anciens scripts, par exemple
!
Ce tutoriel s'achève ici, je vous souhaite une bonne optimisation de vos scripts
!
Et si vous avez des questions, les commentaires sont là.
Tutoriels
Communauté
Mon compte
Recherche
Livre d'or
Publicité
112 Zéros connectés |
8 requêtes |
0.0197s (0.01s)
