PHP caching technology implementation_PHP tutorial

Send me a PHP cache implementation that implements apc and file caching. By inheriting Cache_Abstract, you can call third-party caching tools.
Refer to shindig's cache class and apc.
Php code

2. class CacheException extends Exception {}  
3. /**
4. * Cache abstract class
5. ​*/  
6. abstract class Cache_Abstract {  
7.     /**
8. * Read cache variables
9. * *
10. * @param string $key cache index
11. * @return mixed
12. ​​*/  
13.     abstract public function fetch($key);  
14.       
15.     /**
16. * Cache variables
17. * *
18. * @param string $key cache variable subscript
19. * @param string $value The value of the cache variable
20. * @return bool
21. ​​*/  
22.     abstract public function store($key, $value);  
23.       
24.     /**
25. * Delete cache variables
26. * *
27. * @param string $key cache index
28. * @return Cache_Abstract
29. ​​*/  
30.     abstract public function delete($key);  
31.       
32.     /**
33. * Clear (delete) all caches
34. * *
35. * @return Cache_Abstract
36. ​​*/  
37.     abstract public function clear();  
38.       
39.     /**
40. * Lock cache variables
41. * *
42. * @param string $key cache index
43. * @return Cache_Abstract
44. ​​*/  
45.     abstract public function lock($key);  
46.   
47.     /**
48. * Cache variable unlocking
49. * *
50. * @param string $key cache index
51. * @return Cache_Abstract
52. ​​*/  
53.     abstract public function unlock($key);  
54.   
55.     /**
56. * Get whether the cache variable is locked
57. * *
58. * @param string $key cache index
59. * @return bool
60. ​​*/  
61.     abstract public function isLocked($key);  
62.   
63.     /**
64. * Make sure it is not locked
65. * * Sleep at most $tries times to wait for unlocking, skip and unlock when timeout
66. * *
67. * @param string $key cache index
68. ​​*/  
69.     public function checkLock($key) {  
70. If (!$this->isLocked($key)) {
71. Return $this;
           } 
                                                                        
73. $tries = 10;
74.         $count = 0;                                        
do {
usleep(200);
                   $count ++;                                          
77.                                                                                                                                                    
           $this->isLocked($key) && $this->unlock($key); 
                                                                        
80.          return $this;                                  
}  
}
/**
* APC extended cache implementation
*
*
* @category Mjie
* @package Cache
* @author Liushui Mengchun
* @copyright Copyright (c) 2008-
* @license New BSD License
* @version $Id: Cache/Apc.php version number 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');
           } 
}  
         
/**
* * Save cache variables
* *
* @param string $key
* @param mixed $value
* @return bool
​​*/
Public function store($key, $value) {
          return apc_store($this->_storageKey($key), $value);
}  
         
/**
* Read cache
* *
* @param string $key
* @return mixed
​​*/
Public function fetch($key) {
          return apc_fetch($this->_storageKey($key)); 
}  
125.       
126.     /**
127. * Clear cache
128. * *
129. * @return Cache_Apc
130. ​​*/  
131.     public function clear() {  
132.         apc_clear_cache();  
133.         return $this;  
134.     }  
135.       
136.     /**
137. * Delete cache unit
138. * *
139. * @return Cache_Apc
140. ​​*/  
141.     public function delete($key) {  
142.         apc_delete($this->_storageKey($key));  
143.         return $this;  
144.     }  
145.       
146.     /**
147. * Whether the cache unit is locked
148. * *
149. * @param string $key
150. * @return bool
151. ​​*/  
152.     public function isLocked($key) {  
153.         if ((apc_fetch($this->_storageKey($key) . '.lock')) === false) {  
154.             return false;  
155.         }  
156.           
157.         return true;  
158.     }  
159.       
160.     /**
161. * Lock cache unit
162. * *
163. * @param string $key
164. * @return Cache_Apc
165. ​​*/  
166.     public function lock($key) {  
167.         apc_store($this->_storageKey($key) . '.lock', '', 5);  
168.         return $this;  
169.     }  
170.       
171.     /**
172. * Cache unit unlocked
173. * *
174. * @param string $key
175. * @return Cache_Apc
176. ​​*/  
177.     public function unlock($key) {  
178.         apc_delete($this->_storageKey($key) . '.lock');  
179.         return $this;  
180.     }  
181.       
182.     /**
183. * Full cache name
184. * *
185. * @param string $key
186. * @return string
187. ​​*/  
188.     private function _storageKey($key) {  
189.         return $this->_prefix . '_' . $key;  
190.     }  
191. }  
192.   
193. /**
194. * File cache implementation
195. *
196. *
197. * @category Mjie
198. * @package Cache
199. * @author Liushui Mengchun
200. * @copyright Copyright (c) 2008-
201. * @license New BSD License
202. * @version $Id: Cache/File.php version number 2010-04-18 16:46 cmpan $
203. ​*/  
204. class Cache_File extends Cache_Abstract {  
205.     public $useSubdir     = false;  
206.       
207.     protected $_cachesDir = 'cache';  
208.       
209.     public function __construct() {  
210.         if (defined('DATA_DIR')) {  
211.             $this->_setCacheDir(DATA_DIR . '/cache');  
212.         }  
213.     }  
214.       
215.     /**
216. * Get cache files
217. * *
218. * @param string $key
219. * @return string
220. ​​*/  
221.     protected function _getCacheFile($key) {  
222.         $subdir = $this->useSubdir ? substr($key, 0, 2) . '/' : '';  
223.         return $this->_cachesDir . '/' . $subdir . $key . '.php';  
224.     }  
225.   
226.     /**
227. * Read cache variables
228. * To prevent information leakage, the cache file format is a php file and starts with ""
229. * *
230. * @param string $key cache index
231. * @return mixed
232. ​​*/  
233.     public function fetch($key) {  
234.         $cacheFile = self::_getCacheFile($key);  
235.         if (file_exists($cacheFile) && is_readable($cacheFile)) {  
236.             // include 方式  
237.             //return include $cacheFile;  
238.             // 系列化方式  
239.   
240.             return unserialize(@file_get_contents($cacheFile, false, NULL, 13));  
241.         }  
242.   
243.         return false;  
244.     }  
245.   
246.     /**
247. * Cache variables
248. * To prevent information leakage, the cache file format is a php file and starts with ""
249. * *
250. * @param string $key cache variable subscript
251. * @param string $value The value of the cache variable
252. * @return bool
253. ​​*/  
254.     public function store($key, $value) {  
255.         $cacheFile = self::_getCacheFile($key);  
256.         $cacheDir  = dirname($cacheFile);  
257.   
258.         if(!is_dir($cacheDir)) {  
259.             if(!@mkdir($cacheDir, 0755, true)) {  
260.                 throw new CacheException("Could not make cache directory");  
261.             }  
262.         }  
263.     // 用include方式  
264.         //return @file_put_contents($cacheFile, '
265.   
266.         return @file_put_contents($cacheFile, '' . serialize($value));  
267.     }  
268.   
269.     /**
270. * Delete cache variables
271. * *
272. * @param string $key cache index
273. * @return Cache_File
274. ​​*/  
275.     public function delete($key) {  
276.         if(emptyempty($key)) {  
277.             throw new CacheException("Missing argument 1 for Cache_File::delete()");  
278.         }  
279.           
280.         $cacheFile = self::_getCacheFile($key);  
281.         if(!@unlink($cacheFile)) {  
282.             throw new CacheException("Cache file could not be deleted");  
283.         }  
284.   
285.         return $this;  
286.     }  
287.   
288.     /**
289. * Whether the cache unit has been locked
290. * *
291. * @param string $key
292. * @return bool
293. ​​*/  
294.     public function isLocked($key) {  
295.         $cacheFile = self::_getCacheFile($key);  
296.         clearstatcache();  
297.         return file_exists($cacheFile . '.lock');  
298.     }  
299.   
300.     /** 
301.      * 锁定 
302.      * 
303.      * @param string $key 
304.      * @return Cache_File 
305.      */  
306.     public function lock($key) {  
307.         $cacheFile = self::_getCacheFile($key);  
308.         $cacheDir  = dirname($cacheFile);  
309.         if(!is_dir($cacheDir)) {  
310.             if(!@mkdir($cacheDir, 0755, true)) {  
311.                 if(!is_dir($cacheDir)) {  
312.                     throw new CacheException("Could not make cache directory");  
313.                 }  
314.             }  
315.         }  
316.   
317.         // 设定缓存锁文件的访问和修改时间  
318.         @touch($cacheFile . '.lock');  
319.         return $this;  
320.     }
321.  
322. /** 
323.      * 解锁 
324.      * 
325.      * @param string $key 
326.      * @return Cache_File 
327.      */
328. Public function unlock($key) {
329.          $cacheFile = self::_getCacheFile($key);
330.           @unlink($cacheFile . '.lock');
331.         return 

http://www.bkjia.com/PHPjc/735086.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/735086.htmlTechArticleSend a PHP cache implementation, which implements apc and file caching. By inheriting Cache_Abstract, you can call third-party caching tools. . Refer to shindig's cache class and apc. Php code ?php classCacheE...