php文件缓存类汇总

本文实例讲述了php的文件缓存类。分享给大家供大家参考。具体分析如下：

缓存类是我们开发应用中会常用使用到的功能，下面就来给大家整理几个php文件缓存类了，各个文件缓存类写法不同，但在性能上会有区别，有兴趣测试的朋友可测试一下这些缓存类。

例1

<?php

$fzz = new fzz_cache;

$fzz->kk = $_SERVER; //写入缓存

//$fzz->set("kk",$_SERVER,10000); //此方法不与类属性想冲突，可以用任意缓存名；

print_r($fzz->kk);  //读取缓存

//print_r($fzz->get("kk"));

//unset($fzz->kk); //删除缓存

//$fzz->_unset("kk");

var_dump(isset($fzz->kk)); //判断缓存是否存在

//$fzz->_isset("kk");

//$fzz->clear(); //清理过期缓存

//$fzz->clear_all(); //清理所有缓存文件

class fzz_cache{

 public $limit_time = 20000; //缓存过期时间

 public $cache_dir = "data"; //缓存文件保存目录

 //写入缓存

 function __set($key , $val){

  $this->_set($key ,$val);

 }

 //第三个参数为过期时间

 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");

 }
 //读取缓存

 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;

  }

 }
 //删除缓存文件

 function __unset($key){

  return $this->_unset($key);

 }

 function _unset($key){

  if (@unlink($this->cache_dir."/".$key.".cache")){

   return true;

  }else{

   return false;

  }

 }
 //检查缓存是否存在，过期则认为不存在

 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;

  }

 }
 //清除过期缓存文件

 function clear(){

  $files = scandir($this->cache_dir);

  foreach ($files as $val){

   if (filemtime($this->cache_dir."/".$val)<time()){

    @unlink($this->cache_dir."/".$val);

   }

  }

 }
 //清除所有缓存文件

 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 = "<pre>

<span style='color:red'>error:</span>

".print_r($err->getTrace(),1)."

</pre>";

  if($debug == true) {

   file_put_contents(date('Y-m-d H_i_s').".log",$str);

   return $str;

  }else{

   die($str);

  }

 }

}

?>

例2.从CI社区的stblog和CI的file_helper类中提取出来的php文件缓存类,一个简单的基于文件的key->value缓存类。

这个类可以用来缓存一些基本信息,比如博客的header,footer,sidebar中的一些不经常变化，从数据库中取出的内容,取数据前先判断文件缓存中的内容是否过期,如果没过期取出来,过期了则连接数据库查询,并将结果重新写入文件缓存,更新过期时间。跟memcache使用类似,不过更方便。用在一些小的应用上足够了.

具体代码如下

<?php

define('DIRECTORY_SEPARATOR','/');

define('FOPEN_WRITE_CREATE_DESTRUCTIVE','wb');

define('FOPEN_WRITE_CREATE','ab');

define('DIR_WRITE_MODE', 0777);

class FileCache {

 /**

     * 缓存路径

     *

     * @access private

     * @var string

     */

 private $_cache_path;

 /**

     * 缓存过期时间，单位是秒second

     *

     * @access private

     * @var int

     */

 private $_cache_expire;

 

 /**

     * 解析函数，设置缓存过期实践和存储路径

     * 

     * @access public

     * @return void

     */

 public function __construct($expire, $cache_path)

 {

  $this->_cache_expire = $expire;

  $this->_cache_path = $cache_path;

 }

 

 /**

     * 缓存文件名

     * 

     * @access public

     * @param  string $key

     * @return void

     */

 private function _file($key)

 {

  return $this->_cache_path . md5($key);

 }

 

 /**

     * 设置缓存

     * 

     * @access public

     * @param  string $key 缓存的唯一键

     * @param  string $data 缓存的内容

     * @return bool

     */

 public function set($key, $data)

