Einführung in Memcache

Memcached ist ein leistungsstarker verteilter Speicher-Cache-Server. Entwickelt vom Entwicklungsteam der ausländischen Community-Website LIVEJOURNAL.

Verwendungszweck:

Reduzieren Sie die Anzahl der Datenbankzugriffe durch Zwischenspeichern von Datenbankabfrageergebnissen, um die Geschwindigkeit und Skalierbarkeit dynamischer Webanwendungen zu erhöhen.

memcache ist ein kostenloses und quelloffenes, leistungsstarkes, verteiltes Speicherobjekt-Caching-System. Wird verwendet, um dynamische Webanwendungen zu beschleunigen und die Datenbanklast zu reduzieren.

Funktionen von memcahce

1. Basierend auf der C/S-Architektur, einfaches Protokoll

2. Basierend auf der Libevent-Ereignisverarbeitung {libevent ist eine ereignisgesteuerte Netzwerkbibliothek, die für Windows, Linux, BSD (Unix-Derivatsystem) und andere Plattformen geeignet ist.

3. Integrierte Speicherspeichermethode

4 Verteilungsformel

Anwendbare Szenarien

1. Eine verteilte Bereitstellung ist erforderlich (was verteilt wird: Wenn eine Aufgabe 10 Unteraufgaben hat, legen Sie diese 10 Unteraufgaben separat auf 10 Servern ab, was die Ausführungszeit der Aufgabe erheblich verkürzt ,)

Müssen häufig auf die gleichen Daten zugreifen

Müssen Daten teilen

Einführung in die C/S-Architektur

Installationsstart (siehe PDF-Dokument)

Verwendung verschiedener Befehle

set/add/replace/delete/get/gets/cas/stats/stats items/ append/ prepend/flush_all usw.

einige Funktionen und Einschränkungen gespeichert

①Die Menge der Artikeldaten, die in Memcached gespeichert werden können, ist nicht begrenzt, nur der Speicher reicht aus

②Memcached Single Der vom Prozess verwendete maximale Speicher beträgt 2G. Um mehr Speicher zu verwenden, können Sie mehrere Memcached-Prozesse auf mehreren Ports öffnen.

③ Die maximale Datenablaufzeit beträgt 30 Tage Auch die Konstante REALTIME_MAXDELTA

④60*60*24*30 Control

⑤Die maximale Schlüssellänge beträgt 250 Byte 🎜>

⑥Die maximale Schlüssellänge für ein einzelnes Element beträgt 1 MB. Daten, die 1 MB überschreiten, werden nicht durch die Konstante POWER_BLOCK 1048576 gesteuert.

⑦ Dies ist die Standardplattengröße

⑧Die maximale Anzahl gleichzeitiger Verbindungen beträgt 200, über conn_init() wird freetotal zur Steuerung verwendet, die maximale Anzahl von Softverbindungen beträgt 1024, gesteuert über

⑨settings.maxconns=1024 ⑩Parameter im Zusammenhang mit der Raumbelegung : Settings.factor=1.25, Settings.chunk_size=48, Auswirkungen auf die Datenbelegung von Slab und Schrittweise

Eine Zusammenfassung aller Methoden des Memcache-Clients von PHP
Die Liste aller Methoden der Memcache-Funktion lautet wie folgt:
Memcache::add – Wert hinzufügen. Wenn er bereits vorhanden ist, geben Sie „false“ zurück
Memcache::addServer – Fügen Sie eine Serveradresse zur Verwendung hinzu
Memcache:: close – Ein Memcache-Objekt schließen
Memcache::connect – Ein Memcache-Objekt erstellen
memcache_debug – Debugging-Funktion steuern
Memcache::decrement – ​​Den Wert in einem gespeicherten Schlüssel subtrahieren
Memcache::delete – Löschen ein Schlüsselwert
Memcache::flush – Alle zwischengespeicherten Daten löschen
Memcache::get – Einen Schlüsselwert abrufen
Memcache::getExtendedStats – Die laufenden Systemstatistiken aller Prozesse im Prozesspool abrufen
Memcache::getServerStatus – Ruft die Parameter des laufenden Servers ab
Memcache::getStats – Gibt einige Laufstatistiken des Servers zurück
Memcache::getVersion – Gibt die Versionsinformationen des laufenden Memcache zurück
Memcache::increment – Fügen Sie den Wert in einem gespeicherten Schlüssel hinzu.
Memcache::pconnect – Erstellen Sie ein persistentes Memcache-Verbindungsobjekt.
Memcache::replace – Überschreiben Sie einen vorhandenen Schlüssel.
Memcache::set – Fügen Sie einen Wert hinzu, falls dieser bereits vorhanden ist , überschreiben
Memcache: :setCompressThreshold – Daten komprimieren, die größer als eine bestimmte Größe sind
Memcache::setServerParams – Serverparameter zur Laufzeit ändern

Aufschlüsselung der Memcache-Operationsmethode von PHP

Memcache::add-Nutzung

Der Code lautet wie folgt:

bool Memcache::add ( string $key , Mixed $var [ , int $flag [, int $expire ]] )

Hinweis:
Wenn $key nicht vorhanden ist, verwenden Sie diese Funktion, um den Wert von $var zu speichern. Die funktional äquivalente Funktion ist memcache_add().

Parameter:
$key: Der zu speichernde Schlüsselwert.
$var: Der gespeicherte Wert, der Zeichentyp und der Ganzzahltyp werden als Originalwert gespeichert, andere Typen werden automatisch serialisiert und später gespeichert.
$flag: Ob MEMCACHE_COMPRESSED zum Komprimieren des gespeicherten Werts verwendet werden soll. True bedeutet Komprimierung, False bedeutet keine Komprimierung.
$expire: Die Ablaufzeit des gespeicherten Werts bedeutet, dass er nicht abläuft. Sie können einen Unix-Zeitstempel oder eine Beschreibung verwenden, um die Zeit von jetzt an darzustellen, aber wenn Sie Sekunden verwenden, um sie auszudrücken. sie sollte 2592000 Sekunden (bedeutet 30 Tage) nicht überschreiten.

Rückgabewert:
TRUE bei Erfolg, FALSE bei Fehler. Wenn der $key-Wert bereits vorhanden ist, wird FALSE zurückgegeben. In anderen Fällen ähnelt die Verwendung von Memcache::add() der von Memcache::set().
Beispiel:

Der Code lautet wie folgt:

$memcache_obj = memcache_connect("localhost", 11211);
memcache_add($memcache_obj, 'var_key', 'test variable', false, 30); $memcache_obj->add('var_key', 'test variable', false, 30);
?>

Memcache::addServer-Nutzung

Der Code lautet wie folgt:

bool Memcache::addServer ( string $host [, int $port [, bool $persistent [, int $weight [, int$timeout [, int $retry_interval [, bool $status [, callback $failure_callback ]]]]]] )

Beschreibung:
Fügen Sie der Verbindung eine verwendbare Serveradresse hinzu Im Pool wird die Verbindung mit Memcache::addServer geöffnet und nach Ausführung des Skripts automatisch geschlossen, oder sie kann manuell mit Memcache::close() geschlossen werden. Die gleiche Funktion ist memcache_add_server().
Bei Verwendung dieser Methode (im Vergleich zu den Methoden Memcache::connect() und Memcache::pconnect()) wird die Netzwerkverbindung nur bei Bedarf hergestellt, sodass nicht viele Server hinzugefügt werden müssen den Verbindungspool und erhöhen die Systembelastung, da viele Server möglicherweise nicht verwendet werden.
Die Wiederherstellung nach einem Fehler erfolgt in jeder Phase der Ausführung dieser Methode. Solange andere Server normal funktionieren, werden Benutzer den Fehler dieser Verbindungsanfragen nicht bemerken. Jede Art von Socket- oder Memcached-Fehler auf Serverebene kann ein Failover auslösen. Normale Clientfehler wie das Hinzufügen eines vorhandenen Schlüssels lösen kein Failover aus.

Parameter:
$Host-Serveradresse
$Port-Server-Port
Ob $persistent eine dauerhafte Verbindung ist
$weightDas Gewicht dieses Servers unter allen Servern
$Timeout-Verbindung Dauer
$retry_interval Verbindungswiederholungsintervall, Standard ist 15, auf -1 gesetzt bedeutet keine Wiederholung
$status steuert den Online-Status des Servers
$failure_callback ermöglicht die Einstellung einer Rückruffunktion zur Behandlung von Fehlermeldungen.

Rückgabewert:
TRUE bei Erfolg, FALSE bei Fehler.

Beispiel:

Der Code lautet wie folgt:

$memcache = new Memcache;
$memcache->addServer(' memcache_host', 11211);
$memcache->addServer('memcache_host2′, 11211);

$memcache_connect('memcache_host', 11211); memcache_host ' 2′, 11211);
?>

Memcache::close Verwendung
bool Memcache::close ( void )

Anleitung:
Schließen Sie die Memcache-Serververbindung. Diese Funktion schließt die lange Verbindung nicht. Die lange Verbindung wird nur geschlossen, wenn der Webserver heruntergefahren oder neu gestartet wird. Dieselbe Funktion memcache_close()
Rückgabewert:
Gibt TRUE zurück, wenn erfolgreich, und FALSE, wenn fehlgeschlagen.
Beispiel:



Der Code lautet wie folgt:

$memcache_obj = memcache_connect('memcache_host', 11211) ;
memcache_obj = new Memcache;
$memcache_obj->close(); >?> ;




Memcache::connect-Nutzung

Der Code lautet wie folgt:
bool Memcache ::connect ( string $ host [, int $port [, int $timeout ]] )

Anweisungen:

Öffnen Sie die Memcached-Serververbindung und stellen Sie eine Verbindung zum Memcached-Server her , und öffnen Sie es mit Memcache::connect. Die Verbindung wird automatisch geschlossen, nachdem das Skript ausgeführt wurde. Sie können die Verbindung auch mit Memcache::close() schließen. Die gleiche Funktion ist memcache_connect().

Parameter:

$host: Zeigt auf den Host des Links, den memcached überwacht. Dieser Parameter verfügt über eine weitere spezielle Verbindungsmethode unix:///path/to/memcached.sock, die den Unix-Domänennamen verwendet sockets , in diesem Fall muss der Port auf 0 gesetzt werden
$port: zeigt auf den Port des Links, den memcached überwacht. Bei Unix-Domainnamen-Sockets muss der Port auf 0 gesetzt werden
$timeout: wird zum Herstellen einer Verbindung zum Daemon verwendet. Anzahl der Sekunden für den Prozess. Wenn Sie den Standardwert von 1 Sekunde ändern, müssen Sie berücksichtigen, dass Sie möglicherweise die Vorteile des Cachings verlieren, wenn Ihre Verbindung zu langsam ist.

Rückgabewert:
TRUE bei Erfolg, FALSE bei Fehler.
Beispiel:

Der Code lautet wie folgt:

$memcache_obj = memcache_connect('memcache_host', 11211); >$memcache = new Memcache;

$memcache->connect('memcache_host', 11211);

?>




memcache: :debug

Der Code lautet wie folgt:
bool memcache_debug ( bool $on_off )

Hinweis:
Steuern Sie die Debugging-Funktion, sofern beim Kompilieren von PHP die Option -enable-debug verwendet wird, andernfalls hat diese Funktion keine Wirkung.
Parameter:
$on_off: true bedeutet, das Debuggen einzuschalten, false bedeutet, das Debuggen auszuschalten
Rückgabewert:
Wenn PHP beim Kompilieren die Option -enable-debug verwendet, wird true zurückgegeben, andernfalls wird false zurückgegeben

Memcache::decrement-Nutzung

Der Code lautet wie folgt:

int Memcache::decrement ( string $key [ , int $ value ] )

Erklärung: Die Methode
Memcache::decremen wird verwendet, um den Wert in einem gespeicherten Schlüssel zu subtrahieren. Ihre Verwendung ähnelt Memcache::increment.
Sie können auch die Funktion memcache_decrement() verwenden.
Parameter:
Schlüssel: der Name des Schlüssels, den Sie reduzieren möchten.
Wert: der Wert, den Sie reduzieren möchten.

Rückgabewert:
Bei Erfolg den reduzierten Wert zurückgeben, bei Fehlschlag false zurückgeben.
Beispiel:

Der Code lautet wie folgt:

$memcache = new Memcache; -> connect('localhost', 11211);
$memcache->set('test_item', 8);
$memcache->inkrement('test_item', 4); $memcache- >decrement('test_item', 7);
// Display 5
?>

Dieses Beispiel demonstriert auch die Funktion Memcache::increment.


Memcache::delete-Nutzung


Der Code lautet wie folgt:

bool Memcache::delete ( string $key [, int $timeout ] )

Erläuterung:
Wenn der Parameter $timeout gesetzt ist, läuft der gespeicherte Wert nach den eingestellten Sekunden ab Verwenden Sie die Funktion memcache_delete()

Rückgabewert:
Gibt TRUE zurück, wenn erfolgreich, und FALSE, wenn fehlgeschlagen.

Beispiel:

Der Code lautet wie folgt:

$memcache_obj = memcache_connect('memcache_host', 11211) ;

memcache_obj, 'key_to_delete', 10);

$memcache_obj = new Memcache;
$memcache_obj->connect('memcache_host', 11211); >$memcache_obj ->delete('key_to_delete', 10);

?>

Memcache::flush


Der Code lautet wie folgt:

bool Memcache::flush (void)

Anweisungen:

Alle zwischengespeicherten Daten löschen. Memcache::flush gibt eigentlich keine Ressourcen frei, sondern markiert lediglich alle Caches als abgelaufen, sodass neue Caches den belegten Speicherplatz abdecken können. Die gleiche Funktion ist memcache_flush()

Rückgabewert:
Gibt TRUE zurück, wenn erfolgreich, und FALSE, wenn fehlgeschlagen.

Beispiel:



Der Code lautet wie folgt:

$memcache_obj = memcache_connect( 'memcache_host', 11211);

memcache_bj($memcache_obj); >
$memcache_obj->flush();

?>




Memcache::get

Der Code lautet wie folgt:
string Memcache::get ( string $key [, int &$flags ] )

array Memcache::get ( array $keys [, array &$flags ] )

Erklärung: Die Funktion der
-Methode besteht darin, einen Schlüsselwert zu erhalten, und der Das Ergebnis enthält Schlüssel-Wert-Paare.

Parameter:

$key ist der Schlüsselwert oder ein Array-Wert eines Schlüssels.

$flags Wenn dieser Parameter vorhanden ist, bezieht sich $flags auf den in diesen Parameter geschriebenen Wert. Diese $flags ähneln den $flags in der Funktion Memcache::set().

Rückgabewert:
Bei Erfolg wird der dem Schlüssel entsprechende Wert zurückgegeben. Bei Fehlschlag wird false zurückgegeben.
Beispiel:



Der Code lautet wie folgt folgt:



$memcache_obj = memcache_connect('memcache_host', 11211);

$var = memcache_get($memcache_obj, 'some_key'); 🎜>

$memcache_obj = new Memcache;

$memcache_obj->connect('memcache_host', 11211);

$var = $memcache_obj->get('some_key'); 🎜>$memcache_obj = memcache_connect('memcache_host', 11211);
$var = memcache_get($memcache_obj, Array('some_key', 'another_key'));

$memcache_obj = new Memcache;
$memcache_obj ->connect('memcache_host', 11211);
$var = $memcache_obj->get(Array('some_key', 'second_key'));

?>




Memcache::getExtendedStats




Der Code lautet wie folgt:

array Memcache:: getExtendedStats ([ string $type [ , int $slabid [, int $limit ]]] )

Anweisungen:
Rufen Sie die laufenden Systemstatistiken aller Prozesse im Prozesspool ab. Die gleiche Funktion ist memcache_get_extended_stats()

Parameter:
$type gibt den Typ an, der zurückgegeben werden muss: Reset, Malloc, Maps, Cachedump, Slabs, Items, Sizes
$slabid Der erste Parameter; ist auf „Verwendet“ eingestellt, wenn „cachedump“ verwendet wird.
Wird verwendet, wenn der erste Parameter von $limit auf „cachedump“ gesetzt ist.
Rückgabewert:
Bei Erfolg werden statistische Informationen zurückgegeben, bei Fehler wird false zurückgegeben

Beispiel:

Der Code lautet wie folgt:

< ;?php
$memcache_obj = new Memcache;
$memcache_obj->addServer('memcache_host', 11211);

$ stats = $memcache_obj->getExtendedStats();
//Der Slabs-Mechanismus weist Speicher zu und verwaltet ihn
$statsslab = $memcache_obj->getExtendedStats(slabs);

?> ;

Memcache::getServerStatus

Der Code lautet wie folgt:

int Memcache::getServerStatus ( string $host [, int $port ] )

Beschreibung:
Ruft die Parameter zum Ausführen des Servers ab. Gibt den Online- oder Offline-Status eines Servers zurück. Die gleiche Funktion ist memcache_get_server_status()

Parameter:
$host: Der Host der Abhörverbindung
$port Der Port des Hosts der Abhörverbindung, der Standardwert ist 11211

Rückgabewert:
Wenn der Serverstatus erfolgreich zurückgegeben wird, wird 0 zurückgegeben, wenn der Server nicht gestartet ist. Andere Zahlen zeigen an, dass der Server gestartet ist.

Beispiel:

Der Code lautet wie folgt:

$memcache = new Memcache
$memcache-> addServer(' memcache_host', 11211);
echo $memcache->getServerStatus('memcache_host', 11211);

$memcache = memcache_host', 11211);
echo memcache_get_server_status ($me mcache , 'memcache_host', 11211);

?>

Memcache::getStats

Der Code lautet wie folgt:

array Memcache::getStats ([ string $type [, int $slabid [, int $limit ]]] )

Anleitung:
Einige Laufstatistiken des Servers zurückgeben. Die gleiche Funktion ist memcache_get_stats()

Parameter:
$type gibt den angeforderten Rückgabetyp an: Reset, Malloc, Maps, Cachedump, Slabs, Items, Sizes
$slabid erste Parametereinstellung Wird verwendet, wenn Es wird „cachedump“ verwendet.
Wird verwendet, wenn der erste Parameter von $limit auf „cachedump“ gesetzt ist.


Memcache::getVersion

Der Code lautet wie folgt:

string Memcache::getVersion ( void )

Beschreibung:
Gibt die Versionsinformationen des laufenden Memcaches zurück. Dieselbe Funktion memcache_get_version()

Rückgabewert:
Gibt die Versionsinformationen des Servers erfolgreich zurück und gibt false zurück, wenn dies fehlschlägt.

Beispiel:

Der Code lautet wie folgt:

$memcache = new Memcache
$memcache-> connect('memcache_host', 11211);
echo $memcache->getVersion();

$memcache = memcache_connect('memcache_host', 11211);
echo memcache_get_version($memcache);
?>

Memcache::increment

Der Code lautet wie folgt:

int Memcache::increment ( string $key [, int $value ] )

Füge den Wert in einem gespeicherten Schlüssel hinzu
Verwendungsreferenz Memcache::decrement



Memcache::pconnect

Der Code lautet wie folgt:

bool Memcache::pconnect ( string $host [, int $port [ , int $timeout ]] )

Anweisungen:
Erstellen Sie ein persistentes Memcache-Verbindungsobjekt
Die Verwendung ähnelt Memcache::connect(), dem Der Unterschied besteht darin, dass Memcache: :pconnect eine dauerhafte Verbindung herstellt. Diese Verbindung wird nicht geschlossen, nachdem das Skript ausgeführt oder die Funktion Memcache::close() ausgeführt wurde. Die damit identische Funktion ist memcache_pconnect()

Parameter:
$host: Zeigt auf den Host des Links, den memcached überwacht. Dieser Parameter verfügt über eine weitere spezielle Verbindungsmethode: unix:///path / to/memcached.sock, d. h. Unix-Domainnamen-Sockets verwenden. In diesem Fall muss der Port auf 0 gesetzt werden.
$port: Zeigt auf den Port des Links, auf den memcached lauscht Bei Unix-Domainnamen-Sockets muss der Port auf 0 eingestellt werden langsam ist, verlieren Sie möglicherweise den Vorteil des Cachings.

Rückgabewert:
TRUE bei Erfolg, FALSE bei Fehler

Der Code lautet wie folgt:

$memcache_obj = memcache_pconnect('memcache_host', 11211);

$memcache_obj = new Memcache;
$memcache_obj->pconnect( 'memcache_host', 11211);

?>

Memcache::replace

Der Code lautet wie folgt:

bool Memcache::replace ( string $key , Mixed $var [, int $flag [, int $expire ]] )

Erläuterung:
Vorhandenen Schlüssel überschreiben. Die gleiche Funktion ist memcache_replace()

Parameter:
$key: Der zu speichernde Schlüsselwert.
$var: Der gespeicherte Wert, der Zeichentyp und der Ganzzahltyp werden als Originalwert gespeichert, andere Typen werden automatisch serialisiert und später gespeichert.
$flag: Ob MEMCACHE_COMPRESSED zum Komprimieren des gespeicherten Werts verwendet werden soll. True bedeutet Komprimierung, False bedeutet keine Komprimierung.
$expire: Die Ablaufzeit des gespeicherten Werts bedeutet, dass er nicht abläuft. Sie können einen Unix-Zeitstempel oder eine Beschreibung verwenden, um die Zeit von jetzt an darzustellen, aber wenn Sie Sekunden verwenden, um sie auszudrücken. sie sollte 2592000 Sekunden (bedeutet 30 Tage) nicht überschreiten.

Rückgabewert:
TRUE bei Erfolg, FALSE bei Fehler. Wenn der $key-Wert bereits vorhanden ist, wird FALSE zurückgegeben.

Der Code lautet wie folgt:

$memcache_obj = memcache_connect('memcache_host', 11211); 🎜>memcache_replace($memcache_obj, „test_key“, „some variable“, false, 30);
$memcache_obj->replace(“test_key“, „some variable“, false, 30); >?> ;

Memcache::set


Der Code lautet wie folgt:

bool Memcache: :set ( string $key , Mixed $var [, int $flag [, int $expire ]] )

Beschreibung:

Fügen Sie einen Wert hinzu und Überschreiben Sie es, wenn es bereits vorhanden ist. Schreiben. Die gleiche Funktion ist memcache_set()

Parameter:
$key: Der zu speichernde Schlüsselwert.
$var: Der gespeicherte Wert, der Zeichentyp und der Ganzzahltyp werden als Originalwert gespeichert, andere Typen werden automatisch serialisiert und später gespeichert.
$flag: Ob MEMCACHE_COMPRESSED zum Komprimieren des gespeicherten Werts verwendet werden soll. True bedeutet Komprimierung, False bedeutet keine Komprimierung.
$expire: Die Ablaufzeit des gespeicherten Werts bedeutet, dass er nicht abläuft. Sie können einen Unix-Zeitstempel oder eine Beschreibung verwenden, um die Zeit von jetzt an darzustellen, aber wenn Sie Sekunden verwenden, um sie auszudrücken. sie sollte 2592000 Sekunden (bedeutet 30 Tage) nicht überschreiten.

Rückgabewert:
TRUE bei Erfolg, FALSE bei Fehler.

Beispiel:



Der Code lautet wie folgt:

$memcache_obj = new Memcache;

$memcache_obj->connect ('memcache_host ', 11211);

$memcache_obj->set('var_key', 'irgendeine wirklich große Variable', MEMCACHE_COMPRESSED, 50);
echo $memcache_obj->get('var_key');

Memcache::setCompressThreshold


Der Code lautet wie folgt:

bool Memcache:: setCompressThreshold ( int $threshold [ , float $min_ savings ] )

Beschreibung:

Komprimieren Sie Daten, die größer als eine bestimmte Größe sind. Die gleiche Funktion ist memcache_set_compress_threshold()

Parameter:
Die setCompressThreshold-Methode verfügt über zwei Parameter. Der erste Parameter stellt den kritischen Punkt der Verarbeitungsdatengröße dar und der zweite Parameter stellt das Komprimierungsverhältnis dar, das standardmäßig 0,2 beträgt .

Rückgabewert:
TRUE bei Erfolg, FALSE bei Fehler.

Beispiel:

Der Code lautet wie folgt:

$memcache_obj = new Memcache; ->addServer('memcache_host', 11211);
$memcache_obj->setCompressThreshold(20000, 0.2);

$memcache_connect('memcache_host', 11211);
memcache_set_compress_thre sollst ($memcache_obj, 20000, 0.2);

?>

Memcache::setServerParams


Der Code lautet wie folgt:
bool Memcache::setServerParams ( string $host [, int $port [, int $timeout [, int$retry_interval [, bool $status [, callback $failure_callback ]] ]]] )

Anweisungen:

Serverparameter zur Laufzeit ändern. Die gleiche Funktion ist memcache_set_server_params().

Parameter:
$Host-Server-Adresse
$Port-Server-Port
$Timeout-Dauer der Verbindung
$retry_intervalIntervallzeit zwischen Verbindungswiederholungen, Standard ist 15, auf -1 eingestellt bedeutet nein erneut versuchen
$status steuert den Online-Status des Servers
$failure_callback ermöglicht das Festlegen einer Rückruffunktion zur Behandlung von Fehlermeldungen.

Rückgabewert:
TRUE bei Erfolg, FALSE bei Fehler.

Beispiel:

Der Code lautet wie folgt:

function _callback_memcache_failure($host, $port) {
print "memcache '$host:$port' failed"; 🎜>$memcache = new Memcache;

//Hinzufügen eines Servers im Offline-Modus
$memcache->addServer('memcache_host', 11211, false, 1, 1, -1, false);

// Den Server online stellen
$memcache->setServerParams('memcache_host', 11211, 1, 15, true, '_callback_memcache_failure');

$memcache_obj = memcache_connect( 'memcache_host', 11211);
memcache_set_server_params($memcache_obj, 'memcache_host', 11211, 1, 15, true, '_callback_memcache_failure');

?>

6. Umfassende Anwendungsbeispiele

Der Code lautet wie folgt:

//Connection

$mem = new Memcache ;
$mem->connect("db.nowamagic.net", 12000);
//Daten speichern
$mem->set('key1', 'This is first value', 0, 60);
$val = $mem->get('key1');
echo "Get key1 value: " 🎜>/ /Daten ersetzen
$mem->replace('key1', 'This is replacement value', 0, 60);
$val = $mem->get('key1');
echo "Get key1 value: " . $val . "
"; , 'ddd' );
$mem->set('key2', $arr, 0, 60);
$val2 = $mem->get('key2');
echo "Schlüssel2-Wert abrufen:";
print_r($val2);
echo "
"; ;
$val = $mem->get('key1');
echo "Get key1 value: "
";
$ mem->flush();
$val2 = $mem->get('key2');
echo "Get key2 value: ";
echo "
";
//Verbindung schließen
$mem->close();



Wenn normal, gibt der Browser Folgendes aus:

Der Code lautet wie folgt:


Wert von Schlüssel1 abrufen: Dies ist der erste Wert
Wert von Schlüssel1 abrufen: Dies ist der Ersetzungswert
Schlüssel2-Wert abrufen: Array ( [0] => aaa [1] => bbb [2] => ccc [3] => ddd )

Schlüssel1-Wert abrufen:

Schlüssel2-Wert abrufen :

7. Beispielprogrammcode-Analyse

Initialisieren Sie ein Memcache-Objekt: $mem = neuer Memcache; , der erste Der Parameter ist die IP-Adresse des Servers oder der Hostname. Der zweite Parameter ist der offene Port von Memcache: $mem->connect("192.168.0.200", 12000);
Daten speichern Für den Memcache-Server ist der erste Parameter der Datenschlüssel, der zum Auffinden von Daten verwendet wird, der zweite Parameter ist der Dateninhalt, der gespeichert werden muss, hier ist eine Zeichenfolge, der dritte Parameter ist eine Markierung, die im Allgemeinen auf 0 gesetzt ist oder MEMCACHE_COMPRESSED. Der vierte Parameter ist die Gültigkeitsdauer der Daten. Wenn diese Zeit verstrichen ist, werden die Daten vom Memcache-Server gelöscht auf 0, wir haben hier 60 eingestellt, was der effektiven Zeit von einer Minute entspricht: $mem->set('key1', 'This is first value', 0, 60); Rufen Sie ein Datenelement vom Memcache-Server ab. Es gibt nur einen Parameter, nämlich den Schlüssel, der im vorherigen Schritt festgelegt wurde. Geben Sie nun nach dem Abrufen dieser Daten die Ausgabe aus:

Der Code lautet wie folgt:

$ val = $mem->get('key1′);
echo "Get key1 value: " $ val;

Verwenden Sie nun die Ersetzungsmethode, um den Wert von key1 oben zu ersetzen. Die Parameter der Ersetzungsmethode sind die gleichen wie eingestellt, aber der erste Parameter key1 muss der Schlüssel sein, um den Dateninhalt zu ersetzen . Die endgültige Ausgabe lautet:

Der Code lautet wie folgt:

$mem ->replace('key1', 'This is replacement value', 0, 60);

$val = $mem->get('key1');

echo "Get key1 value: " .

In ähnlicher Weise kann Memcache auch Arrays speichern Es folgt ein Array, das im Memcache gespeichert, dann abgerufen und ausgegeben wird:

Der Code lautet wie folgt:

$arr = array('aaa', 'bbb', 'ccc' , 'ddd');

$mem->set('key2', $arr, 0, 60);

$val2 = $mem->get('key2'); ($val2);


Löschen Sie nun Daten, verwenden Sie die Löschschnittstelle, der Parameter ist ein Schlüssel. Dann können Sie die Schlüsseldaten des Memcache-Servers löschen. Es gibt kein Ergebnis in der endgültigen Ausgabe :

Der Code lautet wie folgt:

$mem->delete('key1');
$val = $mem->get('key1');
echo "Get key1 value: " . br />";

Schließlich löschen wir alle auf dem Memcache-Server gespeicherten Daten. Wir werden feststellen, dass die Daten verschwunden sind. Schließlich sind die Ausgabeschlüssel2-Daten leer und schließlich ist es geschlossen.

Der Code lautet wie folgt:

$mem->flush(
$val2 = $mem->get('key2'); );
echo „Schlüssel2-Wert abrufen:“;
print_r($val2);
Wann Memcache und Memcache-Nutzungsumgebung verwendet werden sollen

Websites, die Memcache verwenden, haben im Allgemeinen einen relativ hohen Datenverkehr. Um den Druck auf die Datenbank zu verringern, wird Memcache als Cache-Bereich verwendet, um einen Teil davon zu speichern der Informationen im Speicher, sodass diese schnell für den Zugriff verarbeitet werden können. Der allgemeine Fokus liegt also darauf, wie der Datenbankdruck aufgeteilt und verteilt werden kann. Schließlich ist die Speicherkapazität eines einzelnen Memcaches begrenzt. Ich bringe hier lediglich meine persönlichen Meinungen zum Ausdruck, die ich nicht praktiziert habe und die nur als Referenz dienen sollen.

Verteilte Anwendung

Memcache unterstützt ursprünglich verteilte Anwendungen, aber unser Client wurde leicht geändert, um eine bessere Unterstützung zu bieten. Unsere Schlüssel können entsprechend und regelmäßig gekapselt werden. Bei einer benutzerbasierten Website verfügt beispielsweise jeder Benutzer über eine Benutzer-ID, sodass diese gemäß einer festen ID extrahiert und abgerufen werden kann Zuerst werden auf einem Memcache-Server die Daten der Benutzer, die mit 2 beginnen, gespeichert, auf dem zweiten Memcache-Server werden die Zugangsdaten zunächst entsprechend der Benutzer-ID konvertiert und abgerufen.
Dies hat jedoch den Nachteil, dass eine Beurteilung der Benutzer-ID erforderlich ist. Wenn das Unternehmen inkonsistent ist oder andere Arten von Anwendungen möglicherweise nicht so geeignet sind, können Sie dies basierend auf Ihrem tatsächlichen Unternehmen in Betracht ziehen oder darüber nachdenken geeignetere Methode.

Datenbankdruck reduzieren

Dies ist grundsätzlich wichtig, wenn auf die Datenbank zugegriffen wird Die Leistung ist extrem beeinträchtigt und es können nicht mehr Benutzer gleichzeitig bedient werden. Beispielsweise sperrt MySQL die Tabelle sehr häufig, sodass Memcache den Druck auf die Datenbank teilen kann. Wir brauchen eine Möglichkeit, die aktuelle Architektur auf eine relativ kleine Weise zu ändern, die keine großen Änderungen am Frontend erfordert.
Eine einfache Methode, die ich in Betracht ziehe:
Das Back-End-Datenbankbetriebsmodul extrahiert alle Auswahlvorgänge (unabhängig von Aktualisieren/Löschen/Einfügen) und verwendet dann den entsprechenden Hash-Algorithmus, um die entsprechende SQL zu berechnen und einen Hash zu erhalten den Datenschlüssel (z. B. MD5 oder SHA) und verwenden Sie dann diesen Schlüssel, um die Daten im Memcache zu finden. Wenn die Daten nicht vorhanden sind, bedeutet dies, dass sie nicht in den Cache geschrieben wurden, und extrahieren Sie die Daten aus der Datenbank. Einer ist im Array-Klassenformat und legt dann die Daten in Memcache ab. Der Schlüssel ist der Hash-Wert von SQL. Anschließend wird eine entsprechende Ablaufzeit festgelegt, z. B. eine Stunde. Anschließend werden die Daten in einer Stunde aus dem Cache extrahiert , wodurch der Druck auf die Datenbank effektiv verringert wird. Der Nachteil besteht darin, dass die Daten nicht in Echtzeit angezeigt werden, wenn sie geändert werden, und dass sie möglicherweise auch viel Speicher beanspruchen Die Zeit kann enorm sein. Dies ist ein Faktor, der berücksichtigt werden muss.
Memcache-Sicherheit


Unser oben genannter Memcache-Server funktioniert direkt nach der Verbindung mit dem Client ohne jeglichen Überprüfungsprozess. Wenn der Server also direkt offengelegt wird, ist er im Internet gefährlicher Zumindest werden die Daten durchgesickert und von anderen, nicht verwandten Personen eingesehen, und im schlimmsten Fall wird der Server angegriffen, da Mecache mit Root-Rechten ausgeführt wird und es möglicherweise einige unbekannte Fehler oder Pufferüberläufe gibt. Diese sind uns unbekannt , die Gefahren sind also absehbar. Aus Sicherheitsgründen möchte ich zwei Vorschläge machen, um das Eindringen von Hackern oder Datenlecks zu verhindern.

Intranet-Zugriff

Am besten verwenden Sie den Intranet-Zugriff zwischen den beiden Servern, normalerweise zwischen dem Webserver und dem Memcache-Server. Übliche Server verfügen über zwei Netzwerkkarten, eine auf das Internet und eine auf das Intranet. Wenn unser Memcache-Server gestartet wird, überwacht er die IP-Adresse und die IP-Adresse von Durch die Verwendung von Ports und Intranetzugängen können andere illegale Zugriffe wirksam verhindert werden.

Der Code lautet wie folgt: # memcached -d -m 1024 -u root -l 192.168.0.200 -p 11211 -c 1024 -P /tmp/memcached.pid

Der Memcache-Server ist so eingestellt, dass er den Port 11211 der IP 192.168.0.200 im Intranet überwacht, 1024 MB Speicher belegt und maximal 1024 gleichzeitige Verbindungen zulässt.

Richten Sie eine Firewall ein
Eine Firewall ist eine einfache und effektive Möglichkeit. Wenn beide Server mit dem Internet verbunden sind und Sie über die externe IP auf Memcache zugreifen müssen, ist dies möglich Erwägen Sie die Verwendung einer Firewall oder eines Proxys, um unbefugten Zugriff zu filtern. Im Allgemeinen können wir unter Linux iptables oder ipfw unter FreeBSD verwenden, um einige Regeln festzulegen, um illegalen Zugriff zu verhindern. Beispielsweise können wir festlegen, dass unser Webserver nur auf unseren Memcache-Server zugreifen darf, während andere Zugriffe blockiert werden.

Der Code lautet wie folgt:

# iptables -F
# iptables -P INPUT DROP
# iptables -A INPUT -p tcp -s 192.168.0.2 –dport 11211 -j ACCEPT
# iptables -A INPUT -p udp -s 192.168.0.2 –dport 11211 -j ACCEPT

Die obige iptables-Regel erlaubt nur dem Webserver 192.168.0.2 den Zugriff auf den Memcache Server, der einige illegale Zugriffe wirksam verhindern kann. Entsprechend können Sie auch einige andere Regeln hinzufügen, um die Sicherheit zu erhöhen.

Eigentlicher Kampf

//memcached-Konfiguration
/****************************************** * */
$mem_ip='127.0.0.1';
$mem_port=11211;
$mem_prefix='';
/********************************************/

/ ********************************************/
//Session Memcached-Konfiguration, bitte konfigurieren Sie es auf einen unabhängigen Memcache-Dienst (andere IP oder andere Portnummer),
//mehrere Spiegelstationen müssen gleich eingestellt sein, sonst wird es Ursache Sitzung verloren
//Kein anderes Programm kann diesen Dienst nutzen, um Konflikte zu vermeiden.
/********************************************/
$session_mem_ip='127.0.0.1';
$session_mem_port=11212;

function Instance_Memcached()
{
static $mem=false;
if($mem==false && isset($GLOBALS['mem_ip']) && isset($GLOBALS['mem_port']) && extension_loaded('memcache'))
{
$mem=new Memcache;
$mem->pconnect($GLOBALS['mem_ip'],$GLOBALS['mem_port']) or die('Kann keine Verbindung zum Memcache-Server herstellen! ');
}
return $mem;
}

Das obige ist der detaillierte Inhalt vonEinführung in Memcache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!