Memcached est un serveur de cache mémoire distribué hautes performances. Développé par l'équipe de développement du site Web de la communauté étrangère LIVEJOURNAL.
Objectif d'utilisation :
Réduisez le nombre d'accès à la base de données en mettant en cache les résultats des requêtes de base de données pour augmenter la vitesse et l'évolutivité des applications Web dynamiques.
memcache est un système de mise en cache d'objets à mémoire distribuée, gratuit et open source, hautes performances. Utilisé pour accélérer les applications Web dynamiques et réduire la charge de la base de données.
Caractéristiques de memcahce
1 Basé sur l'architecture C/S, protocole simple
2 Basé sur le traitement des événements libevent {libevent. est une bibliothèque réseau déclenchée par un événement, adaptée à Windows, Linux, BSD (système dérivé d'Unix) et à d'autres plates-formes🎜>
3. Méthode de stockage en mémoire intégrée
4. Formule de distribution
Scénarios applicables
1. Un déploiement distribué est requis (ce qui est distribué : si une tâche comporte 10 sous-tâches, placez ces 10 sous-tâches sur 10 serveurs séparément, ce qui réduira considérablement le temps d'exécution des tâches ,)
2. Besoin d'accéder fréquemment aux mêmes données
3 Besoin de partager des données
Introduction à l'architecture C/S
. 
Démarrage de l'installation (voir document PDF)
Utilisation de diverses commandes
set/add/replace/delete/get/gets/cas/stats/stats items/ append/ prepend/flush_all, etc.
memcahced certaines fonctionnalités et limitations
①La quantité de données d'éléments qui peuvent être enregistrées dans Memcached n'est pas limitée, seule la mémoire est suffisante
②Memcached unique La mémoire maximale utilisée par le processus est de 2 Go. Pour utiliser plus de mémoire, vous pouvez ouvrir plusieurs processus Memcached sur plusieurs ports
③ Le délai d'expiration maximum des données est de 30 jours. S'il est défini sur permanent, il le sera. expire également à ce moment-là. Constant REALTIME_MAXDELTA
④60*60*24*30 Control
⑤La longueur maximale de la clé est de 250 octets. Elle ne peut pas être stockée au-delà de cette longueur Constant KEY_MAX_LENGTH 250 Control<.>
⑥La longueur maximale de la clé pour un seul élément. Les données sont de 1 Mo. Les données dépassant 1 Mo ne seront pas stockées. Elles sont contrôlées par la constante POWER_BLOCK 1048576.
⑦ C'est la taille de dalle par défaut
⑧Le nombre maximum de connexions simultanées est de 200, via conn_init() freetotal est utilisé pour contrôler, le nombre maximum de connexions logicielles est de 1024, contrôlé via
⑨settings.maxconns=1024 ⑩Paramètres liés à l'occupation de l'espace : settings.factor=1.25, settings.chunk_size=48, affectant l'occupation des données de la dalle et par étapes
Un résumé de toutes les méthodes du client Memcache de PHP
La liste de toutes les méthodes de la fonction memcache est la suivante : Memcache::add – Ajouter une valeur, si elle existe déjà, renvoyer false
Memcache::addServer - Ajouter une adresse de serveur à utiliser
Memcache:: close - Ferme un objet Memcache
Memcache::connect - Créer un objet Memcache
memcache_debug - Contrôler la fonction de débogage
Memcache::decrement - Soustraire la valeur dans une clé enregistrée
Memcache::delete - Supprimer une valeur clé
Memcache::flush - Effacer toutes les données mises en cache
Memcache::get - Obtenir une valeur clé
Memcache::getExtendedStats - Obtenir les statistiques du système en cours d'exécution de tous les processus dans le pool de processus
Memcache::getServerStatus - Récupère les paramètres du serveur en cours d'exécution
Memcache::getStats - Renvoie quelques statistiques d'exécution du serveur
Memcache::getVersion - Renvoie les informations de version du Memcache en cours d'exécution
Memcache::increment - Ajouter la valeur dans une clé enregistrée
Memcache::pconnect - Créer un objet de connexion persistante Memcache
Memcache::replace - Écraser une clé existante
Memcache::set - Ajouter une valeur, si elle existe déjà , écraser
Memcache: :setCompressThreshold – Compresser les données supérieures à une certaine taille
Memcache::setServerParams – Modifier les paramètres du serveur au moment de l'exécution
Répartition de la méthode de fonctionnement Memcache de PHP
Memcache::add utilisation
Le code est le suivant :
bool Memcache::add ( string $key , mixte $var [ , int $flag [, int $expire ]] )
Remarque :
Si $key n'existe pas, utilisez cette fonction pour stocker la valeur de $var. La fonction fonctionnellement équivalente est memcache_add().
Paramètres :
$key : La valeur de la clé à stocker.
$var : La valeur stockée, le type de caractère et le type entier seront enregistrés comme valeur d'origine, les autres types seront automatiquement sérialisés et enregistrés ultérieurement.
$flag : s'il faut utiliser MEMCACHE_COMPRESSED pour compresser la valeur stockée, true signifie compression, false signifie aucune compression.
$expire : Le délai d'expiration de la valeur stockée. S'il est 0, cela signifie qu'elle n'expirera pas. Vous pouvez utiliser un horodatage ou une description Unix pour représenter l'heure à partir de maintenant, mais lorsque vous utilisez des secondes pour l'exprimer, elle ne doit pas dépasser 2592 000 secondes (soit 30 jours).
Valeur de retour :
VRAI en cas de succès, FALSE en cas d'échec. Si la valeur $key existe déjà, FALSE sera renvoyé. Dans d'autres cas, l'utilisation de Memcache::add() est similaire à Memcache::set().
Exemple :
Le code est le suivant :
$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);
?>
Utilisation de Memcache::addServer
Le code est le suivant :
bool Memcache::addServer ( string $host [, int $port [, bool $persistent [, int $weight [, int$timeout [, int $retry_interval [, bool $status [, callback $failure_callback ]]]]]] )
Description :
Ajouter une adresse de serveur utilisable à la connexion Dans le pool, la connexion est ouverte avec Memcache::addServer et automatiquement fermée après l'exécution du script, ou elle peut être fermée manuellement avec Memcache::close(). La même fonction est memcache_add_server().
Lors de l'utilisation de cette méthode (par rapport aux méthodes Memcache::connect() et Memcache::pconnect()), la connexion réseau ne sera établie qu'en cas de besoin, il ne sera donc pas nécessaire d'ajouter beaucoup de serveurs à le pool de connexions et augmente la charge du système, car de nombreux serveurs peuvent ne pas être utilisés.
La récupération après échec se produira à n'importe quelle étape de l'exécution de cette méthode. Tant que les autres serveurs fonctionnent normalement, les utilisateurs ne remarqueront pas l'échec de ces demandes de connexion. Tout type d’erreur au niveau du socket ou du serveur Memcached peut déclencher un basculement. Les erreurs normales du client, telles que l'ajout d'une clé existante, ne déclencheront pas le basculement.
Paramètres :
$adresse du serveur hôte
$port port du serveur
Si $persistent est une connexion persistante
$weightLe poids de ce serveur parmi tous les serveurs
$timeout connection durée
$retry_interval intervalle de nouvelle tentative de connexion, la valeur par défaut est 15, défini sur -1 signifie aucune nouvelle tentative
$status contrôle l'état en ligne du serveur
$failure_callback permet de définir une fonction de rappel pour gérer les messages d'erreur.
Valeur de retour :
VRAI en cas de succès, FALSE en cas d'échec.
Exemple :
Le code est le suivant :
$memcache = new Memcache
$memcache->addServer(' memcache_host', 11211);
$memcache->addServer('memcache_host2′, 11211);
$memcache_obj = memcache_connect('memcache_host', 11211); memcache_host ' 2′, 11211);
?>
Memcache::close utilisation
bool Memcache::close ( void )
Instructions :
Fermez la connexion au serveur Memcache. Cette fonction ne fermera pas la connexion longue. La connexion longue ne sera fermée que lorsque le serveur Web sera arrêté ou redémarré. La même fonction memcache_close()
Valeur de retour :
Renvoie VRAI en cas de succès, renvoie FAUX en cas d'échec.
Exemple :
Le code est le suivant :
$memcache_obj = memcache_connect('memcache_host', 11211) ;
memcache_close($memcache_obj);
$memcache_obj = new Memcache;
$memcache_obj->connect('memcache_host', 11211); >?> ;
Utilisation de Memcache::connect
Le code est le suivant :
bool Memcache ::connect ( string $ host [, int $port [, int $timeout ]] )
Instructions :
Ouvrez la connexion au serveur memcached, établissez une connexion au serveur memcached , et ouvrez-le avec Memcache::connect. La connexion sera automatiquement fermée une fois le script exécuté. Vous pouvez également utiliser Memcache::close() pour fermer la connexion. La même fonction est memcache_connect().
Paramètres :
$host : Pointe vers l'hôte du lien que memcached écoute. Ce paramètre aura une autre méthode de connexion spéciale unix:///path/to/memcached.sock, qui utilise le nom de domaine Unix. sockets , dans ce cas, le port doit être défini sur 0
$port : pointe vers le port du lien que memcached écoute Dans le cas des sockets de nom de domaine unix, le port doit être défini sur 0 $timeout : utilisé pour se connecter au démon Nombre de secondes pour le processus Lorsque vous modifiez la valeur par défaut de 1 seconde, vous devez considérer que si votre connexion est trop lente, vous risquez de perdre les avantages de la mise en cache.
Valeur de retour :
VRAI en cas de succès, FALSE en cas d'échec.
Exemple :
Le code est le suivant :
$memcache_obj = memcache_connect('memcache_host', 11211); >$memcache = nouveau Memcache;
$memcache->connect('memcache_host', 11211);
memcache : :debug
Le code est le suivant :
bool memcache_debug ( bool $on_off )
Explication :
Contrôlez la fonction de débogage, à condition que l'option -enable-debug soit utilisée lors de la compilation de php, sinon cette fonction n'aura aucun effet.
Paramètres :
$on_off : true signifie activer le débogage, false signifie désactiver le débogage
Valeur de retour :
Si PHP utilise l'option -enable-debug lors de la compilation, renvoie true, sinon renvoie false
Utilisation de Memcache::decrement
Le code est le suivant :
int Memcache::decrement ( string $key [ , int $ value ] )
Explication : La méthode
Memcache::decremen est utilisée pour soustraire la valeur dans une clé enregistrée. Son utilisation est similaire à Memcache::increment.
Vous pouvez également utiliser la fonction memcache_decrement().
Paramètres :
Clé : le nom de la clé que vous souhaitez réduire
Valeur : la valeur que vous souhaitez réduire.
Valeur de retour :
En cas de succès, renvoie la valeur réduite, en cas d'échec, renvoie false.
Exemple :
Le code est le suivant :
$memcache = new Memcache
$memcache; -> connect('localhost', 11211);
$memcache->set('test_item', 8);
$memcache->increment('test_item',
echo); $memcache- >decrement('test_item', 7);
// Display 5
?>
Cet exemple illustre également la fonction Memcache::increment.
Utilisation de Memcache::delete
Le code est le suivant :
bool Memcache::delete ( string $key [, int $timeout ] )
Explication :
Supprimer une valeur clé Si le paramètre $timeout est défini, la valeur stockée expirera après les secondes définies. use Function memcache_delete()
Valeur de retour :
Renvoie VRAI en cas de succès, renvoie FAUX en cas d'échec.
Exemple :
Le code est le suivant :
$memcache_obj = memcache_connect('memcache_host', 11211) ;
memcache_delete($memcache_obj, 'key_to_delete', 10);
$memcache_obj = new Memcache
$memcache_obj->connect('memcache_host', $memcache_obj ->delete('key_to_delete', 10);
?>
Memcache::flush
Le code est le suivant :
bool Memcache::flush (void)
Instructions :
Effacer toutes les données mises en cache. Memcache::flush ne libère pas réellement de ressources, il marque simplement tous les caches comme expirés, afin que les nouveaux caches puissent couvrir l'espace mémoire occupé. La même fonction est memcache_flush()
Valeur de retour :
Renvoie VRAI en cas de succès, renvoie FAUX en cas d'échec.
Exemple :
Le code est le suivant :
$memcache_obj = memcache_connect( 'memcache_host' , 11211);
memcache_flush($memcache_obj);
$memcache_obj = new Memcache
$memcache_obj->connect('memcache_host',
$memcache_obj->flush();
?>
Memcache::get
Le code est le suivant :
string Memcache::get ( string $key [, int &$flags ] )
array Memcache::get ( array $keys [, array &$flags ] )
Explication : La fonction de la méthode
est d'obtenir une valeur clé. La valeur clé peut être un tableau, et le. le résultat contiendra des paires clé-valeur.
Paramètres :
$key est la valeur de clé ou une valeur de tableau d'une clé.
$flags Si ce paramètre existe, alors $flags est lié à la valeur écrite dans ce paramètre. Ces $flags sont similaires aux $flags de la fonction Memcache::set().
Valeur de retour :
En cas de succès, renvoie la valeur correspondant à la clé, en cas d'échec, renvoie false
Exemple :
Le code est tel. suit :
$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
Le code est le suivant :
array Memcache :: getExtendedStats ([ string $type [ , int $slabid [, int $limit ]]] )
Instructions :
Obtenez les statistiques du système en cours d'exécution de tous les processus du pool de processus. La même fonction est memcache_get_extended_stats()
Paramètres :
$type indique le type à renvoyer : reset, malloc, maps, cachedump, slabs, items, size
$slabid Le premier paramètre ; est défini sur Utilisé lors de l'utilisation de "cachedump".
Utilisé lorsque le premier paramètre de $limit est défini sur "cachedump".
Valeur de retour :
En cas de succès, renvoie des informations statistiques, l'échec renverra faux
Exemple :
Le code est le suivant :
< ;?php
$memcache_obj = new Memcache;
$memcache_obj->addServer('memcache_host', 11211);
$memcache_obj->addServer('failed_host', 11211); 🎜>$ stats = $memcache_obj->getExtendedStats();
//Le mécanisme des dalles alloue et gère la mémoire
$statsslab = $memcache_obj->getExtendedStats(slabs
?>); ;
Memcache::getServerStatus
Le code est le suivant :
int Memcache::getServerStatus ( string $host [, int $port ] )
Description :
Obtenir les paramètres d'exécution du serveur. Renvoie l'état en ligne ou hors ligne d'un serveur. La même fonction est memcache_get_server_status()
Paramètres :
$host : L'hôte de la connexion d'écoute
$port Le port de l'hôte de la connexion d'écoute, la valeur par défaut est 11211
Valeur de retour :
Si l'état du serveur est renvoyé avec succès, 0 sera renvoyé si le serveur n'est pas démarré. D'autres chiffres indiquent que le serveur est démarré.
Exemple :
Le code est le suivant :
$memcache = new Memcache
$memcache-> addServer('memcache_host', 11211);
echo $memcache->getServerStatus('memcache_host', 11211);
$memcache = memcache_connect('memcache_host', 11211); ($me mcache, 'memcache_host', 11211);
?>
Memcache::getStats
Le code est le suivant :
array Memcache::getStats ([ string $type [, int $slabid [, int $limit ]]] )
Instructions :
Renvoyer quelques statistiques d'exécution du serveur. La même fonction est memcache_get_stats()
Paramètres :
$type indique le type de retour demandé : reset, malloc, maps, cachedump, slabs, items, size
$slabid premier paramètre utilisé lorsque ; "cachedump" est utilisé.
Utilisé lorsque le premier paramètre de $limit est défini sur "cachedump".
Memcache::getVersion
Le code est le suivant :
string Memcache::getVersion ( void )
Description :
Renvoie les informations de version du Memcache en cours d'exécution. La même fonction memcache_get_version()
Valeur de retour :
Renvoie les informations de version du serveur avec succès et renvoie false en cas d'échec.
Exemple :
Le code est le suivant :
$memcache = new Memcache
$memcache-> connect('memcache_host', 11211);
echo $memcache->getVersion();
$memcache = memcache_connect('memcache_host',
echo memcache_get_version($memcache);
?>
Memcache::increment
Le code est le suivant :
int Memcache:: incrément ( string $key [, int $value ] )
Ajouter la valeur dans une clé enregistrée
Référence d'utilisation Memcache::decrement
Memcache::pconnect
Le code est le suivant :
bool Memcache::pconnect ( string $host [, int $port [ , int $timeout ]] )
Instructions :
Créer un objet de connexion persistant Memcache
L'utilisation est similaire à Memcache::connect(), le la différence est que Memcache: :pconnect est une connexion persistante établie. Cette connexion ne sera pas fermée après l'exécution du script ou l'exécution de la fonction Memcache::close(). La fonction identique est memcache_pconnect()
Paramètres :
$host : Pointe vers l'hôte du lien que memcached écoute. Ce paramètre aura une autre méthode de connexion spéciale unix:///path. / to/memcached.sock, c'est-à-dire utiliser des sockets de nom de domaine Unix. Dans ce cas, le port doit être défini sur 0
$port : pointe vers le port du lien que memcached écoute. sockets de nom de domaine unix, le port doit être défini est 0
$timeout : Le nombre de secondes utilisées pour se connecter au démon Lorsque vous modifiez la valeur par défaut de 1 seconde, vous devez en tenir compte si votre connexion l'est trop. lent, vous risquez de perdre l’avantage de la mise en cache.
Valeur de retour :
VRAI en cas de succès, FALSE en cas d'échec
Le code est le suivant :
$memcache_obj = memcache_pconnect('memcache_host', 11211);
$memcache_obj = new Memcache
$memcache_obj->pconnect( 'memcache_host', 11211);
?>
Memcache::replace
Le code est le suivant :
bool Memcache::replace ( string $key , Mixed $var [, int $flag [, int $expire ]] )
Explication :
Écraser une clé existante. La même fonction est memcache_replace()
Paramètres :
$key : La valeur de clé à stocker.
$var : La valeur stockée, le type de caractère et le type entier seront enregistrés comme valeur d'origine, les autres types seront automatiquement sérialisés et enregistrés ultérieurement.
$flag : s'il faut utiliser MEMCACHE_COMPRESSED pour compresser la valeur stockée, true signifie compression, false signifie aucune compression.
$expire : Le délai d'expiration de la valeur stockée. S'il est 0, cela signifie qu'elle n'expirera pas. Vous pouvez utiliser un horodatage ou une description Unix pour représenter l'heure à partir de maintenant, mais lorsque vous utilisez des secondes pour l'exprimer, elle ne doit pas dépasser 2592 000 secondes (soit 30 jours).
Valeur de retour :
VRAI en cas de succès, FALSE en cas d'échec. Si la valeur $key existe déjà, FALSE sera renvoyé.
Le code est le suivant :
$memcache_obj = memcache_connect('memcache_host', 11211); 🎜>memcache_replace ($memcache_obj, "test_key", "une variable", false, 30);
$memcache_obj->replace("test_key", "une variable", false, 30); >?> ;
Memcache::set
Le code est le suivant :
bool Memcache : :set ( string $key , Mixed $var [, int $flag [, int $expire ]] )
Description :
Ajoutez une valeur et écrasez-le s'il existe déjà. Écrivez. La même fonction est memcache_set()
Paramètres :
$key : La valeur de clé à stocker.
$var : La valeur stockée, le type de caractère et le type entier seront enregistrés comme valeur d'origine, les autres types seront automatiquement sérialisés et enregistrés ultérieurement.
$flag : s'il faut utiliser MEMCACHE_COMPRESSED pour compresser la valeur stockée, true signifie compression, false signifie aucune compression.
$expire : Le délai d'expiration de la valeur stockée. S'il est 0, cela signifie qu'elle n'expirera pas. Vous pouvez utiliser un horodatage ou une description Unix pour représenter l'heure à partir de maintenant, mais lorsque vous utilisez des secondes pour l'exprimer, il ne doit pas dépasser 2592 000 secondes (soit 30 jours).
Valeur de retour :
VRAI en cas de succès, FALSE en cas d'échec.
Exemple :
Le code est le suivant :
$memcache_obj = new Memcache
$memcache_obj->connect; ('memcache_host ', 11211);
$memcache_obj->set('var_key', 'une très grosse variable', MEMCACHE_COMPRESSED, 50
echo $memcache_obj->get('var_key');
Memcache::setCompressThreshold
Le code est le suivant :
bool Memcache :: setCompressThreshold ( int $threshold [ , float $min_ saving ] )
Description :
Compressez les données supérieures à une certaine taille. La même fonction est memcache_set_compress_threshold()
Paramètres :
La méthode setCompressThreshold a deux paramètres. Le premier paramètre représente le point critique du traitement de la taille des données et le deuxième paramètre représente le taux de compression, qui est par défaut de 0,2. .
Valeur de retour :
VRAI en cas de succès, FALSE en cas d'échec.
Exemple :
Le code est le suivant :
$memcache_obj = new Memcache
$memcache_obj; - & gt; ($memcache_obj, 20000, 0.2);
?>
Memcache::setServerParams
Le code est le suivant :
bool Memcache::setServerParams ( string $host [, int $port [, int $timeout [, int$retry_interval [, bool $status [, callback $failure_callback ]] ]]] )
Instructions :
Modifier les paramètres du serveur au moment de l'exécution. La même fonction est memcache_set_server_params().
Paramètres :
$adresse du serveur hôte
$port port du serveur
$durée d'expiration de la connexion
$retry_intervalIntervalle entre les tentatives de connexion, la valeur par défaut est 15, défini sur -1 signifie non retry
$status contrôle l'état en ligne du serveur
$failure_callback permet de définir une fonction de rappel pour gérer les messages d'erreur.
Valeur de retour :
VRAI en cas de succès, FALSE en cas d'échec.
Exemple :
Le code est le suivant :
function _callback_memcache_failure($host, $port) {
print "memcache '$host:$port' a échoué"
}
$memcache = new Memcache;
//Ajouter un serveur en mode hors ligne
$memcache->addServer('memcache_host', 11211, false, 1, 1, -1, false);
// Mettre le serveur en ligne
$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. Exemples d'utilisation complets
Le code est le suivant :
//Connexion
$mem = new Memcache ;
$mem->connect("db.nowamagic.net", 12000);
//Enregistrer les données
$mem->set('key1', 'C'est le premier value', 0, 60);
$val = $mem->get('key1');
echo "Obtenir la valeur key1 : " . 🎜>/ /Remplacer les données
$mem->replace('key1', 'Ceci est la valeur de remplacement', 0, 60
$val = $mem->get('key1');
echo "Obtenir la valeur key1 : " . $val . "
"
//Enregistrer le tableau
$arr = array('aaa', 'bbb', 'ccc' , 'ddd' );
$mem->set('key2', $arr, 0, 60);
$val2 = $mem->get('key2'); "Obtenir la valeur key2 : "
print_r($val2);
echo "
"
//Supprimer les données
$mem->delete('key1') ;
$val = $mem->get('key1');
echo "Obtenir la valeur key1 : "
" ;
$ mem->flush();
$val2 = $mem->get('key2');
echo "Obtenir la valeur key2 : "
print_r($val2);
echo "
"
//Fermer la connexion
$mem->close();
Si c'est normal, le navigateur affichera :
Le code est le suivant :
Obtenir la valeur key1 : c'est la première valeur
Obtenir la valeur key1 : ceci est la valeur de remplacement
Obtenir la valeur key2 : Array ( [0] => aaa [1] => bbb [2] => ccc [3] => ddd )
Obtenir la valeur key1 :
Obtenir la valeur key2 :
7. Exemple d'analyse de code de programme
Initialiser un objet Memcache : $mem = new Memcache Connectez-vous à notre serveur Memcache ; , le premier Le paramètre est l'adresse IP du serveur ou le nom d'hôte. Le deuxième paramètre est le port ouvert de Memcache : $mem->connect("192.168.0.200", 12000); au serveur Memcache, le premier paramètre est la clé des données, utilisée pour localiser une donnée, le deuxième paramètre est le contenu des données qui doit être sauvegardé, voici une chaîne, le troisième paramètre est une marque, généralement définie sur 0 ou MEMCACHE_COMPRESSED. Le quatrième paramètre est la période de validité des données, ce qui signifie que les données sont valides pendant ce temps. Si ce temps est écoulé, les données seront effacées par le serveur Memcache. L'unité est en secondes. à 0, il sera valable pour toujours. Nous avons défini ici 60, qui est la durée effective d'une minute : $mem->set('key1', 'This is first value', 0, 60); Obtenez une donnée du serveur Memcache, elle n'a qu'un seul paramètre, c'est la clé qui doit obtenir les données. Voici la clé1 définie à l'étape précédente. Maintenant, après avoir obtenu ces données, affichez la sortie :
<.>
Le code est le suivant :
$ val = $mem->get('key1′);
echo "Obtenir la valeur key1 : " $. val;
Utilisez maintenant la méthode de remplacement pour remplacer la valeur de key1 ci-dessus. Les paramètres de la méthode de remplacement sont les mêmes que ceux définis, mais le premier paramètre key1 doit être la clé pour remplacer le contenu des données. . Le résultat final est :
Le code est le suivant :
$mem ->replace('key1', 'This is replace value', 0, 60);
$val = $mem->get('key1');
echo "Get key1 value: " 🎜>
De même, Memcache peut également enregistrer des tableaux. Voici un tableau enregistré sur Memcache, puis récupéré et affiché :
Le code est le suivant :
$arr = array('aaa', 'bbb', 'ccc' , 'ddd');
$mem->set('key2', $arr, 0, 60);
$val2 = $mem->get('key2'); ($val2);
Maintenant, supprimez une donnée, utilisez l'interface delte, le paramètre est une clé, puis vous pouvez supprimer les données clés du serveur Memcache. Il n'y a aucun résultat dans la sortie finale. :
Le code est le suivant :
$mem->delete('key1');
$val = $mem->get('key1');
echo "Obtenir la valeur key1 : " $val . br />";
Enfin, nous effaçons toutes les données enregistrées sur le serveur Memcache. Nous constaterons que les données ont disparu. Enfin, les données de sortie key2 sont vides et enfin il est fermé. Connexion :
Le code est le suivant :
$mem->flush();
$val2 = $mem->get('key2'); );
echo "Obtenir la valeur key2 : "
print_r($val2);
echo "
";
Quand utiliser Memcache et l'environnement d'utilisation de Memcache
Les sites Web qui utilisent Memcache ont généralement un trafic relativement important Afin de soulager la pression sur la base de données, Memcache est utilisé comme zone de cache pour enregistrer une partie. des informations dans la mémoire, afin qu'elles puissent être traitées rapidement en amont pour y accéder. L'accent général est donc mis sur la façon de partager la pression de la base de données et de la répartir. Après tout, la capacité mémoire d'un seul Memcache est limitée. J'expose simplement ici mes opinions personnelles, je ne les ai pas mises en pratique et ne doivent être utilisées qu'à titre de référence.
Application distribuée
Memcache prend à l'origine en charge la distribution, mais notre client a été légèrement modifié pour fournir un meilleur support. Nos clés peuvent être encapsulées de manière appropriée et régulière. Par exemple, pour un site Web basé sur les utilisateurs, chaque utilisateur possède un identifiant utilisateur, il peut donc être extrait et accessible selon un identifiant fixe. Par exemple, les utilisateurs commençant par 1 sont stockés dans le fichier. premier Sur un serveur Memcache, les données des utilisateurs commençant par 2 sont stockées sur le deuxième serveur Memcache. Les données d'accès sont d'abord converties et accessibles en fonction de l'ID utilisateur.
Cependant, cela présente l'inconvénient de nécessiter un jugement sur l'ID utilisateur. Si l'entreprise est incohérente ou si d'autres types d'applications peuvent ne pas être aussi adaptés, vous pouvez l'envisager en fonction de votre entreprise réelle ou penser à un. méthode plus adaptée.
Réduire la pression sur la base de données
C'est plus important. Toutes les données sont essentiellement stockées dans la base de données. Chaque fois que la base de données est consultée fréquemment, la base de données sera endommagée. les performances sont extrêmement dégradées et ne peuvent pas servir plus d'utilisateurs en même temps. Par exemple, MySQL verrouille la table très fréquemment, laissez donc Memcache partager la pression sur la base de données. Nous avons besoin d’un moyen de modifier l’architecture actuelle d’une manière relativement modeste et ne nécessitant pas de changements à grande échelle au niveau du front-end.
Une méthode simple que j'envisage :
Le module d'opération de base de données back-end extrait toutes les opérations de sélection (indépendamment de la mise à jour/suppression/insertion), puis utilise l'algorithme de hachage correspondant pour calculer le SQL correspondant afin d'obtenir un hachage la clé de données (telle que MD5 ou SHA), puis utilisez cette clé pour rechercher les données dans Memcache. Si les données n'existent pas, cela signifie qu'elles n'ont pas été écrites dans le cache, puis extrayez les données de la base de données, l'un est au format de classe de tableau, puis définissez les données dans Memcache, la clé est la valeur de hachage du SQL, puis définissez un délai d'expiration en conséquence, par exemple une heure, puis les données d'une heure seront extraites du cache , réduisant efficacement la pression sur la base de données. L'inconvénient est que les données ne sont pas en temps réel. Lorsque les données sont modifiées, elles ne peuvent pas être affichées sur le front-end en temps réel et peuvent également occuper une grande quantité de mémoire. le temps peut être énorme. C’est un facteur qui doit être pris en compte.
Sécurité Memcache
Notre serveur Memcache ci-dessus fonctionne directement après la connexion au client sans aucun processus de vérification, donc si le serveur est directement exposé, c'est plus dangereux sur Internet Au moins, les données sont divulguées et consultées par d'autres personnes indépendantes, et au pire, le serveur est envahi, car Mecache fonctionne avec les privilèges root, et il peut y avoir des bogues inconnus ou des débordements de tampon. Ceux-ci nous sont inconnus. , les dangers sont donc prévisibles. Par souci de sécurité, je voudrais faire deux suggestions pour empêcher les intrusions de pirates informatiques ou les fuites de données.
Accès Intranet
Il est préférable de réaliser l'accès entre les deux serveurs sous la forme d'un intranet, généralement entre le serveur Web et le serveur Memcache. Les serveurs courants ont deux cartes réseau, l'une pointant vers Internet et l'autre vers l'intranet. Laissez ensuite le serveur Web accéder au serveur Memcache via la carte réseau intranet. Lorsque notre serveur Memcache est démarré, il surveille l'adresse IP et l'adresse IP de. Les ports intranet et l'accès intranet peuvent empêcher efficacement d'autres accès illégaux.
Le code est le suivant :
# memcached -d -m 1024 -u root -l 192.168.0.200 -p 11211 -c 1024 -P /tmp/memcached.pid
Le serveur Memcache est configuré pour écouter le port 11211 de l'IP 192.168.0.200 sur l'intranet, occupant 1024 Mo de mémoire, et permettant un maximum de 1024 connexions simultanées.
Configurer un pare-feu
Un pare-feu est un moyen simple et efficace si les deux serveurs sont connectés à Internet et que vous devez accéder à Memcache via l'adresse IP externe, alors vous pouvez. Pensez à utiliser un pare-feu ou un proxy pour filtrer les accès non autorisés. Généralement, sous Linux, nous pouvons utiliser iptables ou ipfw sous FreeBSD pour spécifier certaines règles afin d'empêcher certains accès illégaux. Par exemple, nous pouvons configurer pour autoriser uniquement notre serveur Web à accéder à notre serveur Memcache, tout en bloquant les autres accès.
Le code est le suivant :
# 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
La règle iptables ci-dessus autorise uniquement le serveur Web 192.168.0.2 à accéder au Memcache serveur , qui peut empêcher efficacement certains accès illégaux. En conséquence, vous pouvez également ajouter d'autres règles pour renforcer la sécurité. Cela peut être fait en fonction de vos propres besoins.
Combat réel
//configuration memcached
/****************************************** * */
$mem_ip='127.0.0.1';
$mem_port=11211;
$mem_prefix='';
/********************************************/
/ ********************************************/
//configuration memcached de session, veuillez le configurer sur un service memcache indépendant (IP différente ou numéro de port différent),
//plusieurs stations miroir doivent être définies de la même manière, sinon ce sera cause session Lost
//Aucun autre programme ne peut utiliser ce service pour éviter les conflits.
/********************************************/
$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']) ou die('Impossible de se connecter au serveur memcache ! ');
}
return $mem;
}
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Derniers articles par auteur
-
2023-03-14 15:58:02
-
1970-01-01 08:00:00
-
2023-03-15 07:38:01
-
1970-01-01 08:00:00
-
1970-01-01 08:00:00
-
1970-01-01 08:00:00
-
1970-01-01 08:00:00
-
1970-01-01 08:00:00
-
1970-01-01 08:00:00
-
1970-01-01 08:00:00
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