 {

  $value = serialize($data);

  

  $file = $this->_file($key);

  

     return $this->write_file($file, $value);

 }

 

 /**

     * 获取缓存

     * 

     * @access public

     * @param  string $key 缓存的唯一键

     * @return mixed

     */

 public function get($key)

 {

  $file = $this->_file($key);

  

  /** 文件不存在或目录不可写 */

  if (!file_exists($file) || !$this->is_really_writable($file))

  {

   return false;

  }

  

  /** 缓存没有过期，仍然可用 */

  if ( time() < (filemtime($file) + $this->_cache_expire) ) 

  {

   

   $data = $this->read_file($file);

   

   if(FALSE !== $data)

   {

    return unserialize($data);

   }

   

   return FALSE;

  }

  

  /** 缓存过期，删除之 */

  @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文件缓存

<?php 

class cache

{ 

 private static $_instance = null;

    protected $_options = array(

        'cache_dir'        => "./",

        'file_name_prefix' => 'cache',

     'mode'            => '1', //mode 1 为serialize model 2为保存为可执行文件

    ); 

 

 /**

  * 得到本类实例

  * 

  * @return Ambiguous

  */

 public static function getInstance()

 {

  if(self::$_instance === null)

  {

   self::$_instance = new self();

  }

  return self::$_instance;

 } 

 

 /**

  * 得到缓存信息

  * 

  * @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;

 }

 

 /**

  * 设置一个缓存

  * 

  * @param string $id   缓存id

  * @param array  $data 缓存内容

  * @param int    $cacheLife 缓存生命 默认为0无限生命

  */

 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);

 }

 

    /**

     * 清除一条缓存

     * 

     * @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);

 }

 

 /**

  * 判断缓存是否存在

  * 

  * @param string $id cache_id

  * @return boolean true 缓存存在 false 缓存不存在

  */

 public static function has($id)

 {

  $instance = self::getInstance();

  $file     = $instance->_file($id);

  

  if(!is_file($file))

  {

   return false;

  }

  return true;

 }

 

 /**

  * 通过缓存id得到缓存信息路径

  * @param string $id

  * @return string 缓存文件路径

  */

 protected function _file($id)

 {

  $instance  = self::getInstance();

  $fileNmae  = $instance->_idToFileName($id);

  return $instance->_options['cache_dir'] . $fileNmae;

 } 

 

 /**

  * 通过id得到缓存信息存储文件名

  * 

  * @param  $id

  * @return string 缓存文件名

  */

 protected function _idToFileName($id)

 {

  $instance  = self::getInstance();

  $prefix    = $instance->_options['file_name_prefix'];

  return $prefix . '---' . $id;

 }

 

 /**

  * 通过filename得到缓存id

  * 

  * @param  $id

  * @return string 缓存id

  */

 protected function _fileNameToId($fileName)

 {

  $instance  = self::getInstance();

  $prefix    = $instance->_options['file_name_prefix'];

  return preg_replace('/^' . $prefix . '---(.*)$/', '$1', $fileName);

 }

 

 /**

  * 把数据写入文件

  * 

  * @param string $file 文件名称

  * @param array  $contents 数据内容

  * @return bool 

  */

 protected function _filePutContents($file, $contents)

