用户名:
密 码: 记住
您当前的位置:首页 > 网络编程 > php教程

php文件缓存类实例整理

时间:2015-01-23  来源:西部数据  作者:西部数据

缓存类是我们开发应用中会常用使用到的功能,下面我来给大家整理几个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.  //写入缓存 
  18.  function __set($key , $val){ 
  19.   $this->_set($key ,$val); 
  20.  } 
  21.  //第三个参数为过期时间 
  22.  function _set($key ,$val,$limit_time=null){   
  23.   $limit_time = $limit_time ? $limit_time : $this->limit_time; 
  24.   $file = $this->cache_dir."/".$key.".cache"
  25.   $val = serialize($val); 
  26.   @file_put_contents($file,$valor $this->error(__line__,"fail to write in file"); 
  27.   @chmod($file,0777); 
  28.   @touch($file,time()+$limit_timeor $this->error(__line__,"fail to change time"); 
  29.  } 
  30.  
  31.  
  32.  //读取缓存 
  33.  function __get($key){ 
  34.   return $this->_get($key); 
  35.  } 
  36.  function _get($key){ 
  37.   $file = $this->cache_dir."/".$key.".cache"
  38.   if (@filemtime($file)>=time()){ 
  39.    return unserialize(file_get_contents($file)); 
  40.   }else
  41.    @unlink($fileor $this->error(__line__,"fail to unlink"); 
  42.    return false; 
  43.   } 
  44.  } 
  45.  
  46.  
  47.  //删除缓存文件 
  48.  function __unset($key){ 
  49.   return $this->_unset($key); 
  50.  } 
  51.  function _unset($key){ 
  52.   if (@unlink($this->cache_dir."/".$key.".cache")){ 
  53.    return true; 
  54.   }else
  55.    return false; 
  56.   } 
  57.  } 
  58.  
  59.  
  60.  //检查缓存是否存在,过期则认为不存在 
  61.  function __isset($key){ 
  62.   return $this->_isset($key); 
  63.  } 
  64.  function _isset($key){ 
  65.   $file = $this->cache_dir."/".$key.".cache"
  66.   if (@filemtime($file)>=time()){ 
  67.    return true; 
  68.   }else
  69.    @unlink($file) ; 
  70.    return false; 
  71.   } 
  72.  } 
  73.  
  74.  
  75.  //清除过期缓存文件 
  76.  function clear(){ 
  77.   $files = scandir($this->cache_dir); 
  78.   foreach ($files as $val){ 
  79.    if (filemtime($this->cache_dir."/".$val)<time()){ 
  80.     @unlink($this->cache_dir."/".$val); 
  81.    } 
  82.   } 
  83.  } 
  84.  
  85.  
  86.  //清除所有缓存文件 
  87.  function clear_all(){ 
  88.   $files = scandir($this->cache_dir); 
  89.   foreach ($files as $val){ 
  90.    @unlink($this->cache_dir."/".$val); 
  91.   } 
  92.  } 
  93.  
  94.  function error($msg,$debug = false) { 
  95.   $err = new Exception($msg); 
  96.   $str = "<pre> 
  97. <span style='color:red'>error:</span> 
  98. ".print_r($err->getTrace(),1)." 
  99. </pre>";//开源代码phpfensi.com 
  100.   if($debug == true) { 
  101.    file_put_contents(date('Y-m-d H_i_s').".log",$str); 
  102.    return $str
  103.   }else
  104.    die($str); 
  105.   } 
  106.  } 
  107. ?> 

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

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

  1. <?php  
  2. class cache 
  3. {  
  4.  private static $_instance = null; 
  5.  
  6.     protected $_options = array
  7.         'cache_dir'        => "./"
  8.         'file_name_prefix' => 'cache'
  9.      'mode'            => '1'//mode 1 为serialize model 2为保存为可执行文件 
  10.     );  
  11.  
  12.  /** 
  13.   * 得到本类实例 
  14.   *  
  15.   * @return Ambiguous 
  16.   */ 
  17.  public static function getInstance() 
  18.  { 
  19.   if(self::$_instance === null) 
  20.   { 
  21.    self::$_instance = new self(); 
  22.   } 
  23.   return self::$_instance
  24.  }  
  25.  
  26.  /** 
  27.   * 得到缓存信息 
  28.   *  
  29.   * @param string $id 
  30.   * @return boolean|array 
  31.   */ 
  32.  public static function get($id
  33.  { 
  34.   $instance = self::getInstance(); 
  35.    
  36.   //缓存文件不存在 
  37.   if(!$instance->has($id)) 
  38.   { 
  39.    return false; 
  40.   } 
  41.    
  42.   $file = $instance->_file($id); 
  43.    
  44.   $data = $instance->_fileGetContents($file); 
  45.    
  46.   if($data['expire'] == 0 || time() < $data['expire']) 
  47.   { 
  48.    return $data['contents']; 
  49.   } 
  50.   return false; 
  51.  } 
  52.  
  53.  /** 
  54.   * 设置一个缓存 
  55.   *  
  56.   * @param string $id   缓存id 
  57.   * @param array  $data 缓存内容 
  58.   * @param int    $cacheLife 缓存生命 默认为0无限生命 
  59.   */ 
  60.  public static function set($id$data$cacheLife = 0) 
  61.  { 
  62.   $instance = self::getInstance(); 
  63.    
  64.   $time = time(); 
  65.   $cache      = array(); 
  66.   $cache['contents'] = $data
  67.   $cache['expire']   = $cacheLife === 0 ? 0 : $time + $cacheLife
  68.   $cache['mtime']    = $time
  69.    
  70.   $file = $instance->_file($id); 
  71.    
  72.   return $instance->_filePutContents($file$cache); 
  73.  } 
  74.  
  75.     /** 
  76.      * 清除一条缓存 
  77.      *  
  78.      * @param string cache id   
  79.      * @return void 
  80.      */    
  81.  public static function delete($id
  82.  { 
  83.   $instance = self::getInstance(); 
  84.    
  85.   if(!$instance->has($id)) 
  86.   { 
  87.    return false; 
  88.   } 
  89.      $file = $instance->_file($id); 
  90.      //删除该缓存 
  91.      return unlink($file); 
  92.  } 
  93.  
  94.  /** 
  95.   * 判断缓存是否存在 
  96.   *  
  97.   * @param string $id cache_id 
  98.   * @return boolean true 缓存存在 false 缓存不存在 
  99.   */ 
  100.  public static function has($id
  101.  { 
  102.   $instance = self::getInstance(); 
  103.   $file     = $instance->_file($id); 
  104.    
  105.   if(!is_file($file)) 
  106.   { 
  107.    return false; 
  108.   } 
  109.   return true; 
  110.  } 
  111.  
  112.  /** 
  113.   * 通过缓存id得到缓存信息路径 
  114.   * @param string $id 
  115.   * @return string 缓存文件路径 
  116.   */ 
  117.  protected function _file($id
  118.  { 
  119.   $instance  = self::getInstance(); 
  120.   $fileNmae  = $instance->_idToFileName($id); 
  121.   return $instance->_options['cache_dir'] . $fileNmae
  122.  }  
  123.  
  124.  /** 
  125.   * 通过id得到缓存信息存储文件名 
  126.   *  
  127.   * @param  $id 
  128.   * @return string 缓存文件名 
  129.   */ 
  130.  protected function _idToFileName($id
  131.  { 
  132.   $instance  = self::getInstance(); 
  133.   $prefix    = $instance->_options['file_name_prefix']; 
  134.   return $prefix . '---' . $id
  135.  } 
  136.  
  137.  /** 
  138.   * 通过filename得到缓存id 
  139.   *  
  140.   * @param  $id 
  141.   * @return string 缓存id 
  142.   */ 
  143.  protected function _fileNameToId($fileName
  144.  { 
  145.   $instance  = self::getInstance(); 
  146.   $prefix    = $instance->_options['file_name_prefix']; 
  147.   return preg_replace('/^' . $prefix . '---(.*)$/''$1'$fileName); 
  148.  } 
  149.  
  150.  /** 
  151.   * 把数据写入文件 
  152.   *  
  153.   * @param string $file 文件名称 
  154.   * @param array  $contents 数据内容 
  155.   * @return bool  
  156.   */ 
  157.  protected function _filePutContents($file$contents
  158.  { 
  159.   if($this->_options['mode'] == 1) 
  160.   { 
  161.    $contents = serialize($contents); 
  162.   } 
  163.   else  
  164.   { 
  165.    $time = time();  
  166.          $contents = "<?phpn"
  167.                  " // mktime: "$time"n"
  168.                  " return "
  169.                  var_export($contents, true). 
  170.                  "n?>"
  171.   } 
  172.    
  173.   $result = false; 
  174.      $f = @fopen($file'w'); 
  175.         if ($f) { 
  176.             @flock($f, LOCK_EX); 
  177.             fseek($f, 0); 
  178.             ftruncate($f, 0); 
  179.             $tmp = @fwrite($f$contents); 
  180.             if (!($tmp === false)) { 
  181.                 $result = true; 
  182.             } 
  183.             @fclose($f); 
  184.         } 
  185.   @chmod($file,0777); 
  186.   return $result;     
  187.  } 
  188.  
  189.  /** 
  190.   * 从文件得到数据 
  191.   *  
  192.   * @param  sring $file 
  193.   * @return boolean|array 
  194.   */ 
  195.  protected function _fileGetContents($file
  196.  { 
  197.   if(!is_file($file)) 
  198.   { 
  199.    return false; 
  200.   } 
  201.    
  202.   if($this->_options['mode'] == 1) 
  203.   { 
  204.    $f = @fopen($file'r');  
  205.    @$data = fread($f,filesize($file)); 
  206.    @fclose($f); 
  207.    return unserialize($data); 
  208.   } 
  209.   else 
  210.   { 
  211.    return include $file
  212.   } 
  213.  } 
  214.  
  215.  /** 
  216.   * 构造函数 
  217.   */ 
  218.  protected function __construct() 
  219.  { 
  220.  
  221.  } 
  222.  
  223.  /** 
  224.   * 设置缓存路径 
  225.   *  
  226.   * @param string $path 
  227.   * @return self 
  228.   */ 
  229.  public static function setCacheDir($path
  230.  { 
  231.   $instance  = self::getInstance(); 
  232.         if (!is_dir($path)) { 
  233.             exit('file_cache: ' . $path.' 不是一个有效路径 '); 
  234.         } 
  235.         if (!is_writable($path)) { 
  236.             exit('file_cache: 路径 "'.$path.'" 不可写'); 
  237.         } 
  238.      
  239.         $path = rtrim($path,'/') . '/'
  240.         $instance->_options['cache_dir'] = $path
  241.          
  242.         return $instance
  243.  } 
  244.  
  245.  /** 
  246.   * 设置缓存文件前缀 
  247.   *  
  248.   * @param srting $prefix 
  249.   * @return self 
  250.   */ 
  251.  public static function setCachePrefix($prefix
  252.  { 
  253.   $instance  = self::getInstance(); 
  254.   $instance->_options['file_name_prefix'] = $prefix
  255.   return $instance
  256.  } 
  257.  
  258.  /** 
  259.   * 设置缓存存储类型 
  260.   *  
  261.   * @param int $mode 
  262.   * @return self 
  263.   */ 
  264.  public static function setCacheMode($mode = 1) 
  265.  { 
  266.   $instance  = self::getInstance(); 
  267.   if($mode == 1) 
  268.   { 
  269.    $instance->_options['mode'] = 1; 
  270.   } 
  271.   else 
  272.   { 
  273.    $instance->_options['mode'] = 2; 
  274.   } 
  275.    
  276.   return $instance
  277.  } 
  278.  
  279.  /** 
  280.   * 删除所有缓存 
  281.   * @return boolean 
  282.   */ 
  283.  public static function flush() 
  284.  { 
  285.   $instance  = self::getInstance(); 
  286.   $glob = @glob($instance->_options['cache_dir'] . $instance->_options['file_name_prefix'] . '--*'); 
  287.    
  288.   if(emptyempty($glob)) 
  289.   { 
  290.    return false; 
  291.   } 
  292.    
  293.   foreach ($glob as $v
  294.   { 
  295.    $fileName = basename($v); 
  296.    $id =  $instance->_fileNameToId($fileName); 
  297.    $instance->delete($id); 
  298.   } 
  299.   return true; 
  300.  } 
  301.  
  302. /* 初始化设置cache的配置信息什么的 */ 
  303. cache::setCachePrefix('core'); //设置缓存文件前缀 
  304. cache::setCacheDir('./cache'); //设置存放缓存文件夹路径 
  305.  
  306. //模式1 缓存存储方式 
  307. //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;} 
  308. //模式2 缓存存储方式 
  309. /* 
  310.  <?php 
  311.  // mktime: 1318224645 
  312.  return array ( 
  313.   'contents' =>  
  314.   array ( 
  315.     0 => 1, 
  316.     1 => 2, 
  317.     2 => 3, 
  318.     3 => 34, 
  319.     4 => 5, 
  320.     5 => 6, 
  321.     6 => 6, 
  322.   ), 
  323.   'expire' => 0, 
  324.   'mtime' => 1318224645, 
  325. ) 
  326. ?> 
  327.  *  
  328.  *  
  329.  */ 
  330. cache::setCacheMode('2'); 
  331.  
  332. if(!$row = cache::get('zj2')) 
  333.  
  334.  $array = array(1,2,3,34,5,6,6); 
  335.  $row = cache::set('zj2',$array); 
  336. // cache::flush(); 清空所有缓存 
  337.  
  338. print_r($row); 
  339.  
  340. 件缓存 class     
  341.  
  342. <?php 
  343. /** 
  344.  * 文件缓存类 
  345.  * @author  xiaojiong & 290747680@qq.com 
  346.  * @date 2011-08-17 
  347.  */ 
  348. class cache 
  349.  const FILE_LIFE_KEY = 'FILE_LIFE_KEY'
  350.  
  351.  const CLEAR_ALL_KEY = 'CLEAR_ALL'
  352.  
  353.     static $_instance = null; 
  354.  
  355.     protected $_options = array
  356.         'cache_dir' => './cache'
  357.         'file_locking' => true, 
  358.         'file_name_prefix' => 'cache'
  359.         'cache_file_umask' => 0777, 
  360.      'file_life'  => 100000 
  361.     ); 
  362.      
  363.     static function &getInstance($options = array()) 
  364.     { 
  365.      if(self::$_instance === null) 
  366.      { 
  367.       self::$_instance = new self($options); 
  368.      }  
  369.      return self::$_instance
  370.     } 
  371.      
  372.     /** 
  373.      * 设置参数 
  374.      * @param  array $options 缓存参数 
  375.      * @return void 
  376.      */ 
  377.  static function &setOptions($options = array()) 
  378.  { 
  379.          return self::getInstance($options); 
  380.  } 
  381.  
  382.     /** 
  383.      * 构造函数 
  384.      * @param  array $options 缓存参数 
  385.      * @return void 
  386.      */ 
  387.     private function __construct($options = array()) 
  388.     {   
  389.         if ($this->_options['cache_dir'] !== null) { 
  390.     
  391.    $dir = rtrim($this->_options['cache_dir'],'/') . '/'
  392.          $this->_options['cache_dir'] = $dir
  393.           
  394.    if (!is_dir($this->_options['cache_dir'])) { 
  395.              mkdir($this->_options['cache_dir'],0777,TRUE); 
  396.          } 
  397.          if (!is_writable($this->_options['cache_dir'])) { 
  398.              exit('file_cache: 路径 "'$this->_options['cache_dir'] .'" 不可写'); 
  399.          } 
  400.        
  401.         } else { 
  402.            exit('file_cache: "options" cache_dir 不能为空 '); 
  403.         } 
  404.     } 
  405.  
  406.     /** 
  407.      * 设置缓存路径 
  408.      * @param  string  $value 
  409.      * @return void 
  410.      */ 
  411.     static function setCacheDir($value
  412.     { 
  413.      $self = & self::getInstance(); 
  414.       
  415.         if (!is_dir($value)) { 
  416.             exit('file_cache: ' . $value.' 不是一个有效路径 '); 
  417.         } 
  418.         if (!is_writable($value)) { 
  419.             exit('file_cache: 路径 "'.$value.'" 不可写'); 
  420.         } 
  421.      
  422.         $value = rtrim($this->_options['cache_dir'],'/') . '/'
  423.          
  424.         $self->_options['cache_dir'] = $value
  425.     } 
  426.      
  427.     /** 
  428.      * 存入缓存数据 
  429.      * @param  array  $data          放入缓存的数据 
  430.      * @param  string $id            缓存id(又名缓存识别码) 
  431.      * @param  cache_life            缓存时间 
  432.      * @return boolean True if no problem 
  433.      */ 
  434.     static function save($data$id = null, $cache_life = null) 
  435.     { 
  436.      $self = & self::getInstance(); 
  437.         if (!$id) { 
  438.             if ($self->_id) { 
  439.                 $id = $self->_id; 
  440.             } else { 
  441.                 exit('file_cache:save() id 不能为空!'); 
  442.             } 
  443.         } 
  444.         $time = time(); 
  445.          
  446.         if($cache_life) { 
  447.          $data[self::FILE_LIFE_KEY] = $time + $cache_life
  448.         } 
  449.   elseif 
  450.   ($cache_life != 0){ 
  451.          $data[self::FILE_LIFE_KEY] = $time + $self->_options['file_life']; 
  452.         } 
  453.          
  454.         $file = $self->_file($id); 
  455.          
  456.         $data = "<?phpn"
  457.                 " // mktime: "$time"n"
  458.                 " return "
  459.                 var_export($data, true). 
  460.                 "n?>" 
  461.                 ; 
  462.          
  463.         $res = $self->_filePutContents($file$data); 
  464.         return $res
  465.     } 
  466.      
  467.      
  468.     /** 
  469.      * 得到缓存信息 
  470.      * 
  471.      * @param  string  $id  缓存id 
  472.      * @return string|array 缓存数据 
  473.      */ 
  474.     static function load($id
  475.     { 
  476.         $self = & self::getInstance(); 
  477.      $time = time(); 
  478.      //检测缓存是否存在 
  479.      if (!$self->test($id)) { 
  480.             // The cache is not hit ! 
  481.             return false; 
  482.         } 
  483.          
  484.   //全部清空识别文件 
  485.         $clearFile = $self->_file(self::CLEAR_ALL_KEY); 
  486.    
  487.   $file = $self->_file($id); 
  488.    
  489.         //判断缓存是否已被全部清除 
  490.      if(is_file($clearFile) && filemtime($clearFile) > filemtime($file)) 
  491.      { 
  492.       return false; 
  493.      } 
  494.         
  495.         $data = $self->_fileGetContents($file); 
  496.       if(emptyempty($data[self::FILE_LIFE_KEY]) || $time < $data[self::FILE_LIFE_KEY]) { 
  497.             unset($data[self::FILE_LIFE_KEY]);  
  498.        return $data;    
  499.       } 
  500.       return false; 
  501.     }     
  502.      
  503.     /** 
  504.      * 写入缓存文件 
  505.      * 
  506.      * @param  string $file   缓存路径 
  507.      * @param  string $string 缓存信息 
  508.      * @return boolean true 成功 
  509.      */ 
  510.     protected function _filePutContents($file$string
  511.     { 
  512.      $self = & self::getInstance(); 
  513.         $result = false; 
  514.         $f = @fopen($file'ab+'); 
  515.         if ($f) { 
  516.             if ($self->_options['file_locking']) @flock($f, LOCK_EX); 
  517.             fseek($f, 0); 
  518.             ftruncate($f, 0); 
  519.             $tmp = @fwrite($f$string); 
  520.             if (!($tmp === false)) { 
  521.                 $result = true; 
  522.             } 
  523.             @fclose($f); 
  524.         } 
  525.         @chmod($file$self->_options['cache_file_umask']); 
  526.         return $result
  527.     } 
  528.      
  529.     /** 
  530.      * 格式化后的缓存文件路径 
  531.      * 
  532.      * @param  string $id 缓存id 
  533.      * @return string 缓存文件名(包括路径) 
  534.      */ 
  535.     protected function _file($id
  536.     { 
  537.      $self = & self::getInstance(); 
  538.         $fileName = $self->_idToFileName($id); 
  539.         return $self->_options['cache_dir'] . $fileName
  540.     }     
  541.      
  542.     /** 
  543.      * 格式化后的缓存文件名字 
  544.      * 
  545.      * @param  string $id 缓存id 
  546.      * @return string 缓存文件名 
  547.      */ 
  548.     protected function _idToFileName($id
  549.     { 
  550.      $self = & self::getInstance(); 
  551.         $self->_id = $id
  552.         $prefix = $self->_options['file_name_prefix']; 
  553.         $result = $prefix . '---' . $id
  554.         return $result
  555.     }    
  556.      
  557.     /** 
  558.      * 判断缓存是否存在 
  559.      * 
  560.      * @param  string $id Cache id 
  561.      * @return boolean True 缓存存在 False 缓存不存在 
  562.      */ 
  563.     static function test($id
  564.     { 
  565.      $self = & self::getInstance(); 
  566.         $file = $self->_file($id); 
  567.          
  568.         if (!is_file($file)) { 
  569.             return false; 
  570.         } 
  571.          
  572.         return true; 
  573.     } 
  574.      
  575.     /** 
  576.      * 得到缓存信息 
  577.      * 
  578.      * @param  string $file 缓存路径 
  579.      * @return string 缓存内容 
  580.      */ 
  581.     protected function _fileGetContents($file
  582.     { 
  583.         if (!is_file($file)) { 
  584.             return false; 
  585.         } 
  586.         return include $file
  587.     }      
  588.      
  589.     /** 
  590.      * 清除所有缓存 
  591.      *  
  592.      * @return void 
  593.      */     
  594.     static function clear() 
  595.     { 
  596.      $self = & self::getInstance(); 
  597.      $self->save('CLEAR_ALL',self::CLEAR_ALL_KEY);  
  598.     }    
  599.  
  600.     /** 
  601.      * 清除一条缓存 
  602.      *  
  603.      * @param string cache id   
  604.      * @return void 
  605.      */    
  606.     static function del($id
  607.     { 
  608.   $self = & self::getInstance(); 
  609.      if(!$self->test($id)){ 
  610.       // 该缓存不存在 
  611.       return false; 
  612.      } 
  613.      $file = $self->_file($id); 
  614.      return unlink($file); 
  615.     }  
  616.  
  617. 存入数据 
  618.  
  619. <?php 
  620. $config = array
  621.  'name' => 'xiaojiong'
  622.  'qq'   => '290747680'
  623.  'age'  => '20'
  624. ); 
  625.  
  626. //第一个参数 缓存data 
  627. //第二个参数 缓存id 
  628. //第三个参数 cache_life 0 永不过期(cache::clear()清空所有除外) 默认cache_life 为option_cache_life 
  629. cache::save($config,'config',0); 
  630.  
  631. 载入数据 
  632.  
  633. <?php 
  634. //只有一个参数 cache_id 
  635. $config = cache::load('config'); 
  636.  
  637. 清空缓存 
  638.  
  639. <?php 
  640. //清空指定缓存 
  641. cache::del('config'); 
  642. //清空所有缓存 
  643. cache::clear(); 
  644.  
  645. cache信息配置 
  646.  
  647. //在执行所有cache_func前调用 
  648.  
  649. $_options = array
  650.     'cache_dir' => './cache'//缓存文件目录 
  651.     'file_name_prefix' => 'cache',//缓存文件前缀 
  652.     'file_life'  => 100000, //缓存文件生命 
  653. ); 
  654. cache::setOptions($options); 
  655.  
  656. //再执行 就会按着新配置信息执行,否则是默认信息 
  657. cache::save($arr,'arr'); 
  658.  
  659. //就是这个方法 貌似不合理 望大家指点 
  660. ?> 
来顶一下
返回首页
返回首页
推荐资讯
WiFi太不安全:7岁女孩11分钟内入侵公共网络 WiFi太不安全:7岁女孩11分钟内入侵近期刚刚发布研究说WiFi网络能获得人们手机里多少私人信息,
不服跑个分?人工智能也出现“刷分”乱象 不服跑个分?人工智能也出现“刷分2014年,人工智能领域突然爆发,成为了科研和科技创业的热门
相关文章
栏目更新
栏目热门