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
package com.xfktech.nurse.platform.config.utils;

import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class LocalCacheUtil {

    // 缓存map
    private static Map<String, Object> cacheMap = new ConcurrentHashMap<String, Object>();
    // 缓存有效期map
    private static Map<String, Long> expireTimeMap = new ConcurrentHashMap<String, Long>();


    /**
     * 获取指定的value，如果key不存在或者已过期，则返回null
     *
     * @param key
     * @return
     */
    public static Object get(String key) {
        if (!cacheMap.containsKey(key)) {
            return null;
        }
        if (expireTimeMap.containsKey(key)) {
            if (expireTimeMap.get(key) < System.currentTimeMillis()) { // 缓存失效，已过期
                return null;
            }
        }
        return cacheMap.get(key);
    }

    /**
     * @param key
     * @param <T>
     * @return
     */
    public static <T> T getT(String key) {
        Object obj = get(key);
        return obj == null ? null : (T) obj;
    }

    /**
     * 设置value（不过期）
     *
     * @param key
     * @param value
     */
    public static void set(String key, Object value) {
        cacheMap.put(key, value);
    }

    /**
     * 设置value
     *
     * @param key
     * @param value
     * @param second 过期时间（秒）
     */
    public static void set(final String key, Object value, int second) {
        final long expireTime = System.currentTimeMillis() + second * 1000;
        cacheMap.put(key, value);
        expireTimeMap.put(key, expireTime);
        if (cacheMap.size() > 2) { // 清除过期数据
            new Thread(new Runnable() {
                @Override
                public void run() {
                    // 此处若使用foreach进行循环遍历，删除过期数据，会抛出java.util.ConcurrentModificationException异常
                    Iterator<Map.Entry<String, Object>> iterator = cacheMap.entrySet().iterator();
                    while (iterator.hasNext()) {
                        Map.Entry<String, Object> entry = iterator.next();
                        if (expireTimeMap.containsKey(entry.getKey())) {
                            long expireTime = expireTimeMap.get(key);
                            if (System.currentTimeMillis() > expireTime) {
                                iterator.remove();
                                expireTimeMap.remove(entry.getKey());
                            }
                        }
                    }
                }
            }).start();
        }
    }

    /**
     * key是否存在
     *
     * @param key
     * @return
     */
    public static boolean isExist(String key) {
        return cacheMap.containsKey(key);
    }

    /**
     * 清除缓存
     *
     * @param key
     */
    public static void remove(String key) {
        cacheMap.remove(key);
    }

    public static void main(String[] args) {
        LocalCacheUtil.set("testKey_1", "testValue_1");
        LocalCacheUtil.set("testKey_2", "testValue_2", 10);
        LocalCacheUtil.set("testKey_3", "testValue_3");
        LocalCacheUtil.set("testKey_4", "testValue_4", 1);
        Object testKey_2 = LocalCacheUtil.get("testKey_2");
        System.out.println(testKey_2);
    }

}