Die umfassendere Cache-Klasse von PHP

/*

 * Name:    wrapperCache

 * Hinweise:   Wrapper-Cache für FileCache, Memcache/Memcached, APC, Xcache und Eaccelerator

$cacheObj =wrapperCache::getInstance('memcache',30,array(array('host'=>'localhost'))));

echo $cacheObj->cache(' key','value');

*/

class wrapperCache {

    const DEFAULT_MEMCACHE_PORT     = 11211;

    const CACHE_TYPE_AUTO           = 'auto';

    const CACHE_TYPE_EACCELERATOR   = 'eaccelerator';

    const CACHE_TYPE_APC            = 'apc';

    const CHE_TYPE_MEMCACHE       = 'memcache';

    const CACHE_TYPE_MEMCACHED      = 'memcached';

    const CACHE_TYPE_FILE           = 'filecache';

    const CACHE_TYPE_XCACHE         = 'xcache';

    private $cache_params;   //zusätzliche Parameter für externe Caches wie Pfad oder Verbindungsoption memcached

    public  $cache_expire;   //Sekunden, in denen der Cache abläuft

    private $cache_type;     //Typ des zu verwendenden Caches

    private $cache_external; //Externe Instanz des Caches, kann FileCache oder Memcache sein

    private static $instance;//Instanz dieser Klasse

    // Gibt immer nur eine zurück Instanz

    öffentliche statische Funktion getInstance($type=self::CACHE_TYPE_AUTO, $exp_time=3600, $params='cache/'){

        if (!isset(self::$instance )) { //existiert nicht

            self::$instance = new self($type, $exp_time, $params); //geht zum Konstruktor

        }

        return self::$instance;

    }

    // Cache-Konstruktor, optionale Ablaufzeit und Cache-Pfad

    private function __construct($type, $exp_time, $params) {

        $this->cache_expire = $exp_time;

        $this->cache_params = $params;

        $this->setCacheType($type);

    }

öffentliche Funktion __destruct() {

        unset($this->cache_external);

    }

    // Benutzer am Klonen hindern die Instanz

    öffentliche Funktion __clone(){

        $this->cacheError('Klonen ist nicht zulässig.');

    }

    //löscht Cache aus Ordner

   public function clearCache(){

        switch($this->cache_type){

            case self ::CACHE_TYPE_EACCELERATOR :

                eaccelerator_clean();

                eaccelerator_clear();

                break;

            Fall selbst: :CACHE_TYPE_APC :

                apc_clear_cache('user');

                break;

            case self::CACHE_ TYPE_XCACHE :

                xcache_clear_cache(XC_TYPE_VAR, 0);

              break;

            case self::CACHE_TYPE_MEMCACHE. :

                $this->cache_external- >flush();

                break;

          case self::CACHE_TYPE_MEMCACHED :

                $this->cache_ex ternal-> Flush();

                break;

            case self::CACHE_TYPE_FILE:

                $this->cache_external->delete Cache( );

                break;

        }

    }

    //schreibt oder liest den Cache

   öffentlicher Funktionscache($key, $value = '', $ttl = '') {

        if ($value != '') { //will schreiben

            if ($ttl == '') $ttl = $this->cache_expire;

            $ this->put($key, $value, $ttl);

        } else return $this->get($key);

        //Wert lesen

    }

    //erstellt neue Cache-Dateien mit den angegebenen Daten, $key== Name des Caches, Daten, zu speichernde Informationen/Werte

