Introduction détaillée aux exemples de code de la classe Memcache de PHP (opération de domaine) qui prend en charge les opérations de groupe

Memcache est une méthode de cache couramment utilisée dans le développement PHP et constitue un composant essentiel des systèmes à haute concurrence.
En développement réel, Memcache a un problème insatisfaisant, c'est-à-dire que Memcache ne peut pas prendre en charge les opérations de groupe sur les clés.

Les opérations de groupe peuvent également être appelées opérations de domaine. Par exemple, un système d'articles utilise Memcache dans la partie frontale pour mettre en cache les données de la page de liste et les données de la page de détail de l'article. Ensuite, lorsqu'un article est publié en arrière-plan, la page de liste doit être mise à jour avec la dernière liste, ce qui peut impliquer de nombreuses pages de liste. Bien entendu, pour la page de détail de l’article, elle n’a pas besoin d’être mise à jour.

D'accord, nous devons actuellement supprimer le cache d'origine afin que le programme puisse mettre à jour automatiquement les données de la page de liste. Cependant, il y a un problème avec l'utilisation de la fonction de vidage de Memcache, c'est-à-dire qu'elle effacera toutes les données, y compris les données des pages de liste et des pages d'articles, lorsque tous les caches seront supprimés et que le cache sera reconstruit. une charge très élevée.

De plus, il peut y avoir des cas où certaines variables de cache que vous ne souhaitez pas supprimer seront perdues, telles que les configurations de programme, les structures de tables de base de données mises en cache pour accélérer, etc.

Nous avons donc besoin d'un mécanisme de mise en cache qui prend en charge les opérations de groupe. Nous pouvons définir la page de liste dans un groupe, les données de la page d'article dans un autre groupe, la configuration du programme dans un autre groupe, et ainsi de suite. Lorsque vous devez reconstruire la page de liste, il vous suffit de supprimer toutes les données du groupe de pages de liste sans affecter les données des autres groupes.

Après avoir testé plusieurs solutions, la solution suivante est la plus idéale et la plus rapide Regardons d'abord le code, puis parlons du principe :

<?php 
class MyCache 
{ 
    private $mmc = null; 
    private $group = null; 
    function __construct($group){ 
        if(!class_exists(&#39;mmcache&#39;)){ 
            $this->mmc = false; 
            return; 
        } 
        $this->mmc = new memcache(); 
        $this->mmc->addServer(&#39;192.168.1.5&#39;, 11211); 
        $this->mmc->addServer(&#39;192.168.1.6&#39;, 11211); 
        $this->group = $group; 
        $this->version = $this->mmc->get(&#39;version_&#39;.$group); 
	if(empty($this->version)){
	 $this->version=1;	
	}   
    } 
    function set($key, $var, $expire=3600){ 
        if(!$this->mmc)return; 
	$this->check_version($this->group,$this->version,$key);
        return $this->mmc->set($this->group.&#39;_&#39;.$this->version.&#39;_&#39;.$key, $var, $expire); 
    } 
    function get($key){ 
        if(!$this->mmc)return; 
	$this->check_version($this->group,$this->version,$key);
        return $this->mmc->get($this->group.&#39;_&#39;.$this->version.&#39;_&#39;.$key); 
    } 
    function incr($key, $value=1){ 
        if(!$this->mmc)return; 
        return $this->mmc->increment($this->group.&#39;_&#39;.$this->version.&#39;_&#39;.$key, $value); 
    } 
    function decr($key, $value=1){ 
        if(!$this->mmc)return; 
        return $this->mmc->decrement($this->group.&#39;_&#39;.$this->version.&#39;_&#39;.$key, $value); 
    } 
    function delete($key){ 
        if(!$this->mmc)return; 
        return $this->mmc->delete($this->group.&#39;_&#39;.$this->version.&#39;_&#39;.$key); 
    } 
    function flush(){ 
        if(!$this->mmc)return; 
        ++$this->version; 
        $this->mmc->set(&#39;version_&#39;.$this->group, $this->version); 
    } 
   function check_version($goup,$version,$key){
		if($version>1){
			$version_old=$version-1;
			return $this->mmc->delete($goup.&#39;_&#39;.$version_old.&#39;_&#39;.$key);
		}
    }

} 
?>

.
La classe ci-dessus Elle est relativement complète, comprenant la connexion au service Memcache, la définition et l'obtention de valeurs, l'augmentation et la diminution des valeurs, ainsi que la suppression de clés et la suppression de tout (flush). Cela inclut les fonctions d'opération Memcache régulières et les extensions aux opérations de suppression complète (vidage).

Comme vous pouvez le voir dans le code, la fonction de vidage du groupe de support est implémentée via la clé de version. Autrement dit, chaque fois que la variable du groupe est enregistrée, la valeur de version sera ajoutée à la clé. de la variable. Version La valeur est un nombre (à partir de 1) et la valeur de version sera utilisée lors du stockage et de la récupération de la clé.

Lorsque le développeur souhaite vider les données du groupe actuel, l'opération de vidage modifie simplement certaines valeurs de version (plus une). Ensuite, lors du prochain accès à la clé, la valeur d'origine ne sera pas). obtenu. ——Parce que la version a changé, c'est-à-dire que le nom de la clé a changé. De cette manière, la valeur d'origine sera automatiquement recyclée par Memcache sans aucune surcharge d'efficacité. De plus, le programme ajoute uniquement le stockage et la récupération d'une version, la quantité de données est extrêmement faible et n'a pratiquement aucun impact sur l'efficacité du système.

Grâce aux classes ci-dessus, des opérations de groupe peuvent être effectuées sur le cache Memcache, et cette classe PHP peut également être étendue, comme l'ajout d'un socket pour accéder directement à la fonction d'interface de memcache, afin qu'il n'y ait pas besoin pour installer l'extension memcache dans la classe d'environnement PHP, ce qui est plus efficace pour éviter les erreurs de vidage, et après avoir ajouté des mécanismes de mise en cache tels que apc, l'accès par socket à l'interface memcache ne sera pas beaucoup plus lent que l'expansion.

De plus, la classe MyCache a une fonction supplémentaire : lorsque le service memcache échoue, la classe MyCache renvoie simplement une valeur nulle sans faire directement d'erreur.
L'utilisation de la classe Mycache avec les éléments suivants :

// 引入定义 
include('MyCache.php'); 
 
// 实例化 
$mc = new MyCache('abc'); // 要有域 
 
// 设置值 
$mc->set('word', 'hello world', 900); 
 
// 取得值 
echo $mc->get('word'); 
 
// 删除值 
$mc->delete('word'); 
echo $mc->get('word'); 
 
$mc->set('counter', 1, 290000); 
echo $mc->get('counter'); 
 
// 增加值 
$mc->incr('counter'); 
$mc->incr('counter'); 
echo $mc->get('counter'); 
 
// 减少值 
$mc->decr('counter'); 
echo $mc->get('counter'); 
 
// 按组删 
$mc->flush();

Ce qui précède est le contenu de l'instance de code de la classe MEMCACHE (opération de domaine) exploitée par le groupe de support PHP, Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !