Java实现一个简单的缓存方法

更新时间：2017年04月19日 09:23:41 作者：BrightLoong

本篇文章主要介绍了Java实现一个简单的缓存方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧

缓存是在web开发中经常用到的，将程序经常使用到或调用到的对象存在内存中，或者是耗时较长但又不具有实时性的查询数据放入内存中，在一定程度上可以提高性能和效率。下面我实现了一个简单的缓存，步骤如下。

创建缓存对象EntityCache.java

public class EntityCache {
  /**
   * 保存的数据
   */
  private Object datas;

  /**
   * 设置数据失效时间,为0表示永不失效
   */
  private long timeOut;

  /**
   * 最后刷新时间
   */
  private long lastRefeshTime;

  public EntityCache(Object datas, long timeOut, long lastRefeshTime) {
    this.datas = datas;
    this.timeOut = timeOut;
    this.lastRefeshTime = lastRefeshTime;
  }
  public Object getDatas() {
    return datas;
  }
  public void setDatas(Object datas) {
    this.datas = datas;
  }
  public long getTimeOut() {
    return timeOut;
  }
  public void setTimeOut(long timeOut) {
    this.timeOut = timeOut;
  }
  public long getLastRefeshTime() {
    return lastRefeshTime;
  }
  public void setLastRefeshTime(long lastRefeshTime) {
    this.lastRefeshTime = lastRefeshTime;
  }


}

定义缓存操作接口，ICacheManager.java

public interface ICacheManager {
  /**
   * 存入缓存
   * @param key
   * @param cache
   */
  void putCache(String key, EntityCache cache);

  /**
   * 存入缓存
   * @param key
   * @param cache
   */
  void putCache(String key, Object datas, long timeOut);

  /**
   * 获取对应缓存
   * @param key
   * @return
   */
  EntityCache getCacheByKey(String key);

  /**
   * 获取对应缓存
   * @param key
   * @return
   */
  Object getCacheDataByKey(String key);

  /**
   * 获取所有缓存
   * @param key
   * @return
   */
  Map<String, EntityCache> getCacheAll();

  /**
   * 判断是否在缓存中
   * @param key
   * @return
   */
  boolean isContains(String key);

  /**
   * 清除所有缓存
   */
  void clearAll();

  /**
   * 清除对应缓存
   * @param key
   */
  void clearByKey(String key);

  /**
   * 缓存是否超时失效
   * @param key
   * @return
   */
  boolean isTimeOut(String key);

  /**
   * 获取所有key
   * @return
   */
  Set<String> getAllKeys();
}

实现接口ICacheManager，CacheManagerImpl.java

这里我使用了ConcurrentHashMap来保存缓存，本来以为这样就是线程安全的，其实不然，在后面的测试中会发现它并不是线程安全的。

public class CacheManagerImpl implements ICacheManager {
  private static Map<String, EntityCache> caches = new ConcurrentHashMap<String, EntityCache>();

  /**
   * 存入缓存
   * @param key
   * @param cache
   */
  public void putCache(String key, EntityCache cache) {
    caches.put(key, cache);
  }

  /**
   * 存入缓存
   * @param key
   * @param cache
   */
  public void putCache(String key, Object datas, long timeOut) {
    timeOut = timeOut > 0 ? timeOut : 0L;
    putCache(key, new EntityCache(datas, timeOut, System.currentTimeMillis()));
  }

  /**
   * 获取对应缓存
   * @param key
   * @return
   */
  public EntityCache getCacheByKey(String key) {
    if (this.isContains(key)) {
      return caches.get(key);
    }
    return null;
  }

  /**
   * 获取对应缓存
   * @param key
   * @return
   */
  public Object getCacheDataByKey(String key) {
    if (this.isContains(key)) {
      return caches.get(key).getDatas();
    }
    return null;
  }

  /**
   * 获取所有缓存
   * @param key
   * @return
   */
  public Map<String, EntityCache> getCacheAll() {
    return caches;
  }

  /**
   * 判断是否在缓存中
   * @param key
   * @return
   */
  public boolean isContains(String key) {
    return caches.containsKey(key);
  }

  /**
   * 清除所有缓存
   */
  public void clearAll() {
    caches.clear();
  }

  /**
   * 清除对应缓存
   * @param key
   */
  public void clearByKey(String key) {
    if (this.isContains(key)) {
      caches.remove(key);
    }
  }

  /**
   * 缓存是否超时失效
   * @param key
   * @return
   */
  public boolean isTimeOut(String key) {
    if (!caches.containsKey(key)) {
      return true;
    }
    EntityCache cache = caches.get(key);
    long timeOut = cache.getTimeOut();
    long lastRefreshTime = cache.getLastRefeshTime();
    if (timeOut == 0 || System.currentTimeMillis() - lastRefreshTime >= timeOut) {
      return true;
    }
    return false;
  }

  /**
   * 获取所有key
   * @return
   */
  public Set<String> getAllKeys() {
    return caches.keySet();
  }
}

CacheListener.java,失效数据并移除。

public class CacheListener{
  Logger logger = Logger.getLogger("cacheLog");
  private CacheManagerImpl cacheManagerImpl;
  public CacheListener(CacheManagerImpl cacheManagerImpl) {
    this.cacheManagerImpl = cacheManagerImpl;
  }

  public void startListen() {
    new Thread(){
      public void run() {
        while (true) {
          for(String key : cacheManagerImpl.getAllKeys()) {
            if (cacheManagerImpl.isTimeOut(key)) {
             cacheManagerImpl.clearByKey(key);
             logger.info(key + "缓存被清除");
           }
          } 
        }
      } 
    }.start();

  }
}

测试类TestCache.java