   private function put($key, $data, $ttl = '') {

        if ($ttl == '') $ttl = $this->cache_expire;

Switch ($ this- & gt; cache_type) {

case self :: cache_type_eaccelerator:

EACCelerator_put ($ Key, Serialize ($ Data), $ ttl) ;

                break;

            case self::CACHE_TYPE_APC :

              apc_store($key, $data, $ttl);

                break;

            case self::CACHE_TYPE_XCACHE :

                xcache_set($key, serialize($data), $ttl);

                break;

            case self::CACHE_TYPE_MEMCACHE :

                $data=serialize($data);

                $this ->cache_external->set($key, $data, false, $ttl);

                break;

            case self::CACHE_TYPE_MEMCACHED :

                $data=serialize($data);

                $this->cache_external->set($key, $data, $ttl);

                break;

            case self::CACHE_TYPE_FILE :

                $this->cache_external->cache($key,$data);

                break;

        }

    $key){

        switch($this->cache_type){

            case self::CACHE_TYPE_EACCELERATOR :

                $data =  unserialize(eaccelerator_get($key));

                break;

            case self::CACHE_TYPE_APC :

                $data =  apc_fetch($key);

break;

            case self::CACHE_TYPE_XCACHE :

                $data =  unserialize(xcache_get($key));

             Pause;

            case self::CACHE_TYPE_MEMCACHE :

                $data = unserialize($this->cache_external->get($key));

                break;

            case self::CACHE_TYPE_MEMCACHED :

              $data =. unserialize($this->cache_external-> ;get($key ));

                break;

            case self::CACHE_TYPE_FILE :

                $data = $this->cache_external- > Cache($key);

                break;

        }

        return $data;

    }

    //Schlüssel aus Cache löschen

   öffentliche Funktion delete($key){

        switch($this->cache_type){

            case self::CACHE_TYPE_EACCELERATOR :

                eaccelerator_rm($key);

                break;

            case self::CACHE_TYPE_APC :

                apc_delete($key);

               Pause;

            case self::CACHE_TYPE_XCACHE :

                xcache_unset($key);

                break;

            case self::CACHE_TYPE_MEMCACHE :

              $this->cache_external->delete($key);

                break;

            case self::CACHE_TYPE_MEMCACHED :

              $this->cache_external->delete($key);

                break;

            case self::CACHE_TYPE_FILE :

                $this->cache_external->delete($key);

                break;

       }

    }

    // Überladung für die Anwendungsvariablen und automatisch zwischengespeichert

    öffentliche Funktion __set($name, $value) {

        $ this->put($name, $value, $this->cache_expire);

    }

    öffentliche Funktion __get($name) {

        return $this->get($name);

    }

    öffentliche Funktion __isset($key) {// echo "Ist '$name' gesetzt?n"

        if ($this->get($key) !== false)  return true;

        else return false;

    }

    öffentliche Funktion __unset($name) {//echo "Unsetting '$name'n";

        $this-> delete($name);

    }

    //Überladungen beenden

    öffentliche Funktion getCacheType(){

return $this->cache_type;

    }

    //Setzt den Cache, wenn er installiert ist, andernfalls löst er einen Fehler aus

