缓存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.}