缓存可分为二大类:
一、通过文件缓存,顾名思义文件缓存是指把数据存储在磁盘上,不管你是以XML格式,序列化文件DAT格式还是其它文件格式;
二、内存缓存,也就是实现一个类中静态Map,对这个Map进行常规的增删查.
下面为一个简单的缓存代码
- package lhm.hcy.guge.frameset.cache;
- import java.util.*;
- /**
- * <p>Title: </p>
- *
- * <p>Description: 管理缓存</p>
- * Deep blue 2008-11-28 think
- * 可扩展的功能:当chche到内存溢出时必须清除掉最早期的一些缓存对象,这就要求对每个缓存对象保存创建时间
- * <p>Copyright: Copyright (c) 2008</p>
- *
- * <p>Company: </p>
- *
- * @author Deepblue 2008-11-11
- * @version 1.0
- */
- 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<String> arr = new ArrayList<String>();
- 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<String> 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<String> 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;
- /**
- * <p>Title: </p>
- *
- * <p>Description: 缓存DTO</p>
- *
- * <p>Copyright: Copyright (c) 2008</p>
- *
- * <p>Company: </p>
- *
- * @author Deepblue 2008-11-11
- * @version 1.0
- */
- 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();
- }
- }
http://www.javaeye.com/topic/544021
自己写的话,只能用在内存策略中,下面这代码我已经在好几个项目中应用过了,至今为止还未出现不正确的情况。
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
|
import
java.util.Collection;
import
java.util.Collections;
import
java.util.Iterator;
import
java.util.List;
import
java.util.Map;
import
java.util.concurrent.ConcurrentHashMap;
import
org.springframework.beans.factory.annotation.Autowired;
import
org.springframework.stereotype.Component;
import
net.blogjava.frankiegao123.log.slf4j.Log;
import
net.blogjava.frankiegao123.log.slf4j.LogFactory;
/**
* <p>System.Config 配置缓存</p>
*
* @author frankiegao123
* 2010-6-10 下午02:48:35
*/
@Component
(
"configCache"
)
public
class
ConfigCache
implements
ConfigService {
private
final
static
Log log = LogFactory.getLog(ConfigCache.
class
);
/**
* 更新缓存时记录的时间
*/
private
volatile
long
time = 0L;
/**
* 正在更新缓存时的门闩,为 true 时表示当前没有更新缓存,为 true 时表示当前正在更新缓存
*/
private
volatile
boolean
updateGate =
true
;
/**
* 缓存容器
*/
private
Map<String, SysConfig> cache =
new
ConcurrentHashMap<String, SysConfig>();
private
CommonDao commonDao;
@Autowired
public
ConfigCache(CommonDao commonDao) {
this
.commonDao = commonDao;
log.info(
"initializing cache..."
);
refreshCache();
time = System.currentTimeMillis();
log.info(
"initialized cache finished, cache size: {}, set cache time to current: {}, cache timeout: {}ms"
, cache.size(), time, ConfigConstant.CACHE_TIMEOUT);
}
/**
* <p>根据配置的键名获取配置值</p>
*
* @param configKey
* @return
* @author frankiegao123
* 2010-6-10 上午11:18:33
*/
public
SysConfig getSysConfig(String configKey) {
long
current = System.currentTimeMillis();
if
(updateGate && isTimeout(current)) {
synchronized
(
this
) {
if
(updateGate) {
timeoutSynRefresh(current);
}
}
}
return
cache.get(configKey);
}
/**
* <p>超时时更新缓存。该方法需要在同步环境中调用</p>
* @param current
* @author frankiegao123
* 2010-6-10 上午11:16:30
*/
private
void
timeoutSynRefresh(
long
current) {
updateGate =
false
;
log.info(
"refresh cache start..., time out: {}, size: {}, set updateGate to false"
, (current - time) /
1000.0
, cache.size());
try
{
refreshCache();
time = current;
log.info(
"refresh cache finished, size after update: {}, set cache time to current: {}"
, cache.size(), String.valueOf(time));
}
catch
(Exception e) {
log.error(
"refresh cache failed"
, e);
}
finally
{
updateGate =
true
;
log.info(
"refresh cache finished, set updateGate to true"
);
}
}
/**
* <p>更新缓存数据</p>
*
* @author frankiegao123
* 2010-6-10 上午11:15:55
*/
private
void
refreshCache() {
List<SysConfig> configs = commonDao.getSysConfigs();
for
(Iterator<SysConfig> i = configs.iterator(); i.hasNext(); ) {
SysConfig config = i.next();
cache.put(config.getKey(), config);
}
commonDao.clear();
SysConfig config = cache.get(SysConfig.TEST_KEY);
if
(config ==
null
) {
log.error(
"refresh cache, cannot find TEST_KEY"
);
}
else
{
log.info(
"refresh cache, find TEST_KEY = [{}]"
, config.getValue());
}
}
/**
* <p>缓存是否超时</p>
*
* @param current
* @return
* @author frankiegao123
* 2010-6-10 上午11:16:12
*/
private
boolean
isTimeout(
long
current) {
return
(current - time >= ConfigConstant.CACHE_TIMEOUT);
}
Collection<SysConfig> getSysConfigs() {
return
Collections.unmodifiableCollection(cache.values());
}
int
getSize() {
return
cache.size();
}
long
getTime() {
return
time;
}
boolean
isUpdateGate() {
return
updateGate;
}
void
refresh() {
time = 0L;
log.info(
"refresh: reset cache time to 0"
);
getSysConfig(
"none"
);
log.info(
"refresh: refresh cache finished, cache: {0}"
, String.valueOf(time));
}
}
|