PHP file cache class summary, _PHP tutorial

php file cache class summary,

The example in this article describes the file caching class of PHP. Share it with everyone for your reference. The specific analysis is as follows:

Cache class is a commonly used function when we develop applications. Let’s sort out several PHP file cache classes for you. Each file cache class is written differently, but there will be differences in performance. Those who are interested in testing it Friends can test these cache classes.

Example 1

Copy code The code is as follows:

$fzz = new fzz_cache;
$fzz->kk = $_SERVER; //Write cache
//$fzz->set("kk",$_SERVER,10000); //This method does not conflict with class attributes, and any cache name can be used;
print_r($fzz->kk); //Read cache
//print_r($fzz->get("kk"));
//unset($fzz->kk); //Delete cache
//$fzz->_unset("kk");
var_dump(isset($fzz->kk)); //Determine whether the cache exists
//$fzz->_isset("kk");
//$fzz->clear(); //Clear expired cache
//$fzz->clear_all(); //Clear all cache files
class fzz_cache{
public $limit_time = 20000; //Cache expiration time
public $cache_dir = "data"; //Cache file storage directory
//Write cache
function __set($key, $val){
$this->_set($key ,$val);
}
//The third parameter is the expiration time
function _set($key,$val,$limit_time=null){
$limit_time = $limit_time ? $limit_time : $this->limit_time;
$file = $this->cache_dir."/".$key.".cache";
$val = serialize($val);
@file_put_contents($file,$val) or $this->error(__line__,"fail to write in file");
@chmod($file,0777);
@touch($file,time()+$limit_time) or $this->error(__line__,"fail to change time");
}

//Read cache
function __get($key){
Return $this->_get($key);
}
function _get($key){
$file = $this->cache_dir."/".$key.".cache";
if (@filemtime($file)>=time()){
Return unserialize(file_get_contents($file));
}else{
@unlink($file) or $this->error(__line__,"fail to unlink");
Return false;
}
}

//Delete cache files
function __unset($key){
Return $this->_unset($key);
}
function _unset($key){
if (@unlink($this->cache_dir."/".$key.".cache")){
Return true;
}else{
Return false;
}
}

//Check whether the cache exists, if it expires, it is considered not to exist
function __isset($key){
return $this->_isset($key);
}
function _isset($key){
$file = $this->cache_dir."/".$key.".cache";
if (@filemtime($file)>=time()){
Return true;
}else{
@unlink($file) ;
Return false;
}
}

//Clear expired cache files
function clear(){
$files = scandir($this->cache_dir);
foreach ($files as $val){
if (filemtime($this->cache_dir."/".$val) @unlink($this->cache_dir."/".$val);
}
}
}

//Clear all cache files
function clear_all(){
$files = scandir($this->cache_dir);
foreach ($files as $val){
@unlink($this->cache_dir."/".$val);
}
}

function error($msg,$debug = false) {
$err = new Exception($msg);
$str = "

<br>
<span style='color:red'>error:</span><br>
".print_r($err->getTrace(),1)."<br>

";
if($debug == true) {
file_put_contents(date('Y-m-d H_i_s').".log",$str);
Return $str;
}else{
die($str);
}
}
}
?>

Example 2. PHP file cache class extracted from CI community's stblog and CI's file_helper class, a simple file-based key->value cache class.

This class can be used to cache some basic information, such as some infrequent changes in the header, footer, and sidebar of the blog, and the content taken out from the database. Before fetching the data, first determine whether the content in the file cache has expired. If not, Take it out when it expires. If it expires, connect to the database to query, rewrite the results into the file cache, and update the expiration time. It is similar to using memcache, but more convenient. It is enough for some small applications.

The specific code is as follows

Copy code The code is as follows:

define('DIRECTORY_SEPARATOR','/');
define('FOPEN_WRITE_CREATE_DESTRUCTIVE','wb');
define('FOPEN_WRITE_CREATE','ab');
define('DIR_WRITE_MODE', 0777);
class FileCache {
 /**
* Cache path
*
* @access private
* @var string
​​*/
 private $_cache_path;
 /**
* Cache expiration time, unit is second
*
* @access private
* @var int
​​*/
 private $_cache_expire;
 
 /**
* Parse function, set cache expiration practice and storage path
* *
* @access public
* @return void
​​*/
 public function __construct($expire, $cache_path)
 {
  $this->_cache_expire = $expire;
  $this->_cache_path = $cache_path;
 }
 
 /**
* Cache file name
* *
* @access public
* @param string $key
* @return void
​​*/
 private function _file($key)
 {
  return $this->_cache_path . md5($key);
 }
 
 /**
* * Set cache
* *
* @access public
* @param string $key The unique key of the cache
* @param string $data cached content
* @return bool
​​*/
 public function set($key, $data)
 {
  $value = serialize($data);
 
  $file = $this->_file($key);
 
     return $this->write_file($file, $value);
 }
 
 /**
* Get cache
* *
* @access public
* @param string $key The unique key of the cache
* @return mixed
​​*/
 public function get($key)
 {
  $file = $this->_file($key);
 
  /**File does not exist or directory is not writable*/
  if (!file_exists($file) || !$this->is_really_writable($file))
  {
   return false;
  }
 
  /**The cache has not expired and is still available*/
  if ( time() < (filemtime($file) + $this->_cache_expire) )
  {
  
   $data = $this->read_file($file);
  
   if(FALSE !== $data)
   {
    return unserialize($data);
   }
  
   return FALSE;
  }
 
  /**Cache expires, delete it*/
  @unlink($file);
  return FALSE;
  }
 
  function read_file($file)
 {
  if ( ! file_exists($file))
  {
   return FALSE;
  }
 
  if (function_exists('file_get_contents'))
  {
   return file_get_contents($file); 
  }
  if ( ! $fp = @fopen($file, FOPEN_READ))
  {
   return FALSE;
  }
 
  flock($fp, LOCK_SH);//读取之前加上共享锁
 
  $data = '';
  if (filesize($file) > 0)
  {
   $data =& fread($fp, filesize($file));
  }
  flock($fp, LOCK_UN);//释放锁
  fclose($fp);
  return $data;
 }
 
  function write_file($path, $data, $mode = FOPEN_WRITE_CREATE_DESTRUCTIVE)
 {
  if ( ! $fp = @fopen($path, $mode))
  {
   return FALSE;
  }
 
  flock($fp, LOCK_EX);
  fwrite($fp, $data);
  flock($fp, LOCK_UN);
  fclose($fp);
 
  return TRUE;
 }
 function is_really_writable($file)//兼容各平台判断文件是否有写入权限
 {
  // If we're on a Unix server with safe_mode off we call is_writable
  if (DIRECTORY_SEPARATOR == '/' AND @ini_get("safe_mode") == FALSE)
  {
   return is_writable($file);
  }
 
  // For windows servers and safe_mode "on" installations we'll actually
  // write a file then read it.  Bah...
  if (is_dir($file))
  {
   $file = rtrim($file, '/').'/'.md5(rand(1,100));
 
   if (($fp = @fopen($file, FOPEN_WRITE_CREATE)) === FALSE)
   {
    return FALSE;
   }
 
   fclose($fp);
   @chmod($file, DIR_WRITE_MODE);
   @unlink($file);
   return TRUE;
  }
  elseif (($fp = @fopen($file, FOPEN_WRITE_CREATE)) === FALSE)
  {
   return FALSE;
  }
 
  fclose($fp);
  return TRUE;
 }
}
$cache = new FileCache(30,'cache/');
$cache->set('test','this is a test.');
print $cache->get('test');
/* End of file FlieCache.php */

 
例3.自己觉得很好用的php文件缓存

复制代码 代码如下:

class cache
{
 private static $_instance = null;
    protected $_options = array(
        'cache_dir'        => "./",
        'file_name_prefix' => 'cache',
     'mode'            => '1', //mode 1 为serialize model 2为保存为可执行文件
    );
 
 /**
* Get an instance of this class
*
* @return Ambiguous
​*/
 public static function getInstance()
 {
  if(self::$_instance === null)
  {
   self::$_instance = new self();
  }
  return self::$_instance;
 }
 
 /**
* Get cache information
*
* @param string $id
* @return boolean|array
​*/
 public static function get($id)
 {
  $instance = self::getInstance();
 
  //缓存文件不存在
  if(!$instance->has($id))
  {
   return false;
  }
 
  $file = $instance->_file($id);
 
  $data = $instance->_fileGetContents($file);
 
  if($data['expire'] == 0 || time() < $data['expire'])
  {
   return $data['contents'];
  }
  return false;
 }
 
