时时商务社区

标题: php文件缓存类汇总 [打印本页]

作者: xgnic 时间: 2018-2-14 05:52

         本文实例讲述了php的文件缓存类。分享给大家供大家参考。具体分析如下：
缓存类是我们开发应用中会常用使用到的功能，下面就来给大家整理几个php文件缓存类了，各个文件缓存类写法不同，但在性能上会有区别，有兴趣测试的朋友可测试一下这些缓存类。
例1
[U]复制代码[/U] 代码如下: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)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 = "
error:
".print_r($err->getTrace(),1)."
";
  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使用类似,不过更方便。用在一些小的应用上足够了.
具体代码如下
[U]复制代码[/U] 代码如下:_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() _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文件缓存
[U]复制代码[/U] 代码如下: "./",
      '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() _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 = "";
  }

  $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 缓存存储方式
/*

  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
[U]复制代码[/U] 代码如下: './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 = ""
            ;

      $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 _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);
}
}
存入数据
[U]复制代码[/U] 代码如下: 'xiaojiong',
'qq' => '290747680',
'age'  => '20',
);
//第一个参数缓存data
//第二个参数缓存id
//第三个参数 cache_life 0 永不过期(cache::clear()清空所有除外) 默认cache_life 为option_cache_life
cache::save($config,'config',0);
载入数据
[U]复制代码[/U] 代码如下: './cache', //缓存文件目录
'file_name_prefix' => 'cache',//缓存文件前缀
'file_life'  => 100000, //缓存文件生命
);
cache::setOptions($options);
//再执行就会按着新配置信息执行，否则是默认信息
cache::save($arr,'arr');
这个方法貌似不合理，感兴趣的朋友可以加以改进。希望本文所述对大家的PHP程序设计有所帮助。


您可能感兴趣的文章:

PHP Memcached + APC + 文件缓存封装实现代码

php文件缓存方法总结

欢迎光临时时商务社区 (http://bbs.4435.cn/)