Map作為緩存使用

public class MapCache {

    /**
     * 默認存儲1024個緩存
     */
    private static final int DEFAULT_CACHES = 1024;

    private static final MapCache INS = new MapCache();

    public static MapCache single() {
        return INS;
    }

    /**
     * 緩存容器
     */
    private static Map<String, CacheObject> cachePool;

    public MapCache() {
        this(DEFAULT_CACHES);
    }

    public MapCache(int cacheCount) {
        cachePool = new ConcurrentHashMap(cacheCount);
    }

    /**
     * 讀取一個緩存
     *
     * @param key 緩存key
     * @param <T>
     * @return
     */
    public static <T> T get(String key) {
        CacheObject cacheObject = cachePool.get(key);
        if (null != cacheObject) {
            long cur = System.currentTimeMillis() / 1000;
            if (cacheObject.getExpired() <= 0 || cacheObject.getExpired() > cur) {
                Object result = cacheObject.getValue();
                return (T) result;
            }
        }
        return null;
    }

    /**
     * 讀取一個hash類型緩存
     *
     * @param key   緩存key
     * @param field 緩存field
     * @param <T>
     * @return
     */
    public <T> T hget(String key, String field) {
        key = key + ":" + field;
        return this.get(key);
    }

    /**
     * 設置一個緩存
     *
     * @param key   緩存key
     * @param value 緩存value
     */
    public static void set(String key, Object value) {
        INS.set(key, value, -1);
    }

    /**
     * 設置一個緩存並帶過期時間
     *
     * @param key     緩存key
     * @param value   緩存value
     * @param expired 過期時間，單位為秒
     */
    public void set(String key, Object value, long expired) {
        expired = expired > 0 ? System.currentTimeMillis() / 1000 + expired : expired;
        CacheObject cacheObject = new CacheObject(key, value, expired);
        cachePool.put(key, cacheObject);
    }

    /**
     * 設置一個hash緩存
     *
     * @param key   緩存key
     * @param field 緩存field
     * @param value 緩存value
     */
    public void hset(String key, String field, Object value) {
        this.hset(key, field, value, -1);
    }

    /**
     * 設置一個hash緩存並帶過期時間
     *
     * @param key     緩存key
     * @param field   緩存field
     * @param value   緩存value
     * @param expired 過期時間，單位為秒
     */
    public void hset(String key, String field, Object value, long expired) {
        key = key + ":" + field;
        expired = expired > 0 ? System.currentTimeMillis() / 1000 + expired : expired;
        CacheObject cacheObject = new CacheObject(key, value, expired);
        cachePool.put(key, cacheObject);
    }

    /**
     * 根據key刪除緩存
     *
     * @param key 緩存key
     */
    public static void del(String key) {
        cachePool.remove(key);
    }

    /**
     * 根據key和field刪除緩存
     *
     * @param key   緩存key
     * @param field 緩存field
     */
    public void hdel(String key, String field) {
        key = key + ":" + field;
        this.del(key);
    }

    /**
     * 清空緩存
     */
    public void clean() {
        cachePool.clear();
    }

    static class CacheObject {
        private String key;
        private Object value;
        private long expired;

        public CacheObject(String key, Object value, long expired) {
            this.key = key;
            this.value = value;
            this.expired = expired;
        }

        public String getKey() {
            return key;
        }

        public Object getValue() {
            return value;
        }

        public long getExpired() {
            return expired;
        }
    }
}

轉載處：https://blog.csdn.net/xsj_blog/article/details/83056143