常用缓存Cache机制的实现

http://s9.51cto.com/wyfs02/M02/4D/B8/wKiom1RYPOTQNg_TAABhiu7QyrQ667.jpg-wh_651x-s_3000583049.jpg

Cache

所谓缓存，就是将程序或系统经常要调用的对象存在内存中，一遍其使用时可以快速调用，不必再去创建新的重复的实例。这样做可以减少系统开销，提高系统效率。

缓存主要可分为二大类:

一、通过文件缓存,顾名思义文件缓存是指把数据存储在磁盘上，不管你是以XML格式，序列化文件DAT格式还是其它文件格式； 

二、内存缓存，也就是实现一个类中静态Map,对这个Map进行常规的增删查.

代码如下 ：

1. package lhm.hcy.guge.frameset.cache; 
2. import java.util.*; 
3.  //Description: 管理缓存 
4.  //可扩展的功能：当chche到内存溢出时必须清除掉最早期的一些缓存对象，这就要求对每个缓存对象保存创建时间 
5. public class CacheManager { 
6.     private static HashMap cacheMap = new HashMap(); 
7.     //单实例构造方法 
8.     private CacheManager() { 
9.         super(); 
10.     } 
11.     //获取布尔值的缓存 
12.     public static boolean getSimpleFlag(String key){ 
13.         try{ 
14.             return (Boolean) cacheMap.get(key); 
15.         }catch(NullPointerException e){ 
16.             return false; 
17.         } 
19.     public static long getServerStartdt(String key){ 
20.         try { 
21.             return (Long)cacheMap.get(key); 
22.         } catch (Exception ex) { 
23.             return 0; 
26.     //设置布尔值的缓存 
27.     public synchronized static boolean setSimpleFlag(String key,boolean flag){ 
28.         if (flag && getSimpleFlag(key)) {//假如为真不允许被覆盖 
30.         }else{ 
31.             cacheMap.put(key, flag); 
32.             return true; 
35.     public synchronized static boolean setSimpleFlag(String key,long serverbegrundt){ 
36.         if (cacheMap.get(key) == null) { 
37.             cacheMap.put(key,serverbegrundt); 
43.     //得到缓存。同步静态方法 
44.     private synchronized static Cache getCache(String key) { 
45.         return (Cache) cacheMap.get(key); 
47.     //判断是否存在一个缓存 
48.     private synchronized static boolean hasCache(String key) { 
49.         return cacheMap.containsKey(key); 
51.     //清除所有缓存 
52.     public synchronized static void clearAll() { 
53.         cacheMap.clear(); 
55.     //清除某一类特定缓存,通过遍历HASHMAP下的所有对象，来判断它的KEY与传入的TYPE是否匹配 
56.     public synchronized static void clearAll(String type) { 
57.         Iterator i = cacheMap.entrySet().iterator(); 
58.         String key; 
59.         ArrayList arr = new ArrayList(); 
61.             while (i.hasNext()) { 
62.                 java.util.Map.Entry entry = (java.util.Map.Entry) i.next(); 
63.                 key = (String) entry.getKey(); 
64.                 if (key.startsWith(type)) { //如果匹配则删除掉 
65.                     arr.add(key); 
66.                 } 
67.             } 
68.             for (int k = 0; k < arr.size(); k++) { 
69.                 clearOnly(arr.get(k)); 
72.             ex.printStackTrace(); 
75.     //清除指定的缓存 
76.     public synchronized static void clearOnly(String key) { 
77.         cacheMap.remove(key); 
79.     //载入缓存 
80.     public synchronized static void putCache(String key, Cache obj) { 
81.         cacheMap.put(key, obj); 
83.     //获取缓存信息 
84.     public static Cache getCacheInfo(String key) { 
85.         if (hasCache(key)) { 
86.             Cache cache = getCache(key); 
87.             if (cacheExpired(cache)) { //调用判断是否终止方法 
88.                 cache.setExpired(true); 
90.             return cache; 
91.         }else 
92.             return null; 
94.     //载入缓存信息 
95.     public static void putCacheInfo(String key, Cache obj, long dt,boolean expired) { 
96.         Cache cache = new Cache(); 
97.         cache.setKey(key); 
98.         cache.setTimeOut(dt + System.currentTimeMillis()); //设置多久后更新缓存 
99.         cache.setValue(obj); 
100.         cache.setExpired(expired); //缓存默认载入时，终止状态为FALSE 
101.         cacheMap.put(key, cache); 
103.     //重写载入缓存信息方法 
104.     public static void putCacheInfo(String key,Cache obj,long dt){ 
107.         cache.setTimeOut(dt+System.currentTimeMillis()); 
109.         cache.setExpired(false); 
110.         cacheMap.put(key,cache); 
112.     //判断缓存是否终止 
113.     public static boolean cacheExpired(Cache cache) { 
114.         if (null == cache) { //传入的缓存不存在 
117.         long nowDt = System.currentTimeMillis(); //系统当前的毫秒数 
118.         long cacheDt = cache.getTimeOut(); //缓存内的过期毫秒数 
119.         if (cacheDt <= 0||cacheDt>nowDt) { //过期时间小于等于零时,或者过期时间大于当前时间时，则为FALSE 
121.         } else { //大于过期时间 即过期 
125.     //获取缓存中的大小 
126.     public static int getCacheSize() { 
127.         return cacheMap.size(); 
129.     //获取指定的类型的大小 
130.     public static int getCacheSize(String type) { 
131.         int k = 0; 
138.                 if (key.indexOf(type) != -1) { //如果匹配则删除掉 
139.                     k++; 
145.         return k; 
147.     //获取缓存对象中的所有键值名称 
148.     public static ArrayList getCacheAllkey() { 
149.         ArrayList a = new ArrayList(); 
151.             Iterator i = cacheMap.entrySet().iterator(); 
154.                 a.add((String) entry.getKey()); 
156.         } catch (Exception ex) {} finally { 
157.             return a; 
160.     //获取缓存对象中指定类型 的键值名称 
161.     public static ArrayList getCacheListkey(String type) { 
169.                 if (key.indexOf(type) != -1) { 
170.                     a.add(key); 
177. } 
179. public class Cache { 
180.         private String key;//缓存ID 
181.         private Object value;//缓存数据 
182.         private long timeOut;//更新时间 
183.         private boolean expired; //是否终止 
184.         public Cache() { 
185.                 super(); 
187.         public Cache(String key, Object value, long timeOut, boolean expired) { 
188.                 this.key = key; 
189.                 this.value = value; 
190.                 this.timeOut = timeOut; 
191.                 this.expired = expired; 
193.         public String getKey() { 
194.                 return key; 
196.         public long getTimeOut() { 
197.                 return timeOut; 
199.         public Object getValue() { 
200.                 return value; 
202.         public void setKey(String string) { 
203.                 key = string; 
205.         public void setTimeOut(long l) { 
206.                 timeOut = l; 
208.         public void setValue(Object object) { 
209.                 value = object; 
211.         public boolean isExpired() { 
212.                 return expired; 
214.         public void setExpired(boolean b) { 
215.                 expired = b; 
218. //测试类， 
219. class Test { 
220.     public static void main(String[] args) { 
221.         System.out.println(CacheManager.getSimpleFlag("alksd")); 
222. //        CacheManager.putCache("abc", new Cache()); 
223. //        CacheManager.putCache("def", new Cache()); 
224. //        CacheManager.putCache("ccc", new Cache()); 
225. //        CacheManager.clearOnly(""); 
226. //        Cache c = new Cache(); 
227. //        for (int i = 0; i < 10; i++) { 
228. //            CacheManager.putCache("" + i, c); 
229. //        } 
230. //        CacheManager.putCache("aaaaaaaa", c); 
231. //        CacheManager.putCache("abchcy;alskd", c); 
232. //        CacheManager.putCache("cccccccc", c); 
233. //        CacheManager.putCache("abcoqiwhcy", c); 
234. //        System.out.println("删除前的大小："+CacheManager.getCacheSize()); 
235. //        CacheManager.getCacheAllkey(); 
236. //        CacheManager.clearAll("aaaa"); 
237. //        System.out.println("删除后的大小："+CacheManager.getCacheSize());