java本地缓存

import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Date;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;

public class LocalCache {

    private static Logger LOGGER = LoggerFactory.getLogger(LocalCache.class);

    /**
     * 后台清理线程是否已经开启
     */
    private final static AtomicBoolean backgroundProcessStarted = new AtomicBoolean(false);

    /**
     * 清理缓存线程 清理间隔 单位 毫秒
     * 5分钟
     */
    private final static Long BACKGROUND_PROCESSOR_DELAY_MILLIS = 10 * 60 * 1000L;

    /**
     * 缓存map
     */
    private static ConcurrentHashMap<String, LocalCacheItem> cacheMap = new ConcurrentHashMap<String, LocalCacheItem>();

    /**
     * 写缓存
     * 第一次写的时候开启 后台自动清理缓存线程
     *
     * @param key
     * @param value
     * @param expireTimeMillis 过期时间 单位 毫秒
     */
    public static void put(String key, Object value, long expireTimeMillis) {
        // 第一次写的时候开启 后台自动清理缓存线程
        if (!backgroundProcessStarted.getAndSet(true)) {
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        try {
                            //休眠
                            Thread.sleep(BACKGROUND_PROCESSOR_DELAY_MILLIS);
                            backgroundProcess();
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                            LOGGER.error("SessionManagerImpl.backgroundProcess error", e);
                        }
                    }
                }
            });
            t.setDaemon(true);
            t.start();
        }

        //写缓存
        LocalCacheItem item = new LocalCacheItem(value, System.currentTimeMillis(), expireTimeMillis);
        cacheMap.put(key, item);
    }

    /**
     * 后台自动过期缓存 线程
     */
    private static void backgroundProcess() {
        if (cacheMap == null || cacheMap.size() <= 0) {
            return;
        }
        Set<Map.Entry<String, LocalCacheItem>> entries = cacheMap.entrySet();
        for (Map.Entry<String, LocalCacheItem> entry : entries) {
            LocalCacheItem value = entry.getValue();
            if (System.currentTimeMillis() - value.getCreateTimeMillis() > value.getExpireTimeMillis()) {
                cacheMap.remove(entry.getKey());
            }
        }
    }

    /**
     * 获取缓存
     *
     * @param key
     * @return
     */
    public static Object get(String key) {
        if (StringUtils.isEmpty(key)) {
            return null;
        }

        LocalCacheItem item = cacheMap.get(key);
        if (item == null) {
            return null;
        }

        //已过期
        if (item.getExpireTimeMillis() > 0 && (System.currentTimeMillis() - item.getCreateTimeMillis() >= item.getExpireTimeMillis())) {
            cacheMap.remove(key);
            return null;
        }

        return item.getValue();

    }


    /**
     * 缓存项
     */
    private static class LocalCacheItem {

        /**
         * 缓存对象
         */
        private Object value;

        /**
         * 缓存创建时间
         */
        private long createTimeMillis;

        /**
         * 缓存过期时间，0值代表永不过期
         */
        private long expireTimeMillis;

        public LocalCacheItem(Object value, long createTimeMillis, long expireTimeMillis) {
            this.value = value;
            this.createTimeMillis = createTimeMillis;
            this.expireTimeMillis = expireTimeMillis;
        }

        public Object getValue() {
            return value;
        }

        public void setValue(Object value) {
            this.value = value;
        }

        public long getCreateTimeMillis() {
            return createTimeMillis;
        }

        public void setCreateTimeMillis(long createTimeMillis) {
            this.createTimeMillis = createTimeMillis;
        }

        public long getExpireTimeMillis() {
            return expireTimeMillis;
        }

        public void setExpireTimeMillis(long expireTimeMillis) {
            this.expireTimeMillis = expireTimeMillis;
        }

    }

    /**
     * 生成缓存的key
     *
     * @param pJoinPoint
     * @return
     */
    public static String generateKey(ProceedingJoinPoint pJoinPoint) {
        String targetName = pJoinPoint.getTarget().getClass().getName();
        String methodName = pJoinPoint.getSignature().getName();
        Object[] arguments = pJoinPoint.getArgs();
        return generateKey(targetName, methodName, arguments);
    }

    public static String generateKey(String targetName, String methodName,
                                     Object... arguments) {
        StringBuilder sb = new StringBuilder();
        sb.append(targetName)
                .append(LocalCacheKeyConstants.SYMBOL_DIT)
                .append(methodName);
        if ((arguments != null) && (arguments.length != 0)) {
            for (int i = 0; i < arguments.length; i++) {
                if (arguments[i] instanceof Date) {
                    sb.append(LocalCacheKeyConstants.SYMBOL_DIT).append(
                            DateUtils.format((Date) arguments[i], "yyyyMMddHHmmssSSS"));
                } else {
                    sb.append(LocalCacheKeyConstants.SYMBOL_DIT).append(arguments[i]);
                }
            }
        }
        return sb.toString();
    }
}