LXXV. Memcache Functions

Введение

Memcache module provides handy procedural and object oriented interface to memcached, highly effective caching daemon, which was especially designed to decrease database load in dynamic web applications.

This module doesn't have native support of multiple servers, but you still can implement it yourself in your application. Establish several memcached connections, set priority level for each server etc.

More information about memcached can be found at http://www.danga.com/memcached/.

Требования

This module uses functions of zlib to support on-the-fly data compression. Zlib is required to install this module.

PHP 4.3.3 or newer is required to use the memcache extension.

Установка

Это расширение PECL не поставляется вместе с PHP. Дополнительная информация, такая как новый версии, скачивание, исходные файлы, информация о разработчике и CHANGELOG, могут быть найдены здесь: http://pecl.php.net/package/memcache.

In order to use these functions you must compile PHP with Memcache support by using the --enable-memcache[=DIR] option.

Windows users will enable php_memcache.dll inside of php.ini in order to use these functions. Вы можете скачать DLL этого расширения PECL со страницы PHP Downloads или http://snaps.php.net/.

Предопределенные константы

Таблица 1. MemCache Constants

NameDescription
MEMCACHE_COMPRESSED (integer) Used to turn on-the-fly data compression on with Memcache::set(), Memcache::add() и Memcache::replace().

Настройка во время выполнения

Данное расширение не определяет никакие директивы конфигурации в php.ini.

Типы ресурсов

There is only one resource type used in memcache module - it's the link identifier for a cache server connection.

Примеры

Пример 1. memcache extension overview example

<?php

$memcache = new Memcache;
$memcache->connect('localhost', 11211) or die ("Could not connect");

$version = $memcache->getVersion();
echo "Server's version: ".$version."<br/>\n";

$tmp_object = new stdClass;
$tmp_object->str_attr = 'test';
$tmp_object->int_attr = 123;

$memcache->set('key', $tmp_object, false, 10) or die ("Failed to save data at the server");
echo "Store data in the cache (data will expire in 10 seconds)<br/>\n";

$get_result = $memcache->get('key');
echo "Data from the cache:<br/>\n";

var_dump($get_result);

?>

In the above example, an object is being saved in the cache and then retrieved back. Object and other non-scalar types are serialized before saving, so it's impossible to store resources (i.e. connection identifiers and others) in the cache.

Содержание
Memcache::add -- Add an item to the server
Memcache::close -- Close memcached server connection
Memcache::connect -- Open memcached server connection
memcache_debug -- Turn debug output on/off
Memcache::decrement -- Decrement item's value
Memcache::delete -- Delete item from the server
Memcache::flush -- Flush all existing items at the server
Memcache::get -- Retrieve item from the server
Memcache::getStats -- Get statistics of the server
Memcache::getVersion -- Return version of the server
Memcache::increment -- Increment item's value
Memcache::pconnect -- Open memcached server persistent connection
Memcache::replace -- Replace value of the existing item
Memcache::set -- Store data at the server


Memcache Functions
iliya at pisem dot net
19-Jan-2006 12:35
one more "intelligent" cache aggregator:
https://svn.shadanakar.org/onPHP/ trunk/core/Cache/AggregateCache.class.php
can be used with several cache connectors - memcached, filesystem, etc.
(remove whitespace manually)
Gregor J. Rothfuss
21-Nov-2005 09:18
The next version will have failover. It's been committed three weeks ago. Usage notes here: http://www.codecomments.com/archive367-2005-10-659421.html
Ron
14-Sep-2005 01:19
An improvement to the above:

The above class will cause an error if all cache servers are down.  The preferred behavior is to just have a cache miss (or take no action in the case of write operations) and return false, so the app can run in non-cached mode if all cache servers are down.

To make this happen, simply change the connection usage to look something like this in each affected function.  This code is for the get() function:

       $con = $this->_getConForKey($key);
       if ($con === false) return false;
       return $con->get($key);

Similarly, the affected code in the set() function would look like this:
   $con = $this->_getConForKey($key);
   if ($con === false) return false;
   return $con->set($key, $var, $compress, $expire);

Modify each function accordingly, and if all of your cache servers are down, you can still function (although more slowly due to the 100% cache miss rate).
Ron
14-Sep-2005 10:20
Here is a simple memcached aggregator class which distributes the cache among multiple cache servers.  If a server fails, the load is redistributed automatically.  It uses persistent connections.

The constructor takes an array of arrays, with each inner array representing a server, with a 'server' (string) attribute that is the IP addres or host name of the memcached server, and a 'port' (int) attribute that is the port number on which memcached is running on the server.

All of the existing memcached API functions are implemented except getStats() and getVersion(), which are server-specific.

<?php
class MemcachedAggregator {
   var $connections;

   public function __construct($servers) {
   // Attempt to establish/retrieve persistent connections to all servers.
   // If any of them fail, they just don't get put into our list of active
   // connections.
   $this->connections = array();
   for ($i = 0, $n = count($servers); $i < $n; $i++) {
       $server = $servers[$i];
       $con = memcache_pconnect($server['host'], $server['port']);
       if (!($con == false)) {
       $this->connections[] = $con;
       }
   }
   }

   private function _getConForKey($key) {
   $hashCode = 0;
   for ($i = 0, $len = strlen($key); $i < $len; $i++) {
       $hashCode = (int)(($hashCode*33)+ord($key[$i])) & 0x7fffffff;
   }
   if (($ns = count($this->connections)) > 0) {
       return $this->connections[$hashCode%$ns];
   }
   return false;
   }

   public function debug($on_off) {
   $result = false;
   for ($i = 0; $i < count($connections); $i++) {
       if ($this->connections[$i]->debug($on_off)) $result = true;
   }
   return $result;
   }

   public function flush() {
   $result = false;
   for ($i = 0; $i < count($connections); $i++) {
       if ($this->connections[$i]->flush()) $result = true;
   }
   return $result;
   }

/// The following are not implemented:
///getStats()
///getVersion()

   public function get($key) {
   if (is_array($key)) {
       $dest = array();
       foreach ($key as $subkey) {
       $val = get($subkey);
       if (!($val === false)) $dest[$subkey] = $val;
       }
       return $dest;
   } else {
       return $this->_getConForKey($key)->get($key);
   }
   }

   public function set($key, $var, $compress=0, $expire=0) {
   return $this->_getConForKey($key)->set($key, $var, $compress, $expire);
   }

   public function add($key, $var, $compress=0, $expire=0) {
   return $this->_getConForKey($key)->add($key, $var, $compress, $expire);
   }

   public function replace($key, $var, $compress=0, $expire=0) {
   return $this->_getConForKey($key)->replace
       ($key, $var, $compress, $expire);
   }

   public function delete($key, $timeout=0) {
   return $this->_getConForKey($key)->delete($key, $timeout);
   }

   public function increment($key, $value=1) {
   return $this->_getConForKey($key)->increment($key, $value);
   }

   public function decrement($key, $value=1) {
   return $this->_getConForKey($key)->decrement($key, $value);
   }

}
?>

<mcve_voidMemcache::add>
 Last updated: Tue, 15 Nov 2005