 /**
* Set up a cache
*
* @param string $id Cache id
* @param array $data cache content
* @param int $cacheLife Cache life Default is 0 unlimited life
​*/
 public static function set($id, $data, $cacheLife = 0)
 {
  $instance = self::getInstance();
 
  $time = time();
  $cache      = array();
  $cache['contents'] = $data;
  $cache['expire']   = $cacheLife === 0 ? 0 : $time + $cacheLife;
  $cache['mtime']    = $time;
 
  $file = $instance->_file($id);
 
  return $instance->_filePutContents($file, $cache);
 }
 
    /**
* Clear a cache
* *
* @param string cache id
* @return void
​​*/  
 public static function delete($id)
 {
  $instance = self::getInstance();
 
  if(!$instance->has($id))
  {
   return false;
  }
     $file = $instance->_file($id);
     //删除该缓存
     return unlink($file);
 }
 
 /**
* Determine whether the cache exists
*
* @param string $id cache_id
* @return boolean true cache exists false cache does not exist
​*/
 public static function has($id)
 {
  $instance = self::getInstance();
  $file     = $instance->_file($id);
 
  if(!is_file($file))
  {
   return false;
  }
  return true;
 }
 
 /**
* Get cache information path through cache id
* @param string $id
* @return string cache file path
​*/
 protected function _file($id)
 {
  $instance  = self::getInstance();
  $fileNmae  = $instance->_idToFileName($id);
  return $instance->_options['cache_dir'] . $fileNmae;
 }
 
 /**
* Get cache information storage file name through id
*
* @param $id
* @return string cache file name
​*/
 protected function _idToFileName($id)
 {
  $instance  = self::getInstance();
  $prefix    = $instance->_options['file_name_prefix'];
  return $prefix . '---' . $id;
 }
 
 /**
* Get the cache id through filename
*
* @param $id
* @return string cache id
​*/
 protected function _fileNameToId($fileName)
 {
  $instance  = self::getInstance();
  $prefix    = $instance->_options['file_name_prefix'];
  return preg_replace('/^' . $prefix . '---(.*)$/', '$1', $fileName);
 }
 
 /**
* Write data to file
*
* @param string $file file name
* @param array $contents data content
* @return bool
​*/
 protected function _filePutContents($file, $contents)
 {
  if($this->_options['mode'] == 1)
  {
   $contents = serialize($contents);
  }
  else
  {
   $time = time();
         $contents = "                  " // mktime: ". $time. "n".
                 " return ".
                 var_export($contents, true).
                 "n?>";
  }
 
  $result = false;
     $f = @fopen($file, 'w');
        if ($f) {
            @flock($f, LOCK_EX);
            fseek($f, 0);
            ftruncate($f, 0);
            $tmp = @fwrite($f, $contents);
            if (!($tmp === false)) {
                $result = true;
            }
            @fclose($f);
        }
  @chmod($file,0777);
  return $result;   
 }
 
 /**
* Get data from file
*
* @param sring $file
* @return boolean|array
​*/
 protected function _fileGetContents($file)
 {
  if(!is_file($file))
  {
   return false;
  }
 
  if($this->_options['mode'] == 1)
  {
   $f = @fopen($file, 'r');
   @$data = fread($f,filesize($file));
   @fclose($f);
   return unserialize($data);
  }
  else
  {
   return include $file;
  }
 }
 
 /**
* Constructor
​*/
 protected function __construct()
 {
 
 }
 
 /**
* Set cache path
*
* @param string $path
* @return self
​*/
 public static function setCacheDir($path)
 {
  $instance  = self::getInstance();
        if (!is_dir($path)) {
            exit('file_cache: ' . $path.' 不是一个有效路径 ');
        }
        if (!is_writable($path)) {
            exit('file_cache: 路径 "'.$path.'" 不可写');
        }
   
        $path = rtrim($path,'/') . '/';
        $instance->_options['cache_dir'] = $path;
       
        return $instance;
 }
 
 /**
* Set cache file prefix
*
* @param srting $prefix
* @return self
​*/
 public static function setCachePrefix($prefix)
 {
  $instance  = self::getInstance();
  $instance->_options['file_name_prefix'] = $prefix;
  return $instance;
 }
 
