Community Learn Tools Library Leisure
search
English
Home > Backend Development > PHP Tutorial > Implementation code of apc and file cache classes in php

Implementation code of apc and file cache classes in php

WBOY
Release： 2016-07-25 08:57:16
Original
960 people have browsed it

  3. class CacheException extends Exception {}

  4. /**
  5. * Cache abstract class
  6. */
  7. abstract class Cache_Abstract {
  8. /**
  9. * Read cache variable
  10. *
  11. * @param string $key cache subscript
  12. * @return mixed
  13. */
  14. abstract public function fetch($key);

  15. /**

  16. * Cache variable
  17. *
  18. * @param string $key cache variable subscript
  19. * @param string $value cache variable value
  20. * @return bool
  21. */
  22. abstract public function store($key, $value);

  23. /**

  24. * Delete cache variables
  25. *
  26. * @param string $key cache subscript
  27. * @return Cache_Abstract
  28. */
  29. abstract public function delete($key);

  30. /**

  31. * Clear (delete) all caches
  32. *
  33. * @return Cache_Abstract
  34. */
  35. abstract public function clear();

  36. /**

  37. * Lock cache variable
  38. *
  39. * @param string $key cache subscript
  40. * @return Cache_Abstract
  41. */
  42. abstract public function lock($key);
  43. /**
  44. * Cache variable unlock
  45. *
  46. * @param string $key cache subscript
  47. * @return Cache_Abstract
  48. */
  49. abstract public function unlock($key);
  50. /**
  51. * Get whether the cache variable is locked
  52. *
  53. * @param string $key cache subscript
  54. * @return bool
  55. */
  56. abstract public function isLocked($key);
  57. /**
  58. * Make sure it is not locked
  59. * Sleep at most $tries times to wait for unlocking, skip and unlock after timeout
  60. *
  61. * @param string $key cache subscript
  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 extended cache implementation
  81. *
  82. * @by bbs.it-home.org
  83. * @category Mjie
  84. * @package Cache
  85. * @license New BSD License
  86. * @version $Id: Cache/Apc.php version number 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. * Save cache variables
  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. * Read cache
  107. *
  108. * @param string $key
  109. * @return mixed
  110. */
  111. public function fetch($key) {
  112. return apc_fetch($this->_storageKey($key));
  113. }

  114. /**

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

  123. /**

  124. * Delete cache unit
  125. *
  126. * @return Cache_Apc
  127. */
  128. public function delete($key) {
  129. apc_delete($this->_storageKey($key));
  130. return $this;
  131. }

  132. /**

  133. * Whether the cache unit is locked
  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. * Lock cache unit
  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. * Cache unit unlock
  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. *Full cache name
  167. *
  168. * @param string $key
  169. * @return string
  170. */
  171. private function _storageKey($key) {
  172. return $this->_prefix . '_' . $key;
  173. }
  174. }
  175. /**
  176. * File cache implementation
  177. *
  178. * @by bbs.it-home.org
  179. * @category Mjie
  180. * @package Cache
  181. * @license New BSD License
  182. * @version $Id: Cache/File.php version number 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. * Get cache file
  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. * Read cache variables
  202. * To prevent information leakage, the cache file format is a php file and starts with ""
  203. *
  204. * @param string $key cache subscript
  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. * Cache variable
  216. * To prevent information leakage, the cache file format is a php file and starts with ""
  217. *
  218. * @param string $key cache variable subscript
  219. * @param string $value The value of the cache variable
  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. * Delete cache variable
  234. *
  235. * @param string $key cache subscript
  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. * Whether the cache unit is locked
  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. * Lock
  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. * Unlock
  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. * Set the file cache directory
  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. * Clear all caches
  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. * Data structure of cache unit
  347. * array(
  348. * 'time' => time(), // Timestamp when cache is written
  349. * 'expire' => $expire, // Cache expiration time
  350. * 'valid' => true, // Whether the cache is valid
  351. * 'data' => $value // The cached value
  352. * );
  353. */
  354. final class Cache {
  355. /**
  356. * Cache expiration time length (s)
  357. *
  358. * @var int
  359. */
  360. private $_expire = 3600;
  361. /**
  362. * Cache processing class
  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. * Set cache
  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. * Read cache
  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. * Read the cache, including expired and invalid ones, to get the complete storage structure
  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. * Delete cache
  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. * Disable cache
  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. * Set cache expiration time (s)
  466. *
  467. * @param int $expire
  468. */
  469. public function setExpire($expire) {
  470. $this->_expire = (int) $expire;
  471. return $this;
  472. }
  473. }
  474. ?>

复制代码


Related labels：
php中apc和文件缓存类的实现代码
source：php.cn
Previous article：Implementation code of php enhanced mhash function Next article：PHP code to calculate specified folder information (number of folders, number of files, folder size)
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Latest Articles by Author
Latest Issues
Challenges when using window.location.href to redirect to a new page I'm having trouble redirecting to a local domain php file, I've got it ready to redirect t...
From 2024-04-04 12:57:06
0
1
446
What is the modern equivalent of LESS string-set For an example of string sets and their uses, see Using LESS String Set Properties and Con...
From 2024-04-02 13:29:36
0
1
361
How to make an image appear in the center of the header? First of all, my code is based on 3 files, an HTML, a CSS and a JS. It should be noted tha...
From 2024-04-01 23:49:58
0
1
372
Arrays in PHP: surprising results when adding new items So I'm writing code that allows me to collect images collected by the Instaloaderpython li...
From 2024-03-31 14:10:42
0
1
405
Related Topics
More>
Popular Recommendations
Popular Tutorials
More>
Related Tutorials
Popular Recommendations
Latest courses
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template