当前位置:首页 > PHP教程 > php高级应用 > 列表

php实现文件数据缓存实现代码

发布:smiling 来源: PHP粉丝网  添加日期:2014-09-09 10:03:09 浏览: 评论:0 

缓存技术是每次访问页面的时候,都会先检测相应的缓存是否存在,如果不存在,就连接数据库,得到数据,完成模板变量的赋值,显示页面,同时生成缓存文件,这样下次访问的时候缓存文件就发挥作用了.

而不会再执行if块的数据查询语句了,当然,在实际使用中会有很多东西要考虑,比如,有效期的设置,缓存组的设置等等.

php实现文件数据缓存实现代码如下:

  1. <?php   
  2. class cacheexception extends exception {}   
  3. /**  
  4.  * 缓存抽象类  
  5.  */   
  6. abstract class cache_abstract {   
  7.     /**  
  8.      * 读缓存变量  
  9.      *  
  10.      * @param string $key 缓存下标  
  11.      * @return mixed  
  12.      */   
  13.     abstract public function fetch($key);   
  14.        
  15.     /**  
  16.      * 缓存变量  
  17.      *  
  18.      * @param string $key 缓存变量下标  
  19.      * @param string $value 缓存变量的值  
  20.      * @return bool  
  21.      */   
  22.     abstract public function store($key$value);   
  23.        
  24.     /**  
  25.      * 删除缓存变量  
  26.      *  
  27.      * @param string $key 缓存下标  
  28.      * @return cache_abstract  
  29.      */   
  30.     abstract public function delete($key);   
  31.        
  32.     /**  
  33.      * 清(删)除所有缓存  
  34.      *  
  35.      * @return cache_abstract  
  36.      */   
  37.     abstract public function clear();   
  38.        
  39.     /**  
  40.      * 锁定缓存变量  
  41.      *  
  42.      * @param string $key 缓存下标  
  43.      * @return cache_abstract  
  44.      */   
  45.     abstract public function lock($key);   
  46.    
  47.     /**  
  48.      * 缓存变量解锁  
  49.      *  
  50.      * @param string $key 缓存下标  
  51.      * @return cache_abstract  
  52.      */   
  53.     abstract public function unlock($key);   
  54.    
  55.     /**  
  56.      * 取得缓存变量是否被锁定  
  57.      *  
  58.      * @param string $key 缓存下标  
  59.      * @return bool  
  60.      */   
  61.     abstract public function islocked($key);   
  62.    
  63.     /**  
  64.      * 确保不是锁定状态  
  65.      * 最多做$tries次睡眠等待解锁,超时则跳过并解锁  
  66.      *  
  67.      * @param string $key 缓存下标  
  68.      */   
  69.     public function checklock($key) {   
  70.         if (!$this->islocked($key)) {   
  71.             return $this;   
  72.         }   
  73.            
  74.         $tries = 10;   
  75.         $count = 0;   
  76.         do {   
  77.             usleep(200);   
  78.             $count ++;   
  79.         } while ($count <= $tries && $this->islocked($key));  // 最多做十次睡眠等待解锁,超时则跳过并解锁   
  80.    
  81.         $this->islocked($key) && $this->unlock($key);   
  82.            
  83.         return $this;   
  84.     }   
  85. }   
  86.    
  87.    
  88. /**  
  89.  * apc扩展缓存实现  
  90.  *   
  91.  *   
  92.  * @category   mjie  
  93.  * @package    cache  
  94.  * @author     流水孟春  
  95.  * @copyright  copyright (c) 2008- <cmpan(at)qq.com>  
  96.  * @license    new bsd license  
  97.  * @version    $id: cache/apc.php 版本号 2010-04-18 23:02 cmpan $  
  98.  */   
  99. class cache_apc extends cache_abstract {   
  100.        
  101.     protected $_prefix = 'cache.mjie.net';   
  102.        
  103.     public function __construct() {   
  104.         if (!function_exists('apc_cache_info')) {   
  105.             throw new cacheexception('apc extension didn't installed');   
  106.         }   
  107.     }   
  108.        
  109.     /**  
  110.      * 保存缓存变量  
  111.      *  
  112.      * @param string $key  
  113.      * @param mixed $value  
  114.      * @return bool  
  115.      */   
  116.     public function store($key$value) {   
  117.         return apc_store($this->_storagekey($key), $value);   
  118.     }   
  119.        
  120.     /**  
  121.      * 读取缓存  
  122.      *  
  123.      * @param string $key  
  124.      * @return mixed  
  125.      */   
  126.     public function fetch($key) {   
  127.         return apc_fetch($this->_storagekey($key));   
  128.     }   
  129.        
  130.     /**  
  131.      * 清除缓存  
  132.      *  
  133.      * @return cache_apc  
  134.      */   
  135.     public function clear() {   
  136.         apc_clear_cache();   
  137.         return $this;   
  138.     }   
  139.        
  140.     /**  
  141.      * 删除缓存单元  
  142.      *  
  143.      * @return cache_apc  
  144.      */   
  145.     public function delete($key) {   
  146.         apc_delete($this->_storagekey($key));   
  147.         return $this;   
  148.     }   
  149.        
  150.     /**  
  151.      * 缓存单元是否被锁定  
  152.      *  
  153.      * @param string $key  
  154.      * @return bool  
  155.      */   
  156.     public function islocked($key) {   
  157.         if ((apc_fetch($this->_storagekey($key) . '.lock')) === false) {   
  158.             return false;   
  159.         }   
  160.            
  161.         return true;   
  162.     }   
  163.        
  164.     /**  
  165.      * 锁定缓存单元  
  166.      *  
  167.      * @param string $key  
  168.      * @return cache_apc  
  169.      */   
  170.     public function lock($key) {   
  171.         apc_store($this->_storagekey($key) . '.lock''', 5);   
  172.         return $this;   
  173.     }   
  174.        
  175.     /**  
  176.      * 缓存单元解锁  
  177.      *  
  178.      * @param string $key  
  179.      * @return cache_apc  
  180.      */   
  181.     public function unlock($key) {   
  182.         apc_delete($this->_storagekey($key) . '.lock');   
  183.         return $this;   
  184.     }   
  185.        
  186.     /**  
  187.      * 完整缓存名  
  188.      *  
  189.      * @param string $key  
  190.      * @return string  
  191.      */   
  192.     private function _storagekey($key) {   
  193.         return $this->_prefix . '_' . $key;   
  194.     }   
  195. }   
  196.    
  197. /**  
  198.  * 文件缓存实现  
  199.  *   
  200.  *   
  201.  * @category   mjie  
  202.  * @package    cache  
  203.  * @author     流水孟春  
  204.  * @copyright  copyright (c) 2008- <cmpan(at)qq.com>  
  205.  * @license    new bsd license  
  206.  * @version    $id: cache/file.php 版本号 2010-04-18 16:46 cmpan $  
  207.  */   
  208. class cache_file extends cache_abstract {   
  209.     public $usesubdir     = false;   
  210.        
  211.     protected $_cachesdir = 'cache';   
  212.        
  213.     public function __construct() {   
  214.         if (defined('data_dir')) {   
  215.             $this->_setcachedir(data_dir . '/cache');   
  216.         }   
  217.     }   
  218.        
  219.     /**  
  220.      * 获取缓存文件  
  221.      *  
  222.      * @param string $key  
  223.      * @return string  
  224.      */   
  225.     protected function _getcachefile($key) {   
  226.         $subdir = $this->usesubdir ? substr($key, 0, 2) . '/' : '';   
  227.         return $this->_cachesdir . '/' . $subdir . $key . '.php';   
  228.     }   
  229.    
  230.     /**  
  231.      * 读取缓存变量  
  232.      * 为防止信息泄露,缓存文件格式为php文件,并以"<?php exit;?>"开头  
  233.      *   
  234.      * @param string $key 缓存下标  
  235.      * @return mixed  
  236.      */   
  237.     public function fetch($key) {   
  238.         $cachefile = self::_getcachefile($key);   
  239.         if (file_exists($cachefile) && is_readable($cachefile)) {   
  240.             // include 方式   
  241.             //return include $cachefile;   
  242.             // 系列化方式   
  243.    
  244.             return unserialize(@file_get_contents($cachefile, false, null, 13));   
  245.         }   
  246.    
  247.         return false;   
  248.     }   
  249.    
  250.     /**  
  251.      * 缓存变量  
  252.      * 为防止信息泄露,缓存文件格式为php文件,并以"<?php exit;?>"开头  
  253.      *  
  254.      * @param string $key 缓存变量下标  
  255.      * @param string $value 缓存变量的值  
  256.      * @return bool  
  257.      */   
  258.     public function store($key$value) {   
  259.         $cachefile = self::_getcachefile($key);   
  260.         $cachedir  = dirname($cachefile);   
  261.    
  262.         if(!is_dir($cachedir)) {   
  263.             if(!@mkdir($cachedir, 0755, true)) {   
  264.                 throw new cacheexception("could not make cache directory");  
  265.             }   
  266.         }   
  267.     // 用include方式   
  268.         //return @file_put_contents($cachefile, '<?php return ' . var_export($value, true). ';');   
  269.    
  270.         return @file_put_contents($cachefile'<?php exit;?>' . serialize($value));   
  271.     }   
  272.    
  273.     /**  
  274.      * 删除缓存变量  
  275.      *  
  276.      * @param string $key 缓存下标  
  277.      * @return cache_file  
  278.      */   
  279.     public function delete($key) {   
  280.         if(emptyempty($key)) {   
  281.             throw new cacheexception("missing argument 1 for cache_file::delete()");   
  282.         }   
  283.            
  284.         $cachefile = self::_getcachefile($key);   
  285.         if(!@unlink($cachefile)) {   
  286.             throw new cacheexception("cache file could not be deleted");   
  287.         }   
  288.    
  289.         return $this;   
  290.     }   
  291.    
  292.     /**  
  293.      * 缓存单元是否已经锁定  
  294.      *  
  295.      * @param string $key  
  296.      * @return bool  
  297.      */   
  298.     public function islocked($key) {   
  299.         $cachefile = self::_getcachefile($key);   
  300.         clearstatcache();   
  301.         return file_exists($cachefile . '.lock');   
  302.     }   
  303.    
  304.     /**  
  305.      * 锁定  
  306.      *  
  307.      * @param string $key  
  308.      * @return cache_file  
  309.      */   
  310.     public function lock($key) {   
  311.         $cachefile = self::_getcachefile($key);   
  312.         $cachedir  = dirname($cachefile);   
  313.         if(!is_dir($cachedir)) {   
  314.             if(!@mkdir($cachedir, 0755, true)) {   
  315.                 if(!is_dir($cachedir)) {   
  316.                     throw new cacheexception("could not make cache directory");   
  317.                 }   
  318.             }   
  319.         }   
  320.    
  321.         // 设定缓存锁文件的访问和修改时间   
  322.         @touch($cachefile . '.lock');   
  323.         return $this;   
  324.     }   
  325.      
  326.     /**  
  327.      * 解锁  
  328.      *  
  329.      * @param string $key  
  330.      * @return cache_file  
  331.      */   
  332.     public function unlock($key) {   
  333.     //开源代码phpfensi.com 
  334.         $cachefile = self::_getcachefile($key);   
  335.         @unlink($cachefile . '.lock');   
  336.         return 
  337. ?> 

下面来看一款关于smarty缓存的文件实例代码,再来看看smarty提供的页面缓存功能:

  1. <?php 
  2.  
  3. require('smarty.class.php'); 
  4.  
  5. $smarty = new smarty; 
  6.  
  7. $smarty->caching = true; 
  8.  
  9. if(!$smarty->is_cached('index.tpl')) { 
  10.  
  11.  // no cache available, do variable assignments here. 
  12.  
  13.  $contents = get_database_contents(); 
  14.  
  15.  $smarty->assign($contents); 
  16.  
  17.  
  18. $smarty->display('index.tpl'); 
  19.  
  20. ?> 

php缓存技术工作时,当程序查询数据的时候,会把相应的结果序列化后保存到文件中,以后同样的查询语句就可以不用直接查询数据库,而是从缓存文件中获得,这一改进使得程序运行速度得以太幅度提升.

Tags: php缓存代码 php文件缓存

分享到: