/*
* Name: wrapperCache
* Notes: wrapper cache for fileCache, memcache/memcached, APC, Xcache and 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 CACHE_TYPE_MEMCACHE = 'memcache';
const CACHE_TYPE_MEMCACHED = 'memcached';
const CACHE_TYPE_FILE = 'filecache';
const CACHE_TYPE_XCACHE = 'xcache';
private $cache_params; //extra params for external caches like path or connection option memcached
public $cache_expire; //seconds that the cache expires
private $cache_type; //type of cache to use
private $cache_external; //external instance of cache, can be fileCache or memcache
private static $instance;//Instance of this class
// Always returns only one instance
public static function getInstance($type=self::CACHE_TYPE_AUTO, $exp_time=3600, $params='cache/'){
if (!isset(self::$instance)) { //doesn't exists the isntance
self::$instance = new self($type, $exp_time, $params); //goes to the constructor
}
return self::$instance;
}
//cache constructor, optional expiring time and cache path
private function __construct($type, $exp_time, $params) {
$this->cache_expire = $exp_time;
$this->cache_params = $params;
$this->setCacheType($type);
}
public function __destruct() {
unset($this->cache_external);
}
// Prevent users to clone the instance
public function __clone(){
$this->cacheError('Clone is not allowed.');
}
//deletes cache from folder
public function clearCache(){
switch($this->cache_type){
case self::CACHE_TYPE_EACCELERATOR :
eaccelerator_clean();
eaccelerator_clear();
break;
case self::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_external->flush();
break;
case self::CACHE_TYPE_FILE:
$this->cache_external->deleteCache();
break;
}
}
//writes or reads the cache
public function cache($key, $value = '', $ttl = '') {
if ($value != '') { //wants to write
if ($ttl == '') $ttl = $this->cache_expire;
$this->put($key, $value, $ttl);
} else return $this->get($key);
//reading value
}
//creates new cache files with the given data, $key== name of the cache, data the info/values to store
private function put($key, $data, $ttl = '') {
if ($ttl == '') $ttl = $this->cache_expire;
switch($this->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;
}
}
//returns cache for the given key
private function get($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));
break;
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;
}
//delete key from cache
public function delete($key){
switch($this->cache_type){
case self::CACHE_TYPE_EACCELERATOR :
eaccelerator_rm($key);
break;
case self::CACHE_TYPE_APC :
apc_delete($key);
break;
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;
}
}
// Overloading for the Application variables and automatically cached
public function __set($name, $value) {
$this->put($name, $value, $this->cache_expire);
}
public function __get($name) {
return $this->get($name);
}
public function __isset($key) {//echo "Is '$name' set?\n"
if ($this->get($key) !== false) return true;
else return false;
}
public function __unset($name) {//echo "Unsetting '$name'\n";
$this->delete($name);
}
//end overloads
public function getCacheType(){
return $this->cache_type;
}
//sets the cache if its installed if not triggers error
public function setCacheType($type){
$this->cache_type=strtolower($type);
switch($this->cache_type){
case self::CACHE_TYPE_EACCELERATOR :
if (!function_exists('eaccelerator_get')) $this->cacheError('eaccelerator not found');
break;
case self::CACHE_TYPE_APC :
if (!function_exists('apc_fetch')) $this->cacheError('APC not found');
break;
case self::CACHE_TYPE_XCACHE :
if (function_exists('xcache_get')) $this->cacheError('Xcache not found');
break;
case self::CACHE_TYPE_MEMCACHE :
if (class_exists('Memcache')) $this->init_mem();
else $this->cacheError('memcache not found');
break;
case self::CACHE_TYPE_MEMCACHED :
if (class_exists('Memcached')) $this->init_mem(true);
else $this->cacheError('memcached not found');
break;
case self::CACHE_TYPE_FILE :
if (class_exists('fileCache'))$this->init_filecache();
else $this->cacheError('fileCache not found');
break;
case self::CACHE_TYPE_AUTO ://try to auto select a cache system
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();
else $this->cacheError('not any compatible cache was found');
break;
default://not any cache selected or wrong one selected
$msg='Not any cache type selected';
if (isset($type)) $msg='Unrecognized cache type selected '.$type.'';
$this->cacheError($msg);
break;
}
}
private function init_mem($useMemecached = false) { //get instance of the memcache/memcached class
if (is_array($this->cache_params)) {
if ($useMemecached) {
$this->cache_type = self::CACHE_TYPE_MEMCACHED;
$this->cache_external = new Memcached();
} else {
$this->cache_type = self::CACHE_TYPE_MEMCACHE;
$this->cache_external = new Memcache;
}
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 . ' needs an array, example:wrapperCache::getInstance("' . $this->cache_type . '",30,array(array("host"=>"localhost")));');
}
private function init_filecache(){//get instance of the filecache class
$this->cache_type = self::CACHE_TYPE_FILE ;
$this->cache_external = fileCache::getInstance($this->cache_expire, $this->cache_params);
}
public function getAvailableCache($return_format='html'){//returns the available cache
$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_MEMCACHE, 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 .= 'Found/Compatible';
else $ret .= 'Not Found/Incompatible';
$ret .= '';
}
return $ret . '
} else return $avCaches;
}
private function cacheError($msg){//triggers error
trigger_error('
wrapperCache error: '.$msg.
'
If you want you can try with \'auto\' for auto select a compatible cache.
Or choose a supported cache from list:'.$this->getAvailableCache(), E_USER_ERROR);
}
}
Bagaimana untuk membuka fail php
Bagaimana untuk mengalih keluar beberapa elemen pertama tatasusunan dalam php
Apa yang perlu dilakukan jika penyahserialisasian php gagal
Bagaimana untuk menyambungkan php ke pangkalan data mssql
Bagaimana untuk menyambung php ke pangkalan data mssql
Bagaimana untuk memuat naik html
Bagaimana untuk menyelesaikan aksara bercelaru dalam PHP
Bagaimana untuk membuka fail php pada telefon bimbit
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
