java 缓存的简单实现

实现一个简单的缓存，具有缓存添加，获取，删除，过期自动删除等，主要存储方式为Map

首先建一个缓存数据实体类，用到了lombok消除get set 和全参构造函数

[java] view plain copy

1. import lombok.AllArgsConstructor;
2. import lombok.Getter;
3. import lombok.Setter;
5. @Getter
6. @Setter
7. @AllArgsConstructor
8. public class CacheEntity {
9. /**
10. * 数据主体
11. */
12. private Object data;
14. /**
15. * 超时时长，0永不超时
16. */
17. private Long timeout;
19. /**
20. * 缓存设置初始时间
21. */
22. private Long initialTime;
23. }

再建一个缓存具体操作接口，支持对缓存的各种操作

[java] view plain copy

1. import java.u;
2. import java.u;
4. public interface CacheManager {
5. /**
6. * 存入缓存
7. * @param key
8. * @param data
9. */
10. void put(String key, CacheEntity cacheData);
12. /**
13. * 存入缓存
14. * @param key
15. * @param data
16. * @param timeout
17. */
18. void put(String key, Object data, Long timeout);
20. /**
21. * 获取缓存
22. * @param key
23. * @return
24. */
25. CacheEntity getCacheByKey(String key);
27. /**
28. * 获取所有缓存
29. * @return
30. */
31. Map<String, CacheEntity> getCacheAll();
33. /**
34. * 判断缓存是否存在
35. * @param key
36. * @return
37. */
38. boolean isExist(String key);
40. /**
41. * 清除所有缓存
42. */
43. void clearAll();
45. /**
46. * 清除对应缓存
47. * @param key
48. */
49. void clearByKey(String key);
51. /**
52. * 缓存是否失效
53. * @param key
54. * @return
55. */
56. boolean isTimeOut(String key);
58. /**
59. * 获取所有key
60. * @return
61. */
62. Set<String> getKeys();
63. }

对缓存接口实现，主要运用ConcurrentHashMap来保证多线程读写

[java] view plain copy

1. import java.u;
2. import java.u;
3. import java.u;
5. public class CacheManagerImpl implements CacheManager{
7. private static Map<String, CacheEntity> caches = new ConcurrentHashMap<>();
9. @Override
10. public void put(String key, CacheEntity cacheData) {
11. cac(key, cacheData);
12. }
14. @Override
15. public void put(String key, Object data, Long timeout) {
16. timeout = timeout > 0? timeout : 0L;
17. put(key, new CacheEntity(data, timeout, Sy()));
18. }
20. @Override
21. public CacheEntity getCacheByKey(String key) {
22. i(key))
23. return cac(key);
24. return null;
25. }
27. @Override
28. public Map<String, CacheEntity> getCacheAll() {
29. return caches;
30. }
32. @Override
33. public boolean isExist(String key) {
34. return cac(key);
35. }
37. @Override
38. public void clearAll() {
39. cac();
40. }
42. @Override
43. public void clearByKey(String key) {
44. if (key)) {
45. cac(key);
46. }
47. }
49. @Override
50. public boolean isTimeOut(String key) {
51. if (!(key)) {
52. return true;
53. }
55. CacheEntity cacheEntity = cac(key);
56. Long timeOut = cac();
57. Long initialTime = cac();
59. if (timeOut == 0 || Sy() - initialTime < timeOut) {
60. return false;
61. }
62. return true;
64. }
66. @Override
67. public Set<String> getKeys() {
68. return cac();
69. }
71. }

然后再新建一个线程对该缓存进行监听，来处理过期数据

[java] view plain copy

1. import java.u;
3. public class CacheListener {
4. private CacheManager cacheManager;
6. public CacheListener(CacheManager cacheManager) {
7. = cacheManager;
8. }
10. public void startListen() {
11. new Thread(new Runnable() {
13. @Override
14. public void run() {
15. while(true) {
16. Set<String> keys = cac();
18. for (String key : keys) {
19. i(key)) {
20. cac(key);
21. Sy(key + " 被清除了");
22. }
23. }
25. try {
26. T(5000);
27. Sy("休息5s再检查");
28. } catch (InterruptedException e) {
29. // TODO Auto-generated catch block
30. e.printStackTrace();
31. }
32. }
33. }
34. }).start();
35. }
36. }

最后测试类如下

[java] view plain copy

1. import java.u;
2. import java.u;
4. public class TestCache {
5. public static void main(String[] args) {
6. CacheManager cacheManager = new CacheManagerImpl();
7. cac("testtimeout", "kkkkkkkkk", 20 * 1000L);
8. cac("test1", "111111111", 0L);
9. cac("test2", "222222222222222", 100 * 1000L);
10. cac("test3", "33333333333333", 0L);
11. CacheListener cacheListener = new CacheListener(cacheManager);
12. cac();
14. Sy("getCacheAll : " + Arrays.asLi()));
15. Sy("getCacheKeyAll : " + Arrays.asList(cac()));
16. Sy("getKey : " + Arrays.asLi("test1")));
17. Sy("isExist false: " + Arrays.asLi("test")));
18. Sy("isExist true: " + Arrays.asLi("test1")));
19. Sy("istimeOut false: " + Arrays.asLi("test1")));
21. try {
22. TimeUnit.SECONDS.sleep(30);
23. } catch (InterruptedException e) {
24. // TODO Auto-generated catch block
25. e.printStackTrace();
26. }
28. Sy("isExist : " + Arrays.asLi("testtimeout")));
29. }
30. }

运行结果：