   öffentliche Funktion setCacheType($type){

        $this->cache_type=strtolower($type);

        switch($this->cache_type){

            case self::CACHE_TYPE_EACCELERATOR :

              if (!function_exists('eaccelerator_get')) $this->cacheError('eaccelerator notfound');

               Pause;

            case self::CACHE_TYPE_APC :

                if (!function_exists('apc_fetch')) $this->cacheError('APC nicht gefunden') ;

                break;

            case self::CACHE_TYPE_XCACHE :

                if (function_exists('xcache_get') ) $this-> CacheError('Xcache nicht gefunden') _exists('Memcache ')) $this->init_mem();

                else $this->cacheError('memcache nicht gefunden');

                break;

            case self::CACHE_TYPE_MEMCACHED :

              if (class_exists('Memcached')) $this->init_mem(true);

                else ->cacheError ('memcached nicht gefunden');

                break;

            case self::CACHE_TYPE_FILE :

                if (class_exists(' fileCache' ))$this->init_filecache();

                else $this->cacheError('fileCache nicht gefunden');

                break;

            case self::CACHE_TYPE_AUTO ://versuchen, automatisch ein Cache-System auszuwählen

                if (function_exists('eaccelerator_get') ) $this->cache_type = self::CACHE_TYPE_EACCELERATOR;

                elseif (function_exists('apc_fetch'))       $this->cache_type = self::CACHE_TYPE_APC ;

               elseif (function_exists(' xcache_get'))      $this->cache_type = self::CACHE_TYPE_XCACHE;

              elseif (class_exists('Memcache'))           $this->init_mem();

             elseif (class_exists( 'Memcached'))          $this->init_mem(true);

              elseif (class_exists('fileCache'))          $this->init_filecache();

              sonst $this-> ;cacheError('kein kompatibler Cache gefunden');

                break;

            default://kein oder falscher Cache ausgewählt

                $msg='Kein Cache-Typ ausgewählt';

                if (isset($type)) $msg='Unbekannter Cache-Typ ausgewählt '.$type.'

$ this- & gt; cacheError ($ msg);

break; 🎜>

   private function init_mem($useMemecached = false) { //Instanz der Memcache/Memcached-Klasse abrufen

        if (is_array($this->cache_params)) {

            if ($useMemecached) {

                $this->cache_type = self::CACHE_TYPE_MEMCACHED;

                $this->cache_external = new Memcached();

                            $this->cache_type = self::CACHE_TYPE_MEMCACHE;

              $this->cache_external = new.

           }

            foreach ($this->cache_params as $server) {

                $server['port'] = isset($server['port']) ? (int)$server['port'] : self::DEFAULT_MEMCACHE_PORT;

                if ($useMemecached) {

                    $this->cache_external->addServer($server['host '], $server['port']);

                } else {

                    $server['persistent'] = isset($server['persistent']) ? (bool)$server['persistent'] : true;

                    $this->cache_external->addServer($server['host'], $server['port'], $server[' persistent']);

                }

            }

        } else $this->cacheError($this->cache_type . ' benötigt ein Array, Beispiel:wrapperCache: :getInstance("' . $this->cache_type . '",30,array(array("host"=>"localhost")));');

    }

    private Funktion init_filecache(){//get-Instanz der Filecache-Klasse

        $this->cache_type = self::CACHE_TYPE_FILE ;

        $this ->cache_external = fileCache::getInstance($this->cache_expire, $this->cache_params);

    }

    öffentliche Funktion getAvailableCache ($return_format='html'){//gibt den verfügbaren Cache zurück

        $avCaches   = array();

        $avCaches[] = array(self::CACHE_TYPE_EACCELERATOR,function_exists('eaccelerator_get '));

        $avCaches[] = array(self::CACHE_TYPE_APC,         function_exists('apc_fetch')) ;

        $avCaches[] = array(self::CACHE_TYPE_XCACHE,      function_exists('xcache_get'));

        $avCaches[] = array(self::CACHE_TYPE_MEMCACHED,    class_exists('Memcache'));

        $avCaches[] = array(self::CACHE_TYPE_MEMCACHED,   class_exists('Memcached')) ;

        $avCaches[] = array(self::CACHE_TYPE_FILE,        class_exists('fileCache'));

        if ($return_format == 'html ') {

            $ret = '

';

            foreach ($avCaches as $c) {

                $ret .= '

• ' . $c[0] . ' - ';

                  if ($c[1]) $ret .= 'Gefunden/Kompatibel';

                  else $ret .= 'Nicht gefunden/Inkompatibel';

                  $ret .= '';

              }

              return $ret . '

';

        } else return $avCaches;

    }

    private function cacheError($msg){ //triggers error

        trigger_error('
wrapperCache error: '.$msg.

            '
Wenn Sie Wenn Sie möchten, können Sie es mit „auto“ versuchen, um automatisch einen kompatiblen Cache auszuwählen.

                   
Oder wählen Sie einen unterstützten Cache aus der Liste:'.$this->getAvailableCache(), E_USER_ERROR);

    }

}