服务器之家：专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|JAVA教程|ASP教程|

服务器之家 - 编程语言 - JAVA教程 - Java中常用缓存Cache机制的实现

Java中常用缓存Cache机制的实现

2020-06-28 11:56杜瑞祺 JAVA教程

这篇文章主要介绍了Java中常用缓存Cache机制的实现代码,具有一定的参考价值，感兴趣的小伙伴们可以参考一下

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

缓存主要可分为二大类:   

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

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

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

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。

  • Java
  • 缓存
  • Cache

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    501 　 2000 　 1433 　 415 　 内存卡 　 随机抽取 　 选择排序法 　 对象池模式 　 子线程 　 下载器 　 十六进制字符 　 响应 　 静态工厂 　 构造函数 　 swt 　 Overview 　 短信猫 　 作业调度 　 空心菱形 　 htmlparser 　 支票 　 金额大写转换 　 终止循环体 　 AspectJ 　 面向切面编程 　 方法名 　 网址信息 　 动态代理模式 　 线程安全 　 && 　
    © 2019-2020 服务器之家 版权所有 www.zzvips.com 关于我们联系我们版权申明网站地图