 /**
* Set cache storage type
*
* @param int $mode
* @return self
​*/
public static function setCacheMode($mode = 1)
{
$instance = self::getInstance();
if($mode == 1)
{
$instance->_options['mode'] = 1;
}
else
{
$instance->_options['mode'] = 2;
}

return $instance;
}

/**
* Delete all caches
* @return boolean
​*/
public static function flush()
{
$instance = self::getInstance();
$glob = @glob($instance->_options['cache_dir'] . $instance->_options['file_name_prefix'] . '--*');

if(empty($glob))
{
Return false;
}

foreach ($glob as $v)
{
$fileName = basename($v);
$id = $instance->_fileNameToId($fileName);
$instance->delete($id);
}
return true;
}
}
/* Initialize and set cache configuration information etc. */
cache::setCachePrefix('core'); //Set cache file prefix
cache::setCacheDir('./cache'); //Set the cache folder path
//Mode 1 cache storage method
//a:3:{s:8:"contents";a:7:{i:0;i:1;i:1;i:2;i:2;i:3;i:3;i: 34;i:4;i:5;i:5;i:6;i:6;i:6;}s:6:"expire";i:0;s:5:"mtime";i:1318218422 ;}
//Mode 2 cache storage method
/*
// mktime: 1318224645
return array (
'contents' =>
array (
0 => 1,
1 => 2,
2 => 3,
3 => 34,
4 => 5,
5 => 6,
6 => 6,
),
'expire' => 0,
'mtime' => 1318224645,
)
?>
*
*
*/
cache::setCacheMode('2');
if(!$row = cache::get('zj2'))
{

$array = array(1,2,3,34,5,6,6);
$row = cache::set('zj2',$array);
}
// cache::flush(); Clear all caches
print_r($row);

File cache class

Copy code The code is as follows:

/**
* File cache class
* @date 2011-08-17
​*/
class cache
{
 const FILE_LIFE_KEY = 'FILE_LIFE_KEY';
 
 const CLEAR_ALL_KEY = 'CLEAR_ALL';
 
    static $_instance = null;
 
    protected $_options = array(
        'cache_dir' => './cache',
        'file_locking' => true,
        'file_name_prefix' => 'cache',
        'cache_file_umask' => 0777,
     'file_life'  => 100000
    );
   
    static function &getInstance($options = array())
    {
     if(self::$_instance === null)
     {
      self::$_instance = new self($options);
     }
     return self::$_instance;
    }
   
    /**
*Set parameters
* @param array $options cache parameters
* @return void
​​*/
 static function &setOptions($options = array())
 {
         return self::getInstance($options);
 }
 
    /**
* Constructor
* @param array $options cache parameters
* @return void
​​*/
    private function __construct($options = array())
    { 
        if ($this->_options['cache_dir'] !== null) {
  
   $dir = rtrim($this->_options['cache_dir'],'/') . '/';
         $this->_options['cache_dir'] = $dir;
        
   if (!is_dir($this->_options['cache_dir'])) {
             mkdir($this->_options['cache_dir'],0777,TRUE);
         }
         if (!is_writable($this->_options['cache_dir'])) {
             exit('file_cache: 路径 "'. $this->_options['cache_dir'] .'" 不可写');
         }
     
        } else {
           exit('file_cache: "options" cache_dir 不能为空 ');
        }
    }
    /**
* Set cache path
* @param string $value
* @return void
​​*/
    static function setCacheDir($value)
    {
     $self = & self::getInstance();
    
        if (!is_dir($value)) {
            exit('file_cache: ' . $value.' 不是一个有效路径 ');
        }
        if (!is_writable($value)) {
            exit('file_cache: 路径 "'.$value.'" 不可写');
        }
   
        $value = rtrim($this->_options['cache_dir'],'/') . '/';
       
        $self->_options['cache_dir'] = $value;
    }
   
    /**
     * 存入缓存数据
     * @param  array  $data          放入缓存的数据
     * @param  string $id            缓存id(又名缓存识别码)
     * @param  cache_life            缓存时间
     * @return boolean True if no problem
     */
    static function save($data, $id = null, $cache_life = null)
    {
     $self = & self::getInstance();
        if (!$id) {
            if ($self->_id) {
                $id = $self->_id;
            } else {
                exit('file_cache:save() id 不能为空!');
            }
        }
        $time = time();
       
        if($cache_life) {
         $data[self::FILE_LIFE_KEY] = $time + $cache_life;
        }
  elseif
  ($cache_life != 0){
         $data[self::FILE_LIFE_KEY] = $time + $self->_options['file_life'];
        }
       
        $file = $self->_file($id);
       
        $data = "                 " // mktime: ". $time. "n".
                " return ".
                var_export($data, true).
                "n?>"
                ;
       
        $res = $self->_filePutContents($file, $data);
        return $res;
    }
   
   
    /**
* Get cache information
*
* @param string $id cache id
* @return string|array cache data
​​*/
    static function load($id)
    {
        $self = & self::getInstance();
     $time = time();
     //检测缓存是否存在
     if (!$self->test($id)) {
            // The cache is not hit !
            return false;
        }
       
  //全部清空识别文件
        $clearFile = $self->_file(self::CLEAR_ALL_KEY);
 
  $file = $self->_file($id);
 
        //判断缓存是否已被全部清除
     if(is_file($clearFile) && filemtime($clearFile) > filemtime($file))
     {
      return false;
     }
      
        $data = $self->_fileGetContents($file);
      if(empty($data[self::FILE_LIFE_KEY]) || $time < $data[self::FILE_LIFE_KEY]) {
            unset($data[self::FILE_LIFE_KEY]);
       return $data;  
      }
      return false;
    }   
   