 {

  if($this->_options['mode'] == 1)

  {

   $contents = serialize($contents);

  }

  else 

  {

   $time = time(); 

         $contents = "<?phpn".

                 " // 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;    

 }

 

 /**

  * 从文件得到数据

  * 

  * @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;

  }

 }

 

 /**

  * 构造函数

  */

 protected function __construct()

 {

 

 }

 

 /**

  * 设置缓存路径

  * 

  * @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;

 }

 

 /**

  * 设置缓存文件前缀

  * 

  * @param srting $prefix

  * @return self

  */

 public static function setCachePrefix($prefix)

 {

  $instance  = self::getInstance();

  $instance->_options['file_name_prefix'] = $prefix;

  return $instance;

 }

 

 /**

  * 设置缓存存储类型

  * 

  * @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;

 }

 

 /**

  * 删除所有缓存

  * @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;

 }

}

/* 初始化设置cache的配置信息什么的 */

cache::setCachePrefix('core'); //设置缓存文件前缀

cache::setCacheDir('./cache'); //设置存放缓存文件夹路径

//模式1 缓存存储方式

//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;}

//模式2 缓存存储方式

/*

 <?php

 // 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(); 清空所有缓存

print_r($row);

 
文件缓存 class   

<?php

/**

 * 文件缓存类

 * @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;

    }

    

    /**

     * 设置参数

     * @param  array $options 缓存参数

     * @return void

     */

 static function &setOptions($options = array())

 {

         return self::getInstance($options);

 }

 

    /**

     * 构造函数

     * @param  array $options 缓存参数

     * @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 不能为空 ');

        }

    }

    /**

     * 设置缓存路径

     * @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 = "<?phpn".

                " // mktime: ". $time. "n".

                " return ".

                var_export($data, true).

                "n?>"

                ;

        

        $res = $self->_filePutContents($file, $data);

        return $res;

    }

    

    

    /**

     * 得到缓存信息

     *

     * @param  string  $id  缓存id

     * @return string|array 缓存数据

     */

    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;

    }

    

    /**

     * 格式化后的缓存文件路径

     *

     * @param  string $id 缓存id

     * @return string 缓存文件名(包括路径)

     */

    protected function _file($id)

    {

     $self = & self::getInstance();

        $fileName = $self->_idToFileName($id);

        return $self->_options['cache_dir'] . $fileName;

    }    

    

    /**

     * 格式化后的缓存文件名字

     *

     * @param  string $id 缓存id

     * @return string 缓存文件名

     */

    protected function _idToFileName($id)

    {

     $self = & self::getInstance();

        $self->_id = $id;

        $prefix = $self->_options['file_name_prefix'];

        $result = $prefix . '---' . $id;

        return $result;

    }   

    

    /**

     * 判断缓存是否存在

     *

     * @param  string $id Cache id

     * @return boolean True 缓存存在 False 缓存不存在

     */

    static function test($id)

    {

     $self = & self::getInstance();

        $file = $self->_file($id);

        

        if (!is_file($file)) {

            return false;

        }

        

        return true;

    }

    

    /**

     * 得到缓存信息

     *

     * @param  string $file 缓存路径

     * @return string 缓存内容

     */

    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); 

    }   

 

    /**

     * 清除一条缓存

     * 

     * @param string cache id  

     * @return void

     */   

    static function del($id)

    {

  $self = & self::getInstance();

     if(!$self->test($id)){

      // 该缓存不存在

      return false;

     }

     $file = $self->_file($id);

     return unlink($file);

    } 

}

存入数据

<?php

$config = array(

 'name' => 'xiaojiong',

 'qq'   => '290747680',

 'age'  => '20',

);

//第一个参数 缓存data

//第二个参数 缓存id

//第三个参数 cache_life 0 永不过期(cache::clear()清空所有除外) 默认cache_life 为option_cache_life

cache::save($config,'config',0);

载入数据

<?php

//只有一个参数 cache_id

$config = cache::load('config');

清空缓存

<?php

//清空指定缓存

cache::del('config');

//清空所有缓存

cache::clear();

cache信息配置

//在执行所有cache_func前调用

$_options = array(

    'cache_dir' => './cache', //缓存文件目录

    'file_name_prefix' => 'cache',//缓存文件前缀

    'file_life'  => 100000, //缓存文件生命

);

cache::setOptions($options);

//再执行 就会按着新配置信息执行，否则是默认信息

cache::save($arr,'arr');

这个方法貌似不合理，感兴趣的朋友可以加以改进。希望本文所述对大家的PHP程序设计有所帮助。