首页 > php开发 > php实现文件数据缓存实现代码

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

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

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

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

<?php   
	class cacheexception extends exception {}   
	/**  
	 * 缓存抽象类  
	 */   
	abstract class cache_abstract {   
	    /**  
	     * 读缓存变量  
	     *  
	     * @param string $key 缓存下标  
	     * @return mixed  
	     */   
	    abstract public function fetch($key);   
	       
	    /**  
	     * 缓存变量  
	     *  
	     * @param string $key 缓存变量下标  
	     * @param string $value 缓存变量的值  
	     * @return bool  
	     */   
	    abstract public function store($key, $value);   
	       
	    /**  
	     * 删除缓存变量  
	     *  
	     * @param string $key 缓存下标  
	     * @return cache_abstract  
	     */   
	    abstract public function delete($key);   
	       
	    /**  
	     * 清(删)除所有缓存  
	     *  
	     * @return cache_abstract  
	     */   
	    abstract public function clear();   
	       
	    /**  
	     * 锁定缓存变量  
	     *  
	     * @param string $key 缓存下标  
	     * @return cache_abstract  
	     */   
	    abstract public function lock($key);   
	   
	    /**  
	     * 缓存变量解锁  
	     *  
	     * @param string $key 缓存下标  
	     * @return cache_abstract  
	     */   
	    abstract public function unlock($key);   
	   
	    /**  
	     * 取得缓存变量是否被锁定  
	     *  
	     * @param string $key 缓存下标  
	     * @return bool  
	     */   
	    abstract public function islocked($key);   
	   
	    /**  
	     * 确保不是锁定状态  
	     * 最多做$tries次睡眠等待解锁,超时则跳过并解锁  
	     *  
	     * @param string $key 缓存下标  
	     */   
	    public function checklock($key) {   
	        if (!$this->islocked($key)) {   
	            return $this;   
	        }   
	           
	        $tries = 10;   
	        $count = 0;   
	        do {   
	            usleep(200);   
	            $count ++;   
	        } while ($count <= $tries && $this->islocked($key));  // 最多做十次睡眠等待解锁,超时则跳过并解锁   
	   
	        $this->islocked($key) && $this->unlock($key);   
	           
	        return $this;   
	    }   
	}   
	   
	   
	/**  
	 * apc扩展缓存实现  
	 *   
	 *   
	 * @category   mjie  
	 * @package    cache  
	 * @author     流水孟春  
	 * @copyright  copyright (c) 2008- <cmpan(at)qq.com>  
	 * @license    new bsd license  
	 * @version    $id: cache/apc.php 版本号 2010-04-18 23:02 cmpan $  
	 */   
	class cache_apc extends cache_abstract {   
	       
	    protected $_prefix = 'cache.mjie.net';   
	       
	    public function __construct() {   
	        if (!function_exists('apc_cache_info')) {   
	            throw new cacheexception('apc extension didn't installed');   
	        }   
	    }   
	       
	    /**  
	     * 保存缓存变量  
	     *  
	     * @param string $key  
	     * @param mixed $value  
	     * @return bool  
	     */   
	    public function store($key, $value) {   
	        return apc_store($this->_storagekey($key), $value);   
	    }   
	       
	    /**  
	     * 读取缓存  
	     *  
	     * @param string $key  
	     * @return mixed  
	     */   
	    public function fetch($key) {   
	        return apc_fetch($this->_storagekey($key));   
	    }   
	       
	    /**  
	     * 清除缓存  
	     *  
	     * @return cache_apc  
	     */   
	    public function clear() {   
	        apc_clear_cache();   
	        return $this;   
	    }   
	       
	    /**  
	     * 删除缓存单元  
	     *  
	     * @return cache_apc  
	     */   
	    public function delete($key) {   
	        apc_delete($this->_storagekey($key));   
	        return $this;   
	    }   
	       
	    /**  
	     * 缓存单元是否被锁定  
	     *  
	     * @param string $key  
	     * @return bool  
	     */   
	    public function islocked($key) {   
	        if ((apc_fetch($this->_storagekey($key) . '.lock')) === false) {   
	            return false;   
	        }   
	           
	        return true;   
	    }   
	       
	    /**  
	     * 锁定缓存单元  
	     *  
	     * @param string $key  
	     * @return cache_apc  
	     */   
	    public function lock($key) {   
	        apc_store($this->_storagekey($key) . '.lock', '', 5);   
	        return $this;   
	    }   
	       
	    /**  
	     * 缓存单元解锁  
	     *  
	     * @param string $key  
	     * @return cache_apc  
	     */   
	    public function unlock($key) {   
	        apc_delete($this->_storagekey($key) . '.lock');   
	        return $this;   
	    }   
	       
	    /**  
	     * 完整缓存名  
	     *  
	     * @param string $key  
	     * @return string  
	     */   
	    private function _storagekey($key) {   
	        return $this->_prefix . '_' . $key;   
	    }   
	}   
	   
	/**  
	 * 文件缓存实现  
	 *   
	 *   
	 * @category   mjie  
	 * @package    cache  
	 * @author     流水孟春  
	 * @copyright  copyright (c) 2008- <cmpan(at)qq.com>  
	 * @license    new bsd license  
	 * @version    $id: cache/file.php 版本号 2010-04-18 16:46 cmpan $  
	 */   
	class cache_file extends cache_abstract {   
	    public $usesubdir     = false;   
	       
	    protected $_cachesdir = 'cache';   
	       
	    public function __construct() {   
	        if (defined('data_dir')) {   
	            $this->_setcachedir(data_dir . '/cache');   
	        }   
	    }   
	       
	    /**  
	     * 获取缓存文件  
	     *  
	     * @param string $key  
	     * @return string  
	     */   
	    protected function _getcachefile($key) {   
	        $subdir = $this->usesubdir ? substr($key, 0, 2) . '/' : '';   
	        return $this->_cachesdir . '/' . $subdir . $key . '.php';   
	    }   
	   
	    /**  
	     * 读取缓存变量  
	     * 为防止信息泄露,缓存文件格式为php文件,并以"<?php exit;"开头  
	     *   
	     * @param string $key 缓存下标  
	     * @return mixed  
	     */   
	    public function fetch($key) {   
	        $cachefile = self::_getcachefile($key);   
	        if (file_exists($cachefile) && is_readable($cachefile)) {   
	            // include 方式   
	            //return include $cachefile;   
	            // 系列化方式   
	   
	            return unserialize(@file_get_contents($cachefile, false, null, 13));   
	        }   
	   
	        return false;   
	    }   
	   
	    /**  
	     * 缓存变量  
	     * 为防止信息泄露,缓存文件格式为php文件,并以"<?php exit;"开头  
	     *  
	     * @param string $key 缓存变量下标  
	     * @param string $value 缓存变量的值  
	     * @return bool  
	     */   
	    public function store($key, $value) {   
	        $cachefile = self::_getcachefile($key);   
	        $cachedir  = dirname($cachefile);   
	   
	        if(!is_dir($cachedir)) {   
	            if(!@mkdir($cachedir, 0755, true)) {   
	                throw new cacheexception("could not make cache directory");  
	            }   
	        }   
	    // 用include方式   
	        //return @file_put_contents($cachefile, '<?php return ' . var_export($value, true). ';');   
	   
	        return @file_put_contents($cachefile, '<?php exit;' . serialize($value));   
	    }   
	   
	    /**  
	     * 删除缓存变量  
	     *  
	     * @param string $key 缓存下标  
	     * @return cache_file  
	     */   
	    public function delete($key) {   
	        if(emptyempty($key)) {   
	            throw new cacheexception("missing argument 1 for cache_file::delete()");   
	        }   
	           
	        $cachefile = self::_getcachefile($key);   
	        if(!@unlink($cachefile)) {   
	            throw new cacheexception("cache file could not be deleted");   
	        }   
	   
	        return $this;   
	    }   
	   
	    /**  
	     * 缓存单元是否已经锁定  
	     *  
	     * @param string $key  
	     * @return bool  
	     */   
	    public function islocked($key) {   
	        $cachefile = self::_getcachefile($key);   
	        clearstatcache();   
	        return file_exists($cachefile . '.lock');   
	    }   
	   
	    /**  
	     * 锁定  
	     *  
	     * @param string $key  
	     * @return cache_file  
	     */   
	    public function lock($key) {   
	        $cachefile = self::_getcachefile($key);   
	        $cachedir  = dirname($cachefile);   
	        if(!is_dir($cachedir)) {   
	            if(!@mkdir($cachedir, 0755, true)) {   
	                if(!is_dir($cachedir)) {   
	                    throw new cacheexception("could not make cache directory");   
	                }   
	            }   
	        }   
	   
	        // 设定缓存锁文件的访问和修改时间   
	        @touch($cachefile . '.lock');   
	        return $this;   
	    }   
	     
	    /**  
	     * 解锁  
	     *  
	     * @param string $key  
	     * @return cache_file  
	     */   
	    public function unlock($key) {   
	    //开源代码phprm.com 
	        $cachefile = self::_getcachefile($key);   
	        @unlink($cachefile . '.lock');   
	        return 
	 

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

<?php 
	 
	require('smarty.class.php'); 
	 
	$smarty = new smarty; 
	 
	$smarty->caching = true; 
	 
	if(!$smarty->is_cached('index.tpl')) { 
	 
	 // no cache available, do variable assignments here. 
	 
	 $contents = get_database_contents(); 
	 
	 $smarty->assign($contents); 
	 
	} 
	 
	$smarty->display('index.tpl'); 
	 
	 

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

永久地址:http://www.phprm.com/develop/fs5075.html

转载随意~请带上教程地址吧^^

标签:php文件缓存 php缓存代码

相关文章

发表留言