当前位置：Gxlcms > PHP教程 > php中apc和文件缓存类的实现代码

php中apc和文件缓存类的实现代码

时间：2021-07-01 10:21:17 帮助过：2人阅读

  3. class CacheException extends Exception {}

  4. /**
  5. * 缓存抽象类
  6. */
  7. abstract class Cache_Abstract {
  8. /**
  9. * 读缓存变量
  10. *
  11. * @param string $key 缓存下标
  12. * @return mixed
  13. */
  14. abstract public function fetch($key);

  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. * @param string $key 缓存下标
  27. * @return Cache_Abstract
  28. */
  29. abstract public function delete($key);

  30. /**

  31. * 清(删)除所有缓存
  32. *
  33. * @return Cache_Abstract
  34. */
  35. abstract public function clear();

  36. /**

  37. * 锁定缓存变量
  38. *
  39. * @param string $key 缓存下标
  40. * @return Cache_Abstract
  41. */
  42. abstract public function lock($key);
  43. /**
  44. * 缓存变量解锁
  45. *
  46. * @param string $key 缓存下标
  47. * @return Cache_Abstract
  48. */
  49. abstract public function unlock($key);
  50. /**
  51. * 取得缓存变量是否被锁定
  52. *
  53. * @param string $key 缓存下标
  54. * @return bool
  55. */
  56. abstract public function isLocked($key);
  57. /**
  58. * 确保不是锁定状态
  59. * 最多做$tries次睡眠等待解锁，超时则跳过并解锁
  60. *
  61. * @param string $key 缓存下标
  62. */
  63. public function checkLock($key) {
  64. if (!$this->isLocked($key)) {
  65. return $this;
  66. }
  68. $tries = 10;
  69. $count = 0;
  70. do {
  71. usleep(200);
  72. $count ++;
  73. } while ($count <= $tries && $this->isLocked($key)); // 最多做十次睡眠等待解锁，超时则跳过并解锁
  74. $this->isLocked($key) && $this->unlock($key);
  76. return $this;
  77. }
  78. }

  79. /**

  80. * APC扩展缓存实现
  81. *
  82. * @by bbs.it-home.org
  83. * @category Mjie
  84. * @package Cache
  85. * @license New BSD License
  86. * @version $Id: Cache/Apc.php 版本号 2010-04-18 23:02 cmpan $
  87. */
  88. class Cache_Apc extends Cache_Abstract {

  89. protected $_prefix = 'cache.mjie.net';

  90. public function __construct() {

  91. if (!function_exists('apc_cache_info')) {
  92. throw new CacheException('apc extension didn\'t installed');
  93. }
  94. }

  95. /**

  96. * 保存缓存变量
  97. *
  98. * @param string $key
  99. * @param mixed $value
  100. * @return bool
  101. */
  102. public function store($key, $value) {
  103. return apc_store($this->_storageKey($key), $value);
  104. }

  105. /**

  106. * 读取缓存
  107. *
  108. * @param string $key
  109. * @return mixed
  110. */
  111. public function fetch($key) {
  112. return apc_fetch($this->_storageKey($key));
  113. }

  114. /**

  115. * 清除缓存
  116. *
  117. * @return Cache_Apc
  118. */
  119. public function clear() {
  120. apc_clear_cache();
  121. return $this;
  122. }

  123. /**

  124. * 删除缓存单元
  125. *
  126. * @return Cache_Apc
  127. */
  128. public function delete($key) {
  129. apc_delete($this->_storageKey($key));
  130. return $this;
  131. }

  132. /**

  133. * 缓存单元是否被锁定
  134. *
  135. * @param string $key
  136. * @return bool
  137. */
  138. public function isLocked($key) {
  139. if ((apc_fetch($this->_storageKey($key) . '.lock')) === false) {
  140. return false;
  141. }
  143. return true;
  144. }

  145. /**

  146. * 锁定缓存单元
  147. *
  148. * @param string $key
  149. * @return Cache_Apc
  150. */
  151. public function lock($key) {
  152. apc_store($this->_storageKey($key) . '.lock', '', 5);
  153. return $this;
  154. }

  155. /**

  156. * 缓存单元解锁
  157. *
  158. * @param string $key
  159. * @return Cache_Apc
  160. */
  161. public function unlock($key) {
  162. apc_delete($this->_storageKey($key) . '.lock');
  163. return $this;
  164. }

  165. /**

  166. * 完整缓存名
  167. *
  168. * @param string $key
  169. * @return string
  170. */
  171. private function _storageKey($key) {
  172. return $this->_prefix . '_' . $key;
  173. }
  174. }
  175. /**
  176. * 文件缓存实现
  177. *
  178. * @by bbs.it-home.org
  179. * @category Mjie
  180. * @package Cache
  181. * @license New BSD License
  182. * @version $Id: Cache/File.php 版本号 2010-04-18 16:46 cmpan $
  183. */
  184. class Cache_File extends Cache_Abstract {

  185. protected $_cachesDir = 'cache';

  186. public function __construct() {

  187. if (defined('DATA_DIR')) {
  188. $this->_setCacheDir(DATA_DIR . '/cache');
  189. }
  190. }

  191. /**

  192. * 获取缓存文件
  193. *
  194. * @param string $key
  195. * @return string
  196. */
  197. protected function _getCacheFile($key) {
  198. return $this->_cachesDir . '/' . substr($key, 0, 2) . '/' . $key . '.php';
  199. }
  200. /**
  201. * 读取缓存变量
  202. * 为防止信息泄露，缓存文件格式为php文件，并以""开头
  203. *
  204. * @param string $key 缓存下标
  205. * @return mixed
  206. */
  207. public function fetch($key) {
  208. $cacheFile = self::_getCacheFile($key);
  209. if (file_exists($cacheFile) && is_readable($cacheFile)) {
  210. return unserialize(@file_get_contents($cacheFile, false, NULL, 13));
  211. }
  212. return false;
  213. }
  214. /**
  215. * 缓存变量
  216. * 为防止信息泄露，缓存文件格式为php文件，并以""开头
  217. *
  218. * @param string $key 缓存变量下标
  219. * @param string $value 缓存变量的值
  220. * @return bool
  221. */
  222. public function store($key, $value) {
  223. $cacheFile = self::_getCacheFile($key);
  224. $cacheDir = dirname($cacheFile);
  225. if(!is_dir($cacheDir)) {
  226. if([url=mailto:!@mkdir($cacheDir]!@mkdir($cacheDir[/url], 0755, true)) {
  227. throw new CacheException("Could not make cache directory");
  228. }
  229. }
  230. return @file_put_contents($cacheFile, '' . serialize($value));
  231. }
  232. /**
  233. * 删除缓存变量
  234. *
  235. * @param string $key 缓存下标
  236. * @return Cache_File
  237. */
  238. public function delete($key) {
  239. if(empty($key)) {
  240. throw new CacheException("Missing argument 1 for Cache_File::delete()");
  241. }
  243. $cacheFile = self::_getCacheFile($key);
  244. if([url=mailto:!@unlink($cacheFile]!@unlink($cacheFile[/url])) {
  245. throw new CacheException("Cache file could not be deleted");
  246. }
  247. return $this;
  248. }
  249. /**
  250. * 缓存单元是否已经锁定
  251. *
  252. * @param string $key
  253. * @return bool
  254. */
  255. public function isLocked($key) {
  256. $cacheFile = self::_getCacheFile($key);
  257. clearstatcache();
  258. return file_exists($cacheFile . '.lock');
  259. }
  260. /**
  261. * 锁定
  262. *
  263. * @param string $key
  264. * @return Cache_File
  265. */
  266. public function lock($key) {
  267. $cacheFile = self::_getCacheFile($key);
  268. $cacheDir = dirname($cacheFile);
  269. if(!is_dir($cacheDir)) {
  270. if([url=mailto:!@mkdir($cacheDir]!@mkdir($cacheDir[/url], 0755, true)) {
  271. if(!is_dir($cacheDir)) {
  272. throw new CacheException("Could not make cache directory");
  273. }
  274. }
  275. }
  276. // 设定缓存锁文件的访问和修改时间
  277. @touch($cacheFile . '.lock');
  278. return $this;
  279. }
  281. /**
  282. * 解锁
  283. *
  284. * @param string $key
  285. * @return Cache_File
  286. */
  287. public function unlock($key) {
  288. $cacheFile = self::_getCacheFile($key);
  289. @unlink($cacheFile . '.lock');
  290. return $this;
  291. }
  292. /**
  293. * 设置文件缓存目录
  294. * @param string $dir
  295. * @return Cache_File
  296. */
  297. protected function _setCacheDir($dir) {
  298. $this->_cachesDir = rtrim(str_replace('\\', '/', trim($dir)), '/');
  299. clearstatcache();
  300. if(!is_dir($this->_cachesDir)) {
  301. mkdir($this->_cachesDir, 0755, true);
  302. }
  303. //
  304. return $this;
  305. }
  307. /**
  308. * 清空所有缓存
  309. *
  310. * @return Cache_File
  311. */
  312. public function clear() {
  313. // 遍历目录清除缓存
  314. $cacheDir = $this->_cachesDir;
  315. $d = dir($cacheDir);
  316. while(false !== ($entry = $d->read())) {
  317. if('.' == $entry[0]) {
  318. continue;
  319. }
  321. $cacheEntry = $cacheDir . '/' . $entry;
  322. if(is_file($cacheEntry)) {
  323. @unlink($cacheEntry);
  324. } elseif(is_dir($cacheEntry)) {
  325. // 缓存文件夹有两级
  326. $d2 = dir($cacheEntry);
  327. while(false !== ($entry = $d2->read())) {
  328. if('.' == $entry[0]) {
  329. continue;
  330. }
  332. $cacheEntry .= '/' . $entry;
  333. if(is_file($cacheEntry)) {
  334. @unlink($cacheEntry);
  335. }
  336. }
  337. $d2->close();
  338. }
  339. }
  340. $d->close();
  342. return $this;
  343. }
  344. }
  345. /**
  346. * 缓存单元的数据结构
  347. * array(
  348. * 'time' => time(), // 缓存写入时的时间戳
  349. * 'expire' => $expire, // 缓存过期时间
  350. * 'valid' => true, // 缓存是否有效
  351. * 'data' => $value // 缓存的值
  352. * );
  353. */
  354. final class Cache {
  355. /**
  356. * 缓存过期时间长度(s)
  357. *
  358. * @var int
  359. */
  360. private $_expire = 3600;
  361. /**
  362. * 缓存处理类
  363. *
  364. * @var Cache_Abstract
  365. */
  366. private $_storage = null;
  367. /**
  368. * @return Cache
  369. */
  370. static public function createCache($cacheClass = 'Cache_File') {
  371. return new self($cacheClass);
  372. }
  373. private function __construct($cacheClass) {
  374. $this->_storage = new $cacheClass();
  375. }
  376. /**
  377. * 设置缓存
  378. *
  379. * @param string $key
  380. * @param mixed $value
  381. * @param int $expire
  382. */
  383. public function set($key, $value, $expire = false) {
  384. if (!$expire) {
  385. $expire = $this->_expire;
  386. }
  388. $this->_storage->checkLock($key);
  390. $data = array('time' => time(), 'expire' => $expire, 'valid' => true, 'data' => $value);
  391. $this->_storage->lock($key);
  393. try {
  394. $this->_storage->store($key, $data);
  395. $this->_storage->unlock($key);
  396. } catch (CacheException $e) {
  397. $this->_storage->unlock($key);
  398. throw $e;
  399. }
  400. }
  401. /**
  402. * 读取缓存
  403. *
  404. * @param string $key
  405. * @return mixed
  406. */
  407. public function get($key) {
  408. $data = $this->fetch($key);
  409. if ($data && $data['valid'] && !$data['isExpired']) {
  410. return $data['data'];
  411. }
  413. return false;
  414. }
  415. /**
  416. * 读缓存，包括过期的和无效的，取得完整的存贮结构
  417. *
  418. * @param string $key
  419. */
  420. public function fetch($key) {
  421. $this->_storage->checkLock($key);
  422. $data = $this->_storage->fetch($key);
  423. if ($data) {
  424. $data['isExpired'] = (time() - $data['time']) > $data['expire'] ? true : false;
  425. return $data;
  426. }
  428. return false;
  429. }
  430. /**
  431. * 删除缓存
  432. *
  433. * @param string $key
  434. */
  435. public function delete($key) {
  436. $this->_storage->checkLock($key)
  437. ->lock($key)
  438. ->delete($key)
  439. ->unlock($key);
  440. }

  441. public function clear() {

  442. $this->_storage->clear();
  443. }
  444. /**
  445. * 把缓存设为无效
  446. *
  447. * @param string $key
  448. */
  449. public function setInvalidate($key) {
  450. $this->_storage->checkLock($key)
  451. ->lock($key);
  452. try {
  453. $data = $this->_storage->fetch($key);
  454. if ($data) {
  455. $data['valid'] = false;
  456. $this->_storage->store($key, $data);
  457. }
  458. $this->_storage->unlock($key);
  459. } catch (CacheException $e) {
  460. $this->_storage->unlock($key);
  461. throw $e;
  462. }
  463. }

  464. /**

  465. * 设置缓存过期时间（s）
  466. *
  467. * @param int $expire
  468. */
  469. public function setExpire($expire) {
  470. $this->_expire = (int) $expire;
  471. return $this;
  472. }
  473. }
  474. ?>

人气教程排行

本站所有资源全部来源于网络，若本站发布的内容侵害到您的隐私或者利益，请联系我们删除！