1

13693261870

2022-09-16 fee60c3e25fac0982f3b8cb8feea7225c4ed22f8

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
package com.terra.proxy.controller;
 
import java.util.Date;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
 
/**
 * 简单对象缓存管理
 * Created by lxb on 2018/7/1
 */
public class CacheManager {
 
    private static final long DEFAULT_TIMEOUT = 30000;
    private long cacheTimeout;
    private static CacheManager defaultInstance;
    private static Map<String, CacheData> CACHE_DATA = new ConcurrentHashMap<String, CacheData>();
 
 
    private CacheManager(long timeout) {
 
        this.cacheTimeout = timeout;
 
        new ClearThread().start();
 
    }
 
    private class ClearThread extends Thread {
        ClearThread() {
            setName("clear cache thread");
        }
 
        public void run() {
            while (true) {
                try {
                    long now = System.currentTimeMillis();
                    Object[] keys = CACHE_DATA.keySet().toArray();
                    for (Object key : keys) {
                        CacheData data = CACHE_DATA.get(key);
                        if (data != null && (data.getExpire() > 0 && data.getSaveTime() < new Date().getTime())) {
                            synchronized (CACHE_DATA) {
                                CACHE_DATA.remove(key);
                            }
                        }
                    }
 
                    Thread.sleep(cacheTimeout);
 
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
 
    public static synchronized final CacheManager getDefault() {
        if (defaultInstance == null) {
            defaultInstance = new CacheManager(DEFAULT_TIMEOUT);
        }
        return defaultInstance;
 
    }
 
    private class CacheData<T> {
        CacheData(T t, int expire) {
            this.data = t;
            this.expire = expire <= 0 ? 0 : expire * 1000;
            this.saveTime = new Date().getTime() + this.expire;
        }
 
        private T data;
        private long saveTime; // 存活时间
        private long expire; // 过期时间 小于等于0标识永久存活
 
        public T getData() {
            return data;
        }
 
        public long getExpire() {
            return expire;
        }
 
        public long getSaveTime() {
            return saveTime;
        }
    }
 
 
    public <T> T getData(String key, Load<T> load, int expire) {
        T data = getData(key);
        if (data == null && load != null) {
            data = load.load();
            if (data != null) {
                setData(key, data, expire);
            }
        }
        return data;
    }
 
    public <T> T getData(String key) {
        CacheData<T> data = CACHE_DATA.get(key);
        if (data != null && (data.getExpire() <= 0 || data.getSaveTime() >= new Date().getTime())) {
            return data.getData();
        }
        return null;
    }
 
    public <T> void setData(String key, T data, int expire) {
        CACHE_DATA.put(key, new CacheData(data, expire));
    }
 
    public void clear(String key) {
        CACHE_DATA.remove(key);
    }
 
    public void clearAll() {
        CACHE_DATA.clear();
    }
 
    public interface Load<T> {
        T load();
    }
 
}