Detaillierte Einführung in Codebeispiele der Memcache-Klasse (Domänenoperation) von PHP, die Gruppenoperationen unterstützt

Memcache ist eine Cache-Methode, die häufig in der PHP-Entwicklung verwendet wird und eine wesentliche Komponente in Systemen mit hoher Parallelität ist.
In der tatsächlichen Entwicklung gibt es bei Memcache ein unbefriedigendes Problem: Memcache kann keine Gruppenoperationen für Schlüssel unterstützen.

Gruppenoperationen können auch als Domänenoperationen bezeichnet werden. Beispielsweise verwendet ein Artikelsystem Memcache im Front-End-Teil, um Listenseitendaten und Artikeldetailseitendaten zwischenzuspeichern. Wenn dann ein Artikel im Hintergrund veröffentlicht wird, sollte die Listenseite auf die neueste Liste aktualisiert werden – was viele Listenseiten umfassen kann. Für die Artikeldetailseite muss diese natürlich nicht aktualisiert werden.

Okay, zu diesem Zeitpunkt müssen wir den ursprünglichen Cache löschen, damit das Programm die Listenseitendaten automatisch aktualisieren kann. Es gibt jedoch ein Problem bei der Verwendung der Flush-Funktion von Memcache, das heißt, es werden alle Daten gelöscht, einschließlich der Daten von Listenseiten und Artikelseiten. Wenn alle Caches gelöscht und der Cache neu erstellt werden, ist dies der Fall eine sehr hohe Belastung.

Darüber hinaus kann es Fälle geben, in denen einige Cache-Variablen verloren gehen, die Sie nicht löschen möchten, z. B. Programmkonfigurationen, Datenbanktabellenstrukturen, die zur Beschleunigung zwischengespeichert werden usw.

Wir benötigen also einen Caching-Mechanismus, der Gruppenoperationen unterstützt, die Listenseite in eine Gruppe, die Artikelseitendaten in eine andere Gruppe, die Programmkonfiguration in eine andere Gruppe und so weiter. Wenn Sie die Listenseite neu erstellen müssen, müssen Sie nur alle Daten in der Listenseitengruppe löschen, ohne dass dies Auswirkungen auf die Daten in anderen Gruppen hat.

Nachdem wir mehrere Lösungen getestet haben, ist die folgende Lösung die idealste und schnellste. Schauen wir uns zuerst den Code an und sprechen dann über das Prinzip:

<?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);
		}
    }

} 
?>

Die obige Klasse ist relativ vollständig, einschließlich der Verknüpfung mit dem Memcache-Dienst, dem Festlegen und Abrufen von Werten, dem Erhöhen und Verringern von Werten sowie dem Löschen von Schlüsseln und dem Löschen aller (Flush). Dazu gehören reguläre Memcache-Betriebsfunktionen und Erweiterungen für vollständige Löschvorgänge (Flush).

Wie Sie dem Code entnehmen können, wird die Flush-Funktion der Support-Gruppe über den Versionsschlüssel implementiert. Das heißt, jedes Mal, wenn die Variable der Gruppe gespeichert wird, wird der Versionswert zum Schlüssel hinzugefügt der Variablen. Version Der Wert ist eine Zahl (beginnend bei 1), und der Versionswert wird beim Speichern und Abrufen des Schlüssels verwendet.

Wenn der Entwickler die Daten der aktuellen Gruppe löschen möchte, ändert der Spülvorgang einfach einige Versionswerte (plus einen). Beim nächsten Zugriff auf den Schlüssel ist der ursprüngliche Wert nicht mehr vorhanden erhalten – Weil sich die Version geändert hat, dh der Schlüsselname hat sich geändert. Auf diese Weise wird der ursprüngliche Wert von Memcache automatisch ohne Effizienzaufwand recycelt. Darüber hinaus fügt das Programm nur das Speichern und Abrufen einer Version hinzu, die Datenmenge ist äußerst gering und hat grundsätzlich keinen Einfluss auf die Systemeffizienz.

Über die oben genannten Klassen können Gruppenoperationen im Memcache-Cache ausgeführt werden, und diese PHP-Klasse kann auch erweitert werden, z. B. durch Hinzufügen eines Sockets für den direkten Zugriff auf die Schnittstellenfunktion von Memcache, sodass keine Notwendigkeit besteht Installieren Sie die Memcache-Erweiterung in der PHP-Umgebungsklasse, um Fehloperationen beim Flush effektiver zu vermeiden. Nach dem Hinzufügen von Caching-Mechanismen wie APC ist der Socket-Zugriff auf die Memcache-Schnittstelle nicht viel langsamer als die Erweiterung.

Darüber hinaus verfügt die MyCache-Klasse über eine zusätzliche Funktion: Wenn der Memcache-Dienst ausfällt, gibt die MyCache-Klasse einfach einen Nullwert zurück, ohne direkt einen Fehler zu machen.
Die Verwendung der Mycache-Klasse mit Folgendem:

// 引入定义 
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();

Das Obige ist der Inhalt der Codeinstanz der MEMCACHE-Klasse (Domänenoperation), die von betrieben wird die PHP-Supportgruppe. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!