public class TestCache {
  Logger logger = Logger.getLogger("cacheLog");
  /**
   * 测试缓存和缓存失效
   */
  @Test
  public void testCacheManager() {
    CacheManagerImpl cacheManagerImpl = new CacheManagerImpl();
    cacheManagerImpl.putCache("test", "test", 10 * 1000L);
    cacheManagerImpl.putCache("myTest", "myTest", 15 * 1000L);
    CacheListener cacheListener = new CacheListener(cacheManagerImpl);
    cacheListener.startListen();
    logger.info("test:" + cacheManagerImpl.getCacheByKey("test").getDatas());
    logger.info("myTest:" + cacheManagerImpl.getCacheByKey("myTest").getDatas());
    try {
      TimeUnit.SECONDS.sleep(20);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    logger.info("test:" + cacheManagerImpl.getCacheByKey("test"));
    logger.info("myTest:" + cacheManagerImpl.getCacheByKey("myTest"));
  }

  /**
   * 测试线程安全
   */
  @Test
  public void testThredSafe() {
    final String key = "thread";
    final CacheManagerImpl cacheManagerImpl = new CacheManagerImpl();
    ExecutorService exec = Executors.newCachedThreadPool();
    for (int i = 0; i < 100; i++) {
      exec.execute(new Runnable() {
        public void run() {
            if (!cacheManagerImpl.isContains(key)) {
              cacheManagerImpl.putCache(key, 1, 0);
            } else {
              //因为+1和赋值操作不是原子性的，所以把它用synchronize块包起来
              synchronized (cacheManagerImpl) {
                int value = (Integer) cacheManagerImpl.getCacheDataByKey(key) + 1; 
                cacheManagerImpl.putCache(key,value , 0);
              }
            }
        }
      });
    }
    exec.shutdown(); 
    try {
      exec.awaitTermination(1, TimeUnit.DAYS);
    } catch (InterruptedException e1) {
      e1.printStackTrace();
    } 

    logger.info(cacheManagerImpl.getCacheDataByKey(key).toString());
  }
}

testCacheManager()输出结果如下：

2017-4-17 10:33:51 io.github.brightloong.cache.TestCache testCacheManager
信息: test:test
2017-4-17 10:33:51 io.github.brightloong.cache.TestCache testCacheManager
信息: myTest:myTest
2017-4-17 10:34:01 io.github.brightloong.cache.CacheListener$1 run
信息: test缓存被清除
2017-4-17 10:34:06 io.github.brightloong.cache.CacheListener$1 run
信息: myTest缓存被清除
2017-4-17 10:34:11 io.github.brightloong.cache.TestCache testCacheManager
信息: test:null
2017-4-17 10:34:11 io.github.brightloong.cache.TestCache testCacheManager
信息: myTest:null

testThredSafe()输出结果如下（选出了各种结果中的一个举例）：

2017-4-17 10:35:36 io.github.brightloong.cache.TestCache testThredSafe
信息: 96

可以看到并不是预期的结果100，为什么呢？ConcurrentHashMap只能保证单次操作的原子性，但是当复合使用的时候，没办法保证复合操作的原子性，以下代码：

if (!cacheManagerImpl.isContains(key)) {
              cacheManagerImpl.putCache(key, 1, 0);
            }

多线程的时候回重复更新value，设置为1，所以出现结果不是预期的100。所以办法就是在CacheManagerImpl.java中都加上synchronized，但是这样一来相当于操作都是串行，使用ConcurrentHashMap也没有什么意义，不过只是简单的缓存还是可以的。或者对测试方法中的run里面加上synchronized块也行，都是大同小异。更高效的方法我暂时也想不出来，希望大家能多多指教。

java
缓存

java实现省市区三级联动
这篇文章主要为大家详细介绍了java实现省市区三级联动，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2022-06-06
springboot接口参数校验JSR303的实现
本文主要介绍了springboot接口参数校验JSR303的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2022-08-08
概述Java的struts2框架
本篇文章主要对struts2框架概念、优缺点进行简要概述。相信会对大家学习Java有所帮助，需要的朋友一起来看下吧
2016-12-12
Lombok的@CustomLog流畅的公司多场景日志
这篇文章主要为大家介绍了Lombok的@CustomLog流畅的公司多场景日志开发详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2023-02-02
Jackson使用示例-Bean、XML、Json之间相互转换
Jackson是一个强大工具,可用于Json、XML、实体之间的相互转换,JacksonXmlElementWrapper用于指定List等集合类,外围标签名,JacksonXmlProperty指定包装标签名,或者指定标签内部属性名,JacksonXmlRootElement指定生成xml根标签的名字,JacksonXmlText指定当前这个值
2024-05-05
Java中toString函数的使用示例代码
toString()函数用于将当前对象以字符串的形式返回，比如我定义了一个User类，创建了一个user对象，然后使用相应命令去打印user对象，本文结合示例代码介绍了toString函数的使用,需要的朋友可以参考下
2024-02-02
混乱的Java日志体系及集成jar包梳理分析
这篇文章主要详细的为大家梳理分析了剪不断理还乱的Java日志体系，以及日志系统涉及到的繁杂的各种集成 jar 包，有需要的朋友可以借鉴参考下，希望能够有所帮助
2022-03-03
基于SpringBoot启动类静态资源路径问题
这篇文章主要介绍了SpringBoot启动类静态资源路径问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-09-09
java 二进制数据与16进制字符串相互转化方法
今天小编就为大家分享一篇java 二进制数据与16进制字符串相互转化方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2018-07-07
Springcloud ribbon负载均衡算法实现
这篇文章主要介绍了Springcloud ribbon负载均衡算法实现,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2020-04-04

Java实现一个简单的缓存方法

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具