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

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 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. ?>

复制代码