Memcache : un vrai système de cache performant et facile a utiliser avec php

<?php
class mcd
{
        private $_memcache      = NULL;                 // (object)     memcache instance
        private $_status        = NULL;                 // (bool)       cache enable
 
        private $_params        = array(
                'use_pconnect'  => false,                    // (bool)       use persistent connexion
                'use_zlib'      => false,                    // (bool)       use zlib to store conpressed data
                'timeout'       => 1,                        // (int)        timeout (secondes)
                'default_ttl'   => 86400                     // (int)        default item ttl (secondes)
        );
 
        private $_servers       = array(
                array(
                        'host'          => 'localhost',      // (srting)     hostname or ip
                        'port'          => '11211',          // (int)        tcp port
                        'weight'        => 50                // (int)        server's weight
                ),
        //      array(
        //              'host'          => 'mcd.plumbr.com',
        //              'port'          => '11211',
        //              'weight'        => 10
        //      ),      
        );
 
        /**
         * New instance of memcache
         *
         * @param array $params         parameters
         * @param array $servers        servers pool
         */
        public function __construct($params = array(), $servers = NULL) {
                $this->_status = (true === defined('CACHE_ENABLE') and true === CACHE_ENABLE ? true : false);
                $this->_params = array_merge($this->_params, $params);
 
                $this->_params['use_zlib'] = (true === $this->_params['use_zlib'] ? MEMCACHE_COMPRESSED : 0);
 
                if(NULL !== $servers) $this->_servers = $servers;
 
                if(true === $this->_status) {
                        try {
                                $this->_memcache = new Memcache;
                                assert('true === is_object($this->_memcache)');
                                $this->_connect();
                        } catch(Exception $e) {
                                trigger_error(var_export($e, true), E_USER_WARNING);
                        }
                }
        }
 
        /**
         * (void) Connect to the memcache pool servers
         */
        private function _connect() {
                foreach($this->_servers as $server) {
                        if(false === array_key_exists('host', $server) or false === array_key_exists('port', $server))
                                throw new Exception('Bad server config :/');
 
                        if(false === $this->_memcache->addServer(
                                $server['host'],
                                $server['port'],
                                $this->_params['use_pconnect'],
                                (true === array_key_exists('weight', $server) ? $server['weight'] : 50),
                                $this->_params['timeout']
                        )) throw new Exception('Cannot connect to memcached '.$server['host'].':'.$server['port']);
                }
        }
 
        /**
         * Return the value cached item
         *
         * @param mixed $data   item value
         * @param string $name  item key
         * @param int $ttl              item cache ttl
         * @return mixed                return false if an erro rhas occured
         */
        public function set(&$data, $name, $ttl = NULL) {
                assert('true === is_string($name)');
                if(false === $this->_status) return false;
 
                if(NULL === $ttl) $ttl = $this->_params['default_ttl'];
 
                if(false === $this->_memcache->set($name, $data, $this->_params['use_zlib'], $ttl)) {
                        trigger_error('Cannot set '.$name.' into memcache server', E_USER_WARNING);
                        return false;
                }
 
                return true;
        }
 
        /**
         * Retrieve item from the server
         *
         * @param string $name  item's name
         * @return mixed                return false if an error has occured
         */
        public function get($name) {
                assert('true === is_string($name)');
 
                return (false === $this->_status ? false : $this->_memcache->get($name));
        }
 
        /**
         * (void) Flush all existing items
         */
        public function flush() {
                $this->_memcache->flush();
        }
 
        /**
         * Destructor: close the connexions to memcached
         */
        public function __destruct() {
                if($this->_memcache) $this->_memcache->close();
        }
}
 
error_reporting(E_ALL);
ini_set('display_errors', 1);
define('CACHE_ENABLE' , true);
 
$data = array('foo' => time());                      // data to store
 
$cache = new mcd(array('use_zlib' => true));
 
$cache->set($data, 'foo', 2);                        // store $data
var_dump($cache->get('foo'));                        // retreive $data
sleep(3);
var_dump($cache->get('foo'));                        // test cache expiration: have to return false
 
$cache->set($data, 'foo');
var_dump($cache->get('foo'));
$cache->flush();                                     // flush entire cached items
var_dump($cache->get('foo'));                        // test cache flush: have to return false
?>