当前位置:首页 > PHP教程 > php类库 > 列表

php文件缓存类汇总

发布:smiling 来源: PHP粉丝网  添加日期:2021-04-27 19:49:02 浏览: 评论:0 

这篇文章主要介绍了php文件缓存类,实例汇总了常见的文件缓存类及其用法,非常具有实用价值,需要的朋友可以参考下

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

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

例1代码如下:

  1. <?php 
  2. $fzz = new fzz_cache; 
  3. $fzz->kk = $_SERVER//写入缓存 
  4. //$fzz->set("kk",$_SERVER,10000); //此方法不与类属性想冲突,可以用任意缓存名; 
  5. print_r($fzz->kk);  //读取缓存 
  6. //print_r($fzz->get("kk")); 
  7. //unset($fzz->kk); //删除缓存 
  8. //$fzz->_unset("kk"); 
  9. var_dump(isset($fzz->kk)); //判断缓存是否存在 
  10. //$fzz->_isset("kk"); 
  11. //$fzz->clear(); //清理过期缓存 
  12. //$fzz->clear_all(); //清理所有缓存文件 
  13. class fzz_cache{ 
  14.  public $limit_time = 20000; //缓存过期时间 
  15.  public $cache_dir = "data"//缓存文件保存目录 
  16.  //写入缓存 
  17.  function __set($key , $val){ 
  18.   $this->_set($key ,$val); 
  19.  } 
  20.  //第三个参数为过期时间 
  21.  function _set($key ,$val,$limit_time=null){  
  22.   $limit_time = $limit_time ? $limit_time : $this->limit_time; 
  23.   $file = $this->cache_dir."/".$key.".cache"
  24.   $val = serialize($val); 
  25.   @file_put_contents($file,$valor $this->error(__line__,"fail to write in file"); 
  26.   @chmod($file,0777); 
  27.   @touch($file,time()+$limit_timeor $this->error(__line__,"fail to change time"); 
  28.  } 
  29.  //读取缓存 
  30.  function __get($key){ 
  31.   return $this->_get($key); 
  32.  } 
  33.  function _get($key){ 
  34.   $file = $this->cache_dir."/".$key.".cache"
  35.   if (@filemtime($file)>=time()){ 
  36.    return unserialize(file_get_contents($file)); 
  37.   }else
  38.    @unlink($fileor $this->error(__line__,"fail to unlink"); 
  39.    return false; 
  40.   } 
  41.  } 
  42.  
  43.  //删除缓存文件 
  44.  function __unset($key){ 
  45.   return $this->_unset($key); 
  46.  } 
  47.  function _unset($key){ 
  48.   if (@unlink($this->cache_dir."/".$key.".cache")){ 
  49.    return true; 
  50.   }else
  51.    return false; 
  52.   } 
  53.  } 
  54.  
  55.  //检查缓存是否存在,过期则认为不存在 
  56.  function __isset($key){ 
  57.   return $this->_isset($key); 
  58.  } 
  59.  function _isset($key){ 
  60.   $file = $this->cache_dir."/".$key.".cache"
  61.   if (@filemtime($file)>=time()){ 
  62.    return true; 
  63.   }else
  64.    @unlink($file) ; 
  65.    return false; 
  66.   } 
  67.  } 
  68.  
  69.  //清除过期缓存文件 
  70.  function clear(){ 
  71.   $files = scandir($this->cache_dir); 
  72.   foreach ($files as $val){ 
  73.    if (filemtime($this->cache_dir."/".$val)<time()){ 
  74.     @unlink($this->cache_dir."/".$val); 
  75.    } 
  76.   } 
  77.  } 
  78.  
  79.  //清除所有缓存文件 
  80.  function clear_all(){ 
  81.   $files = scandir($this->cache_dir); 
  82.   foreach ($files as $val){ 
  83.    @unlink($this->cache_dir."/".$val); 
  84.   } 
  85.  } 
  86.  
  87.  function error($msg,$debug = false) { 
  88.   $err = new Exception($msg); 
  89.   $str = "<pre> 
  90. <span style='color:red'>error:</span> 
  91. ".print_r($err->getTrace(),1)." 
  92. </pre>"; 
  93.   if($debug == true) { 
  94.    file_put_contents(date('Y-m-d H_i_s').".log",$str); 
  95.    return $str
  96.   }else
  97.    die($str); 
  98.   } 
  99.  } 
  100. ?> 

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

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

