Heim >Backend-Entwicklung >PHP-Tutorial >PHP缓存技术实现_PHP教程

PHP缓存技术实现_PHP教程

WBOY
WBOYOriginal
2016-07-13 10:38:31921Durchsuche

发个PHP缓存实现,实现了apc和文件缓存,继承Cache_Abstract即可实现调用第三方的缓存工具。
参考shindig的缓存类和apc。
Php代码

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

www.bkjia.comtruehttp://www.bkjia.com/PHPjc/735086.htmlTechArticle发个PHP缓存实现,实现了apc和文件缓存,继承Cache_Abstract即可实现调用第三方的缓存工具。 参考shindig的缓存类和apc。 Php代码 ?php classCacheE...
Stellungnahme:
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn