【Java使用】通过Map将数据缓存到内存中

使用ConcurrentHashMap，可以保证在并发环境下不会出现键值对被覆盖的问题

常量定义

与redis类似，定义一个默认的缓存时长、缓存容量、储存数据的结构（采用的Map<String,Object>）
此外，需要一个定时器来控制缓存的超时时间，逻辑上类似于一个定时任务线程，可以采用线程池中的ScheduledExecutorService创建

/**
     * 默认缓存时长 单位s
     */
    private static final int DEFAULT_TIMEOUT = 3600;

    /**
     * 默认缓存容量
     */
    private static final int DEFAULT_SIZE = 10000;

    /**
     * 存储数据
     */
    private static final Map<String, Object> data;

    /**
     * 定时器  用来控制 缓存的超时时间
     */
    private static final ScheduledExecutorService executorService;

初始化

对data和ScheduledExecutorService进行初始化，私有构造函数，使其作为一个单例

   // 初始化
    static {
        data = new ConcurrentHashMap<>(DEFAULT_SIZE);
        executorService = new ScheduledThreadPoolExecutor(2);
    }

    /**
     * 私有化构造函数
     */
    private CrossInfoCache() {
    }

几个主要的方法

使用了定时器调度任务，用于定时清除对应key的缓存

 /**
  * 增加缓存 默认有效时长
  *
  * @param key
  * @param value
  */
 public static void put(String key, Object value) {
     data.put(key, value);
     executorService.schedule(new TimerTask() {
         @Override
         public void run() {
             remove(key);
         }
     }, DEFAULT_TIMEOUT, TimeUnit.SECONDS);
 }

 /**
  * 增加缓存  并设置缓存时长 单位 s
  *
  * @param key
  * @param value
  * @param timeout 缓存时长 单位s
  */
 public static void put(String key, Object value, int timeout) {
     data.put(key, value);

     executorService.schedule(() -> remove(key), timeout, TimeUnit.SECONDS);
 }

 /**
  * 增加缓存 并指定过期时间点
  *
  * @param key
  * @param value
  * @param expireTime 指定过期时间点
  */
 public static void put(String key, Object value, LocalDateTime expireTime) {
     data.put(key, value);
     LocalDateTime nowTime = LocalDateTime.now();
     long seconds = Duration.between(nowTime, expireTime).getSeconds();
     executorService.schedule(() -> remove(key), seconds, TimeUnit.SECONDS);
 }

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

 /**
  * 获取当前缓存中 所有的key
  *
  * @return
  */
 public static Set<String> cacheKeys() {
     return data.keySet();
 }

 /**
  * 获取当前缓存所有内容
  *
  * @return
  */
 public static Map<String, Object> allCache() {
     return data;
 }

 /**
  * 判断缓存是否包含key
  *
  * @param key
  * @return
  */
 public boolean containKey(String key) {
     return data.containsKey(key);
 }

 /**
  * 获取当前缓存大小
  *
  * @return
  */
 public static int size() {
     return data.size();
 }

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

 /**
  * 清空所有缓存
  */
 public static void clear() {
     if (size() > 0) {
         data.clear();
     }
 }