具体代码如下:

  1. <?php 
  2. define('DIRECTORY_SEPARATOR','/'); 
  3. define('FOPEN_WRITE_CREATE_DESTRUCTIVE','wb'); 
  4. define('FOPEN_WRITE_CREATE','ab'); 
  5. define('DIR_WRITE_MODE', 0777); 
  6. class FileCache { 
  7.  /** 
  8.      * 缓存路径 
  9.      * 
  10.      * @access private 
  11.      * @var string 
  12.      */ 
  13.  private $_cache_path
  14.  /** 
  15.      * 缓存过期时间,单位是秒second 
  16.      * 
  17.      * @access private 
  18.      * @var int 
  19.      */ 
  20.  private $_cache_expire
  21.  
  22.  /** 
  23.      * 解析函数,设置缓存过期实践和存储路径 
  24.      * 
  25.      * @access public 
  26.      * @return void 
  27.      */ 
  28.  public function __construct($expire$cache_path
  29.  { 
  30.   $this->_cache_expire = $expire
  31.   $this->_cache_path = $cache_path
  32.  } 
  33.  
  34.  /** 
  35.      * 缓存文件名 
  36.      * 
  37.      * @access public 
  38.      * @param  string $key 
  39.      * @return void 
  40.      */ 
  41.  private function _file($key
  42.  { 
  43.   return $this->_cache_path . md5($key); 
  44.  } 
  45.  
  46.  /** 
  47.      * 设置缓存 
  48.      * 
  49.      * @access public 
  50.      * @param  string $key 缓存的唯一键 
  51.      * @param  string $data 缓存的内容 
  52.      * @return bool 
  53.      */ 
  54.  public function set($key$data
  55.  { 
  56.   $value = serialize($data); 
  57.  
  58.   $file = $this->_file($key); 
  59.  
  60.      return $this->write_file($file$value); 
  61.  } 
  62.  
  63.  /** 
  64.      * 获取缓存 
  65.      * 
  66.      * @access public 
  67.      * @param  string $key 缓存的唯一键 
  68.      * @return mixed 
  69.      */ 
  70.  public function get($key
  71.  { 
  72.   $file = $this->_file($key); 
  73.  
  74.   /** 文件不存在或目录不可写 */ 
  75.   if (!file_exists($file) || !$this->is_really_writable($file)) 
  76.   { 
  77.    return false; 
  78.   } 
  79.  
  80.   /** 缓存没有过期,仍然可用 */ 
  81.   if ( time() < (filemtime($file) + $this->_cache_expire) ) 
  82.   { 
  83.    
  84.    $data = $this->read_file($file); 
  85.    
  86.    if(FALSE !== $data
  87.    { 
  88.     return unserialize($data); 
  89.    } 
  90.    
  91.    return FALSE; 
  92.   } 
  93.  
  94.   /** 缓存过期,删除之 */ 
  95.   @unlink($file); 
  96.   return FALSE; 
  97.   } 
  98.  
  99.   function read_file($file
  100.  { 
  101.   if ( ! file_exists($file)) 
  102.   { 
  103.    return FALSE; 
  104.   } 
  105.  
  106.   if (function_exists('file_get_contents')) 
  107.   { 
  108.    return file_get_contents($file);  
  109.   } 
  110.   if ( ! $fp = @fopen($file, FOPEN_READ)) 
  111.   { 
  112.    return FALSE; 
  113.   } 
  114.  
  115.   flock($fp, LOCK_SH);//读取之前加上共享锁 
  116.  
  117.   $data = ''
  118.   if (filesize($file) > 0) 
  119.   { 
  120.    $data =& fread($fpfilesize($file)); 
  121.   } 
  122.   flock($fp, LOCK_UN);//释放锁 
  123.   fclose($fp); 
  124.   return $data
  125.  } 
  126.  
  127.   function write_file($path$data$mode = FOPEN_WRITE_CREATE_DESTRUCTIVE) 
  128.  { 
  129.   if ( ! $fp = @fopen($path$mode)) 
  130.   { 
  131.    return FALSE; 
  132.   } 
  133.  
  134.   flock($fp, LOCK_EX); 
  135.   fwrite($fp$data); 
  136.   flock($fp, LOCK_UN); 
  137.   fclose($fp); 
  138.  
  139.   return TRUE; 
  140.  } 
  141.  function is_really_writable($file)//兼容各平台判断文件是否有写入权限 
  142.  { 
  143.   // If we're on a Unix server with safe_mode off we call is_writable 
  144.   if (DIRECTORY_SEPARATOR == '/' AND @ini_get("safe_mode") == FALSE) 
  145.   { 
  146.    return is_writable($file); 
  147.   } 
  148.  
  149.   // For windows servers and safe_mode "on" installations we'll actually 
  150.   // write a file then read it.  Bah... 
  151.   if (is_dir($file)) 
  152.   { 
  153.    $file = rtrim($file'/').'/'.md5(rand(1,100)); 
  154.  
  155.    if (($fp = @fopen($file, FOPEN_WRITE_CREATE)) === FALSE) 
  156.    { 
  157.     return FALSE; 
  158.    } 
  159.  
  160.    fclose($fp); 
  161.    @chmod($file, DIR_WRITE_MODE); 
  162.    @unlink($file); 
  163.    return TRUE; 
  164.   } 
  165.   elseif (($fp = @fopen($file, FOPEN_WRITE_CREATE)) === FALSE) 
  166.   { 
  167.    return FALSE; 
  168.   } 
  169.  
  170.   fclose($fp); 
  171.   return TRUE; 
  172.  } 
  173. $cache = new FileCache(30,'cache/'); 
  174. $cache->set('test','this is a test.'); 
  175. print $cache->get('test'); 
  176. /* End of file FlieCache.php */ 

例3.自己觉得很好用的php文件缓存,代码如下:

  1. <?php 
  2. class cache 
  3.  private static $_instance = null; 
  4.     protected $_options = array
  5.         'cache_dir'        => "./"
  6.         'file_name_prefix' => 'cache'
  7.      'mode'            => '1'//mode 1 为serialize model 2为保存为可执行文件 
  8.     ); 
  9.  
  10.  /** 
  11.   * 得到本类实例 
  12.   * 
  13.   * @return Ambiguous 
  14.   */ 
  15.  public static function getInstance() 
  16.  { 
  17.   if(self::$_instance === null) 
  18.   { 
  19.    self::$_instance = new self(); 
  20.   } 
  21.   return self::$_instance
  22.  } 
  23.  
  24.  /** 
  25.   * 得到缓存信息 
  26.   * 
  27.   * @param string $id 
  28.   * @return boolean|array 
  29.   */ 
  30.  public static function get($id
  31.  { 
  32.   $instance = self::getInstance(); 
  33.  
  34.   //缓存文件不存在 
  35.   if(!$instance->has($id)) 
  36.   { 
  37.    return false; 
  38.   } 
  39.  
  40.   $file = $instance->_file($id); 
  41.  
  42.   $data = $instance->_fileGetContents($file); 
  43.  
  44.   if($data['expire'] == 0 || time() < $data['expire']) 
  45.   { 
  46.    return $data['contents']; 
  47.   } 
  48.   return false; 
  49.  } 
  50.  
  51.  /** 
  52.   * 设置一个缓存 
  53.   * 
  54.   * @param string $id   缓存id 
  55.   * @param array  $data 缓存内容 
  56.   * @param int    $cacheLife 缓存生命 默认为0无限生命 
  57.   */ 
  58.  public static function set($id$data$cacheLife = 0) 
  59.  { 
  60.   $instance = self::getInstance(); 
  61.  
  62.   $time = time(); 
  63.   $cache      = array(); 
  64.   $cache['contents'] = $data
  65.   $cache['expire']   = $cacheLife === 0 ? 0 : $time + $cacheLife
  66.   $cache['mtime']    = $time
  67.  
  68.   $file = $instance->_file($id); 
  69.  
  70.   return $instance->_filePutContents($file$cache); 
  71.  } 
  72.  
  73.     /** 
  74.      * 清除一条缓存 
  75.      * 
  76.      * @param string cache id  
  77.      * @return void 
  78.      */   
  79.  public static function delete($id
  80.  { 
  81.   $instance = self::getInstance(); 
  82.  
  83.   if(!$instance->has($id)) 
  84.   { 
  85.    return false; 
  86.   } 
  87.      $file = $instance->_file($id); 
  88.      //删除该缓存 
  89.      return unlink($file); 
  90.  } 
  91.  
  92.  /** 
  93.   * 判断缓存是否存在 
  94.   * 
  95.   * @param string $id cache_id 
  96.   * @return boolean true 缓存存在 false 缓存不存在 
  97.   */ 
  98.  public static function has($id
  99.  { 
  100.   $instance = self::getInstance(); 
  101.   $file     = $instance->_file($id); 
  102.  
  103.   if(!is_file($file)) 
  104.   { 
  105.    return false; 
  106.   } 
  107.   return true; 
  108.  } 
  109.  
  110.  /** 
  111.   * 通过缓存id得到缓存信息路径 
  112.   * @param string $id 
  113.   * @return string 缓存文件路径 
  114.   */ 
  115.  protected function _file($id
  116.  { 
  117.   $instance  = self::getInstance(); 
  118.   $fileNmae  = $instance->_idToFileName($id); 
  119.   return $instance->_options['cache_dir'] . $fileNmae
  120.  } 
  121.  
  122.  /** 
  123.   * 通过id得到缓存信息存储文件名 
  124.   * 
  125.   * @param  $id 
  126.   * @return string 缓存文件名 
  127.   */ 
  128.  protected function _idToFileName($id
  129.  { 
  130.   $instance  = self::getInstance(); 
  131.   $prefix    = $instance->_options['file_name_prefix']; 
  132.   return $prefix . '---' . $id
  133.  } 
  134.  
  135.  /** 
  136.   * 通过filename得到缓存id 
  137.   * 
  138.   * @param  $id 
  139.   * @return string 缓存id 
  140.   */ 
  141.  protected function _fileNameToId($fileName
  142.  { 
  143.   $instance  = self::getInstance(); 
  144.   $prefix    = $instance->_options['file_name_prefix']; 
  145.   return preg_replace('/^' . $prefix . '---(.*)$/''$1'$fileName); 
  146.  } 
  147.  
  148.  /** 
  149.   * 把数据写入文件 
  150.   * 
  151.   * @param string $file 文件名称 
  152.   * @param array  $contents 数据内容 
  153.   * @return bool 
  154.   */ 
  155.  protected function _filePutContents($file$contents
  156.  { 
  157.   if($this->_options['mode'] == 1) 
  158.   { 
  159.    $contents = serialize($contents); 
  160.   } 
  161.   else 
  162.   { 
  163.    $time = time(); 
  164.          $contents = "<?phpn"
  165.                  " // mktime: "$time"n"
  166.                  " return "
  167.                  var_export($contents, true). 
  168.                  "n?>"
  169.   } 
  170.  
  171.   $result = false; 
  172.      $f = @fopen($file'w'); 
  173.         if ($f) { 
  174.             @flock($f, LOCK_EX); 
  175.             fseek($f, 0); 
  176.             ftruncate($f, 0); 
  177.             $tmp = @fwrite($f$contents); 
  178.             if (!($tmp === false)) { 
  179.                 $result = true; 
  180.             } 
  181.             @fclose($f); 
  182.         } 
  183.   @chmod($file,0777); 
  184.   return $result;    
  185.  } 
  186.  
  187.  /** 
  188.   * 从文件得到数据 
  189.   * 
  190.   * @param  sring $file 
  191.   * @return boolean|array 
  192.   */ 
  193.  protected function _fileGetContents($file
  194.  { 
  195.   if(!is_file($file)) 
  196.   { 
  197.    return false; 
  198.   } 
  199.  
  200.   if($this->_options['mode'] == 1) 
  201.   { 
  202.    $f = @fopen($file'r'); 
  203.    @$data = fread($f,filesize($file)); 
  204.    @fclose($f); 
  205.    return unserialize($data); 
  206.   } 
  207.   else 
  208.   { 
  209.    return include $file
  210.   } 
  211.  } 
  212.  
  213.  /** 
  214.   * 构造函数 
  215.   */ 
  216.  protected function __construct() 
  217.  { 
  218.  
  219.  } 
  220.  
  221.  /** 
  222.   * 设置缓存路径 
  223.   * 
  224.   * @param string $path 
  225.   * @return self 
  226.   */ 
  227.  public static function setCacheDir($path
  228.  { 
  229.   $instance  = self::getInstance(); 
  230.         if (!is_dir($path)) { 
  231.             exit('file_cache: ' . $path.' 不是一个有效路径 '); 
  232.         } 
  233.         if (!is_writable($path)) { 
  234.             exit('file_cache: 路径 "'.$path.'" 不可写'); 
  235.         } 
  236.     
  237.         $path = rtrim($path,'/') . '/'
  238.         $instance->_options['cache_dir'] = $path
  239.         
  240.         return $instance
  241.  } 
  242.  
  243.  /** 
  244.   * 设置缓存文件前缀 
  245.   * 
  246.   * @param srting $prefix 
  247.   * @return self 
  248.   */ 
  249.  public static function setCachePrefix($prefix
  250.  { 
  251.   $instance  = self::getInstance(); 
  252.   $instance->_options['file_name_prefix'] = $prefix
  253.   return $instance
  254.  } 
  255.  
  256.  /** 
  257.   * 设置缓存存储类型 
  258.   * 
  259.   * @param int $mode 
  260.   * @return self 
  261.   */ 
  262.  public static function setCacheMode($mode = 1) 
  263.  { 
  264.   $instance  = self::getInstance(); 
  265.   if($mode == 1) 
  266.   { 
  267.    $instance->_options['mode'] = 1; 
  268.   } 
  269.   else 
  270.   { 
  271.    $instance->_options['mode'] = 2; 
  272.   } 
  273.  
  274.   return $instance
  275.  } 
  276.  
  277.  /** 
  278.   * 删除所有缓存 
  279.   * @return boolean 
  280.   */ 
  281.  public static function flush() 
  282.  { 
  283.   $instance  = self::getInstance(); 
  284.   $glob = @glob($instance->_options['cache_dir'] . $instance->_options['file_name_prefix'] . '--*'); 
  285.  
  286.   if(emptyempty($glob)) 
  287.   { 
  288.    return false; 
  289.   } 
  290.  
  291.   foreach ($glob as $v
  292.   { 
  293.    $fileName = basename($v); 
  294.    $id =  $instance->_fileNameToId($fileName); 
  295.    $instance->delete($id); 
  296.   } 
  297.   return true; 
  298.  } 
  299. /* 初始化设置cache的配置信息什么的 */ 
  300. cache::setCachePrefix('core'); //设置缓存文件前缀 
  301. cache::setCacheDir('./cache'); //设置存放缓存文件夹路径 
  302. //模式1 缓存存储方式 
  303. //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;} 
  304. //模式2 缓存存储方式 
  305. /* 
  306.  <?php 
  307.  // mktime: 1318224645 
  308.  return array ( 
  309.   'contents' => 
  310.   array ( 
  311.     0 => 1, 
  312.     1 => 2, 
  313.     2 => 3, 
  314.     3 => 34, 
  315.     4 => 5, 
  316.     5 => 6, 
  317.     6 => 6, 
  318.   ), 
  319.   'expire' => 0, 
  320.   'mtime' => 1318224645, 
  321. ) 
  322. ?> 
  323.  * 
  324.  * 
  325.  */ 
  326. cache::setCacheMode('2'); 
  327. if(!$row = cache::get('zj2')) 
  328.  
  329.  $array = array(1,2,3,34,5,6,6); 
  330.  $row = cache::set('zj2',$array); 
  331. // cache::flush(); 清空所有缓存 
  332. print_r($row); 

文件缓存 class,代码如下:

  1. <?php 
  2. /** 
  3.  * 文件缓存类 
  4.  * @date 2011-08-17 
  5.  */ 
  6. class cache 
  7.  const FILE_LIFE_KEY = 'FILE_LIFE_KEY'
  8.  
  9.  const CLEAR_ALL_KEY = 'CLEAR_ALL'
  10.  
  11.     static $_instance = null; 
  12.  
  13.     protected $_options = array
  14.         'cache_dir' => './cache'
  15.         'file_locking' => true, 
  16.         'file_name_prefix' => 'cache'
  17.         'cache_file_umask' => 0777, 
  18.      'file_life'  => 100000 
  19.     ); 
  20.     
  21.     static function &getInstance($options = array()) 
  22.     { 
  23.      if(self::$_instance === null) 
  24.      { 
  25.       self::$_instance = new self($options); 
  26.      } 
  27.      return self::$_instance
  28.     } 
  29.     
  30.     /** 
  31.      * 设置参数 
  32.      * @param  array $options 缓存参数 
  33.      * @return void 
  34.      */ 
  35.  static function &setOptions($options = array()) 
  36.  { 
  37.          return self::getInstance($options); 
  38.  } 
  39.  
  40.     /** 
  41.      * 构造函数 
  42.      * @param  array $options 缓存参数 
  43.      * @return void 
  44.      */ 
  45.     private function __construct($options = array()) 
  46.     {  
  47.         if ($this->_options['cache_dir'] !== null) { 
  48.    
  49.    $dir = rtrim($this->_options['cache_dir'],'/') . '/'
  50.          $this->_options['cache_dir'] = $dir
  51.          
  52.    if (!is_dir($this->_options['cache_dir'])) { 
  53.              mkdir($this->_options['cache_dir'],0777,TRUE); 
  54.          } 
  55.          if (!is_writable($this->_options['cache_dir'])) { 
  56.              exit('file_cache: 路径 "'$this->_options['cache_dir'] .'" 不可写'); 
  57.          } 
  58.       
  59.         } else { 
  60.            exit('file_cache: "options" cache_dir 不能为空 '); 
  61.         } 
  62.     } 
  63.     /** 
  64.      * 设置缓存路径 
  65.      * @param  string  $value 
  66.      * @return void 
  67.      */ 
  68.     static function setCacheDir($value
  69.     { 
  70.      $self = & self::getInstance(); 
  71.      
  72.         if (!is_dir($value)) { 
  73.             exit('file_cache: ' . $value.' 不是一个有效路径 '); 
  74.         } 
  75.         if (!is_writable($value)) { 
  76.             exit('file_cache: 路径 "'.$value.'" 不可写'); 
  77.         } 
  78.     
  79.         $value = rtrim($this->_options['cache_dir'],'/') . '/'
  80.         
  81.         $self->_options['cache_dir'] = $value
  82.     } 
  83.     
  84.     /** 
  85.      * 存入缓存数据 
  86.      * @param  array  $data          放入缓存的数据 
  87.      * @param  string $id            缓存id(又名缓存识别码) 
  88.      * @param  cache_life            缓存时间 
  89.      * @return boolean True if no problem 
  90.      */ 
  91.     static function save($data$id = null, $cache_life = null) 
  92.     { 
  93.      $self = & self::getInstance(); 
  94.         if (!$id) { 
  95.             if ($self->_id) { 
  96.                 $id = $self->_id; 
  97.             } else { 
  98.                 exit('file_cache:save() id 不能为空!'); 
  99.             } 
  100.         } 
  101.         $time = time(); 
  102.         
  103.         if($cache_life) { 
  104.          $data[self::FILE_LIFE_KEY] = $time + $cache_life
  105.         } 
  106.   elseif 
  107.   ($cache_life != 0){ 
  108.          $data[self::FILE_LIFE_KEY] = $time + $self->_options['file_life']; 
  109.         } 
  110.         
  111.         $file = $self->_file($id); 
  112.         
  113.         $data = "<?phpn"
  114.                 " // mktime: "$time"n"
  115.                 " return "
  116.                 var_export($data, true). 
  117.                 "n?>" 
  118.                 ; 
  119.         
  120.         $res = $self->_filePutContents($file$data); 
  121.         return $res
  122.     } 
  123.     
  124.     
  125.     /** 
  126.      * 得到缓存信息 
  127.      * 
  128.      * @param  string  $id  缓存id 
  129.      * @return string|array 缓存数据 
  130.      */ 
  131.     static function load($id
  132.     { 
  133.         $self = & self::getInstance(); 
  134.      $time = time(); 
  135.      //检测缓存是否存在 
  136.      if (!$self->test($id)) { 
  137.             // The cache is not hit ! 
  138.             return false; 
  139.         } 
  140.         
  141.   //全部清空识别文件 
  142.         $clearFile = $self->_file(self::CLEAR_ALL_KEY); 
  143.  
  144.   $file = $self->_file($id); 
  145.  
  146.         //判断缓存是否已被全部清除 
  147.      if(is_file($clearFile) && filemtime($clearFile) > filemtime($file)) 
  148.      { 
  149.       return false; 
  150.      } 
  151.        
  152.         $data = $self->_fileGetContents($file); 
  153.       if(emptyempty($data[self::FILE_LIFE_KEY]) || $time < $data[self::FILE_LIFE_KEY]) { 
  154.             unset($data[self::FILE_LIFE_KEY]); 
  155.        return $data;   
  156.       } 
  157.       return false; 
  158.     }    
  159.     
  160.     /** 
  161.      * 写入缓存文件 
  162.      * 
  163.      * @param  string $file   缓存路径 
  164.      * @param  string $string 缓存信息 
  165.      * @return boolean true 成功 
  166.      */ 
  167.     protected function _filePutContents($file$string
  168.     { 
  169.      $self = & self::getInstance(); 
  170.         $result = false; 
  171.         $f = @fopen($file'ab+'); 
  172.         if ($f) { 
  173.             if ($self->_options['file_locking']) @flock($f, LOCK_EX); 
  174.             fseek($f, 0); 
  175.             ftruncate($f, 0); 
  176.             $tmp = @fwrite($f$string); 
  177.             if (!($tmp === false)) { 
  178.                 $result = true; 
  179.             } 
  180.             @fclose($f); 
  181.         } 
  182.         @chmod($file$self->_options['cache_file_umask']); 
  183.         return $result
  184.     } 
  185.     
  186.     /** 
  187.      * 格式化后的缓存文件路径 
  188.      * 
  189.      * @param  string $id 缓存id 
  190.      * @return string 缓存文件名(包括路径) 
  191.      */ 
  192.     protected function _file($id
  193.     { 
  194.      $self = & self::getInstance(); 
  195.         $fileName = $self->_idToFileName($id); 
  196.         return $self->_options['cache_dir'] . $fileName
  197.     }    
  198.     
  199.     /** 
  200.      * 格式化后的缓存文件名字 
  201.      * 
  202.      * @param  string $id 缓存id 
  203.      * @return string 缓存文件名 
  204.      */ 
  205.     protected function _idToFileName($id
  206.     { 
  207.      $self = & self::getInstance(); 
  208.         $self->_id = $id
  209.         $prefix = $self->_options['file_name_prefix']; 
  210.         $result = $prefix . '---' . $id
  211.         return $result
  212.     }   
  213.     
  214.     /** 
  215.      * 判断缓存是否存在 
  216.      * 
  217.      * @param  string $id Cache id 
  218.      * @return boolean True 缓存存在 False 缓存不存在 
  219.      */ 
  220.     static function test($id
  221.     { 
  222.      $self = & self::getInstance(); 
  223.         $file = $self->_file($id); 
  224.         
  225.         if (!is_file($file)) { 
  226.             return false; 
  227.         } 
  228.         
  229.         return true; 
  230.     } 
  231.     
  232.     /** 
  233.      * 得到缓存信息 
  234.      * 
  235.      * @param  string $file 缓存路径 
  236.      * @return string 缓存内容 
  237.      */ 
  238.     protected function _fileGetContents($file
  239.     { 
  240.         if (!is_file($file)) { 
  241.             return false; 
  242.         } 
  243.         return include $file
  244.     }     
  245.     
  246.     /** 
  247.      * 清除所有缓存 
  248.      * 
  249.      * @return void 
  250.      */    
  251.     static function clear() 
  252.     { 
  253.      $self = & self::getInstance(); 
  254.      $self->save('CLEAR_ALL',self::CLEAR_ALL_KEY); 
  255.     }   
  256.  
  257.     /** 
  258.      * 清除一条缓存 
  259.      * 
  260.      * @param string cache id  
  261.      * @return void 
  262.      */   
  263.     static function del($id
  264.     { 
  265.   $self = & self::getInstance(); 
  266.      if(!$self->test($id)){ 
  267.       // 该缓存不存在 
  268.       return false; 
  269.      } 
  270.      $file = $self->_file($id); 
  271.      return unlink($file); 
  272.     } 

存入数据,代码如下:

  1. <?php 
  2. $config = array
  3.  'name' => 'xiaojiong'
  4.  'qq'   => '290747680'
  5.  'age'  => '20'
  6. ); 
  7. //第一个参数 缓存data 
  8. //第二个参数 缓存id 
  9. //第三个参数 cache_life 0 永不过期(cache::clear()清空所有除外) 默认cache_life 为option_cache_life 
  10. cache::save($config,'config',0); 

载入数据,代码如下:

  1. <?php 
  2. //只有一个参数 cache_id 
  3. $config = cache::load('config'); 
  4. 清空缓存 
  5. <?php 
  6. //清空指定缓存 
  7. cache::del('config'); 
  8. //清空所有缓存 
  9. cache::clear(); 
  10. cache信息配置 
  11. //在执行所有cache_func前调用 
  12. $_options = array
  13.     'cache_dir' => './cache'//缓存文件目录 
  14.     'file_name_prefix' => 'cache',//缓存文件前缀 
  15.     'file_life'  => 100000, //缓存文件生命 
  16. ); 
  17. cache::setOptions($options); 
  18. //再执行 就会按着新配置信息执行,否则是默认信息 
  19. cache::save($arr,'arr'); 

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

Tags: php文件缓存类

分享到: