JAVA缓存的实现

缓存可分为二大类: 
一、通过文件缓存,顾名思义文件缓存是指把数据存储在磁盘上，不管你是以XML格式，序列化文件DAT格式还是其它文件格式；  
二、内存缓存，也就是实现一个类中静态Map,对这个Map进行常规的增删查. 
下面为一个简单的缓存代码 

Java代码  

1. package lhm.hcy.guge.frameset.cache;  
2.   
3. import java.util.*;  
4.   
5. /** 
6.  * <p>Title: </p> 
7.  * 
8.  * <p>Description: 管理缓存</p> 
9.  * Deep blue 2008-11-28 think 
10.  * 可扩展的功能：当chche到内存溢出时必须清除掉最早期的一些缓存对象，这就要求对每个缓存对象保存创建时间 
11.  * <p>Copyright: Copyright (c) 2008</p> 
12.  * 
13.  * <p>Company: </p> 
14.  * 
15.  * @author Deepblue  2008-11-11 
16.  * @version 1.0 
17.  */  
18. public class CacheManager {  
19.     private static HashMap cacheMap = new HashMap();  
20.   
21.     //单实例构造方法  
22.     private CacheManager() {  
23.         super();  
24.     }  
25.     //获取布尔值的缓存  
26.     public static boolean getSimpleFlag(String key){  
27.         try{  
28.             return (Boolean) cacheMap.get(key);  
29.         }catch(NullPointerException e){  
30.             return false;  
31.         }  
32.     }  
33.     public static long getServerStartdt(String key){  
34.         try {  
35.             return (Long)cacheMap.get(key);  
36.         } catch (Exception ex) {  
37.             return 0;  
38.         }  
39.     }  
40.     //设置布尔值的缓存  
41.     public synchronized static boolean setSimpleFlag(String key,boolean flag){  
42.         if (flag && getSimpleFlag(key)) {//假如为真不允许被覆盖  
43.             return false;  
44.         }else{  
45.             cacheMap.put(key, flag);  
46.             return true;  
47.         }  
48.     }  
49.     public synchronized static boolean setSimpleFlag(String key,long serverbegrundt){  
50.         if (cacheMap.get(key) == null) {  
51.             cacheMap.put(key,serverbegrundt);  
52.             return true;  
53.         }else{  
54.             return false;  
55.         }  
56.     }  
57.   
58.   
59.     //得到缓存。同步静态方法  
60.     private synchronized static Cache getCache(String key) {  
61.         return (Cache) cacheMap.get(key);  
62.     }  
63.   
64.     //判断是否存在一个缓存  
65.     private synchronized static boolean hasCache(String key) {  
66.         return cacheMap.containsKey(key);  
67.     }  
68.   
69.     //清除所有缓存  
70.     public synchronized static void clearAll() {  
71.         cacheMap.clear();  
72.     }  
73.   
74.     //清除某一类特定缓存,通过遍历HASHMAP下的所有对象，来判断它的KEY与传入的TYPE是否匹配  
75.     public synchronized static void clearAll(String type) {  
76.         Iterator i = cacheMap.entrySet().iterator();  
77.         String key;  
78.         ArrayList<String> arr = new ArrayList<String>();  
79.         try {  
80.             while (i.hasNext()) {  
81.                 java.util.Map.Entry entry = (java.util.Map.Entry) i.next();  
82.                 key = (String) entry.getKey();  
83.                 if (key.startsWith(type)) { //如果匹配则删除掉  
84.                     arr.add(key);  
85.                 }  
86.             }  
87.             for (int k = 0; k < arr.size(); k++) {  
88.                 clearOnly(arr.get(k));  
89.             }  
90.         } catch (Exception ex) {  
91.             ex.printStackTrace();  
92.         }  
93.     }  
94.   
95.     //清除指定的缓存  
96.     public synchronized static void clearOnly(String key) {  
97.         cacheMap.remove(key);  
98.     }  
99.   
100.     //载入缓存  
101.     public synchronized static void putCache(String key, Cache obj) {  
102.         cacheMap.put(key, obj);  
103.     }  
104.   
105.     //获取缓存信息  
106.     public static Cache getCacheInfo(String key) {  
107.   
108.         if (hasCache(key)) {  
109.             Cache cache = getCache(key);  
110.             if (cacheExpired(cache)) { //调用判断是否终止方法  
111.                 cache.setExpired(true);  
112.             }  
113.             return cache;  
114.         }else  
115.             return null;  
116.     }  
117.   
118.     //载入缓存信息  
119.     public static void putCacheInfo(String key, Cache obj, long dt,boolean expired) {  
120.         Cache cache = new Cache();  
121.         cache.setKey(key);  
122.         cache.setTimeOut(dt + System.currentTimeMillis()); //设置多久后更新缓存  
123.         cache.setValue(obj);  
124.         cache.setExpired(expired); //缓存默认载入时，终止状态为FALSE  
125.         cacheMap.put(key, cache);  
126.     }  
127.     //重写载入缓存信息方法  
128.     public static void putCacheInfo(String key,Cache obj,long dt){  
129.         Cache cache = new Cache();  
130.         cache.setKey(key);  
131.         cache.setTimeOut(dt+System.currentTimeMillis());  
132.         cache.setValue(obj);  
133.         cache.setExpired(false);  
134.         cacheMap.put(key,cache);  
135.     }  
136.   
137.     //判断缓存是否终止  
138.     public static boolean cacheExpired(Cache cache) {  
139.         if (null == cache) { //传入的缓存不存在  
140.             return false;  
141.         }  
142.         long nowDt = System.currentTimeMillis(); //系统当前的毫秒数  
143.         long cacheDt = cache.getTimeOut(); //缓存内的过期毫秒数  
144.         if (cacheDt <= 0||cacheDt>nowDt) { //过期时间小于等于零时,或者过期时间大于当前时间时，则为FALSE  
145.             return false;  
146.         } else { //大于过期时间 即过期  
147.             return true;  
148.         }  
149.     }  
150.   
151.     //获取缓存中的大小  
152.     public static int getCacheSize() {  
153.         return cacheMap.size();  
154.     }  
155.   
156.     //获取指定的类型的大小  
157.     public static int getCacheSize(String type) {  
158.         int k = 0;  
159.         Iterator i = cacheMap.entrySet().iterator();  
160.         String key;  
161.         try {  
162.             while (i.hasNext()) {  
163.                 java.util.Map.Entry entry = (java.util.Map.Entry) i.next();  
164.                 key = (String) entry.getKey();  
165.                 if (key.indexOf(type) != -1) { //如果匹配则删除掉  
166.                     k++;  
167.                 }  
168.             }  
169.         } catch (Exception ex) {  
170.             ex.printStackTrace();  
171.         }  
172.   
173.         return k;  
174.     }  
175.   
176.     //获取缓存对象中的所有键值名称  
177.     public static ArrayList<String> getCacheAllkey() {  
178.         ArrayList a = new ArrayList();  
179.         try {  
180.             Iterator i = cacheMap.entrySet().iterator();  
181.             while (i.hasNext()) {  
182.                 java.util.Map.Entry entry = (java.util.Map.Entry) i.next();  
183.                 a.add((String) entry.getKey());  
184.             }  
185.         } catch (Exception ex) {} finally {  
186.             return a;  
187.         }  
188.     }  
189.   
190.     //获取缓存对象中指定类型 的键值名称  
191.     public static ArrayList<String> getCacheListkey(String type) {  
192.         ArrayList a = new ArrayList();  
193.         String key;  
194.         try {  
195.             Iterator i = cacheMap.entrySet().iterator();  
196.             while (i.hasNext()) {  
197.                 java.util.Map.Entry entry = (java.util.Map.Entry) i.next();  
198.                 key = (String) entry.getKey();  
199.                 if (key.indexOf(type) != -1) {  
200.                     a.add(key);  
201.                 }  
202.             }  
203.         } catch (Exception ex) {} finally {  
204.             return a;  
205.         }  
206.     }  
207.   
208. }  
209.   
210.   
211. package lhm.hcy.guge.frameset.cache;  
212.   
213. /** 
214.  * <p>Title: </p> 
215.  * 
216.  * <p>Description: 缓存DTO</p> 
217.  * 
218.  * <p>Copyright: Copyright (c) 2008</p> 
219.  * 
220.  * <p>Company: </p> 
221.  * 
222.  * @author Deepblue  2008-11-11 
223.  * @version 1.0 
224.  */  
225. public class Cache {  
226.         private String key;//缓存ID  
227.         private Object value;//缓存数据  
228.         private long timeOut;//更新时间  
229.         private boolean expired; //是否终止  
230.         public Cache() {  
231.                 super();  
232.         }  
233.   
234.         public Cache(String key, Object value, long timeOut, boolean expired) {  
235.                 this.key = key;  
236.                 this.value = value;  
237.                 this.timeOut = timeOut;  
238.                 this.expired = expired;  
239.         }  
240.   
241.         public String getKey() {  
242.                 return key;  
243.         }  
244.   
245.         public long getTimeOut() {  
246.                 return timeOut;  
247.         }  
248.   
249.         public Object getValue() {  
250.                 return value;  
251.         }  
252.   
253.         public void setKey(String string) {  
254.                 key = string;  
255.         }  
256.   
257.         public void setTimeOut(long l) {  
258.                 timeOut = l;  
259.         }  
260.   
261.         public void setValue(Object object) {  
262.                 value = object;  
263.         }  
264.   
265.         public boolean isExpired() {  
266.                 return expired;  
267.         }  
268.   
269.         public void setExpired(boolean b) {  
270.                 expired = b;  
271.         }  
272. }  
273.   
274. //测试类，  
275. class Test {  
276.     public static void main(String[] args) {  
277.         System.out.println(CacheManager.getSimpleFlag("alksd"));  
278. //        CacheManager.putCache("abc", new Cache());  
279. //        CacheManager.putCache("def", new Cache());  
280. //        CacheManager.putCache("ccc", new Cache());  
281. //        CacheManager.clearOnly("");  
282. //        Cache c = new Cache();  
283. //        for (int i = 0; i < 10; i++) {  
284. //            CacheManager.putCache("" + i, c);  
285. //        }  
286. //        CacheManager.putCache("aaaaaaaa", c);  
287. //        CacheManager.putCache("abchcy;alskd", c);  
288. //        CacheManager.putCache("cccccccc", c);  
289. //        CacheManager.putCache("abcoqiwhcy", c);  
290. //        System.out.println("删除前的大小："+CacheManager.getCacheSize());  
291. //        CacheManager.getCacheAllkey();  
292. //        CacheManager.clearAll("aaaa");  
293. //        System.out.println("删除后的大小："+CacheManager.getCacheSize());  
294. //        CacheManager.getCacheAllkey();  
295.   
296.   
297.     }  
298. }