PHP比较全面的缓存类

大湖之子

<?php
/*
* 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 <b>'.$type.'</b>';
$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 = '<ul>';
foreach ($avCaches as $c) {
$ret .= '<li>' . $c[0] . ' - ';
if ($c[1]) $ret .= 'Found/Compatible';
else $ret .= 'Not Found/Incompatible';
$ret .= '</ll>';
}
return $ret . '</ul>';
} else return $avCaches;
}
private function cacheError($msg){//triggers error
trigger_error('<br /><b>wrapperCache error</b>: '.$msg.
'<br />If you want you can try with \'auto\' for auto select a compatible cache.
<br />Or choose a supported cache from list:'.$this->getAvailableCache(), E_USER_ERROR);
}
}
 wrapperCache基于文件的缓存处理类 ：
<?php
/*
* Name:    fileCache
fileCache::getInstance(3600,'E:\www\cache\\')->cache('key','value');
* Notes:   fileCache class, caches variables in standalone files if value is too long or uses unique file for small ones
*/
class fileCache {
private $cache_path;//path for the cache
private $cache_expire;//seconds that the cache expires
private $application=array();//application object like in ASP
private $application_file;//file for the application object
private $application_write=false;//if application write is true means there was changes and we need to write the app file
private $debug=false; //no debug by default
private $log=array();//log for the debug system
private $start_time=0;//application start time
private static $content_size=64;//this is the max size can be used in APP cache if bigger writes independent file
private static $instance;//Instance of this class
// Always returns only one instance
public static function getInstance($exp_time=3600,$path='cache/'){
if (!isset(self::$instance)){//doesn't exists the isntance
self::$instance = new self($exp_time,$path);//goes to the constructor
}
return self::$instance;
}
//cache constructor, optional expiring time and cache path
private function __construct($exp_time,$path){
$this->start_time=microtime(true);//time starts
$this->cache_expire=$exp_time;
if ( ! is_writable($path) ) trigger_error('Path not writable:'.$path);
else $this->cache_path=$path;
$this->APP_start();//starting application cache
}
public function __destruct() {
$this->addLog('destruct');
$this->APP_write();//on destruct we write if needed
$this->returnDebug();
}
// Prevent users to clone the instance
public function __clone(){
trigger_error('Clone is not allowed.', E_USER_ERROR);
}
//deletes cache from folder
public function deleteCache($older_than=''){
$this->addLog('delete cache');
if (!is_numeric($older_than)) $older_than=0;
$files = scandir($this->cache_path);
foreach($files as $file){
if (strlen($file)>2 && time() > (filemtime($this->cache_path.$file) + $older_than) ) {
unlink($this->cache_path.$file);//echo "<br />-".$file;
$this->addLog('delete cache file:'.$this->cache_path.$file);
}
}
}
//writes or reads the cache
public function cache($key, $value=''){
if ($value!=''){//wants to write
if (strlen(serialize($value)) > 64 ){//write independent file it's a big result
$this->addLog('cache function write in file key:'. $key);
$this->put($key, $value);
}else{
$this->addLog('cache function write in APP key:'. $key);
$this->APP($key,$value);//write in the APP cache
}
}else{//reading value
if ( $this->APP($key)!=null ){
$this->addLog('cache function read APP key:'. $key);
return $this->APP($key);//returns from app cache
}else{
$this->addLog('cache function read file key:'. $key);
return $this->get($key);//returns from file cache
}
}
}
//deletes a key from cache
public function delete($name){
if ( $this->APP($name)!=null ){//unset the APP var
$this->addLog('unset APP key:'. $name);
unset($this->application[md5($name)]);
$this->application_write=true;//says that we have changes to later save the APP
}elseif ( file_exists($this->fileName($name)) ){//unlink filename
$this->addLog('unset File key:'. $name);
unlink($this->fileName($name));
}
}
// Overloading for the variables and automatically cached
public function __set($name, $value) {
$this->cache($name, $value);
}
public function __get($name) {
return $this->cache($name);
}
public function __isset($name) {//echo "Is '$name' set?\n"
$this->addLog('isset key:'. $name);
$value=$this->cache($name);
return isset($value);
}
public function __unset($name) {//echo "Unsetting '$name'\n";
$this->delete($name);
}
//end overloads
//////////Cache for files individually///////////////////
//creates new cache files with the given data, $key== name of the cache, data the info/values to store
private function put($key, $data){
if ( $this->get($key)!= $data ){//only write if it's different
$values = serialize($data);
$filename = $this->fileName($key);
$file = fopen($filename, 'w');
if ($file){//able to create the file
$this->addLog('writting key: '.$key.' file: '.$filename);
fwrite($file, $values);
fclose($file);
}
else  $this->addLog('unable to write key: '.$key.' file: '.$filename);
}//end if different
}
//returns cache for the given key
private function get($key){
$filename = $this->fileName($key);
if (!file_exists($filename) || !is_readable($filename)){//can't read the cache
$this->addLog('can\'t read key: '.$key.' file: '.$filename);
return null;
}
if ( time() < (filemtime($filename) + $this->cache_expire) ) {//cache for the key not expired
$file = fopen($filename, 'r');// read data file
if ($file){//able to open the file
$data = fread($file, filesize($filename));
fclose($file);
$this->addLog('reading key: '.$key.' file: '.$filename);
return unserialize($data);//return the values
}else{
$this->addLog('unable to read key: '.$key.' file: '.$filename);
return null;
}
}else{
$this->addLog('expired key: '.$key.' file: '.$filename);
unlink($filename);
return null;//was expired you need to create new
}
}
//returns the filename for the cache
private function fileName($key){
return $this->cache_path.md5($key);
}
//////////END Cache for files individually///////////////////
//////////Cache for APP variables///////////////////
//load variables from the file
private function APP_start ($app_file='application'){
$this->application_file=$app_file;
if (file_exists($this->cache_path.$this->application_file)){ // if data file exists, load the cached variables
//erase the cache every X minutes
$app_time=filemtime($this->cache_path.$this->application_file)+$this->cache_expire;
if (time()>$app_time){
$this->addLog('deleting APP file: '.$this->cache_path.$this->application_file);
unlink ($this->cache_path.$this->application_file);//erase the cache
}else{//not expired
$filesize=filesize($this->cache_path.$this->application_file);
if ($filesize>0){
$file = fopen($this->cache_path.$this->application_file, 'r');// read data file
if ($file){
$this->addLog('reading APP file: '.$this->cache_path.$this->application_file);
$data = fread($file, $filesize);
fclose($file);
$this->application = unserialize($data);// build application variables from data file
}//en if file could open
}//end if file size
}
}else{//if the file does not exist we create it
$this->addLog('creating APP file: '.$this->cache_path.$this->application_file);
fopen($this->cache_path.$this->application_file, 'w');
}
}
// write application data to file
private function APP_write(){
if ($this->application_write){
$data = serialize($this->application);
$file = fopen($this->cache_path.$this->application_file, 'w');
if ($file){
$this->addLog('writting APP file: '.$this->cache_path.$this->application_file);
fwrite($file, $data);
fclose($file);
}
}
}
//returns the value form APP cache or stores it
private function APP($var,$value=''){
if ($value!=''){//wants to write
if (is_array($this->application)){
if ( array_key_exists(md5($var), $this->application) ){//exist the value in the APP
$write=false;//we don't need to wirte
if ($this->application[md5($var)]!=$value)$write=true;//but exists and is different then we write
}
else $write=true;//not set we write!
}
else $write=false;
if ($write){
$this->addLog('writting APP key:'.$var);
$this->application[md5($var)]=$value;
$this->application_write=true;//says that we have changes to later save the APP
}
}else{//reading
if ( !is_array($this->application) || ! array_key_exists(md5($var), $this->application) ){
$this->addLog('nothing found for APP key:'.$var);
return null;//nothing found not in array
}else{
$this->addLog('reading APP key:'.$var);
return $this->application[md5($var)];//return value
}
}
}
//////////End Cache for APP variables///////////////////
////DEBUG
//sets debug on or off
public function setDebug($state){
$this->debug=(bool) $state;
}
public function returnDebug($type='HTML'){
if ($this->debug){
switch($type){
case 'array':
return $this->log;
break;
case 'HTML'://returns debug as HTML
echo '<ol>';
foreach($this->log as $key=>$value){//loop in the log var
echo '<li>'.$value.'</li>';
}
echo '</ol>';
break;
}
}
else return false;
}
//add debug log
public function addLog($value){
if ($this->debug){//only if debug enabled
array_push($this->log, round((microtime(true) - $this->start_time),5).'s - '. $value);
}
}
}
?>