    /**
     * 写入缓存文件
     *
     * @param  string $file   缓存路径
     * @param  string $string 缓存信息
     * @return boolean true 成功
     */
    protected function _filePutContents($file, $string)
    {
     $self = & self::getInstance();
        $result = false;
        $f = @fopen($file, 'ab+');
        if ($f) {
            if ($self->_options['file_locking']) @flock($f, LOCK_EX);
            fseek($f, 0);
            ftruncate($f, 0);
            $tmp = @fwrite($f, $string);
            if (!($tmp === false)) {
                $result = true;
            }
            @fclose($f);
        }
        @chmod($file, $self->_options['cache_file_umask']);
        return $result;
    }
   
    /**
* * Formatted cache file path
*
* @param string $id cache id
* @return string cache file name (including path)
​​*/
    protected function _file($id)
    {
     $self = & self::getInstance();
        $fileName = $self->_idToFileName($id);
        return $self->_options['cache_dir'] . $fileName;
    }   
   
    /**
* * Formatted cache file name
*
* @param string $id cache id
* @return string cache file name
​​*/
    protected function _idToFileName($id)
    {
     $self = & self::getInstance();
        $self->_id = $id;
        $prefix = $self->_options['file_name_prefix'];
        $result = $prefix . '---' . $id;
        return $result;
    }  
   
    /**
* Determine whether the cache exists
*
* @param string $id Cache id
* @return boolean True The cache exists False The cache does not exist
​​*/
    static function test($id)
    {
     $self = & self::getInstance();
        $file = $self->_file($id);
       
        if (!is_file($file)) {
            return false;
        }
       
        return true;
    }
   
    /**
* Get cache information
*
* @param string $file cache path
* @return string cache content
​​*/
    protected function _fileGetContents($file)
    {
        if (!is_file($file)) {
            return false;
        }
        return include $file;
    }    
   
    /**
     * 清除所有缓存
     *
* @return void
*/ 
​ static function clear()
{
$self = & self::getInstance();
$self->save('CLEAR_ALL',self::CLEAR_ALL_KEY);
}  

/**
* Clear a cache
* *
* @param string cache id
* @return void
​​*/
​ static function del($id)
{
$self = & self::getInstance();
If(!$self->test($id)){
//The cache does not exist
Return false;
}
$file = $self->_file($id);
Return unlink($file);
}
}

Save data

Copy code The code is as follows:

$config = array(
'name' => 'xiaojiong',
'qq' => '290747680',
'age' => '20',
);
//The first parameter cache data
//Second parameter cache id
//The third parameter cache_life 0 will never expire (except cache::clear() to clear everything). The default cache_life is option_cache_life
cache::save($config,'config',0);

Load data

Copy code The code is as follows:

//Only one parameter cache_id
$config = cache::load('config');
Clear cache
//Clear the specified cache
cache::del('config');
//Clear all caches
cache::clear();
Cache information configuration
//Call
before executing all cache_func $_options = array(
'cache_dir' => './cache', //Cache file directory
'file_name_prefix' => 'cache',//Cache file prefix
'file_life' => 100000, //Cache file life
);
cache::setOptions($options);
//If executed again, it will be executed according to the new configuration information, otherwise it will be the default information
cache::save($arr,'arr');

This method seems unreasonable, and interested friends can improve it. I hope this article will be helpful to everyone’s PHP programming.

http://www.bkjia.com/PHPjc/915434.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/915434.htmlTechArticleA summary of PHP file cache classes. This article describes the PHP file cache class with examples. Share it with everyone for your reference. The specific analysis is as follows: The cache class is commonly used in our development applications...