php实现文件数据缓存实现代码_PHP教程-PHP-Tutorial-php.cn

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

php教程实现文件数据缓存实现代码
缓存技术是每次访问页面的时候，都会先检测相应的缓存是否存在，如果不存在，就连接数据库教程，得到数据，完成模板变量的赋值，显示页面，同时生成缓存文件，这样下次访问的时候缓存文件就发挥作用了，而不会再执行if块的数据查询语句了。当然，在实际使用中会有很多东西要考虑，比如，有效期的设置，缓存组的设置等等

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 islocked($key)); // 最多做十次睡眠等待解锁，超时则跳过并解锁

        $this->islocked($key) && $this->unlock($key);

        return $this;
    }
}

/**
* apc扩展缓存实现
*
*
* @category   mjie
* @package    cache
* @author     流水孟春
* @copyright copyright (c) 2008-
* @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-
* @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文件，并以""开头
     *
     * @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文件，并以""开头
     *
     * @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, '
        return @file_put_contents($cachefile, '' . 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) {
        $cachefile = self::_getcachefile($key);
        @unlink($cachefile . '.lock');
        return

下面来看一款关于smarty缓存的文件实例代码

再来看看smarty提供的页面缓存功能：

　1

　　2require('smarty.class.php');

　　3$smarty = new smarty;

　　4$smarty->caching = true;

　　5if(!$smarty->is_cached('index.tpl')) {

　　6 // no cache available, do variable assignments here.

　　7 $contents = get_database_contents();

　　8 $smarty->assign($contents);

　　9}

　　10$smarty->display('index.tpl');

　　11?>

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