Java手撸一个缓存类似Redis

package com.boot.cache.impl;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * @author liu pei
 * @date 2024年01月22日 下午5:01
 * @Description:
 */
public class LocalExpiringCache {
   

    public static void main(String[] args) {
   
        LocalExpiringCache.getInstance().put("","",100);
    }

    protected static final Logger log = LoggerFactory.getLogger(LocalExpiringCache.class);

    /* 定时清理缓存 */
    private static final ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();

    private static Map<String, CacheItem> cache = null;

    private class CacheItem {
   
        private Object value;
        private Long expirationTime;
        public CacheItem(Object value, long expirationTime) {
   
            this.value = value;
            this.expirationTime = expirationTime;
        }

        public Object getValue() {
   
            return value;
        }

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

        public Long getExpirationTime() {
   
            return expirationTime;
        }

        public void setExpirationTime(Long expirationTime) {
   
            this.expirationTime = expirationTime;
        }
    }

    private static class ExpiringCacheHolder {
   
        private static final LocalExpiringCache INSTANCE = new LocalExpiringCache();
    }

    public static final LocalExpiringCache getInstance() {
   
        return LocalExpiringCache.ExpiringCacheHolder.INSTANCE;
    }

    private LocalExpiringCache() {
   
        log.info("正在初始化缓存池.........");

        cache = new ConcurrentHashMap<>();

        // 注册一个定时线程任务，服务启动1秒之后，每隔500毫秒执行一次
        // 定时清理过期缓存 1000 首次执行时间 500 （毫秒）执行周期,5分钟清理一次
        executor.scheduleAtFixedRate(LocalExpiringCache::clearCache, 1000, 1000*50, TimeUnit.MILLISECONDS);
    }


    public void put(String key, Object value, long expirationSecond) {
   
        long expirationTime = System.currentTimeMillis() + expirationSecond * 1000;
        CacheItem item = new CacheItem(value, expirationTime);
        cache.put(key, item);
    }

    public Object get(String key) {
   
        CacheItem item = cache.get(key);
        if (item != null && System.currentTimeMillis() < item.getExpirationTime()) {
   
            return item.getValue();
        }
        return null; // 缓存项已过期或不存在
    }
    public void remove(String key) {
   
        cache.remove(key);
    }
    public void clear() {
   
        cache.clear();
    }
    public boolean containsKey(String key) {
   
        return cache.containsKey(key);
    }
    public boolean isEmpty() {
   
        return cache.isEmpty();
    }
    public int size() {
   
        return cache.size();
    }


    /**
     * 清理过期的缓存数据
     */
    private static void clearCache() {
   
        if (cache.size() <= 0) {
   
            return;
        }
        // 判断是否过期 过期就从缓存Map删除这个元素
        cache.entrySet().removeIf(entry -> entry.getValue().getExpirationTime() != null && entry.getValue().getExpirationTime() < System.currentTimeMillis());
    }
}