/*
* 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_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;
//Schlüssel aus Cache löschen
öffentliche Funktion delete($key){
switch($this->cache_type){
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) {
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 .= '
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);
}
}
So öffnen Sie eine PHP-Datei
So entfernen Sie die ersten paar Elemente eines Arrays in PHP
Was tun, wenn die PHP-Deserialisierung fehlschlägt?
So verbinden Sie PHP mit der MSSQL-Datenbank
So verbinden Sie PHP mit der MSSQL-Datenbank
So laden Sie HTML hoch
So lösen Sie verstümmelte Zeichen in PHP
So öffnen Sie PHP-Dateien auf einem Mobiltelefon
