写了一个Java的简单缓存模型

缓存操作接口

1. /**
2. * 缓存操作接口
3. *
4. * @author xiudong
5. *
6. * @param <T>
7. */
8. public interface Cache<T> {
9. /**
10. * 刷新缓存数据
11. *
12. * @param key 缓存key
13. * @param target 新数据
14. */
15. void refresh(String key, T target);
16. /**
17. * 获取缓存
18. *
19. * @param key 缓存key
20. * @return 缓存数据
21. */
22. T getCache(String key);
23. /**
24. * 判断缓存是否过期
25. *
26. * @param key 缓存key
27. * @return 如果缓存过期返回true， 否则返回false
28. */
29. Boolean isExpired(String key);
30. /**
31. * 设置缓存过期时间
32. *
33. * @param key 缓存key
34. * @param millsec 缓存过期时间，单位：毫秒
35. */
36. void setExpired(Long millsec);
37. /**
38. * 是否存在缓存对象
39. *
40. * @param key 缓存key
41. * @return 存在返回true，不存在返回false
42. */
43. Boolean exist(String key);
44. }

1. import java.util.Date;
2. /**
3. * 缓存实体
4. *
5. * @author xiudong
6. *
7. * @param <T>
8. */
9. public class LastCache<T> {
10. /**
11. * 上次缓存的数据
12. */
13. private T data;
14. /**
15. * 最后刷新时间
16. */
17. private long refreshtime;
18. public LastCache(T data) {
19. this(data, new Date().getTime());
20. }
21. public LastCache(T data, long refreshtime) {
22. this.data = data;
23. this.refreshtime = refreshtime;
24. }
25. public T getData() {
26. return data;
27. }
28. public void setData(T data) {
29. this.data = data;
30. }
31. public long getRefreshtime() {
32. return refreshtime;
33. }
34. public void setRefreshtime(long refreshtime) {
35. this.refreshtime = refreshtime;
36. }
37. }

1. import java.util.Date;
2. import java.util.Map;
3. import java.util.concurrent.ConcurrentHashMap;
4. /**
5. * 简单的缓存模型
6. *
7. * @author xiudong
8. *
9. * @param <T>
10. */
11. public class SimpleCached<T> implements Cache<T> {
12. /**
13. * 缓存数据索引
14. */
15. private Map<String, LastCache<T>> cache = new ConcurrentHashMap<String, LastCache<T>>();
16. /**
17. * 缓存超时时间，单位：毫秒
18. */
19. private Long expired = 0L;
20. public SimpleCached() {
21. this(5 * 1000 * 60L);
22. }
23. public SimpleCached(Long expired) {
24. this.expired = expired;
25. }
26. @Override
27. public void refresh(String key, T target) {
28. if (cache.containsKey(key)) {
29. cache.remove(key);
30. }
31. cache.put(key, new LastCache<T>(target));
32. }
33. @Override
34. public T getCache(String key) {
35. if (!this.exist(key)) {
36. return null;
37. }
38. return cache.get(key).getData();
39. }
40. @Override
41. public Boolean isExpired(String key) {
42. if (!this.exist(key)) {
43. return null;
44. }
45. long currtime = new Date().getTime();
46. long lasttime = cache.get(key).getRefreshtime();
47. return (currtime - lasttime) > expired;
48. }
49. @Override
50. public void setExpired(Long millsec) {
51. this.expired = millsec;
52. }
53. @Override
54. public Boolean exist(String key) {
55. return cache.containsKey(key);
56. }
57. }